CMake: Create PocoConfig.cmake to make importable from other CMake projects

The generated PocoConfig.cmake can be used by other CMake projects using find_package.

ApacheConnector/CMakeLists.txt

@@ -8,14 +8,18 @@ POCO_SOURCES_AUTO( SRCS ${SRCS_G})
 file(GLOB_RECURSE HDRS_G "include/*.h" )
 POCO_HEADERS_AUTO( SRCS ${HDRS_G})
 
-include_directories( "include" )
-
-add_library( ${LIBNAME} SHARED ${SRCS} )
-set_target_properties( ${LIBNAME}
+add_library( "${LIBNAME}" SHARED ${SRCS} )
+set_target_properties( "${LIBNAME}"
     PROPERTIES
     VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
     DEFINE_SYMBOL ApacheHandlers_EXPORTS)
-target_link_libraries( ${LIBNAME} )
+target_link_libraries( "${LIBNAME}" )
+target_include_directories( "${LIBNAME}"
+    PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:include>
+    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
+    )
 
 if (ENABLE_TESTS)
   add_subdirectory(samples)

CMakeLists.txt

@@ -8,7 +8,7 @@
 
 project(Poco)
 
-cmake_minimum_required(VERSION 2.8.0)
+cmake_minimum_required(VERSION 3.0.0)
 
 file(STRINGS "${CMAKE_SOURCE_DIR}/libversion" SHARED_LIBRARY_VERSION)
 
@@ -75,12 +75,18 @@ option(ENABLE_PDF "Enable PDF" ON)
 option(ENABLE_UTIL "Enable Util" ON)
 option(ENABLE_NET "Enable Net" ON)
 option(ENABLE_NETSSL "Enable NetSSL" ON)
+option(ENABLE_NETSSL_WIN "Enable NetSSL Windows" ON)
 option(ENABLE_CRYPTO "Enable Crypto" ON)
 option(ENABLE_DATA "Enable Data" ON)
+option(ENABLE_DATA_SQLITE "Enable Data SQlite" ON)
+option(ENABLE_DATA_MYSQL "Enable Data MySQL" ON)
+option(ENABLE_DATA_ODBC "Enable Data ODBC" ON)
 option(ENABLE_SEVENZIP "Enable SevenZip" ON)
 option(ENABLE_ZIP "Enable Zip" ON)
 option(ENABLE_APACHECONNECTOR "Enable ApacheConnector" ON)
 
+option(FORCE_OPENSSL "Force usage of OpenSSL even under windows" OFF)
+
 option(ENABLE_TESTS
   "Set to OFF|ON (default is OFF) to control build of POCO tests & samples" OFF)
 
@@ -115,32 +121,21 @@ else ()
   message(STATUS "Build with using internal copy of sqlite, libz, pcre, expat, ...")
 endif ()
 
-# Set local include path
-include_directories( CppUnit/include CppUnit/WinTestRunner/include Foundation/include XML/include Net/include NetSSL_OpenSSL/include Util/include Data/include Data/MySQL/include Data/SQLite/include Data/ODBC/include Zip/include Crypto/include Web/include JSON/include MongoDB/include PDF/include SevenZip/include)
-
 include(CheckTypeSize)
 find_package(Cygwin)
 
-#include(CMakeDetermineCompilerId)
-
 # OS Detection
-if(CMAKE_SYSTEM MATCHES "Windows")
-
- add_definitions( -DPOCO_OS_FAMILY_WINDOWS)
- set(SYSLIBS iphlpapi gdi32 odbc32)
-
- if (CMAKE_C_COMPILER_ID MATCHES "MSVC")
-        message(STATUS "XXX: MS Visual Compiler detected")
- endif (CMAKE_C_COMPILER_ID MATCHES "MSVC")
+if(WIN32)
+  add_definitions( -DPOCO_OS_FAMILY_WINDOWS -DUNICODE -D_UNICODE)
+  #set(SYSLIBS iphlpapi gdi32 odbc32)
+endif(WIN32)
 
-endif(CMAKE_SYSTEM MATCHES "Windows")
-
-if (CMAKE_SYSTEM MATCHES "Linux" AND NOT ANDROID )
+if (UNIX AND NOT ANDROID )
   add_definitions( -DPOCO_OS_FAMILY_UNIX )
   # Standard 'must be' defines
   add_definitions( -D_XOPEN_SOURCE=500 -D_REENTRANT -D_THREAD_SAFE -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64)
   set(SYSLIBS  pthread dl rt)
-endif(CMAKE_SYSTEM MATCHES "Linux" AND NOT ANDROID )
+endif(UNIX AND NOT ANDROID )
 
 if (CMAKE_SYSTEM MATCHES "SunOS")
   add_definitions( -DPOCO_OS_FAMILY_UNIX )
@@ -150,15 +145,15 @@ if (CMAKE_SYSTEM MATCHES "SunOS")
 endif(CMAKE_SYSTEM MATCHES "SunOS")
 
 if (CMAKE_COMPILER_IS_MINGW)
-    add_definitions(-DWC_NO_BEST_FIT_CHARS=0x400  -DPOCO_WIN32_UTF8)
-    add_definitions(-mno-cygwin -D_WIN32 -DMINGW32 -DWINVER=0x500 -DODBCVER=0x0300 -DPOCO_THREAD_STACK_SIZE -DFoundation_Config_INCLUDED )
+  add_definitions(-DWC_NO_BEST_FIT_CHARS=0x400  -DPOCO_WIN32_UTF8)
+  add_definitions(-mno-cygwin -D_WIN32 -DMINGW32 -DWINVER=0x500 -DODBCVER=0x0300 -DPOCO_THREAD_STACK_SIZE -DFoundation_Config_INCLUDED )
   link_directories(/usr/local/lib /usr/lib)
   include_directories(/usr/local/include /usr/include)
 endif (CMAKE_COMPILER_IS_MINGW)
 
-if (CMAKE_COMPILER_IS_CYGWIN)
+if (CYGWIN)
 #    add_definitions(-DWC_NO_BEST_FIT_CHARS=0x400  -DPOCO_WIN32_UTF8)
-endif (CMAKE_COMPILER_IS_CYGWIN)
+endif (CYGWIN)
 
 # SunPro C++
 if (${CMAKE_CXX_COMPILER_ID} MATCHES "SunPro")
@@ -170,10 +165,14 @@ if (IOS)
   add_definitions( -DPOCO_HAVE_IPv6 -DPOCO_NO_FPENVIRONMENT -DPOCO_NO_STAT64 -DPOCO_NO_SHAREDLIBS -DPOCO_NO_NET_IFTYPES )
 endif(IOS)
 
-#ANDROID
+#Android
 if (ANDROID)
   add_definitions( -DPOCO_ANDROID -DPOCO_NO_FPENVIRONMENT -DPOCO_NO_WSTRING -DPOCO_NO_SHAREDMEMORY )
-endif()
+endif(ANDROID)
+
+
+# Collect the built libraries and include dirs, the will be used to create the PocoConfig.cmake file
+set(Poco_COMPONENTS "")
 
 if (ENABLE_TESTS)
    add_subdirectory(CppUnit)
@@ -182,43 +181,62 @@ endif ()
 add_subdirectory(Foundation)
 if(ENABLE_XML)
 add_subdirectory(XML)
+list(APPEND Poco_COMPONENTS "XML")
 endif()
 if(ENABLE_JSON)
 add_subdirectory(JSON)
+list(APPEND Poco_COMPONENTS "JSON")
 endif()
 if(ENABLE_MONGODB)
 add_subdirectory(MongoDB)
+list(APPEND Poco_COMPONENTS "MongoDB")
 endif()
 if(ENABLE_PDF)
 add_subdirectory(PDF)
+list(APPEND Poco_COMPONENTS "PDF")
 endif()
 if(ENABLE_UTIL)
 add_subdirectory(Util)
+list(APPEND Poco_COMPONENTS "Util")
 endif()
 if(ENABLE_NET)
 add_subdirectory(Net)
+list(APPEND Poco_COMPONENTS "Net")
 endif()
 
-# OPENSSL_SSL_LIBRARY
+
+#NetSSL
+
+
+if(WIN32 AND ENABLE_NETSSL_WIN)
+    add_subdirectory(NetSSL_Win)
+    list(APPEND Poco_COMPONENTS "NetSSL_Win")
+endif(WIN32 AND ENABLE_NETSSL_WIN)
+
 find_package(OpenSSL)
 if(OPENSSL_FOUND)
     include_directories("${OPENSSL_INCLUDE_DIR}")
     if(ENABLE_NETSSL)
     add_subdirectory(NetSSL_OpenSSL)
+    list(APPEND Poco_COMPONENTS "NetSSL_OpenSSL")
     endif()
     if(ENABLE_CRYPTO)
     add_subdirectory(Crypto)
+    list(APPEND Poco_COMPONENTS "Crypto")
     endif()
 endif(OPENSSL_FOUND)
 
 if(ENABLE_DATA)
 add_subdirectory(Data)
+list(APPEND Poco_COMPONENTS "Data")
 endif()
 if(ENABLE_SEVENZIP)
 add_subdirectory(SevenZip)
+list(APPEND Poco_COMPONENTS "SevenZip")
 endif()
 if(ENABLE_ZIP)
 add_subdirectory(Zip)
+list(APPEND Poco_COMPONENTS "Zip")
 endif()
 
 find_package(APR)
@@ -227,6 +245,7 @@ if(APRUTIL_FOUND AND APACHE_FOUND)
     include_directories( "${APACHE_INCLUDE_DIR}" "${APRUTIL_INCLUDE_DIR}" )
     if(ENABLE_APACHECONNECTOR)
     add_subdirectory(ApacheConnector)
+    list(APPEND Poco_COMPONENTS "ApacheConnector")
     endif()
 endif(APRUTIL_FOUND AND APACHE_FOUND)
 
@@ -253,9 +272,38 @@ set(CPACK_PACKAGE_INSTALL_DIRECTORY "/usr/local")
 
 include(CPack)
 
+#############################################################
+# cmake config files 
+
+include(CMakePackageConfigHelpers)
+write_basic_package_version_file(
+  "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/${PROJECT_NAME}ConfigVersion.cmake"
+  VERSION ${PROJECT_VERSION}
+  COMPATIBILITY AnyNewerVersion
+)
+
+configure_file(cmake/${PROJECT_NAME}Config.cmake.in "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/${PROJECT_NAME}Config.cmake" @ONLY)
+install(
+    FILES
+        ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/${PROJECT_NAME}Config.cmake
+        ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}/${PROJECT_NAME}ConfigVersion.cmake
+    DESTINATION
+        "lib/cmake/${PROJECT_NAME}"
+    COMPONENT
+        Devel
+)
+
+# in tree build settings
+#configure_file(PocoBuildTreeSettings.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/PocoBuildTreeSettings.cmake @ONLY)
+
+
 message(STATUS "CMake ${CMAKE_VERSION} successfully configured ${PROJECT_NAME} using ${CMAKE_GENERATOR} generator")
 message(STATUS "Installation target path: ${CMAKE_INSTALL_PREFIX}")
 
 message(STATUS "C_FLAGS:  =${CMAKE_C_FLAGS}")
 message(STATUS "CXX_FLAGS:=${CMAKE_CXX_FLAGS}")
 
