/src/Image_LibPNG154/CMakeLists.txt

http://github.com/Akranar/daguerreo · CMake · 418 lines · 275 code · 47 blank · 96 comment · 36 complexity · e24aa402b0a236a04aac58f7dd931307 MD5 · raw file 

    

  1. cmake_minimum_required(VERSION 2.4.4)
    2. 

  2. set(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS true)
    3. 

  3. 

  4. if(UNIX AND NOT DEFINED CMAKE_BUILD_TYPE)
    5. 

  5.   if(CMAKE_MAJOR_VERSION EQUAL 2 AND CMAKE_MINOR_VERSION EQUAL 4)
    6. 

  6.     # workaround CMake 2.4.x bug
    7. 

  7.     set(CMAKE_BUILD_TYPE "RelWithDebInfo" CACHE STRING
    8. 

  8.         "Choose the type of build, options are:
    9. 

  9.            None(CMAKE_CXX_FLAGS or CMAKE_C_FLAGS used)
    10. 

  10.            Debug
    11. 

  11.            Release
    12. 

  12.            RelWithDebInfo
    13. 

  13.            MinSizeRel.")
    14. 

  14.   else()
    15. 

  15.     set(CMAKE_BUILD_TYPE "RelWithDebInfo" CACHE STRING
    16. 

  16.         "Choose the type of build, options are:
    17. 

  17.            None(CMAKE_CXX_FLAGS or CMAKE_C_FLAGS used)
    18. 

  18.            Debug
    19. 

  19.            Release
    20. 

  20.            RelWithDebInfo
    21. 

  21.            MinSizeRel.")
    22. 

  22.   endif()
    23. 

  23. endif()
    24. 

  24. 

  25. project(libpng C)
    26. 

  26. enable_testing()
    27. 

  27. 

  28. # Copyright (C) 2007-2011 Glenn Randers-Pehrson
    29. 

  29. 

  30. # This code is released under the libpng license.
    31. 

  31. # For conditions of distribution and use, see the disclaimer
    32. 

  32. # and license in png.h
    33. 

  33. 

  34. set(PNGLIB_MAJOR 1)
    35. 

  35. set(PNGLIB_MINOR 5)
    36. 

  36. set(PNGLIB_RELEASE 4)
    37. 

  37. set(PNGLIB_NAME libpng${PNGLIB_MAJOR}${PNGLIB_MINOR})
    38. 

  38. set(PNGLIB_VERSION ${PNGLIB_MAJOR}.${PNGLIB_MINOR}.${PNGLIB_RELEASE})
    39. 

  39. 

  40. # needed packages
    41. 

  41. ##Original:
    42. 

  42.     #find_package(ZLIB REQUIRED)
    43. 

  43.     #include_directories(${ZLIB_INCLUDE_DIR})
    44. 

  44. ##Akranar Added Begin:
    45. 

  45. SET(PNG_PROJECT_NAME Image_LibPNG154)
    46. 

  46. SET(ZLIB_LIBRARY IO_ZLIB)
    47. 

  47. SET(ZLIB_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../IO_ZLIB)
    48. 

  48. SET(ZLIB_INCLUDE_DIR ${ZLIB_INCLUDE_DIR} ${CMAKE_CURRENT_BINARY_DIR}/../IO_ZLIB)
    49. 

  49. include_directories(${ZLIB_INCLUDE_DIR})
    50. 

  50. SET(SKIP_INSTALL_ALL TRUE)
    51. 

  51. ##Akranar Added End:
    52. 

  52. 

  53. if(NOT WIN32)
    54. 

  54.   find_library(M_LIBRARY
    55. 

  55.     NAMES m
    56. 

  56.     PATHS /usr/lib /usr/local/lib
    57. 

  57.   )
    58. 

  58.   if(NOT M_LIBRARY)
    59. 

  59.     message(STATUS
    60. 

  60.       "math library 'libm' not found - floating point support disabled")
    61. 

  61.   endif()
    62. 

  62. else()
    63. 

  63.   # not needed on windows
    64. 

  64.   set(M_LIBRARY "")
    65. 

  65. endif()
    66. 

  66. 

  67. # COMMAND LINE OPTIONS
    68. 

  68. if(DEFINED PNG_SHARED)
    69. 

  69.   option(PNG_SHARED "Build shared lib" ${PNG_SHARED})
    70. 

  70. else()
    71. 

  71.   option(PNG_SHARED "Build shared lib" OFF) #Akranar changed from ON to OFF
    72. 

  72. endif()
    73. 

  73. if(DEFINED PNG_STATIC)
    74. 

  74.   option(PNG_STATIC "Build static lib" ${PNG_STATIC})
    75. 

  75. else()
    76. 

  76.   option(PNG_STATIC "Build static lib" ON)
    77. 

  77. endif()
    78. 

  78. 

  79. ##Akranar Deleted Begin:
    80. 

  80. #if(MINGW)
    81. 

  81. #  option(PNG_TESTS  "Build pngtest" NO)
    82. 

  82. #else()
    83. 

  83. #  option(PNG_TESTS  "Build pngtest" YES)
    84. 

  84. #endif()
    85. 

  85. #
    86. 

  86. #option(PNG_NO_CONSOLE_IO "FIXME" YES)
    87. 

  87. #option(PNG_NO_STDIO      "FIXME" YES)
    88. 

  88. #option(PNG_DEBUG         "Build with debug output" NO)
    89. 

  89. #option(PNGARG            "FIXME" YES)
    90. 

  90. ##TODO:
    91. 

  91. ## PNG_CONSOLE_IO_SUPPORTED
    92. 

  92. #
    93. 

  93. ## maybe needs improving, but currently I don't know when we can enable what :)
    94. 

  94. #set(png_asm_tmp "OFF")
    95. 

  95. #if(NOT WIN32)
    96. 

  96. #  find_program(uname_executable NAMES uname PATHS /bin /usr/bin /usr/local/bin)
    97. 

  97. #  if(uname_executable)
    98. 

  98. #    exec_program(${uname_executable}
    99. 

  99. #                 ARGS --machine OUTPUT_VARIABLE uname_output)
    100. 

  100. #    if("uname_output" MATCHES "^.*i[1-9]86.*$")
    101. 

  101. #      set(png_asm_tmp "ON")
    102. 

  102. #    else("uname_output" MATCHES "^.*i[1-9]86.*$")
    103. 

  103. #      set(png_asm_tmp "OFF")
    104. 

  104. #    endif("uname_output" MATCHES "^.*i[1-9]86.*$")
    105. 

  105. #  endif(uname_executable)
    106. 

  106. #else()
    107. 

  107. #  # this env var is normally only set on win64
    108. 

  108. #  set(TEXT "ProgramFiles(x86)")
    109. 

  109. #  if("$ENV{${TEXT}}" STREQUAL "")
    110. 

  110. #    set(png_asm_tmp "ON")
    111. 

  111. #  endif("$ENV{${TEXT}}" STREQUAL "")
    112. 

  112. #endif()
    113. 

  113. ##Akranar Delete End
    114. 

  114. 

  115. # SET LIBNAME
    116. 

  116. set(PNG_LIB_NAME png${PNGLIB_MAJOR}${PNGLIB_MINOR})
    117. 

  117. 

  118. # to distinguish between debug and release lib
    119. 

  119. set(CMAKE_DEBUG_POSTFIX "d")
    120. 

  120. 

  121. # Use the prebuilt pnglibconf.h file from the scripts folder
    122. 

  122. configure_file(${CMAKE_CURRENT_SOURCE_DIR}/scripts/pnglibconf.h.prebuilt
    123. 

  123.                ${CMAKE_CURRENT_BINARY_DIR}/pnglibconf.h)
    124. 

  124. include_directories(${CMAKE_CURRENT_BINARY_DIR})
    125. 

  125. 

  126. # OUR SOURCES
    127. 

  127. set(libpng_public_hdrs
    128. 

  128.   png.h
    129. 

  129.   pngconf.h
    130. 

  130.   ${CMAKE_CURRENT_BINARY_DIR}/pnglibconf.h
    131. 

  131. )
    132. 

  132. set(libpng_sources
    133. 

  133.   ${libpng_public_hdrs}
    134. 

  134.   pngdebug.h
    135. 

  135.   pnginfo.h
    136. 

  136.   pngpriv.h
    137. 

  137.   pngstruct.h
    138. 

  138.   png.c
    139. 

  139.   pngerror.c
    140. 

  140.   pngget.c
    141. 

  141.   pngmem.c
    142. 

  142.   pngpread.c
    143. 

  143.   pngread.c
    144. 

  144.   pngrio.c
    145. 

  145.   pngrtran.c
    146. 

  146.   pngrutil.c
    147. 

  147.   pngset.c
    148. 

  148.   pngtrans.c
    149. 

  149.   pngwio.c
    150. 

  150.   pngwrite.c
    151. 

  151.   pngwtran.c
    152. 

  152.   pngwutil.c
    153. 

  153. )
    154. 

  154. set(pngtest_sources
    155. 

  155.   pngtest.c
    156. 

  156. )
    157. 

  157. # SOME NEEDED DEFINITIONS
    158. 

  158. 

  159. add_definitions(-DPNG_CONFIGURE_LIBPNG)
    160. 

  160. 

  161. if(MSVC)
    162. 

  162.   add_definitions(-DPNG_NO_MODULEDEF -D_CRT_SECURE_NO_DEPRECATE)
    163. 

  163. endif(MSVC)
    164. 

  164. 

  165. if(PNG_SHARED OR  NOT MSVC)
    166. 

  166.   #if building msvc static this has NOT to be defined
    167. 

  167.   add_definitions(-DZLIB_DLL)
    168. 

  168. endif()
    169. 

  169. 

  170. 

  171. if(PNG_CONSOLE_IO_SUPPORTED)
    172. 

  172.   add_definitions(-DPNG_CONSOLE_IO_SUPPORTED)
    173. 

  173. endif()
    174. 

  174. 

  175. if(PNG_NO_CONSOLE_IO)
    176. 

  176.   add_definitions(-DPNG_NO_CONSOLE_IO)
    177. 

  177. endif()
    178. 

  178. 

  179. if(PNG_NO_STDIO)
    180. 

  180.   add_definitions(-DPNG_NO_STDIO)
    181. 

  181. endif()
    182. 

  182. 

  183. if(PNG_DEBUG)
    184. 

  184.   add_definitions(-DPNG_DEBUG)
    185. 

  185. endif()
    186. 

  186. 

  187. if(NOT M_LIBRARY AND NOT WIN32)
    188. 

  188.   add_definitions(-DPNG_NO_FLOATING_POINT_SUPPORTED)
    189. 

  189. endif()
    190. 

  190. 

  191. # NOW BUILD OUR TARGET
    192. 

  192. include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${ZLIB_INCLUDE_DIR})
    193. 

  193. 

  194. if(PNG_SHARED)
    195. 

  195.   add_library(${PNG_LIB_NAME} SHARED ${libpng_sources})
    196. 

  196.   if(MSVC)
    197. 

  197.     # msvc does not append 'lib' - do it here to have consistent name
    198. 

  198.     set_target_properties(${PNG_LIB_NAME} PROPERTIES PREFIX "lib")
    199. 

  199.     set_target_properties(${PNG_LIB_NAME} PROPERTIES IMPORT_PREFIX "lib")
    200. 

  200.   endif()
    201. 

  201.   target_link_libraries(${PNG_LIB_NAME} ${ZLIB_LIBRARY} ${M_LIBRARY})
    202. 

  202. endif()
    203. 

  203. 

  204. if(PNG_STATIC)
    205. 

  205. # does not work without changing name
    206. 

  206. ##Original:
    207. 

  207. #  set(PNG_LIB_NAME_STATIC ${PNG_LIB_NAME}_static)
    208. 

  208. #  add_library(${PNG_LIB_NAME_STATIC} STATIC ${libpng_sources})
    209. 

  209. #  if(MSVC)
    210. 

  210. #    # msvc does not append 'lib' - do it here to have consistent name
    211. 

  211. #    set_target_properties(${PNG_LIB_NAME_STATIC} PROPERTIES PREFIX "lib")
    212. 

  212. #  endif()
    213. 

  213. #  target_link_libraries(${PNG_LIB_NAME_STATIC} ${ZLIB_LIBRARY} ${M_LIBRARY})
    214. 

  214. ##Akranar Change Begin:
    215. 

  215.     SET(PNG_LIB_NAME_STATIC ${PNG_PROJECT_NAME})
    216. 

  216.     ADD_LIBRARY(${PNG_LIB_NAME_STATIC} STATIC ${libpng_sources})
    217. 

  217. ##Akranar Change End:
    218. 

  218. endif()
    219. 

  219. 

  220. 

  221. if(PNG_SHARED AND WIN32)
    222. 

  222.   set_target_properties(${PNG_LIB_NAME} PROPERTIES DEFINE_SYMBOL PNG_BUILD_DLL)
    223. 

  223. endif()
    224. 

  224. 

  225. if(PNG_TESTS AND PNG_SHARED)
    226. 

  226.   # does not work with msvc due to png_lib_ver issue
    227. 

  227.   add_executable(pngtest ${pngtest_sources})
    228. 

  228.   target_link_libraries(pngtest ${PNG_LIB_NAME})
    229. 

  229.   add_test(pngtest ./pngtest ${CMAKE_CURRENT_SOURCE_DIR}/pngtest.png)
    230. 

  230. endif()
    231. 

  231. 

  232. #
    233. 

  233. # Set a variable with CMake code which:
    234. 

  234. # Creates a symlink from src to dest (if possible) or alternatively
    235. 

  235. # copies if different.
    236. 

  236. macro(_png_generate_symlink_code CODE SRC DEST)
    237. 

  237.   if(WIN32 AND NOT CYGWIN)
    238. 

  238.     set(_png_gsc_message "Copying ${SRC} to ${DEST} if needed")
    239. 

  239.     set(_png_gsc_operation "copy_if_different")
    240. 

  240.   else()
    241. 

  241.     set(_png_gsc_message "Symlinking ${SRC} to ${DEST}")
    242. 

  242.     set(_png_gsc_operation "create_symlink")
    243. 

  243.   endif()
    244. 

  244. 

  245.   set(${CODE} "
    246. 

  246.     message(STATUS \"${_png_gsc_message}\")
    247. 

  247.     execute_process(COMMAND \${CMAKE_COMMAND} -E ${_png_gsc_operation}
    248. 

  248.       \"${SRC}\" \"${DEST}\")
    249. 

  249.     ")
    250. 

  250. endmacro()
    251. 

  251. 

  252. # CREATE PKGCONFIG FILES
    253. 

  253. # we use the same files like ./configure, so we have to set its vars
    254. 

  254. if(NOT DEFINED CMAKE_INSTALL_LIBDIR)
    255. 

  255.   set(CMAKE_INSTALL_LIBDIR lib)
    256. 

  256. endif(NOT DEFINED CMAKE_INSTALL_LIBDIR)
    257. 

  257. set(prefix      ${CMAKE_INSTALL_PREFIX})
    258. 

  258. set(exec_prefix ${CMAKE_INSTALL_PREFIX})
    259. 

  259. set(libdir      ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR})
    260. 

  260. set(includedir  ${CMAKE_INSTALL_PREFIX}/include)
    261. 

  261. set(LIBS        "-lz -lm")
    262. 

  262. configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libpng.pc.in
    263. 

  263.   ${CMAKE_CURRENT_BINARY_DIR}/${PNGLIB_NAME}.pc @ONLY)
    264. 

  264. _png_generate_symlink_code(PNG_PC_INSTALL_CODE
    265. 

  265.   ${CMAKE_CURRENT_BINARY_DIR}/${PNGLIB_NAME}.pc
    266. 

  266.   ${CMAKE_CURRENT_BINARY_DIR}/libpng.pc)
    267. 

  267. install(CODE ${PNG_PC_INSTALL_CODE})
    268. 

  268. 

  269. configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libpng-config.in
    270. 

  270.   ${CMAKE_CURRENT_BINARY_DIR}/${PNGLIB_NAME}-config @ONLY)
    271. 

  271. _png_generate_symlink_code(PNG_CONFIG_INSTALL_CODE
    272. 

  272.   ${CMAKE_CURRENT_BINARY_DIR}/${PNGLIB_NAME}-config
    273. 

  273.   ${CMAKE_CURRENT_BINARY_DIR}/libpng-config)
    274. 

  274. install(CODE ${PNG_CONFIG_INSTALL_CODE})
    275. 

  275. 

  276. # SET UP LINKS
    277. 

  277. if(PNG_SHARED)
    278. 

  278.   set_target_properties(${PNG_LIB_NAME} PROPERTIES
    279. 

  279. #   VERSION 15.${PNGLIB_RELEASE}.1.5.4
    280. 

  280.     VERSION 15.${PNGLIB_RELEASE}.0
    281. 

  281.     SOVERSION 15
    282. 

  282.     CLEAN_DIRECT_OUTPUT 1)
    283. 

  283. endif()
    284. 

  284. if(PNG_STATIC)
    285. 

  285.   # MSVC doesn't use a different file extension for shared vs. static
    286. 

  286.   # libs.  We are able to change OUTPUT_NAME to remove the _static
    287. 

  287.   # for all other platforms.
    288. 

  288.   if(NOT MSVC)
    289. 

  289.     set_target_properties(${PNG_LIB_NAME_STATIC} PROPERTIES
    290. 

  290.       OUTPUT_NAME ${PNG_LIB_NAME}
    291. 

  291.       CLEAN_DIRECT_OUTPUT 1)
    292. 

  292.   endif()
    293. 

  293. endif()
    294. 

  294. 

  295. # If CMake > 2.4.x, we set a variable used below to export
    296. 

  296. # targets to an export file.
    297. 

  297. # TODO: Use VERSION_GREATER after our cmake_minimum_required >= 2.6.2
    298. 

  298. if(CMAKE_MAJOR_VERSION GREATER 1 AND CMAKE_MINOR_VERSION GREATER 4)
    299. 

  299.   set(PNG_EXPORT_RULE EXPORT libpng)
    300. 

  300. elseif(CMAKE_MAJOR_VERSION GREATER 2) # future proof
    301. 

  301.   set(PNG_EXPORT_RULE EXPORT libpng)
    302. 

  302. endif()
    303. 

  303. 

  304. # INSTALL
    305. 

  305. if(NOT SKIP_INSTALL_LIBRARIES AND NOT SKIP_INSTALL_ALL )
    306. 

  306.   if(PNG_SHARED)
    307. 

  307.     install(TARGETS ${PNG_LIB_NAME}
    308. 

  308.         ${PNG_EXPORT_RULE}
    309. 

  309.         RUNTIME DESTINATION bin
    310. 

  310.         LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
    311. 

  311.         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
    312. 

  312. 

  313.     # Create a symlink for libpng.dll.a => libpng15.dll.a on Cygwin
    314. 

  314.     if(CYGWIN)
    315. 

  315.       _png_generate_symlink_code(PNG_SHARED_IMPLIB_INSTALL_CODE
    316. 

  316.         ${PNGLIB_NAME}${CMAKE_IMPORT_LIBRARY_SUFFIX}
    317. 

  317.         libpng${CMAKE_IMPORT_LIBRARY_SUFFIX})
    318. 

  318.       install(CODE ${PNG_SHARED_IMPLIB_INSTALL_CODE})
    319. 

  319.       install(FILES
    320. 

  320.         ${CMAKE_CURRENT_BINARY_DIR}/libpng${CMAKE_IMPORT_LIBRARY_SUFFIX}
    321. 

  321.         DESTINATION ${CMAKE_INSTALL_LIBDIR})
    322. 

  322.     endif()
    323. 

  323. 

  324.     if(NOT WIN32)
    325. 

  325.       IF(CMAKE_LIBRARY_OUTPUT_DIRECTORY)
    326. 

  326.         _png_generate_symlink_code(PNG_SHARED_INSTALL_CODE
    327. 

  327.  ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${PNGLIB_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}
    328. 

  328.  ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/libpng${CMAKE_SHARED_LIBRARY_SUFFIX})
    329. 

  329.                 install(CODE ${PNG_SHARED_INSTALL_CODE})
    330. 

  330.                 install(FILES
    331. 

  331.  ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/libpng${CMAKE_SHARED_LIBRARY_SUFFIX}
    332. 

  332.                 DESTINATION ${CMAKE_INSTALL_LIBDIR})
    333. 

  333.       ELSE(CMAKE_LIBRARY_OUTPUT_DIRECTORY)
    334. 

  334.         _png_generate_symlink_code(PNG_SHARED_INSTALL_CODE
    335. 

  335.            ${PNGLIB_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}
    336. 

  336.            libpng${CMAKE_SHARED_LIBRARY_SUFFIX})
    337. 

  337.         install(CODE ${PNG_SHARED_INSTALL_CODE})
    338. 

  338.         install(FILES
    339. 

  339.            ${CMAKE_CURRENT_BINARY_DIR}/libpng${CMAKE_SHARED_LIBRARY_SUFFIX}
    340. 

  340.                 DESTINATION ${CMAKE_INSTALL_LIBDIR})
    341. 

  341.       ENDIF(CMAKE_LIBRARY_OUTPUT_DIRECTORY)
    342. 

  342.     endif()
    343. 

  343.   endif()
    344. 

  344. 

  345.   if(PNG_STATIC)
    346. 

  346.     install(TARGETS ${PNG_LIB_NAME_STATIC}
    347. 

  347.         ${PNG_EXPORT_RULE}
    348. 

  348.             LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
    349. 

  349.             ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
    350. 

  350.     if(NOT WIN32 OR CYGWIN)
    351. 

  351.       IF(CMAKE_ARCHIVE_OUTPUT_DIRECTORY)
    352. 

  352.          _png_generate_symlink_code(PNG_STATIC_INSTALL_CODE
    353. 

  353. ${CMAKE_ARCHIVE_OUTPUT_DIRECTORY}/${PNGLIB_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX}
    354. 

  354.         ${CMAKE_ARCHIVE_OUTPUT_DIRECTORY}/libpng${CMAKE_STATIC_LIBRARY_SUFFIX})
    355. 

  355.         install(CODE ${PNG_STATIC_INSTALL_CODE})
    356. 

  356.         install(FILES
    357. 

  357.           ${CMAKE_ARCHIVE_OUTPUT_DIRECTORY}/libpng${CMAKE_STATIC_LIBRARY_SUFFIX}
    358. 

  358.              DESTINATION ${CMAKE_INSTALL_LIBDIR})
    359. 

  359.       ELSE(CMAKE_ARCHIVE_OUTPUT_DIRECTORY)
    360. 

  360.         _png_generate_symlink_code(PNG_STATIC_INSTALL_CODE
    361. 

  361.            ${PNGLIB_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX}
    362. 

  362.            libpng${CMAKE_STATIC_LIBRARY_SUFFIX})
    363. 

  363.         install(CODE ${PNG_STATIC_INSTALL_CODE})
    364. 

  364.         install(FILES
    365. 

  365.           ${CMAKE_CURRENT_BINARY_DIR}/libpng${CMAKE_STATIC_LIBRARY_SUFFIX}
    366. 

  366.                      DESTINATION ${CMAKE_INSTALL_LIBDIR})
    367. 

  367.       ENDIF(CMAKE_ARCHIVE_OUTPUT_DIRECTORY)
    368. 

  368.     endif()
    369. 

  369.   endif()
    370. 

  370. endif()
    371. 

  371. 

  372. if(NOT SKIP_INSTALL_HEADERS AND NOT SKIP_INSTALL_ALL )
    373. 

  373.   install(FILES ${libpng_public_hdrs}   DESTINATION include)
    374. 

  374.   install(FILES ${libpng_public_hdrs}   DESTINATION include/${PNGLIB_NAME})
    375. 

  375. endif()
    376. 

  376. if(NOT SKIP_INSTALL_EXECUTABLES AND NOT SKIP_INSTALL_ALL )
    377. 

  377.   install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/libpng-config DESTINATION bin)
    378. 

  378.   install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/${PNGLIB_NAME}-config
    379. 

  379.           DESTINATION bin)
    380. 

  380. endif()
    381. 

  381. if(NOT SKIP_INSTALL_FILES AND NOT SKIP_INSTALL_ALL )
    382. 

  382.   # Install man pages
    383. 

  383.   if(NOT PNG_MAN_DIR)
    384. 

  384.     set(PNG_MAN_DIR "share/man")
    385. 

  385.   endif()
    386. 

  386.   install(FILES libpng.3 libpngpf.3      DESTINATION ${PNG_MAN_DIR}/man3)
    387. 

  387.   install(FILES png.5                    DESTINATION ${PNG_MAN_DIR}/man5)
    388. 

  388.   # Install pkg-config files
    389. 

  389.   install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libpng.pc
    390. 

  390.           DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
    391. 

  391.   install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/libpng-config
    392. 

  392.           DESTINATION bin)
    393. 

  393.   install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${PNGLIB_NAME}.pc
    394. 

  394.           DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
    395. 

  395.   install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/${PNGLIB_NAME}-config
    396. 

  396.           DESTINATION bin)
    397. 

  397. endif()
    398. 

  398. 

  399. # On versions of CMake that support it, create an export file CMake
    400. 

  400. # users can include() to import our targets
    401. 

  401. if(PNG_EXPORT_RULE AND NOT SKIP_INSTALL_EXPORT AND NOT SKIP_INSTALL_ALL )
    402. 

  402.   install(EXPORT libpng DESTINATION lib/libpng FILE lib${PNG_LIB_NAME}.cmake)
    403. 

  403. endif()
    404. 

  404. 

  405. # what's with libpng-$VER%.txt and all the extra files?
    406. 

    407. 

  407. 

  408. # UNINSTALL
    409. 

  409. # do we need this?
    410. 

  410. 

  411. 

  412. # DIST
    413. 

  413. # do we need this?
    414. 

  414. 

  415. # to create msvc import lib for mingw compiled shared lib
    416. 

  416. # pexports libpng.dll > libpng.def
    417. 

  417. # lib /def:libpng.def /machine:x86
    418.