+foreach(component ${Poco_COMPONENTS})
+message(STATUS "Building: ${component}")
+endforeach()
+

CppUnit/CMakeLists.txt

@@ -8,12 +8,18 @@ POCO_SOURCES_AUTO( SRCS ${SRCS_G})
 file(GLOB_RECURSE HDRS_G "include/*.h" )
 POCO_HEADERS_AUTO( SRCS ${HDRS_G})
 
-add_library( ${LIBNAME} ${LIB_MODE} ${SRCS} )
-set_target_properties( ${LIBNAME}
+add_library( "${LIBNAME}" ${LIB_MODE} ${SRCS} )
+set_target_properties( "${LIBNAME}"
     PROPERTIES
     VERSION "1" SOVERSION "1"
     DEFINE_SYMBOL CppUnit_EXPORTS)
-target_link_libraries( ${LIBNAME} )
+target_link_libraries( "${LIBNAME}" )
+target_include_directories( "${LIBNAME}"
+    PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:include>
+    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
+    )
 
 if(WIN32)
     add_subdirectory(WinTestRunner)

CppUnit/WinTestRunner/CMakeLists.txt

@@ -13,15 +13,21 @@ POCO_HEADERS_AUTO( WIN_SRCS ${HDRS_G})
 
 # TODO: Is this flag always required?
 add_definitions("-D_AFXDLL")
+#TODO: Use instead of the flag above: find_package(MFC)
 
-include_directories( "src" )
-
-add_library( ${LIBNAME} ${LIB_MODE} ${WIN_SRCS} )
-set_target_properties( ${LIBNAME}
+add_library( "${LIBNAME}" ${LIB_MODE} ${WIN_SRCS} )
+set_target_properties( "${LIBNAME}"
     PROPERTIES
     VERSION "1" SOVERSION "1"
     DEFINE_SYMBOL WinTestRunner_EXPORTS)
-target_link_libraries( ${LIBNAME} CppUnit )
+target_link_libraries( "${LIBNAME}" CppUnit )
+target_include_directories( "${LIBNAME}"
+    PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:include>
+    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
+    )
+
 if(WIN32)
     target_link_libraries( ${LIBNAME} winmm )
 endif(WIN32)

Crypto/CMakeLists.txt

@@ -1,4 +1,5 @@
-set(LIBNAME "PocoCrypto")
+set(LIBNAME "Crypto")
+set(POCO_LIBNAME "Poco${LIBNAME}")
 
 # Sources
 file(GLOB SRCS_G "src/*.cpp")
@@ -8,29 +9,41 @@ POCO_SOURCES_AUTO( SRCS ${SRCS_G})
 file(GLOB_RECURSE HDRS_G "include/*.h" )
 POCO_HEADERS_AUTO( SRCS ${HDRS_G})
 
-add_definitions(-D_USRDLL)
-include_directories( "include" )
+#add_definitions(-D_USRDLL)
 
-add_library( ${LIBNAME} ${LIB_MODE} ${SRCS} )
-set_target_properties( ${LIBNAME} 
-    PROPERTIES 
+add_library( "${LIBNAME}" ${LIB_MODE} ${SRCS} )
+add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}")
+set_target_properties( "${LIBNAME}"
+    PROPERTIES
     VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
-    DEFINE_SYMBOL Crypto_EXPORTS)
-target_link_libraries( ${LIBNAME} PocoFoundation ${OPENSSL_LIBRARIES} )
+    OUTPUT_NAME ${POCO_LIBNAME}
+    DEFINE_SYMBOL Crypto_EXPORTS
+    )
 
+target_link_libraries( "${LIBNAME}" Foundation ${OPENSSL_LIBRARIES} )
+target_include_directories( "${LIBNAME}"
+    PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:include>
+    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
+    )
 install(
     DIRECTORY include/Poco
     DESTINATION include
+    COMPONENT Devel
     PATTERN ".svn" EXCLUDE
     )
 
 install(
-    TARGETS ${LIBNAME}
+    TARGETS "${LIBNAME}" EXPORT "${LIBNAME}Targets"
     LIBRARY DESTINATION lib${LIB_SUFFIX}
     ARCHIVE DESTINATION lib${LIB_SUFFIX}
     RUNTIME DESTINATION bin
+    INCLUDES DESTINATION include
     )
 
+POCO_GENERATE_PACKAGE("${LIBNAME}" "${LIBNAME}Targets" "lib/cmake/${PROJECT_NAME}")
+
 if (ENABLE_TESTS)
   add_subdirectory(samples)
   add_subdirectory(testsuite)

Crypto/cmake/PocoCryptoConfig.cmake

@@ -0,0 +1,4 @@
+include(CMakeFindDependencyMacro)
+set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR})
+find_dependency(PocoFoundation)
+include("${CMAKE_CURRENT_LIST_DIR}/PocoCryptoTargets.cmake")

Data/CMakeLists.txt

@@ -1,4 +1,5 @@
-set(LIBNAME "PocoData")
+set(LIBNAME "Data")
+set(POCO_LIBNAME "Poco${LIBNAME}")
 
 # Sources
 file(GLOB SRCS_G "src/*.cpp")
@@ -17,29 +18,45 @@ if(MSVC AND NOT(MSVC_VERSION LESS 1400))
         PROPERTIES COMPILE_FLAGS "/bigobj")
 endif()
 
-add_library( ${LIBNAME} ${LIB_MODE} ${SRCS} )
-set_target_properties( ${LIBNAME}
+add_library( "${LIBNAME}" ${LIB_MODE} ${SRCS} )
+add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}")
+set_target_properties( "${LIBNAME}"
     PROPERTIES
     VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
-    DEFINE_SYMBOL Data_EXPORTS)
-target_link_libraries( ${LIBNAME} PocoFoundation)
+    OUTPUT_NAME ${POCO_LIBNAME}
+    DEFINE_SYMBOL Data_EXPORTS
+    )
 
+target_link_libraries( "${LIBNAME}" Foundation)
+target_include_directories( "${LIBNAME}"
+    PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:include>
+    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
+    )
 install(
     DIRECTORY include/Poco
     DESTINATION include
+    COMPONENT Devel
     PATTERN ".svn" EXCLUDE
     )
 
 install(
-    TARGETS ${LIBNAME}
+    TARGETS "${LIBNAME}" EXPORT "${LIBNAME}Targets"
     LIBRARY DESTINATION lib${LIB_SUFFIX}
     ARCHIVE DESTINATION lib${LIB_SUFFIX}
     RUNTIME DESTINATION bin
+    INCLUDES DESTINATION include
     )
 
+POCO_GENERATE_PACKAGE("${LIBNAME}" "${LIBNAME}Targets" "lib/cmake/${PROJECT_NAME}")
+
+if(ENABLE_DATA_SQLITE)
 # SQlite3 is built in any case
 add_subdirectory( SQLite )
+endif(ENABLE_DATA_SQLITE)
 
+if(ENABLE_DATA_MYSQL)
 find_package(MySQL)
 if(MYSQL_FOUND)
     include_directories("${MYSQL_INCLUDE_DIR}")
@@ -48,21 +65,24 @@ if(MYSQL_FOUND)
 else()
     message(STATUS "MySQL Support Disabled - no MySQL library")
 endif(MYSQL_FOUND)
+endif(ENABLE_DATA_MYSQL)
 
+if(ENABLE_DATA_ODBC)
 find_package(ODBC)
-if(CMAKE_SYSTEM MATCHES "Windows")
-    set(ODBC_LIBRARIES "")
+if(WIN32 AND NOT WINCE)
+    set(ODBC_LIBRARIES "odbc32" "odbccp32")
     message(STATUS "Windows native ODBC Support Enabled")
     add_subdirectory( ODBC )
-else ()
-    if (ODBC_FOUND)
+else(WIN32 AND NOT WINCE)
+    if(ODBC_FOUND)
         include_directories("${ODBC_INCLUDE_DIRECTORIES}")
         message(STATUS "ODBC Support Enabled")
         add_subdirectory( ODBC )
-    else ()
+    else()
         message(STATUS "ODBC Support Disabled - no ODBC runtime")
-    endif ()
-endif()
+    endif()
+endif(WIN32 AND NOT WINCE)
+endif(ENABLE_DATA_ODBC)
 
 if (ENABLE_TESTS)
     add_subdirectory(samples)

Data/MySQL/CMakeLists.txt

@@ -1,4 +1,5 @@
-set(LIBNAME "PocoDataMySQL")
+set(LIBNAME "DataMySQL")
+set(POCO_LIBNAME "Poco${LIBNAME}")
 
 # Sources
 file(GLOB SRCS_G "src/*.cpp")
@@ -10,28 +11,39 @@ POCO_HEADERS_AUTO( MYSQL_SRCS ${HDRS_G})
 
 add_definitions(-DTHREADSAFE -DNO_TCL)
 
-include_directories( "include" )
-
-add_library( ${LIBNAME} ${LIB_MODE} ${MYSQL_SRCS} )
-set_target_properties( ${LIBNAME} 
+add_library( "${LIBNAME}" ${LIB_MODE} ${MYSQL_SRCS} )
+add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}")
+set_target_properties( "${LIBNAME}"
     PROPERTIES
     VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
-    DEFINE_SYMBOL MySQL_EXPORTS)
-target_link_libraries( ${LIBNAME} PocoData PocoFoundation ${MYSQL_LIB})
+    OUTPUT_NAME ${POCO_LIBNAME}
+    DEFINE_SYMBOL MySQL_EXPORTS
+    )
 
+target_link_libraries( "${LIBNAME}" Foundation Data ${MYSQL_LIB})
+target_include_directories( "${LIBNAME}"
+    PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:include>
+    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
+    )
 install(
     DIRECTORY include/Poco
     DESTINATION include
+    COMPONENT Devel
     PATTERN ".svn" EXCLUDE
     )
 
 install(
-    TARGETS ${LIBNAME}
+    TARGETS "${LIBNAME}" EXPORT "${LIBNAME}Targets"
     LIBRARY DESTINATION lib${LIB_SUFFIX}
     ARCHIVE DESTINATION lib${LIB_SUFFIX}
     RUNTIME DESTINATION bin
+    INCLUDES DESTINATION include
     )
 
+POCO_GENERATE_PACKAGE("${LIBNAME}" "${LIBNAME}Targets" "lib/cmake/${PROJECT_NAME}")
+
 if (ENABLE_TESTS)
     add_subdirectory(testsuite)
 endif ()

Data/MySQL/cmake/PocoDataMySQLConfig.cmake

@@ -0,0 +1,5 @@
+include(CMakeFindDependencyMacro)
+set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR})
+find_dependency(PocoFoundation)
+find_dependency(PocoData)
+include("${CMAKE_CURRENT_LIST_DIR}/PocoDataMySQLTargets.cmake")

Data/ODBC/CMakeLists.txt

@@ -1,4 +1,5 @@
-set(LIBNAME "PocoDataODBC")
+set(LIBNAME "DataODBC")
+set(POCO_LIBNAME "Poco${LIBNAME}")
 
 # Sources
 file(GLOB SRCS_G "src/*.cpp")
@@ -8,30 +9,41 @@ POCO_SOURCES_AUTO( ODBC_SRCS ${SRCS_G})
 file(GLOB_RECURSE HDRS_G "include/*.h" )
 POCO_HEADERS_AUTO( ODBC_SRCS ${HDRS_G})
 
-add_definitions( ${ODBC_CFLAGS} )
+add_definitions( ${ODBC_CFLAGS} -DTHREADSAFE)
 
-include_directories( "include" )
-
-add_library( ${LIBNAME} ${LIB_MODE} ${ODBC_SRCS} )
-set_target_properties( ${LIBNAME} 
+add_library( "${LIBNAME}" ${LIB_MODE} ${ODBC_SRCS} )
+add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}")
+set_target_properties( "${LIBNAME}"
     PROPERTIES
-    VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION} 
-    DEFINE_SYMBOL ODBC_EXPORTS)
-target_link_libraries( ${LIBNAME} PocoData PocoFoundation ${ODBC_LIBRARIES})
+    VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
+    OUTPUT_NAME ${POCO_LIBNAME}
+    DEFINE_SYMBOL ODBC_EXPORTS
+    )
 
+target_link_libraries( "${LIBNAME}" Foundation Data ${ODBC_LIBRARIES})
+target_include_directories( "${LIBNAME}"
+    PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:include>
+    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
+    )
 install(
     DIRECTORY include/Poco
     DESTINATION include
+    COMPONENT Devel
     PATTERN ".svn" EXCLUDE
     )
 
 install(
-    TARGETS ${LIBNAME}
+    TARGETS "${LIBNAME}" EXPORT "${LIBNAME}Targets"
     LIBRARY DESTINATION lib${LIB_SUFFIX}
     ARCHIVE DESTINATION lib${LIB_SUFFIX}
     RUNTIME DESTINATION bin
+    INCLUDES DESTINATION include
     )
 
+POCO_GENERATE_PACKAGE("${LIBNAME}" "${LIBNAME}Targets" "lib/cmake/${PROJECT_NAME}")
+
 if (ENABLE_TESTS)
     add_subdirectory(testsuite)
 endif ()

Data/ODBC/cmake/PocoDataODBCConfig.cmake

@@ -0,0 +1,5 @@
+include(CMakeFindDependencyMacro)
+set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR})
+find_dependency(PocoFoundation)
+find_dependency(PocoData)
+include("${CMAKE_CURRENT_LIST_DIR}/PocoDataODBCTargets.cmake")

Data/SQLite/CMakeLists.txt

@@ -1,4 +1,5 @@
-set(LIBNAME  "PocoDataSQLite")
+set(LIBNAME  "DataSQLite")
+set(POCO_LIBNAME "Poco${LIBNAME}")
 
 # Sources
 file(GLOB SRCS_G "src/*.cpp")
@@ -8,11 +9,9 @@ POCO_SOURCES_AUTO( SQLITE_SRCS ${SRCS_G})
 file(GLOB_RECURSE HDRS_G "include/*.h" )
 POCO_HEADERS_AUTO( SQLITE_SRCS ${HDRS_G})
 
-include_directories( "include" "src" )
-
 if (POCO_UNBUNDLED)
     find_package(SQLite3)
-    set(DATASQLITELIBS PocoData PocoFoundation ${SQLITE3_LIBRARIES})
+    set(DATASQLITELIBS ${SQLITE3_LIBRARIES})
     include_directories("${SQLITE3_INCLUDE_DIRS}")
 else()
     # sqlite3
@@ -24,31 +23,48 @@ else()
         src/sqlite3.h
     )
 
-    set(DATASQLITELIBS PocoData PocoFoundation)
+    set(DATASQLITELIBS "")
 endif()
 
+if(WINCE)
+    add_definitions(-DSQLITE_MSVC_LOCALTIME_API)
+endif(WINCE)
+
 add_definitions(-DSQLITE_THREADSAFE=1 -DSQLITE_DISABLE_LFS -DSQLITE_OMIT_UTF16 -DSQLITE_OMIT_PROGRESS_CALLBACK -DSQLITE_OMIT_COMPLETE -DSQLITE_OMIT_TCL_VARIABLE -DSQLITE_OMIT_DEPRECATED)
 
-add_library( ${LIBNAME} ${LIB_MODE} ${SQLITE_SRCS} )
-set_target_properties( ${LIBNAME}
+add_library( "${LIBNAME}" ${LIB_MODE} ${SQLITE_SRCS} )
+add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}")
+set_target_properties( "${LIBNAME}"
     PROPERTIES
     VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
-    DEFINE_SYMBOL SQLite_EXPORTS)
-target_link_libraries( ${LIBNAME} ${DATASQLITELIBS} )
+    OUTPUT_NAME ${POCO_LIBNAME}
+    DEFINE_SYMBOL SQLite_EXPORTS
+    )
 
+target_link_libraries( "${LIBNAME}" Foundation Data ${DATASQLITELIBS} )
+target_include_directories( "${LIBNAME}"
+    PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:include>
+    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
+    )
 install(
     DIRECTORY include/Poco
     DESTINATION include
+    COMPONENT Devel
     PATTERN ".svn" EXCLUDE
     )
 
 install(
-    TARGETS ${LIBNAME}
+    TARGETS "${LIBNAME}" EXPORT "${LIBNAME}Targets"
     LIBRARY DESTINATION lib${LIB_SUFFIX}
     ARCHIVE DESTINATION lib${LIB_SUFFIX}
     RUNTIME DESTINATION bin
+    INCLUDES DESTINATION include
     )
 
+POCO_GENERATE_PACKAGE("${LIBNAME}" "${LIBNAME}Targets" "lib/cmake/${PROJECT_NAME}")
+
 if (ENABLE_TESTS)
     add_subdirectory(testsuite)
 endif ()

Data/SQLite/cmake/PocoDataSQLiteConfig.cmake

@@ -0,0 +1,5 @@
+include(CMakeFindDependencyMacro)
+set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR})
+find_dependency(PocoFoundation)
+find_dependency(PocoData)
+include("${CMAKE_CURRENT_LIST_DIR}/PocoDataSQLiteTargets.cmake")

Data/cmake/PocoDataConfig.cmake

@@ -0,0 +1,4 @@
+include(CMakeFindDependencyMacro)
+set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR})
+find_dependency(PocoFoundation)
+include("${CMAKE_CURRENT_LIST_DIR}/PocoDataTargets.cmake")

Foundation/CMakeLists.txt

@@ -1,4 +1,5 @@
-set(LIBNAME "PocoFoundation")
+set(LIBNAME "Foundation")
+set(POCO_LIBNAME "Poco${LIBNAME}")
 
 # Sources
 file(GLOB SRCS_G "src/*.cpp")
@@ -15,10 +16,18 @@ POCO_HEADERS_AUTO( SRCS include/Poco/OpcomChannel.h )
 POCO_SOURCES_AUTO_PLAT( SRCS UNIX src/SyslogChannel.cpp )
 POCO_HEADERS_AUTO( SRCS include/Poco/SyslogChannel.h )
 
+# For Windows CE we need to disable these
+if(WINCE)
+POCO_SOURCES_AUTO_PLAT( SRCS OFF
+    src/WindowsConsoleChannel.cpp
+    src/EventLogChannel.cpp
+    )
+else()
 POCO_SOURCES_AUTO_PLAT( SRCS WIN32
     src/WindowsConsoleChannel.cpp
     src/EventLogChannel.cpp
     )
+endif()
 
 POCO_HEADERS_AUTO( SRCS
     include/Poco/WindowsConsoleChannel.h
@@ -90,36 +99,50 @@ else()
     )
 endif (POCO_UNBUNDLED)
 
-if(CMAKE_SYSTEM MATCHES "Windows")
-    add_definitions( -DPCRE_STATIC)
+if(WIN32)
     set(SYSLIBS ${SYSLIBS} iphlpapi)
-else (CMAKE_SYSTEM MATCHES "Windows")
-    add_definitions( -DPCRE_STATIC)
-endif(CMAKE_SYSTEM MATCHES "Windows")
-
-add_library( ${LIBNAME} ${LIB_MODE} ${SRCS}) 
-set_target_properties( ${LIBNAME} 
-    PROPERTIES
-    VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
-    DEFINE_SYMBOL Foundation_EXPORTS)
+endif(WIN32)
 if (${CMAKE_CXX_COMPILER_ID} MATCHES "SunPro")
-    set_target_properties( ${LIBNAME} PROPERTIES LINK_FLAGS "-library=stlport4")
+    set_target_properties( "${LIBNAME}" PROPERTIES LINK_FLAGS "-library=stlport4")
 endif (${CMAKE_CXX_COMPILER_ID} MATCHES "SunPro")
-target_link_libraries( ${LIBNAME} ${SYSLIBS})
+
+# TODO: Why is this here?
+add_definitions( -DPCRE_STATIC)
+
+add_library( "${LIBNAME}" ${LIB_MODE} ${SRCS})
+add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}")
+set_target_properties( "${LIBNAME}"
+    PROPERTIES
+    VERSION ${PROJECT_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
+    OUTPUT_NAME ${POCO_LIBNAME}
+    DEFINE_SYMBOL Foundation_EXPORTS
+    )
+
+target_link_libraries( "${LIBNAME}" ${SYSLIBS})
+target_include_directories( "${LIBNAME}"
+    PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:include>
+    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
+    )
 
 install(
     DIRECTORY include/Poco
     DESTINATION include
+    COMPONENT Devel
     PATTERN ".svn" EXCLUDE
     )
 
 install(
-    TARGETS ${LIBNAME}
+    TARGETS "${LIBNAME}" EXPORT "${LIBNAME}Targets"
     LIBRARY DESTINATION lib${LIB_SUFFIX}
     ARCHIVE DESTINATION lib${LIB_SUFFIX}
     RUNTIME DESTINATION bin
+    INCLUDES DESTINATION include
     )
 
+POCO_GENERATE_PACKAGE("${LIBNAME}" "${LIBNAME}Targets" "lib/cmake/${PROJECT_NAME}")
+
 if (ENABLE_TESTS)
     add_subdirectory( samples )
     add_subdirectory( testsuite )

Foundation/cmake/PocoFoundationConfig.cmake

@@ -0,0 +1 @@
+include("${CMAKE_CURRENT_LIST_DIR}/PocoFoundationTargets.cmake")

JSON/CMakeLists.txt

@@ -1,4 +1,5 @@
-set(LIBNAME "PocoJSON")
+set(LIBNAME "JSON")
+set(POCO_LIBNAME "Poco${LIBNAME}")
 
 # Sources
 file(GLOB SRCS_G "src/*.cpp")
@@ -8,26 +9,40 @@ POCO_SOURCES_AUTO( SRCS ${SRCS_G})
 file(GLOB_RECURSE HDRS_G "include/*.h" )
 POCO_HEADERS_AUTO( SRCS ${HDRS_G})
 
-add_library( ${LIBNAME} ${LIB_MODE} ${SRCS} )
-set_target_properties( ${LIBNAME} 
+add_library( "${LIBNAME}" ${LIB_MODE} ${SRCS} )
+add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}")
+set_target_properties( "${LIBNAME}"
     PROPERTIES
     VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
-    DEFINE_SYMBOL JSON_EXPORTS)
-target_link_libraries( ${LIBNAME} PocoFoundation)
+    OUTPUT_NAME ${POCO_LIBNAME}
+    DEFINE_SYMBOL JSON_EXPORTS
+    )
+
+target_link_libraries( "${LIBNAME}" Foundation)
+target_include_directories( "${LIBNAME}"
+    PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:include>
+    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
+    )
 
 install(
     DIRECTORY include/Poco
     DESTINATION include
+    COMPONENT Devel
     PATTERN ".svn" EXCLUDE
     )
 
 install(
-    TARGETS ${LIBNAME}
+    TARGETS "${LIBNAME}" EXPORT "${LIBNAME}Targets"
     LIBRARY DESTINATION lib${LIB_SUFFIX}
     ARCHIVE DESTINATION lib${LIB_SUFFIX}
     RUNTIME DESTINATION bin
+    INCLUDES DESTINATION include
     )
 
+POCO_GENERATE_PACKAGE("${LIBNAME}" "${LIBNAME}Targets" "lib/cmake/${PROJECT_NAME}")
+
 if (ENABLE_TESTS)
   add_subdirectory(samples)
   add_subdirectory(testsuite)

JSON/cmake/PocoJSONConfig.cmake

@@ -0,0 +1,4 @@
+include(CMakeFindDependencyMacro)
+set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR})
+find_dependency(PocoFoundation)
+include("${CMAKE_CURRENT_LIST_DIR}/PocoJSONTargets.cmake")

MongoDB/CMakeLists.txt

@@ -1,4 +1,5 @@
-set(LIBNAME "PocoMongoDB")
+set(LIBNAME "MongoDB")
+set(POCO_LIBNAME "Poco${LIBNAME}")
 
 # Sources
 file(GLOB SRCS_G "src/*.cpp")
@@ -8,26 +9,39 @@ POCO_SOURCES_AUTO( SRCS ${SRCS_G})
 file(GLOB_RECURSE HDRS_G "include/*.h" )
 POCO_HEADERS_AUTO( SRCS ${HDRS_G})
 
-add_library( ${LIBNAME} ${LIB_MODE} ${SRCS} )
-set_target_properties( ${LIBNAME}
+add_library( "${LIBNAME}" ${LIB_MODE} ${SRCS} )
+add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}")
+set_target_properties( "${LIBNAME}"
     PROPERTIES
     VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
-    DEFINE_SYMBOL MongoDB_EXPORTS)
-target_link_libraries( ${LIBNAME} PocoNet PocoFoundation)
+    OUTPUT_NAME ${POCO_LIBNAME}
+    DEFINE_SYMBOL MongoDB_EXPORTS
+    )
 
+target_link_libraries( "${LIBNAME}" Net Foundation)
+target_include_directories( "${LIBNAME}"
+    PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:include>
+    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
+    )
 install(
     DIRECTORY include/Poco
     DESTINATION include
+    COMPONENT Devel
     PATTERN ".svn" EXCLUDE
     )
 
 install(
-    TARGETS ${LIBNAME}
+    TARGETS "${LIBNAME}" EXPORT "${LIBNAME}Targets"
     LIBRARY DESTINATION lib${LIB_SUFFIX}
     ARCHIVE DESTINATION lib${LIB_SUFFIX}
     RUNTIME DESTINATION bin
+    INCLUDES DESTINATION include
     )
 
+POCO_GENERATE_PACKAGE("${LIBNAME}" "${LIBNAME}Targets" "lib/cmake/${PROJECT_NAME}")
+
 if (ENABLE_TESTS)
   add_subdirectory(samples)
   add_subdirectory(testsuite)

MongoDB/cmake/PocoMongoDBConfig.cmake

@@ -0,0 +1,5 @@
+include(CMakeFindDependencyMacro)
+set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR})
+find_dependency(PocoFoundation)
+find_dependency(PocoNet)
+include("${CMAKE_CURRENT_LIST_DIR}/PocoMongoDBTargets.cmake")

Net/CMakeLists.txt

@@ -1,4 +1,5 @@
-set(LIBNAME "PocoNet")
+set(LIBNAME "Net")
+set(POCO_LIBNAME "Poco${LIBNAME}")
 
 # Sources
 file(GLOB SRCS_G "src/*.cpp")
@@ -8,31 +9,48 @@ POCO_SOURCES_AUTO( SRCS ${SRCS_G})
 file(GLOB_RECURSE HDRS_G "include/*.h" )
 POCO_HEADERS_AUTO( SRCS ${HDRS_G})
 
-#TODO: Can WIN32 be used here?
-if(CMAKE_SYSTEM MATCHES "Windows")
-    set(SYSLIBS ${SYSLIBS} "ws2_32.lib" "iphlpapi.lib")
-endif(CMAKE_SYSTEM MATCHES "Windows")
-
-add_library( ${LIBNAME} ${LIB_MODE} ${SRCS} )
-set_target_properties( ${LIBNAME}
+# Windows and WindowsCE need additional libraries
+if(WIN32)
+    if(WINCE)
+        set(SYSLIBS ${SYSLIBS} "ws2.lib" "iphlpapi.lib")
+    else()    
+        set(SYSLIBS ${SYSLIBS} "ws2_32.lib" "iphlpapi.lib")
+    endif()    
+endif(WIN32)
+
+add_library( "${LIBNAME}" ${LIB_MODE} ${SRCS} )
+add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}")
+set_target_properties( "${LIBNAME}"
     PROPERTIES
     VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
-    DEFINE_SYMBOL Net_EXPORTS)
-target_link_libraries( ${LIBNAME} PocoFoundation ${SYSLIBS})
+    OUTPUT_NAME ${POCO_LIBNAME}
+    DEFINE_SYMBOL Net_EXPORTS
+    )
 
+target_link_libraries( "${LIBNAME}" Foundation ${SYSLIBS})
+target_include_directories( "${LIBNAME}"
+    PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:include>
+    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
+    )
 install(
     DIRECTORY include/Poco
     DESTINATION include
+    COMPONENT Devel
     PATTERN ".svn" EXCLUDE
     )
 
 install(
-    TARGETS ${LIBNAME}
+    TARGETS "${LIBNAME}" EXPORT "${LIBNAME}Targets"
     LIBRARY DESTINATION lib${LIB_SUFFIX}
     ARCHIVE DESTINATION lib${LIB_SUFFIX}
     RUNTIME DESTINATION bin
+    INCLUDES DESTINATION include
     )
 
+POCO_GENERATE_PACKAGE("${LIBNAME}" "${LIBNAME}Targets" "lib/cmake/${PROJECT_NAME}")
+
 if (ENABLE_TESTS)
   add_subdirectory(samples)
   add_subdirectory(testsuite)

Net/cmake/PocoNetConfig.cmake

@@ -0,0 +1,4 @@
+include(CMakeFindDependencyMacro)
+set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR})
+find_dependency(PocoFoundation)
+include("${CMAKE_CURRENT_LIST_DIR}/PocoNetTargets.cmake")

NetSSL_OpenSSL/CMakeLists.txt

@@ -1,4 +1,5 @@
-set(LIBNAME "PocoNetSSL")
+set(LIBNAME "NetSSL")
+set(POCO_LIBNAME "Poco${LIBNAME}")
 
 # Sources
 file(GLOB SRCS_G "src/*.cpp")
@@ -8,26 +9,39 @@ POCO_SOURCES_AUTO( SRCS ${SRCS_G})
 file(GLOB_RECURSE HDRS_G "include/*.h" )
 POCO_HEADERS_AUTO( SRCS ${HDRS_G})
 
-add_library( ${LIBNAME} ${LIB_MODE} ${SRCS} )
-set_target_properties( ${LIBNAME}
+add_library( "${LIBNAME}" ${LIB_MODE} ${SRCS} )
+add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}")
+set_target_properties( "${LIBNAME}"
     PROPERTIES
     VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
-    DEFINE_SYMBOL NetSSL_EXPORTS)
-target_link_libraries( ${LIBNAME} PocoCrypto PocoNet PocoUtil PocoFoundation ${OPENSSL_SSL_LIBRARY} ${OPENSSL_CRYPTO_LIBRARY} )
+    OUTPUT_NAME ${POCO_LIBNAME}
+    DEFINE_SYMBOL NetSSL_EXPORTS
+    )
 
+target_link_libraries( "${LIBNAME}" Crypto Net Util Foundation ${OPENSSL_SSL_LIBRARY} ${OPENSSL_CRYPTO_LIBRARY} )
+target_include_directories( "${LIBNAME}"
+    PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:include>
+    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
+    )
 install(
     DIRECTORY include/Poco
     DESTINATION include
+    COMPONENT Devel
     PATTERN ".svn" EXCLUDE
     )
 
 install(
-    TARGETS ${LIBNAME}
+    TARGETS "${LIBNAME}" EXPORT "${LIBNAME}Targets"
     LIBRARY DESTINATION lib${LIB_SUFFIX}
     ARCHIVE DESTINATION lib${LIB_SUFFIX}
     RUNTIME DESTINATION bin
+    INCLUDES DESTINATION include
     )
 
+POCO_GENERATE_PACKAGE("${LIBNAME}" "${LIBNAME}Targets" "lib/cmake/${PROJECT_NAME}")
+
 if (ENABLE_TESTS)
   add_subdirectory(samples)
   add_subdirectory(testsuite)

NetSSL_OpenSSL/cmake/PocoNetSSLConfig.cmake

@@ -0,0 +1,7 @@
+include(CMakeFindDependencyMacro)
+set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR})
+find_dependency(PocoFoundation)
+find_dependency(PocoUtil)
+find_dependency(PocoNet)
+find_dependency(PocoCrypto)
+include("${CMAKE_CURRENT_LIST_DIR}/PocoNetSSLTargets.cmake")

NetSSL_Win/CMakeLists.txt

@@ -0,0 +1,50 @@
+set(LIBNAME "NetSSLWin")
+set(POCO_LIBNAME "Poco${LIBNAME}")
+
+# Sources
+file(GLOB SRCS_G "src/*.cpp")
+POCO_SOURCES_AUTO( SRCS ${SRCS_G})
+
+# Headers
+file(GLOB_RECURSE HDRS_G "include/*.h" )
+POCO_HEADERS_AUTO( SRCS ${HDRS_G})
+
+add_library( "${LIBNAME}" ${LIB_MODE} ${SRCS} )
+add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}")
+set_target_properties( "${LIBNAME}"
+    PROPERTIES
+    VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
+    OUTPUT_NAME ${POCO_LIBNAME}
+    DEFINE_SYMBOL NetSSL_Win_EXPORTS
+    )
+
+target_link_libraries( "${LIBNAME}" Net Util Foundation Crypt32.lib )
+target_include_directories( "${LIBNAME}"
+    PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:include>
+    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
+    )
+install(
+    DIRECTORY include/Poco
+    DESTINATION include
+    COMPONENT Devel
+    PATTERN ".svn" EXCLUDE
+    )
+
+install(
+    TARGETS "${LIBNAME}" EXPORT "${LIBNAME}Targets"
+    LIBRARY DESTINATION lib${LIB_SUFFIX}
+    ARCHIVE DESTINATION lib${LIB_SUFFIX}
+    RUNTIME DESTINATION bin
+    INCLUDES DESTINATION include
+    )
+
+POCO_GENERATE_PACKAGE("${LIBNAME}" "${LIBNAME}Targets" "lib/cmake/${PROJECT_NAME}")
+
+if (ENABLE_TESTS)
+  #TODO: Looks like the samples use crypto somehow?
+  #add_subdirectory(samples)
+  #add_subdirectory(testsuite)
+endif ()
+

NetSSL_Win/cmake/PocoNetSSLWinConfig.cmake

@@ -0,0 +1,6 @@
+include(CMakeFindDependencyMacro)
+set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR})
+find_dependency(PocoFoundation)
+find_dependency(PocoUtil)
+find_dependency(PocoNet)
+include("${CMAKE_CURRENT_LIST_DIR}/PocoNetSSLWinTargets.cmake")

NetSSL_Win/testsuite/CMakeLists.txt

@@ -0,0 +1,33 @@
+set(TESTUNIT "${LIBNAME}-testrunner")
+
+# Sources
+file(GLOB SRCS_G "src/*.cpp")
+POCO_SOURCES_AUTO( TEST_SRCS ${SRCS_G})
+
+# Headers
+file(GLOB_RECURSE HDRS_G "src/*.h" )
+POCO_HEADERS_AUTO( TEST_SRCS ${HDRS_G})
+
+POCO_SOURCES_AUTO_PLAT( TEST_SRCS WIN32
+    src/WinDriver.cpp
+)
+
+POCO_SOURCES_AUTO_PLAT( TEST_SRCS WINCE
+    src/WinCEDriver.cpp
+)
+
+add_executable( ${TESTUNIT} ${TEST_SRCS} )
+add_test(NAME ${LIBNAME} WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} COMMAND ${TESTUNIT} -all)
+target_link_libraries( ${TESTUNIT} PocoNetSSL PocoCrypto PocoNet PocoUtil PocoXML PocoFoundation CppUnit)
+if( WIN32)
+    add_definitions("-D_AFXDLL")
+    target_link_libraries( ${TESTUNIT} WinTestRunner)
+endif(WIN32)
+
+# The test is run in the build directory. So the test data is copied there too
+add_custom_command(TARGET ${TESTUNIT} POST_BUILD
+                   COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/any.pem ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}
+                   COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/rootcert.pem ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}
+                   COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/testrunner.xml ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${TESTUNIT}.xml
+                   )
+

PDF/CMakeLists.txt

@@ -1,4 +1,5 @@
-set(LIBNAME "PocoPDF")
+set(LIBNAME "PDF")
+set(POCO_LIBNAME "Poco${LIBNAME}")
 
 # Sources
 file(GLOB SRCS_G "src/*.cpp")
@@ -110,28 +111,42 @@ POCO_SOURCES( SRCS libpng
     src/pngwutil.c
 )
 
+#TODO: Can we put this with the below includes? PRIVAT eg.
 include_directories( "include/Poco/PDF" ) # zip src
 
-add_library( ${LIBNAME} ${LIB_MODE} ${SRCS} )
-set_target_properties( ${LIBNAME}
+add_library( "${LIBNAME}" ${LIB_MODE} ${SRCS} )
+add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}")
+set_target_properties( "${LIBNAME}"
     PROPERTIES
     VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
-    DEFINE_SYMBOL PDF_EXPORTS)
-target_link_libraries( ${LIBNAME} ${SYSLIBS} PocoFoundation )
+    OUTPUT_NAME ${POCO_LIBNAME}
+    DEFINE_SYMBOL PDF_EXPORTS
+    )
 
+target_link_libraries( "${LIBNAME}" ${SYSLIBS} Foundation )
+target_include_directories( "${LIBNAME}"
+    PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:include>
+    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
+    )
 install(
     DIRECTORY include/Poco
     DESTINATION include
+    COMPONENT Devel
     PATTERN ".svn" EXCLUDE
     )
 
 install(
-    TARGETS ${LIBNAME}
+    TARGETS "${LIBNAME}" EXPORT "${LIBNAME}Targets"
     LIBRARY DESTINATION lib${LIB_SUFFIX}
     ARCHIVE DESTINATION lib${LIB_SUFFIX}
     RUNTIME DESTINATION bin
+    INCLUDES DESTINATION include
     )
 
+POCO_GENERATE_PACKAGE("${LIBNAME}" "${LIBNAME}Targets" "lib/cmake/${PROJECT_NAME}")
+
 if (ENABLE_TESTS)
   add_subdirectory(samples)
   add_subdirectory(testsuite)

PDF/cmake/PocoPDFConfig.cmake

@@ -0,0 +1,4 @@
+include(CMakeFindDependencyMacro)
+set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR})
+find_dependency(PocoFoundation)
+include("${CMAKE_CURRENT_LIST_DIR}/PocoPDFTargets.cmake")

SevenZip/CMakeLists.txt

@@ -1,4 +1,5 @@
-set(LIBNAME "PocoSevenZip")
+set(LIBNAME "SevenZip")
+set(POCO_LIBNAME "Poco${LIBNAME}")
 
 # Sources
 file(GLOB SRCS_G "src/*.cpp")
@@ -49,28 +50,39 @@ POCO_SOURCES( SRCS 7z
 #    src/XzIn.c
 )
 
-include_directories( include )
-
-add_library( ${LIBNAME} ${LIB_MODE} ${SRCS} )
-set_target_properties( ${LIBNAME}
+add_library( "${LIBNAME}" ${LIB_MODE} ${SRCS} )
+add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}")
+set_target_properties( "${LIBNAME}"
     PROPERTIES
     VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
-    DEFINE_SYMBOL SevenZip_EXPORTS)
-target_link_libraries( ${LIBNAME} PocoUtil PocoXML PocoFoundation)
+    OUTPUT_NAME ${POCO_LIBNAME}
+    DEFINE_SYMBOL SevenZip_EXPORTS
+    )
 
+target_link_libraries( "${LIBNAME}" Util XML Foundation)
+target_include_directories( "${LIBNAME}"
+    PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:include>
+    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
+    )
 install(
     DIRECTORY include/Poco
     DESTINATION include
+    COMPONENT Devel
     PATTERN ".svn" EXCLUDE
     )
 
 install(
-    TARGETS ${LIBNAME}
+    TARGETS "${LIBNAME}" EXPORT "${LIBNAME}Targets"
     LIBRARY DESTINATION lib${LIB_SUFFIX}
     ARCHIVE DESTINATION lib${LIB_SUFFIX}
     RUNTIME DESTINATION bin
+    INCLUDES DESTINATION include
     )
 
+POCO_GENERATE_PACKAGE("${LIBNAME}" "${LIBNAME}Targets" "lib/cmake/${PROJECT_NAME}")
+
 if (ENABLE_TESTS)
   add_subdirectory(samples)
   # TODO: Add tests

SevenZip/cmake/PocoSevenZipConfig.cmake

@@ -0,0 +1,6 @@
+include(CMakeFindDependencyMacro)
+set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR})
+find_dependency(PocoFoundation)
+find_dependency(PocoXML)
+find_dependency(PocoUtil)
+include("${CMAKE_CURRENT_LIST_DIR}/PocoSevenZipTargets.cmake")

Util/CMakeLists.txt

@@ -1,4 +1,5 @@
-set(LIBNAME "PocoUtil")
+set(LIBNAME "Util")
+set(POCO_LIBNAME "Poco${LIBNAME}")
 
 # Sources
 file(GLOB SRCS_G "src/*.cpp")
@@ -14,28 +15,40 @@ POCO_SOURCES_AUTO_PLAT( SRCS WIN32
     src/WinService.cpp
 )
 
-include_directories( "include" )
-
-add_library( ${LIBNAME} ${LIB_MODE} ${SRCS} )
-set_target_properties( ${LIBNAME}
+add_library( "${LIBNAME}" ${LIB_MODE} ${SRCS} )
+add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}")
+set_target_properties( "${LIBNAME}"
     PROPERTIES
     VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
-    DEFINE_SYMBOL Util_EXPORTS)
-target_link_libraries( ${LIBNAME} PocoJSON PocoXML PocoFoundation)
+    OUTPUT_NAME ${POCO_LIBNAME}
+    DEFINE_SYMBOL Util_EXPORTS
+    )
+
+target_link_libraries( "${LIBNAME}" JSON XML Foundation)
+target_include_directories( "${LIBNAME}"
+    PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:include>
+    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
+    )
 
 install(
     DIRECTORY include/Poco
     DESTINATION include
+    COMPONENT Devel
     PATTERN ".svn" EXCLUDE
     )
 
 install(
-    TARGETS ${LIBNAME}
+    TARGETS "${LIBNAME}" EXPORT "${LIBNAME}Targets"
     LIBRARY DESTINATION lib${LIB_SUFFIX}
     ARCHIVE DESTINATION lib${LIB_SUFFIX}
     RUNTIME DESTINATION bin
+    INCLUDES DESTINATION include
     )
 
+POCO_GENERATE_PACKAGE("${LIBNAME}" "${LIBNAME}Targets" "lib/cmake/${PROJECT_NAME}")
+
 if (ENABLE_TESTS)
     add_subdirectory(samples)
     add_subdirectory(testsuite)

Util/cmake/PocoUtilConfig.cmake

@@ -0,0 +1,6 @@
+include(CMakeFindDependencyMacro)
+set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR})
+find_dependency(PocoFoundation)
+find_dependency(PocoXML)
+find_dependency(PocoJSON)
+include("${CMAKE_CURRENT_LIST_DIR}/PocoUtilTargets.cmake")

XML/CMakeLists.txt

@@ -1,4 +1,5 @@
-set(LIBNAME "PocoXML")
+set(LIBNAME "XML")
+set(POCO_LIBNAME "Poco${LIBNAME}")
 
 # Sources
 file(GLOB SRCS_G "src/*.cpp")
@@ -24,28 +25,47 @@ else()
     )
 endif (POCO_UNBUNDLED)
 
-add_definitions(-D_USRDLL -DXML_NS -DXML_DTD -DHAVE_EXPAT_CONFIG_H)
+if(WIN32)
+#TODO: Is XML_STATIC only required with Windows? What does it do?
+add_definitions(-DXML_STATIC -DXML_NS -DXML_DTD -DHAVE_EXPAT_CONFIG_H)
+else()
+add_definitions(-DXML_NS -DXML_DTD -DHAVE_EXPAT_CONFIG_H)
+endif()
 
-add_library( ${LIBNAME} ${LIB_MODE} ${SRCS} )
-set_target_properties( ${LIBNAME}
+add_library( "${LIBNAME}" ${LIB_MODE} ${SRCS} )
+add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}")
+set_target_properties( "${LIBNAME}"
     PROPERTIES
     VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
-    DEFINE_SYMBOL XML_EXPORTS)
-target_link_libraries( ${LIBNAME} ${SYSLIBS} PocoFoundation)
+    OUTPUT_NAME ${POCO_LIBNAME}
+    DEFINE_SYMBOL XML_EXPORTS
+    )
+
+target_link_libraries( "${LIBNAME}" ${SYSLIBS} Foundation)
+target_include_directories( "${LIBNAME}"
+    PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:include>
+    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
+    )
 
 install(
     DIRECTORY include/Poco
     DESTINATION include
+    COMPONENT Devel
     PATTERN ".svn" EXCLUDE
     )
 
 install(
-    TARGETS ${LIBNAME}
+    TARGETS "${LIBNAME}" EXPORT "${LIBNAME}Targets"
     LIBRARY DESTINATION lib${LIB_SUFFIX}
     ARCHIVE DESTINATION lib${LIB_SUFFIX}
     RUNTIME DESTINATION bin
+    INCLUDES DESTINATION include
     )
 
+POCO_GENERATE_PACKAGE("${LIBNAME}" "${LIBNAME}Targets" "lib/cmake/${PROJECT_NAME}")
+
 if (ENABLE_TESTS)
   add_subdirectory(samples)
   add_subdirectory(testsuite)

XML/cmake/PocoXMLConfig.cmake

@@ -0,0 +1,4 @@
+include(CMakeFindDependencyMacro)
+set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR})
+find_dependency(PocoFoundation)
+include("${CMAKE_CURRENT_LIST_DIR}/PocoXMLTargets.cmake")

Zip/CMakeLists.txt

@@ -1,4 +1,5 @@
-set(LIBNAME "PocoZip")
+set(LIBNAME "Zip")
+set(POCO_LIBNAME "Poco${LIBNAME}")
 
 # Sources
 file(GLOB SRCS_G "src/*.cpp")
@@ -8,26 +9,39 @@ POCO_SOURCES_AUTO( SRCS ${SRCS_G})
 file(GLOB_RECURSE HDRS_G "include/*.h" )
 POCO_HEADERS_AUTO( SRCS ${HDRS_G})
 
-add_library( ${LIBNAME} ${LIB_MODE} ${SRCS} )
-set_target_properties( ${LIBNAME} 
+add_library( "${LIBNAME}" ${LIB_MODE} ${SRCS} )
+add_library( "${POCO_LIBNAME}" ALIAS "${LIBNAME}")
+set_target_properties( "${LIBNAME}"
     PROPERTIES
     VERSION ${SHARED_LIBRARY_VERSION} SOVERSION ${SHARED_LIBRARY_VERSION}
-    DEFINE_SYMBOL Zip_EXPORTS)
-target_link_libraries( ${LIBNAME} PocoUtil PocoXML PocoFoundation)
+    OUTPUT_NAME ${POCO_LIBNAME}
+    DEFINE_SYMBOL Zip_EXPORTS
+    )
 
+target_link_libraries( "${LIBNAME}" Util XML Foundation)
+target_include_directories( "${LIBNAME}"
+    PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:include>
+    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
+    )
 install(
     DIRECTORY include/Poco
     DESTINATION include
+    COMPONENT Devel
     PATTERN ".svn" EXCLUDE
     )
 
 install(
-    TARGETS ${LIBNAME}
+    TARGETS "${LIBNAME}" EXPORT "${LIBNAME}Targets"
     LIBRARY DESTINATION lib${LIB_SUFFIX}
     ARCHIVE DESTINATION lib${LIB_SUFFIX}
     RUNTIME DESTINATION bin
+    INCLUDES DESTINATION include
     )
 
+POCO_GENERATE_PACKAGE("${LIBNAME}" "${LIBNAME}Targets" "lib/cmake/${PROJECT_NAME}")
+
 if (ENABLE_TESTS)
   add_subdirectory(samples)
   add_subdirectory(testsuite)

Zip/cmake/PocoZipConfig.cmake

@@ -0,0 +1,6 @@
+include(CMakeFindDependencyMacro)
+set(CMAKE_PREFIX_PATH ${CMAKE_CURRENT_LIST_DIR})
+find_dependency(PocoFoundation)
+find_dependency(PocoUtil)
+find_dependency(PocoXML)
+include("${CMAKE_CURRENT_LIST_DIR}/PocoZipTargets.cmake")

cmake/PocoConfig.cmake.in

@@ -0,0 +1,46 @@
+if (CMAKE_VERSION VERSION_LESS 2.8.9)
+    message(FATAL_ERROR "Poco requires at least CMake version 2.8.9")
+endif()
+
+if (NOT Poco_FIND_COMPONENTS)
+    set(Poco_NOT_FOUND_MESSAGE "The Poco package requires at least one component")
+    set(Poco_FOUND False)
+    return()
+endif()
+
+set(_Poco_FIND_PARTS_REQUIRED)
+if (Poco_FIND_REQUIRED)
+    set(_Poco_FIND_PARTS_REQUIRED REQUIRED)
+endif()
+set(_Poco_FIND_PARTS_QUIET)
+if (Poco_FIND_QUIETLY)
+    set(_Poco_FIND_PARTS_QUIET QUIET)
+endif()
+
+get_filename_component(_Poco_install_prefix "${CMAKE_CURRENT_LIST_DIR}" ABSOLUTE)
+
+set(_Poco_NOTFOUND_MESSAGE)
+
+foreach(module ${Poco_FIND_COMPONENTS})
+    find_package(Poco${module}
+        ${_Poco_FIND_PARTS_QUIET}
+        ${_Poco_FIND_PARTS_REQUIRED}
+        PATHS "${_Poco_install_prefix}" NO_DEFAULT_PATH
+    )
+    if (NOT Poco${module}_FOUND)
+        if (Poco_FIND_REQUIRED_${module})
+            set(_Poco_NOTFOUND_MESSAGE "${_Poco_NOTFOUND_MESSAGE}Failed to find Poco component \"${module}\" config file at \"${_Poco_install_prefix}/Poco${module}/Poco${module}Config.cmake\"\n")
+        elseif(NOT Poco_FIND_QUIETLY)
+            message(WARNING "Failed to find Poco component \"${module}\" config file at \"${_Poco_install_prefix}/Poco${module}/Poco${module}Config.cmake\"")
+        endif()
+    endif()
+
+    # For backward compatibility set the LIBRARIES variable
+    list(APPEND Poco_LIBRARIES "Poco::${module}")
+endforeach()
+
+if (_Poco_NOTFOUND_MESSAGE)
+    set(Poco_NOT_FOUND_MESSAGE "${_Poco_NOTFOUND_MESSAGE}")
+    set(Poco_FOUND False)
+endif()
+

cmake/PocoConfigVersion.cmake.in

@@ -0,0 +1,11 @@
+set(PACKAGE_VERSION @APPLICATION_VERSION@)
+
+# Check whether the requested PACKAGE_FIND_VERSION is compatible
+if("${PACKAGE_VERSION}" VERSION_LESS "${PACKAGE_FIND_VERSION}")
+    set(PACKAGE_VERSION_COMPATIBLE FALSE)
+else()
+    set(PACKAGE_VERSION_COMPATIBLE TRUE)
+    if ("${PACKAGE_VERSION}" VERSION_EQUAL "${PACKAGE_FIND_VERSION}")
+        set(PACKAGE_VERSION_EXACT TRUE)
+    endif()
+endif()