From ad6877e19d425f4d45c7523b216c1deea398f08f Mon Sep 17 00:00:00 2001
From: Bruno Van de Velde <bruno@texus.me>
Date: Sun, 1 Apr 2018 15:38:13 +0200
Subject: [PATCH] Rewrote cmake scripts

---
 CMakeLists.txt                   | 246 +++++++++----------------------
 cmake/Config.cmake               |  39 ++---
 cmake/Macros.cmake               |  97 ++++++++++++
 cmake/TGUIConfig.cmake.in        |  95 ++++++++++++
 cmake/TGUIConfigVersion.cmake.in |  53 +++++++
 doc/CMakeLists.txt               |   4 +-
 examples/CMakeLists.txt          |  25 ++--
 gui-builder/CMakeLists.txt       |  10 +-
 include/TGUI/Config.hpp          |   2 +-
 src/TGUI/Android/CMakeLists.txt  |  24 +--
 src/TGUI/CMakeLists.txt          | 153 +++++++++++--------
 tests/CMakeLists.txt             |  26 ++--
 tests/cmake/CMakeLists.txt       |   8 +
 tests/cmake/main.cpp             |   7 +
 tests/travis_linux.sh            |  11 +-
 15 files changed, 481 insertions(+), 319 deletions(-)
 create mode 100644 cmake/Macros.cmake
 create mode 100644 cmake/TGUIConfig.cmake.in
 create mode 100644 cmake/TGUIConfigVersion.cmake.in
 create mode 100644 tests/cmake/CMakeLists.txt
 create mode 100644 tests/cmake/main.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index eb8613fd..4bcd6035 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,159 +1,85 @@
-# CMake's built-in Android support requires 3.7
 if(CMAKE_SYSTEM_NAME MATCHES "Android")
-    cmake_minimum_required(VERSION 3.7)
+    cmake_minimum_required(VERSION 3.7)  # CMake's built-in Android support requires 3.7
 else()
-    cmake_minimum_required(VERSION 2.8)
+    cmake_minimum_required(VERSION 3.5)  # Can be at most 3.5.1 as long as Ubuntu 16.04 is supported
 endif()
 
-# Define a macro that helps defining an option
-macro(tgui_set_option var default type docstring)
-    if(NOT DEFINED ${var})
-        set(${var} ${default})
-    endif()
-    set(${var} ${${var}} CACHE ${type} ${docstring} FORCE)
-endmacro()
-
-# Define a macro to add compiler flags
-macro(tgui_add_cxx_flag flag)
-    string(REGEX REPLACE "\\+" "\\\\+" escapedFlag ${flag})
-    if (NOT (${CMAKE_CXX_FLAGS} MATCHES ".*${escapedFlag}.*"))
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}" CACHE STRING "C++ compiler flags" FORCE)
-    endif()
-endmacro()
-
-# Use new RPATH behaviors on macOS
-if(NOT CMAKE_VERSION VERSION_LESS 3.0)
-    cmake_policy(SET CMP0042 NEW)
-endif()
-if (NOT CMAKE_VERSION VERSION_LESS 3.9)
+# Use new RPATH behavior on macOS
+if(NOT CMAKE_VERSION VERSION_LESS 3.9)
     cmake_policy(SET CMP0068 NEW)
 endif()
 
-macro(tgui_remove_cxx_flag flagToRemove)
-    string(REPLACE " " ";" TGUI_CXX_FLAGS_LIST ${CMAKE_CXX_FLAGS})
-    set(TGUI_TEMP_CXX_FLAGS "")
-    foreach (flag ${TGUI_CXX_FLAGS_LIST})
-        if (NOT (${flag} STREQUAL "${flagToRemove}"))
-            set(TGUI_TEMP_CXX_FLAGS "${TGUI_TEMP_CXX_FLAGS} ${flag}")
-        endif()
-    endforeach(flag)
-    set(CMAKE_CXX_FLAGS "${TGUI_TEMP_CXX_FLAGS}")
-endmacro()
+include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/Macros.cmake)
 
-# Set a default build type and module path if none was provided
+# Set a default build type
 tgui_set_option(CMAKE_BUILD_TYPE Release STRING "Choose the type of build (Debug or Release)")
 
 # Set CMAKE_MODULE_PATH to find SFML < 2.5 without manually having to specify a module path
-if ((NOT DEFINED SFML_DIR OR "${SFML_DIR}" STREQUAL "" OR "${SFML_DIR}" STREQUAL "SFML_DIR-NOTFOUND") AND NOT DEFINED CMAKE_MODULE_PATH)
+if(NOT SFML_DIR AND NOT CMAKE_MODULE_PATH)
     set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules")
 endif()
 
-# Project name
-project(tgui)
-
-# project version
-SET( MAJOR_VERSION 0 )
-SET( MINOR_VERSION 8 )
-SET( PATCH_VERSION 0 )
+# Project name and version
+project(TGUI VERSION 0.8.0 LANGUAGES CXX)
 
 # Include the configuration file
 include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/Config.cmake)
 
 # Add an option for choosing the build type (shared or static)
-if(NOT (SFML_OS_IOS OR SFML_OS_ANDROID))
+if(NOT TGUI_OS_IOS AND NOT TGUI_OS_ANDROID)
     tgui_set_option(TGUI_SHARED_LIBS TRUE BOOL "TRUE to build TGUI as a shared library, FALSE to build it as a static library")
 else()
-    if(SFML_OS_IOS)
+    if(TGUI_OS_IOS)
         set(TGUI_SHARED_LIBS FALSE)
-    elseif(SFML_OS_ANDROID)
+    elseif(TGUI_OS_ANDROID)
         set(TGUI_SHARED_LIBS TRUE)
     endif()
 endif()
 
 # Add option to build the examples
-if(SFML_OS_IOS OR SFML_OS_ANDROID)
-    set(TGUI_BUILD_EXAMPLES FALSE)
-else()
+if(NOT TGUI_OS_IOS AND NOT TGUI_OS_ANDROID)
     tgui_set_option(TGUI_BUILD_EXAMPLES FALSE BOOL "TRUE to build the TGUI examples, FALSE to ignore them")
+else()
+    set(TGUI_BUILD_EXAMPLES FALSE)
 endif()
 
 tgui_set_option(TGUI_BUILD_TESTS FALSE BOOL "TRUE to build the TGUI tests")
 tgui_set_option(TGUI_BUILD_GUI_BUILDER FALSE BOOL "TRUE to compile the GUI Builder")
 tgui_set_option(TGUI_BUILD_DOC FALSE BOOL "TRUE to generate the API documentation, FALSE to ignore it")
 
-# Set compile flags for gcc and clang
-if (SFML_OS_ANDROID)
-    tgui_remove_cxx_flag(-fno-exceptions)
-    tgui_remove_cxx_flag(-fno-rtti)
+# Define the install directory for miscellaneous files
+if(TGUI_OS_WINDOWS OR TGUI_OS_IOS)
+    set(DEFAULT_INSTALL_MISC_DIR .)
+elseif(TGUI_OS_LINUX OR TGUI_OS_FREEBSD)
+    set(DEFAULT_INSTALL_MISC_DIR share/tgui-${TGUI_VERSION_MAJOR}.${TGUI_VERSION_MINOR})
+elseif(TGUI_OS_MACOSX)
+    set(DEFAULT_INSTALL_MISC_DIR /usr/local/share/tgui-${TGUI_VERSION_MAJOR}.${TGUI_VERSION_MINOR})
+elseif(TGUI_OS_ANDROID)
+    set(DEFAULT_INSTALL_MISC_DIR ${CMAKE_ANDROID_NDK}/sources/third_party/tgui)
+endif()
+tgui_set_option(TGUI_MISC_INSTALL_PREFIX "${DEFAULT_INSTALL_MISC_DIR}" PATH "Prefix installation path for miscellaneous files")
+mark_as_advanced(TGUI_MISC_INSTALL_PREFIX)
 
-    # TGUI was only successfully tested on Android with NDK 12b, which did not work when -std=c++1y (or -std=c++14) is defined
-    tgui_add_cxx_flag(-std=c++11)
-
-    tgui_add_cxx_flag(-fexceptions)
-    tgui_add_cxx_flag(-frtti)
-
-    set(TGUI_ACTIVITY_CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
-
-elseif(SFML_COMPILER_GCC OR SFML_COMPILER_CLANG)
-    tgui_add_cxx_flag(-Wall)
-    tgui_add_cxx_flag(-Wextra)
-    tgui_add_cxx_flag(-Wshadow)
-    tgui_add_cxx_flag(-Wno-long-long)
-    tgui_add_cxx_flag(-pedantic)
-
-    tgui_remove_cxx_flag(-std=c++14)
-    tgui_remove_cxx_flag(-std=gnu++14)
-    tgui_remove_cxx_flag(-std=c++17)
-
-    if (TGUI_USE_CPP17)
-        tgui_add_cxx_flag(-std=c++17)
-        message(WARNING "The library is being build with c++17 features. Keep in mind that you MUST define TGUI_USE_CPP17 in the project using the library as well.")
-    else()
-        if (SFML_COMPILER_GCC AND SFML_OS_WINDOWS)
-            # gnu++14 instead of c++14 because TDM-GCC 5.1 did not declare _fullpath without enabling GNU extensions (other tested MinGW versions did not require it)
-            tgui_add_cxx_flag(-std=gnu++14)
-        else()
-            # The -std=c++14 flag was added in GCC 4.9 and Clang 3.5
-            tgui_add_cxx_flag(-std=c++14)
-        endif()
-    endif()
-
-    # On mac, clang needs another parameter
-    if (SFML_COMPILER_CLANG AND SFML_OS_MACOSX)
-        tgui_add_cxx_flag(-stdlib=libc++)
-    endif()
+if(TGUI_USE_CPP17)
+    message(WARNING "The library is being build with c++17 features. Keep in mind that you MUST define TGUI_USE_CPP17 in the project using the library as well.")
 endif()
 
 # Define an option for choosing between static and dynamic C runtime (VC++ only)
-if (SFML_OS_WINDOWS)
+if(TGUI_OS_WINDOWS)
     tgui_set_option(TGUI_USE_STATIC_STD_LIBS FALSE BOOL "TRUE to statically link to the standard libraries, FALSE to use them as DLLs. This option has to match with the one from sfml.")
 
     # The following combination of flags is not valid
-    if (TGUI_SHARED_LIBS AND TGUI_USE_STATIC_STD_LIBS)
+    if(TGUI_SHARED_LIBS AND TGUI_USE_STATIC_STD_LIBS)
         message(FATAL_ERROR "TGUI_SHARED_LIBS and TGUI_USE_STATIC_STD_LIBS cannot be used together")
     endif()
-
-    # Apply it globally by modifying the compiler flags
-    if(SFML_COMPILER_MSVC AND TGUI_USE_STATIC_STD_LIBS)
-        foreach(flag
-                CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
-                CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
-            if(${flag} MATCHES "/MD")
-                string(REGEX REPLACE "/MD" "/MT" ${flag} "${${flag}}")
-            endif()
-        endforeach()
-    endif()
 endif()
 
 # Mac OS X specific options
-if (SFML_OS_MACOSX)
+if(TGUI_OS_MACOSX)
 
     # Add an option to build framework instead of dylib (release only)
     tgui_set_option(TGUI_BUILD_FRAMEWORK FALSE BOOL "TRUE to build TGUI as a framework library (release only), FALSE to build according to TGUI_SHARED_LIBS")
 
-    # Add an option to let the user specify a custom directory for framework installation
-    tgui_set_option(CMAKE_INSTALL_FRAMEWORK_PREFIX "/Library/Frameworks" STRING "Frameworks installation directory")
-
     # Only the default architecture (i.e. 64-bit) is supported
     if(CMAKE_OSX_ARCHITECTURES AND NOT "${CMAKE_OSX_ARCHITECTURES}" STREQUAL "x86_64")
         message(FATAL_ERROR "Only 64-bit architecture is supported")
@@ -163,15 +89,15 @@ if (SFML_OS_MACOSX)
     # Enable to use of rpath according to CMake Policy CMP0042
     set(CMAKE_MACOSX_RPATH 1)
 
-    if (TGUI_BUILD_FRAMEWORK)
-        # Frameworks are only available for release (because cmake currently doesn't allow specifying a custom framework name so XXX-d is not possible)
+    if(TGUI_BUILD_FRAMEWORK)
+        # Frameworks are only available for release (because cmake currently doesn't allow specifying a custom framework name so TGUI-d is not possible)
         if(NOT CMAKE_BUILD_TYPE STREQUAL "Release")
             message(FATAL_ERROR "CMAKE_BUILD_TYPE should be \"Release\" when TGUI_BUILD_FRAMEWORK is TRUE")
             return()
         endif()
 
         # Frameworks only work with TGUI_SHARED_LIBS enabled
-        if (NOT TGUI_SHARED_LIBS)
+        if(NOT TGUI_SHARED_LIBS)
             message(FATAL_ERROR "TGUI_SHARED_LIBS should be TRUE when TGUI_BUILD_FRAMEWORK is TRUE")
             return()
         endif()
@@ -179,10 +105,10 @@ if (SFML_OS_MACOSX)
 endif()
 
 # Android options
-if(SFML_OS_ANDROID)
+if(TGUI_OS_ANDROID)
 
     # Make sure there's the android library available
-    if (CMAKE_ANDROID_API LESS 19)
+    if(CMAKE_ANDROID_API LESS 19)
         message(FATAL_ERROR "Android API level (${CMAKE_ANDROID_API}) must be equal or greater than 19.")
     endif()
 
@@ -198,9 +124,8 @@ if(SFML_OS_ANDROID)
     set(LIB_SUFFIX "/${CMAKE_ANDROID_ARCH_ABI}")
 
     # Pass shared STL configuration (if any)
-    if (CMAKE_ANDROID_STL_TYPE MATCHES "_shared")
-        add_definitions("-DSTL_LIBRARY=${CMAKE_ANDROID_STL_TYPE}")
-        if (NOT CMAKE_ANDROID_STL_TYPE MATCHES "c\\+\\+_shared")
+    if(CMAKE_ANDROID_STL_TYPE MATCHES "_shared")
+        if(NOT CMAKE_ANDROID_STL_TYPE MATCHES "c\\+\\+_shared")
             message("Android: Using ${CMAKE_ANDROID_STL_TYPE} as STL. Set CMAKE_ANDROID_STL_TYPE to c++_shared, if there are any issues.")
         endif()
     else()
@@ -209,8 +134,8 @@ if(SFML_OS_ANDROID)
 endif()
 
 # Link SFML in the same way as TGUI, unless SFML_STATIC_LIBRARIES is manually specified
-if (NOT DEFINED SFML_STATIC_LIBRARIES)
-  if (TGUI_SHARED_LIBS)
+if(NOT DEFINED SFML_STATIC_LIBRARIES)
+  if(TGUI_SHARED_LIBS)
     set(SFML_STATIC_LIBRARIES FALSE)
   else()
     set(SFML_STATIC_LIBRARIES TRUE)
@@ -219,104 +144,72 @@ endif()
 
 # Attempt to find the SFML dependencies when linking statically
 if(NOT TGUI_SHARED_LIBS)
-    if (SFML_ROOT)
-        if (SFML_OS_WINDOWS)
+    if(SFML_ROOT)
+        if(TGUI_OS_WINDOWS)
             set(CMAKE_INCLUDE_PATH ${CMAKE_INCLUDE_PATH} "${SFML_ROOT}/extlibs/headers")
             if(ARCH_32BITS)
-                if(SFML_COMPILER_MSVC AND MSVC_VERSION LESS 1900) # older than VC++14
+                if(TGUI_COMPILER_MSVC AND MSVC_VERSION LESS 1900) # older than VC++14
                     set(CMAKE_LIBRARY_PATH ${CMAKE_LIBRARY_PATH} "${SFML_ROOT}/extlibs/libs-msvc/x86")
-                elseif(SFML_COMPILER_MSVC) # VC++14 or newer
+                elseif(TGUI_COMPILER_MSVC) # VC++14 or newer
                     set(CMAKE_LIBRARY_PATH ${CMAKE_LIBRARY_PATH} "${SFML_ROOT}/extlibs/libs-msvc-universal/x86")
                 else() # gcc
                     set(CMAKE_LIBRARY_PATH ${CMAKE_LIBRARY_PATH} "${SFML_ROOT}/extlibs/libs-mingw/x86")
                 endif()
             elseif(ARCH_64BITS)
-                if(SFML_COMPILER_MSVC AND MSVC_VERSION LESS 1900) # older than VC++14
+                if(TGUI_COMPILER_MSVC AND MSVC_VERSION LESS 1900) # older than VC++14
                     set(CMAKE_LIBRARY_PATH ${CMAKE_LIBRARY_PATH} "${SFML_ROOT}/extlibs/libs-msvc/x64")
-                elseif(SFML_COMPILER_MSVC) # VC++14 or newer
+                elseif(TGUI_COMPILER_MSVC) # VC++14 or newer
                     set(CMAKE_LIBRARY_PATH ${CMAKE_LIBRARY_PATH} "${SFML_ROOT}/extlibs/libs-msvc-universal/x64")
                 else() # gcc
                     set(CMAKE_LIBRARY_PATH ${CMAKE_LIBRARY_PATH} "${SFML_ROOT}/extlibs/libs-mingw/x64")
                 endif()
             endif()
-        elseif(SFML_OS_MACOSX)
+        elseif(TGUI_OS_MACOSX)
             set(CMAKE_INCLUDE_PATH ${CMAKE_INCLUDE_PATH} "${SFML_ROOT}/extlibs/headers")
             set(CMAKE_LIBRARY_PATH ${CMAKE_LIBRARY_PATH} "${SFML_ROOT}/extlibs/libs-osx/lib/")
-        elseif(SFML_OS_ANDROID)
+        elseif(TGUI_OS_ANDROID)
             set(CMAKE_LIBRARY_PATH ${CMAKE_LIBRARY_PATH} "${CMAKE_ANDROID_NDK}/sources/third_party/sfml/extlibs/lib/${CMAKE_ANDROID_ARCH_ABI}/")
-        elseif(SFML_OS_IOS)
+        elseif(TGUI_OS_IOS)
             set(CMAKE_LIBRARY_PATH ${CMAKE_LIBRARY_PATH} "${SFML_ROOT}/extlibs/libs-ios/")
         endif()
     endif()
 endif()
 
 # Find sfml
-if (SFML_OS_WINDOWS AND SFML_COMPILER_MSVC) # Also look for the main component when using Visual Studio
+if(TGUI_OS_WINDOWS AND TGUI_COMPILER_MSVC) # Also look for the main component when using Visual Studio
     find_package(SFML 2 COMPONENTS main graphics window system)
-elseif (SFML_OS_IOS)  # Use the find_host_package macro from the toolchain on iOS
+elseif(TGUI_OS_IOS)  # Use the find_host_package macro from the toolchain on iOS
     find_host_package(SFML 2 COMPONENTS graphics window system)
 else()
     find_package(SFML 2 COMPONENTS graphics window system)
 endif()
 
-# FindSFML couldn't find SFML
-if (NOT SFML_FOUND)
+# find_package couldn't find SFML
+if(NOT SFML_FOUND)
     set(SFML_DIR "" CACHE PATH "Path to SFMLConfig.cmake")
     set(SFML_ROOT "" CACHE PATH "SFML root directory")
     message(FATAL_ERROR "CMake couldn't find SFML.\nEither set SFML_DIR to the directory containing SFMLConfig.cmake or set the SFML_ROOT entry to SFML's root directory (containing \"include\" and \"lib\" directories).")
 endif()
 
 # Set the path for the libraries
-set( LIBRARY_OUTPUT_PATH "${PROJECT_BINARY_DIR}/lib" )
-
-# Add the sfml and tgui include directories
-include_directories( "${PROJECT_SOURCE_DIR}/include" )
-include_directories( ${SFML_INCLUDE_DIR} )
-
-if (DEFINED SFML_LIBRARIES)
-    # SFML found via FindSFML.cmake
-    set(TGUI_EXT_LIBS ${SFML_LIBRARIES} ${SFML_DEPENDENCIES})
-else()
-    # SFML found via SFMLConfig.cmake
-    if (SFML_OS_WINDOWS AND SFML_COMPILER_MSVC)  # Also look for the main component when using Visual Studio
-        set(TGUI_EXT_LIBS sfml-main sfml-graphics sfml-window sfml-system)
-    else()
-        set(TGUI_EXT_LIBS sfml-graphics sfml-window sfml-system)
-    endif()
-endif()
-
-if(SFML_OS_ANDROID)
-    # We need to link to an extra library on android (to use the asset manager)
-    set(TGUI_EXT_LIBS ${TGUI_EXT_LIBS} "-landroid")
-endif()
-
-# Generate .gcno files when requested
-if (TGUI_BUILD_TESTS AND TGUI_USE_GCOV)
-    tgui_add_cxx_flag(-fprofile-arcs)
-    tgui_add_cxx_flag(-ftest-coverage)
-endif()
+set(LIBRARY_OUTPUT_PATH "${PROJECT_BINARY_DIR}/lib")
 
 # Jump to the CMakeLists.txt file in the source folder
 add_subdirectory(src/TGUI)
 
-# Install the themes on linux
-if (SFML_OS_LINUX)
-    install( DIRECTORY themes DESTINATION "${INSTALL_MISC_DIR}" )
-endif()
-
 # Build the documentation when requested
-if (TGUI_BUILD_DOC)
+if(TGUI_BUILD_DOC)
     add_subdirectory(doc)
 endif()
 
 # Build the examples if requested
-if (TGUI_BUILD_EXAMPLES)
+if(TGUI_BUILD_EXAMPLES)
     add_subdirectory(examples)
 endif()
 
 # Build the tests if requested
-if (TGUI_BUILD_TESTS)
-    if (NOT ${CMAKE_BUILD_TYPE} STREQUAL "Debug")
+if(TGUI_BUILD_TESTS)
+    if(NOT ${CMAKE_BUILD_TYPE} STREQUAL "Debug")
         message(FATAL_ERROR "TGUI_BUILD_TESTS should only be enabled when CMAKE_BUILD_TYPE is Debug")
     endif()
 
@@ -324,29 +217,30 @@ if (TGUI_BUILD_TESTS)
 endif()
 
 # Build the GUI Builder if requested
-if (TGUI_BUILD_GUI_BUILDER)
+if(TGUI_BUILD_GUI_BUILDER)
     add_subdirectory("${PROJECT_SOURCE_DIR}/gui-builder")
 endif()
 
 # Install include files
-if (NOT TGUI_BUILD_FRAMEWORK)
+if(NOT TGUI_BUILD_FRAMEWORK)
     install(DIRECTORY include
             DESTINATION .
             COMPONENT devel
             FILES_MATCHING PATTERN "*.hpp" PATTERN "*.inl")
 endif()
 
-# Install FindTGUI.cmake file
-if(NOT SFML_OS_ANDROID)
-    install(FILES cmake/Modules/FindTGUI.cmake DESTINATION "${INSTALL_MISC_DIR}/cmake/Modules")
+# Install miscellaneous files
+install(FILES license.txt DESTINATION ${TGUI_MISC_INSTALL_PREFIX})
+install(FILES README.md DESTINATION ${TGUI_MISC_INSTALL_PREFIX})
+install(DIRECTORY themes DESTINATION "${TGUI_MISC_INSTALL_PREFIX}")
+if(NOT TGUI_OS_ANDROID)
+    install(FILES cmake/Modules/FindTGUI.cmake DESTINATION "${TGUI_MISC_INSTALL_PREFIX}/cmake/Modules")
 endif()
 
 # Install Android.mk so the NDK knows how to set up TGUI
-if(SFML_OS_ANDROID)
+if(TGUI_OS_ANDROID)
     install(FILES Android.mk DESTINATION .)
 endif()
 
-# Fix CMake install rules broken for iOS (see http://public.kitware.com/Bug/view.php?id=12506)
-if(SFML_OS_IOS)
-    install(DIRECTORY "${CMAKE_BINARY_DIR}/lib/\$ENV{CONFIGURATION}/" DESTINATION lib${LIB_SUFFIX})
-endif()
+# Generate the TGUIConfig.cmake file
+tgui_export_target(TGUIConfigExport)
diff --git a/cmake/Config.cmake b/cmake/Config.cmake
index 59f112e3..a0987944 100644
--- a/cmake/Config.cmake
+++ b/cmake/Config.cmake
@@ -1,6 +1,6 @@
 # detect the OS
 if(${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
-    set(SFML_OS_WINDOWS 1)
+    set(TGUI_OS_WINDOWS 1)
 
     # detect the architecture (note: this test won't work for cross-compilation)
     include(CheckTypeSize)
@@ -14,19 +14,19 @@ if(${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
         return()
     endif()
 elseif(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
-    set(SFML_OS_UNIX 1)
+    set(TGUI_OS_UNIX 1)
     if(ANDROID)
-        set(SFML_OS_ANDROID 1)
+        set(TGUI_OS_ANDROID 1)
     else()
-        set(SFML_OS_LINUX 1)
+        set(TGUI_OS_LINUX 1)
     endif()
 elseif(CMAKE_SYSTEM_NAME MATCHES "^k?FreeBSD$")
-    set(SFML_OS_FREEBSD 1)
+    set(TGUI_OS_FREEBSD 1)
 elseif(${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
     if(IOS)
-        set(SFML_OS_IOS 1)
+        set(TGUI_OS_IOS 1)
     else()
-        set(SFML_OS_MACOSX 1)
+        set(TGUI_OS_MACOSX 1)
 
         # detect OS X version. (use '/usr/bin/sw_vers -productVersion' to extract V from '10.V.x'.)
         EXEC_PROGRAM(/usr/bin/sw_vers ARGS -productVersion OUTPUT_VARIABLE MACOSX_VERSION_RAW)
@@ -37,7 +37,7 @@ elseif(${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
         endif()
     endif()
 elseif(${CMAKE_SYSTEM_NAME} STREQUAL "Android")
-    set(SFML_OS_ANDROID 1)
+    set(TGUI_OS_ANDROID 1)
 else()
     message(FATAL_ERROR "Unsupported operating system or environment")
     return()
@@ -49,32 +49,23 @@ endif()
 if(CMAKE_CXX_COMPILER MATCHES ".*clang[+][+]" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
    # CMAKE_CXX_COMPILER_ID is an internal CMake variable subject to change,
    # but there is no other way to detect CLang at the moment
-   set(SFML_COMPILER_CLANG 1)
+   set(TGUI_COMPILER_CLANG 1)
    execute_process(COMMAND "${CMAKE_CXX_COMPILER}" "--version" OUTPUT_VARIABLE CLANG_VERSION_OUTPUT)
-   string(REGEX REPLACE ".*clang version ([0-9]+\\.[0-9]+).*" "\\1" SFML_CLANG_VERSION "${CLANG_VERSION_OUTPUT}")
+   string(REGEX REPLACE ".*clang version ([0-9]+\\.[0-9]+).*" "\\1" TGUI_CLANG_VERSION "${CLANG_VERSION_OUTPUT}")
 elseif(CMAKE_COMPILER_IS_GNUCXX)
-    set(SFML_COMPILER_GCC 1)
+    set(TGUI_COMPILER_GCC 1)
     execute_process(COMMAND "${CMAKE_CXX_COMPILER}" "-dumpversion" OUTPUT_VARIABLE GCC_VERSION_OUTPUT)
-    string(REGEX REPLACE "([0-9]+\\.[0-9]+).*" "\\1" SFML_GCC_VERSION "${GCC_VERSION_OUTPUT}")
+    string(REGEX REPLACE "([0-9]+\\.[0-9]+).*" "\\1" TGUI_GCC_VERSION "${GCC_VERSION_OUTPUT}")
     execute_process(COMMAND "${CMAKE_CXX_COMPILER}" "--version" OUTPUT_VARIABLE GCC_COMPILER_VERSION)
-    string(REGEX MATCHALL ".*(tdm[64]*-[1-9]).*" SFML_COMPILER_GCC_TDM "${GCC_COMPILER_VERSION}")
+    string(REGEX MATCHALL ".*(tdm[64]*-[1-9]).*" TGUI_COMPILER_GCC_TDM "${GCC_COMPILER_VERSION}")
     execute_process(COMMAND "${CMAKE_CXX_COMPILER}" "-dumpmachine" OUTPUT_VARIABLE GCC_MACHINE)
     string(STRIP "${GCC_MACHINE}" GCC_MACHINE)
     if(GCC_MACHINE MATCHES ".*w64.*")
-        set(SFML_COMPILER_GCC_W64 1)
+        set(TGUI_COMPILER_GCC_W64 1)
     endif()
 elseif(MSVC)
-    set(SFML_COMPILER_MSVC 1)
+    set(TGUI_COMPILER_MSVC 1)
 else()
     message(FATAL_ERROR "Unsupported compiler")
     return()
 endif()
-
-# define the install directory for miscellaneous files
-if(SFML_OS_WINDOWS OR SFML_OS_IOS)
-    set(INSTALL_MISC_DIR .)
-elseif(SFML_OS_LINUX OR SFML_OS_FREEBSD OR SFML_OS_MACOSX)
-    set(INSTALL_MISC_DIR share/tgui-${MAJOR_VERSION}.${MINOR_VERSION})
-elseif(SFML_OS_ANDROID)
-    set(INSTALL_MISC_DIR ${CMAKE_ANDROID_NDK}/sources/third_party/tgui)
-endif()
diff --git a/cmake/Macros.cmake b/cmake/Macros.cmake
new file mode 100644
index 00000000..0f38fdb0
--- /dev/null
+++ b/cmake/Macros.cmake
@@ -0,0 +1,97 @@
+# Macro that helps defining an option
+macro(tgui_set_option var default type docstring)
+    if(NOT DEFINED ${var})
+        set(${var} ${default})
+    endif()
+    set(${var} ${${var}} CACHE ${type} ${docstring} FORCE)
+endmacro()
+
+# Set the compile options used by all targets
+function(tgui_set_global_compile_flags target)
+    if(TGUI_COMPILER_GCC OR TGUI_COMPILER_CLANG)
+        target_compile_options(${target} PRIVATE -Wall)
+        target_compile_options(${target} PRIVATE -Wextra)
+        target_compile_options(${target} PRIVATE -Wshadow)
+        target_compile_options(${target} PRIVATE -Wno-long-long)
+        target_compile_options(${target} PRIVATE -pedantic)
+
+        set_target_properties(${target} PROPERTIES CXX_STANDARD_REQUIRED ON)
+        set_target_properties(${target} PROPERTIES CXX_EXTENSIONS OFF)
+        if(TGUI_USE_CPP17)
+            set_target_properties(${target} PROPERTIES CXX_STANDARD 17)
+        else()
+            set_target_properties(${target} PROPERTIES CXX_STANDARD 14)
+        endif()
+    endif()
+endfunction()
+
+# Set the appropriate standard library on each platform for the given target
+function(tgui_set_stdlib target)
+    # Use libc++ on macOS
+    if(TGUI_OS_MACOSX)
+        if(${CMAKE_GENERATOR} MATCHES "Xcode")
+            set_property(TARGET ${target} PROPERTY XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++")
+        else()
+            target_compile_options(${target} PRIVATE "-stdlib=libc++")
+            target_link_libraries(${target} PRIVATE "-stdlib=libc++")
+        endif()
+    endif()
+
+    # Apply the TGUI_USE_STATIC_STD_LIBS option on windows
+    if(TGUI_OS_WINDOWS)
+        if(TGUI_COMPILER_MSVC AND TGUI_USE_STATIC_STD_LIBS)
+            foreach(flag
+                    CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
+                    CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
+                if(${flag} MATCHES "/MD")
+                    string(REGEX REPLACE "/MD" "/MT" ${flag} "${${flag}}")
+                endif()
+            endforeach()
+        elseif(TGUI_COMPILER_GCC)
+            if(TGUI_USE_STATIC_STD_LIBS AND NOT TGUI_COMPILER_GCC_TDM)
+                target_link_libraries(${target} PRIVATE "-static-libgcc" "-static-libstdc++")
+            elseif(NOT TGUI_USE_STATIC_STD_LIBS AND TGUI_COMPILER_GCC_TDM)
+                target_link_libraries(${target} PRIVATE "-shared-libgcc" "-shared-libstdc++")
+            endif()
+        endif()
+    endif()
+endfunction()
+
+# Generate a TGUIConfig.cmake file (and associated files)
+function(tgui_export_target export_name)
+    include(CMakePackageConfigHelpers)
+    if(CMAKE_VERSION VERSION_LESS 3.11)
+        set(CVF_VERSION ${TGUI_VERSION_MAJOR}.${TGUI_VERSION_MINOR}.${TGUI_VERSION_PATCH})
+        configure_file("${PROJECT_SOURCE_DIR}/cmake/TGUIConfigVersion.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/TGUIConfigVersion.cmake" @ONLY)
+    else()
+        write_basic_package_version_file("${CMAKE_CURRENT_BINARY_DIR}/TGUIConfigVersion.cmake"
+                                         VERSION ${TGUI_VERSION_MAJOR}.${TGUI_VERSION_MINOR}.${TGUI_VERSION_PATCH}
+                                         COMPATIBILITY SameMinorVersion)
+    endif()
+
+    if (TGUI_SHARED_LIBS)
+        set(targets_config_filename TGUISharedTargets.cmake)
+    else()
+        set(targets_config_filename TGUIStaticTargets.cmake)
+    endif()
+
+    export(EXPORT ${export_name}
+           FILE "${CMAKE_CURRENT_BINARY_DIR}/${targets_config_filename}")
+
+    if (TGUI_BUILD_FRAMEWORK)
+        set(config_package_location "TGUI.framework/Resources/CMake")
+    else()
+        set(config_package_location lib/cmake/TGUI)
+    endif()
+    configure_package_config_file("${PROJECT_SOURCE_DIR}/cmake/TGUIConfig.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/TGUIConfig.cmake"
+        INSTALL_DESTINATION "${config_package_location}")
+
+    install(EXPORT ${export_name}
+            FILE ${targets_config_filename}
+            DESTINATION ${config_package_location})
+
+    install(FILES "${CMAKE_CURRENT_BINARY_DIR}/TGUIConfig.cmake"
+                  "${CMAKE_CURRENT_BINARY_DIR}/TGUIConfigVersion.cmake"
+            DESTINATION ${config_package_location}
+            COMPONENT devel)
+endfunction()
diff --git a/cmake/TGUIConfig.cmake.in b/cmake/TGUIConfig.cmake.in
new file mode 100644
index 00000000..63e8a45f
--- /dev/null
+++ b/cmake/TGUIConfig.cmake.in
@@ -0,0 +1,95 @@
+# This script provides the TGUI libraries as imported targets
+# ===========================================================
+#
+# Usage
+# -----
+#
+# Examples:
+#   find_package(TGUI 0.8)
+#   find_package(TGUI 0.8 REQUIRED)
+#
+# By default, the dynamic libraries of TGUI will be found. To find the static ones instead,
+# you must set the TGUI_STATIC_LIBRARIES variable to TRUE before calling find_package(TGUI ...).
+# example:
+#   set(TGUI_STATIC_LIBRARIES TRUE)
+#   find_package(TGUI 0.8 REQUIRED)
+#
+# On macOS by default CMake will search for frameworks. If you want to use static libraries and have installed
+# both TGUI frameworks and TGUI static libraries, your must set CMAKE_FIND_FRAMEWORK to "NEVER" or "LAST"
+# in addition to setting TGUI_STATIC_LIBRARIES to TRUE. Otherwise CMake will check the frameworks bundle config and
+# fail after finding out that it does not provide static libraries. Please refer to CMake documentation for more details.
+#
+# Additionally, keep in mind that TGUI frameworks are only available as release libraries unlike dylibs which
+# are available for both release and debug modes.
+#
+# If TGUI is not installed in a standard path, you can use the TGUI_DIR CMake variable
+# to tell CMake where TGUI's config file is located (PREFIX/lib/cmake/TGUI for a library-based installation,
+# and PREFIX/TGUI.framework/Resources/CMake on macOS for a framework-based installation).
+#
+# Output
+# ------
+#
+# This script defines the following variable:
+# - TGUI_FOUND:        true if all the required modules are found
+#
+# And the following target:
+#   - tgui
+#
+# The TGUI target is the same for both Debug and Release build configurations and will automatically provide
+# correct settings based on your currently active build configuration. The TGUI target name also does not change
+# when using dynamic or static TGUI libraries.
+#
+# example:
+#   find_package(TGUI 0.8 REQUIRED)
+#   add_executable(myapp ...)
+#   target_link_libraries(myapp tgui)
+
+set(FIND_TGUI_PATHS
+    "${CMAKE_CURRENT_LIST_DIR}/../.."
+    ${TGUI_ROOT}
+    $ENV{TGUI_ROOT}
+    ~/Library/Frameworks
+    /Library/Frameworks
+    /usr/local
+    /usr
+    /sw
+    /opt/local
+    /opt/csw
+    /opt)
+
+# Choose which target definitions must be imported
+if (TGUI_STATIC_LIBRARIES)
+	set(TGUI_IS_FRAMEWORK_INSTALL "@TGUI_BUILD_FRAMEWORKS@")
+    if (TGUI_IS_FRAMEWORK_INSTALL)
+        message(WARNING "Static frameworks are not supported by TGUI. Clear TGUI_DIR cache entry, \
+and either change TGUI_STATIC_LIBRARIES or CMAKE_FIND_FRAMEWORK before calling find_package(TGUI)")
+    endif()
+    set(config_name "Static")
+else()
+    set(config_name "Shared")
+endif()
+set(targets_config_file "${CMAKE_CURRENT_LIST_DIR}/TGUI${config_name}Targets.cmake")
+
+# Generate imported targets for TGUI
+if (EXISTS "${targets_config_file}")
+    # Set TGUI_FOUND to TRUE by default, may be overwritten by one of the includes below
+    set(TGUI_FOUND TRUE)
+    include("${targets_config_file}")
+else()
+    set(FIND_TGUI_ERROR "Requested TGUI configuration (${config_name}) was not found")
+    set(TGUI_FOUND FALSE)
+endif()
+
+if (NOT TGUI_FOUND)
+    if(TGUI_FIND_REQUIRED)
+        # fatal error
+        message(FATAL_ERROR "${FIND_TGUI_ERROR}")
+    elseif(NOT TGUI_FIND_QUIETLY)
+        # error but continue
+        message(STATUS "${FIND_TGUI_ERROR}")
+    endif()
+endif()
+
+if (TGUI_FOUND AND NOT TGUI_FIND_QUIETLY)
+    message(STATUS "Found TGUI @TGUI_VERSION_MAJOR@.@TGUI_VERSION_MINOR@.@TGUI_VERSION_PATCH@ in ${CMAKE_CURRENT_LIST_DIR}")
+endif()
diff --git a/cmake/TGUIConfigVersion.cmake.in b/cmake/TGUIConfigVersion.cmake.in
new file mode 100644
index 00000000..8d4ec1eb
--- /dev/null
+++ b/cmake/TGUIConfigVersion.cmake.in
@@ -0,0 +1,53 @@
+# This file was taken from CMake 3.11 and is provided here in order to use it while using older CMake versions
+
+# # This is a basic version file for the Config-mode of find_package().
+# It is used by write_basic_package_version_file() as input file for configure_file()
+# to create a version-file which can be installed along a config.cmake file.
+#
+# The created file sets PACKAGE_VERSION_EXACT if the current version string and
+# the requested version string are exactly the same and it sets
+# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version,
+# but only if the requested major and minor versions are the same as the current
+# one.
+# The variable CVF_VERSION must be set before calling configure_file().
+
+
+set(PACKAGE_VERSION "@CVF_VERSION@")
+
+if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION)
+  set(PACKAGE_VERSION_COMPATIBLE FALSE)
+else()
+
+  if("@CVF_VERSION@" MATCHES "^([0-9]+)\\.([0-9]+)")
+    set(CVF_VERSION_MAJOR "${CMAKE_MATCH_1}")
+    set(CVF_VERSION_MINOR "${CMAKE_MATCH_2}")
+  else()
+    set(CVF_VERSION_MAJOR "@CVF_VERSION@")
+    set(CVF_VERSION_MINOR "")
+  endif()
+
+  if((PACKAGE_FIND_VERSION_MAJOR STREQUAL CVF_VERSION_MAJOR) AND
+     (PACKAGE_FIND_VERSION_MINOR STREQUAL CVF_VERSION_MINOR))
+    set(PACKAGE_VERSION_COMPATIBLE TRUE)
+  else()
+    set(PACKAGE_VERSION_COMPATIBLE FALSE)
+  endif()
+
+  if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION)
+      set(PACKAGE_VERSION_EXACT TRUE)
+  endif()
+endif()
+
+
+# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it:
+if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "@CMAKE_SIZEOF_VOID_P@" STREQUAL "")
+   return()
+endif()
+
+# check that the installed version has the same 32/64bit-ness as the one which is currently searching:
+if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "@CMAKE_SIZEOF_VOID_P@")
+  math(EXPR installedBits "@CMAKE_SIZEOF_VOID_P@ * 8")
+  set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)")
+  set(PACKAGE_VERSION_UNSUITABLE TRUE)
+endif()
+
diff --git a/doc/CMakeLists.txt b/doc/CMakeLists.txt
index f3236059..a4854ea4 100644
--- a/doc/CMakeLists.txt
+++ b/doc/CMakeLists.txt
@@ -48,10 +48,10 @@ add_custom_target(doc ALL
 
 # setup install rules
 install(DIRECTORY ${DOXYGEN_OUTPUT_DIR}/html
-        DESTINATION ${INSTALL_MISC_DIR}/doc
+        DESTINATION ${TGUI_MISC_INSTALL_PREFIX}/doc
         COMPONENT doc)
 if(DOXYGEN_HHC_PROGRAM)
     install(FILES ${DOXYGEN_OUTPUT_DIR}/tgui.chm
-            DESTINATION ${INSTALL_MISC_DIR}/doc
+            DESTINATION ${TGUI_MISC_INSTALL_PREFIX}/doc
             COMPONENT doc)
 endif()
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index 77dfa91f..72733d5c 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -5,27 +5,22 @@ macro(tgui_add_example target)
     # parse the arguments
     cmake_parse_arguments(THIS "" "" "SOURCES" ${ARGN})
 
-    # Make a GUI application on windows (so without the command line)
-    if(SFML_OS_WINDOWS)
+    # Make a GUI application on windows (without having the command line window)
+    if(TGUI_OS_WINDOWS)
         set(GUI_TYPE WIN32)
+        target_link_libraries(${target} PRIVATE sfml-main)
     endif()
 
-    add_executable(${target} ${THIS_SOURCES})
-    target_link_libraries(${target} ${PROJECT_NAME} ${TGUI_EXT_LIBS})
+    add_executable(${target} ${GUI_TYPE} ${THIS_SOURCES})
+    target_link_libraries(${target} PRIVATE tgui)
 
-    # for gcc >= 4.0 on Windows, apply the TGUI_USE_STATIC_STD_LIBS option if it is enabled
-    if(SFML_OS_WINDOWS AND SFML_COMPILER_GCC AND NOT SFML_GCC_VERSION VERSION_LESS "4")
-        if(TGUI_USE_STATIC_STD_LIBS AND NOT SFML_COMPILER_GCC_TDM)
-            set_target_properties(${target} PROPERTIES LINK_FLAGS "-static-libgcc -static-libstdc++")
-        elseif(NOT TGUI_USE_STATIC_STD_LIBS AND SFML_COMPILER_GCC_TDM)
-            set_target_properties(${target} PROPERTIES LINK_FLAGS "-shared-libgcc -shared-libstdc++")
-        endif()
-    endif()
+    tgui_set_global_compile_flags(${target})
+    tgui_set_stdlib(${target})
 
     # Add the install rule for the executable
     install(TARGETS ${target}
-            RUNTIME DESTINATION ${INSTALL_MISC_DIR}/examples/${target} COMPONENT examples
-            BUNDLE DESTINATION ${INSTALL_MISC_DIR}/examples/${target} COMPONENT examples)
+            RUNTIME DESTINATION ${TGUI_MISC_INSTALL_PREFIX}/examples/${target} COMPONENT examples
+            BUNDLE DESTINATION ${TGUI_MISC_INSTALL_PREFIX}/examples/${target} COMPONENT examples)
 
 endmacro()
 
@@ -35,5 +30,5 @@ add_subdirectory(scalable_login_screen)
 
 # install the examples
 install(DIRECTORY "${CMAKE_SOURCE_DIR}/examples/"
-        DESTINATION "${INSTALL_MISC_DIR}/examples/"
+        DESTINATION "${TGUI_MISC_INSTALL_PREFIX}/examples/"
         COMPONENT examples)
diff --git a/gui-builder/CMakeLists.txt b/gui-builder/CMakeLists.txt
index fa1746fa..0f53c0e4 100644
--- a/gui-builder/CMakeLists.txt
+++ b/gui-builder/CMakeLists.txt
@@ -10,8 +10,14 @@ set(GUI_BUILDER_SOURCES
     include/WidgetProperties.hpp
 )
 
-add_executable(gui-builder ${GUI_BUILDER_SOURCES})
-target_link_libraries(gui-builder ${PROJECT_NAME} ${TGUI_EXT_LIBS})
+# Make a GUI application on windows (without having the command line window)
+if(TGUI_OS_WINDOWS)
+    set(GUI_TYPE WIN32)
+    target_link_libraries(gui-builder PRIVATE sfml-main)
+endif()
+
+add_executable(gui-builder ${GUI_TYPE} ${GUI_BUILDER_SOURCES})
+target_link_libraries(gui-builder PRIVATE tgui)
 target_include_directories(gui-builder PRIVATE include)
 
 # Copy the executable to the gui-builder folder
diff --git a/include/TGUI/Config.hpp b/include/TGUI/Config.hpp
index c27c3aa2..5e56b011 100644
--- a/include/TGUI/Config.hpp
+++ b/include/TGUI/Config.hpp
@@ -39,7 +39,7 @@
     #ifdef SFML_SYSTEM_WINDOWS
 
         // Windows compilers need specific (and different) keywords for export and import
-        #ifdef tgui_EXPORTS
+        #ifdef TGUI_EXPORTS
             #define TGUI_API __declspec(dllexport)
         #else
             #define TGUI_API __declspec(dllimport)
diff --git a/src/TGUI/Android/CMakeLists.txt b/src/TGUI/Android/CMakeLists.txt
index c06d301f..f756bc79 100644
--- a/src/TGUI/Android/CMakeLists.txt
+++ b/src/TGUI/Android/CMakeLists.txt
@@ -4,29 +4,21 @@ add_library(tgui-activity SHARED TGUIActivity.cpp)
 # Define the export symbol of the module
 string(REPLACE "-" "_" NAME_UPPER "tgui-activity")
 string(TOUPPER "${NAME_UPPER}" NAME_UPPER)
-set_target_properties(tgui-activity PROPERTIES DEFINE_SYMBOL ${NAME_UPPER}_EXPORTS)
+target_compile_definitions(tgui-activity PRIVATE ${NAME_UPPER}_EXPORTS)
 
 # Add a -d suffix when in debug mode
 set_target_properties(tgui-activity PROPERTIES DEBUG_POSTFIX -d)
 
-# If using gcc >= 4.0 or clang >= 3.0 on a non-Windows platform, we must hide public symbols by default (exported ones are explicitly marked)
-if((SFML_COMPILER_GCC AND NOT SFML_GCC_VERSION VERSION_LESS "4") OR (SFML_COMPILER_CLANG AND NOT SFML_CLANG_VERSION VERSION_LESS "3"))
-    set_target_properties(tgui-activity PROPERTIES COMPILE_FLAGS -fvisibility=hidden)
+# Hide public symbols by default (exported ones are explicitly marked)
+if(TGUI_COMPILER_GCC OR TGUI_COMPILER_CLANG)
+    target_compile_options(tgui-activity PRIVATE -fvisibility=hidden)
 endif()
 
-# tgui-activity library is our bootstrap activity and must not depend on stlport_shared (otherwise Android will fail to load it)
-if (SFML_OS_ANDROID)
-    set_target_properties(tgui-activity PROPERTIES COMPILE_FLAGS -fpermissive)
-    set_target_properties(tgui-activity PROPERTIES LINK_FLAGS "-landroid -llog")
+tgui_set_global_compile_flags(tgui-activity)
+target_compile_definitions(tgui-activity PRIVATE STL_LIBRARY=${CMAKE_ANDROID_STL_TYPE})
+target_compile_options(tgui-activity PRIVATE -fpermissive)
+target_link_libraries(tgui-activity PRIVATE android log)
 
-    # Restore the original compiler flags
-    set(CMAKE_CXX_FLAGS "${TGUI_ACTIVITY_CMAKE_CXX_FLAGS}" CACHE STRING "C++ compiler flags" FORCE)
-
-    # This is a workaround to compile tgui-activity without stlport_shared as dependency
-    set(CMAKE_CXX_CREATE_SHARED_LIBRARY "<CMAKE_CXX_COMPILER> <CMAKE_SHARED_LIBRARY_CXX_FLAGS> <LANGUAGE_COMPILE_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS> <SONAME_FLAG><TARGET_SONAME> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>")
-endif()
-
-# Install rule
 install(TARGETS tgui-activity
         RUNTIME DESTINATION bin COMPONENT bin
         LIBRARY DESTINATION lib${LIB_SUFFIX} COMPONENT bin
diff --git a/src/TGUI/CMakeLists.txt b/src/TGUI/CMakeLists.txt
index 90248241..7d96fee3 100644
--- a/src/TGUI/CMakeLists.txt
+++ b/src/TGUI/CMakeLists.txt
@@ -82,16 +82,16 @@ set(TGUI_SRC
     Widgets/VerticalLayout.cpp
 )
 
-if (TGUI_OPTIMIZE_SINGLE_BUILD)
+if(TGUI_OPTIMIZE_SINGLE_BUILD)
     list(LENGTH TGUI_SRC fileCount)
-    if (TGUI_OPTIMIZE_SINGLE_BUILD_THREADS)
+    if(TGUI_OPTIMIZE_SINGLE_BUILD_THREADS)
         set(threads ${TGUI_OPTIMIZE_SINGLE_BUILD_THREADS})
     else()
         include(ProcessorCount)
         ProcessorCount(threads)
     endif()
 
-    if (${threads} LESS ${fileCount})
+    if(${threads} LESS ${fileCount})
         math(EXPR threads "(${threads} / 2) + 1")
         math(EXPR fileCountMinusOne "${fileCount} - 1")
         math(EXPR threadsMinusOne "${threads} - 1")
@@ -108,110 +108,133 @@ if (TGUI_OPTIMIZE_SINGLE_BUILD)
             endforeach()
         endforeach()
 
-        if (SFML_COMPILER_MSVC)
-            add_compile_options("/bigobj")
-        endif()
-
         set(TGUI_SRC ${NEW_TGUI_SRC})
     endif()
 endif()
 
 # Determine library suffixes depending on static/shared configuration
 if(TGUI_SHARED_LIBS)
-    add_library(${PROJECT_NAME} SHARED ${TGUI_SRC})
-    set_target_properties( ${PROJECT_NAME} PROPERTIES DEBUG_POSTFIX -d )
+    add_library(tgui SHARED ${TGUI_SRC})
+    set_target_properties(tgui PROPERTIES DEFINE_SYMBOL TGUI_EXPORTS)
+    set_target_properties(tgui PROPERTIES DEBUG_POSTFIX -d)
 
     # Set the version and soversion of the target (for compatible systems -- mostly Linuxes)
     # Except for Android which strips soversion suffixes
-    if(NOT SFML_OS_ANDROID)
-        set_target_properties(${PROJECT_NAME} PROPERTIES SOVERSION ${MAJOR_VERSION}.${MINOR_VERSION}.${PATCH_VERSION})
-        set_target_properties(${PROJECT_NAME} PROPERTIES VERSION ${MAJOR_VERSION}.${MINOR_VERSION}.${PATCH_VERSION})
+    if(NOT TGUI_OS_ANDROID)
+        set_target_properties(tgui PROPERTIES SOVERSION ${TGUI_VERSION_MAJOR}.${TGUI_VERSION_MINOR}.${TGUI_VERSION_PATCH})
+        set_target_properties(tgui PROPERTIES VERSION ${TGUI_VERSION_MAJOR}.${TGUI_VERSION_MINOR}.${TGUI_VERSION_PATCH})
     endif()
 
-    # The library should be linked to sfml, unless you are on linux
-    if (NOT SFML_OS_LINUX)
-        target_link_libraries( ${PROJECT_NAME} ${TGUI_EXT_LIBS} )
-
-        # on Windows/gcc get rid of "lib" prefix for shared libraries,
-        # and transform the ".dll.a" suffix into ".a" for import libraries
-        if (SFML_OS_WINDOWS AND SFML_COMPILER_GCC)
-            set_target_properties(${PROJECT_NAME} PROPERTIES PREFIX "")
-            set_target_properties(${PROJECT_NAME} PROPERTIES IMPORT_SUFFIX ".a")
-        endif()
+    # on Windows/gcc get rid of "lib" prefix for shared libraries,
+    # and transform the ".dll.a" suffix into ".a" for import libraries
+    if(TGUI_OS_WINDOWS AND TGUI_COMPILER_GCC)
+        set_target_properties(tgui PROPERTIES PREFIX "")
+        set_target_properties(tgui PROPERTIES IMPORT_SUFFIX ".a")
     endif()
 
 else()
-    add_library(${PROJECT_NAME} STATIC ${TGUI_SRC})
-    set_target_properties(${PROJECT_NAME} PROPERTIES DEBUG_POSTFIX -s-d)
-    set_target_properties(${PROJECT_NAME} PROPERTIES RELEASE_POSTFIX -s)
-    set_target_properties(${PROJECT_NAME} PROPERTIES MINSIZEREL_POSTFIX -s)
-    set_target_properties(${PROJECT_NAME} PROPERTIES RELWITHDEBINFO_POSTFIX -s)
+    add_library(tgui STATIC ${TGUI_SRC})
+    set_target_properties(tgui PROPERTIES DEBUG_POSTFIX -s-d)
+    set_target_properties(tgui PROPERTIES RELEASE_POSTFIX -s)
+    set_target_properties(tgui PROPERTIES MINSIZEREL_POSTFIX -s)
+    set_target_properties(tgui PROPERTIES RELWITHDEBINFO_POSTFIX -s)
+endif()
+
+tgui_set_global_compile_flags(tgui)
+tgui_set_stdlib(tgui)
+
+if(TGUI_OPTIMIZE_SINGLE_BUILD AND TGUI_COMPILER_MSVC)
+    target_compile_options(tgui PRIVATE /bigobj)
+endif()
+
+# Add <project>/include as public include directory
+target_include_directories(tgui PUBLIC $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>)
+if (TGUI_BUILD_FRAMEWORK)
+    target_include_directories(tgui INTERFACE $<INSTALL_INTERFACE:TGUI.framework>)
+else()
+    target_include_directories(tgui INTERFACE $<INSTALL_INTERFACE:include>)
+endif()
+
+# Link to SFML
+if(DEFINED SFML_LIBRARIES)
+    # SFML found via FindSFML.cmake
+    target_include_directories(tgui PUBLIC ${SFML_INCLUDE_DIR})
+    target_link_libraries(tgui PUBLIC ${SFML_LIBRARIES} ${SFML_DEPENDENCIES})
+else()
+    # SFML found via SFMLConfig.cmake
+    target_link_libraries(tgui PUBLIC sfml-graphics)
+endif()
+
+# define TGUI_USE_CPP17 if requested
+if(TGUI_USE_CPP17)
+    target_compile_definitions(tgui PUBLIC TGUI_USE_CPP17)
+endif()
+
+# We need to link to an extra library on android (to use the asset manager)
+if(TGUI_OS_ANDROID)
+    target_link_libraries(tgui PRIVATE android)
+endif()
+
+# Generate .gcno files when requested
+if(TGUI_BUILD_TESTS AND TGUI_USE_GCOV)
+    target_compile_options(tgui PRIVATE -fprofile-arcs)
+    target_compile_options(tgui PRIVATE -ftest-coverage)
 endif()
 
 # Enable automatic reference counting on iOS
-if (SFML_OS_IOS)
+if(TGUI_OS_IOS)
     set_target_properties(${target} PROPERTIES XCODE_ATTRIBUTE_CLANG_ENABLE_OBJC_ARC YES)
 endif()
 
-# for gcc >= 4.0 on Windows, apply the TGUI_USE_STATIC_STD_LIBS option if it is enabled
-if(SFML_OS_WINDOWS AND SFML_COMPILER_GCC AND NOT SFML_GCC_VERSION VERSION_LESS "4")
-    if(TGUI_USE_STATIC_STD_LIBS AND NOT SFML_COMPILER_GCC_TDM)
-        set_target_properties(${PROJECT_NAME} PROPERTIES LINK_FLAGS "-static-libgcc -static-libstdc++")
-    elseif(NOT TGUI_USE_STATIC_STD_LIBS AND SFML_COMPILER_GCC_TDM)
-        set_target_properties(${PROJECT_NAME} PROPERTIES LINK_FLAGS "-shared-libgcc -shared-libstdc++")
-    endif()
-endif()
-
-# if using gcc >= 4.0 or clang >= 3.0 on a non-Windows platform, we must hide public symbols by default
-# (exported ones are explicitely marked)
-if(NOT SFML_OS_WINDOWS AND ((SFML_COMPILER_GCC AND NOT SFML_GCC_VERSION VERSION_LESS "4") OR (SFML_COMPILER_CLANG AND NOT SFML_CLANG_VERSION VERSION_LESS "3")))
-    set_target_properties(${PROJECT_NAME} PROPERTIES COMPILE_FLAGS -fvisibility=hidden)
+# Hide public symbols by default (exported ones are explicitly marked)
+if(TGUI_COMPILER_GCC OR TGUI_COMPILER_CLANG)
+    target_compile_options(tgui PRIVATE -fvisibility=hidden)
 endif()
 
 # Build frameworks or dylibs
-if(SFML_OS_MACOSX AND TGUI_SHARED_LIBS)
+if(TGUI_OS_MACOSX AND TGUI_SHARED_LIBS)
     if(TGUI_BUILD_FRAMEWORK)
         # Adapt target to build frameworks instead of dylibs
-        set_target_properties(${PROJECT_NAME} PROPERTIES
+        set_target_properties(tgui PROPERTIES
                               FRAMEWORK TRUE
-                              FRAMEWORK_VERSION ${MAJOR_VERSION}.${MINOR_VERSION}.${PATCH_VERSION}
-                              MACOSX_FRAMEWORK_IDENTIFIER org.tgui.${PROJECT_NAME}
-                              MACOSX_FRAMEWORK_SHORT_VERSION_STRING ${MAJOR_VERSION}.${MINOR_VERSION}.${PATCH_VERSION}
-                              MACOSX_FRAMEWORK_BUNDLE_VERSION ${MAJOR_VERSION}.${MINOR_VERSION}.${PATCH_VERSION})
+                              FRAMEWORK_VERSION ${TGUI_VERSION_MAJOR}.${TGUI_VERSION_MINOR}.${TGUI_VERSION_PATCH}
+                              MACOSX_FRAMEWORK_IDENTIFIER org.tgui.tgui
+                              MACOSX_FRAMEWORK_SHORT_VERSION_STRING ${TGUI_VERSION_MAJOR}.${TGUI_VERSION_MINOR}.${TGUI_VERSION_PATCH}
+                              MACOSX_FRAMEWORK_BUNDLE_VERSION ${TGUI_VERSION_MAJOR}.${TGUI_VERSION_MINOR}.${TGUI_VERSION_PATCH})
 
         # Install the header files to the framework
-        add_custom_command(TARGET ${PROJECT_NAME}
+        add_custom_command(TARGET tgui
                            POST_BUILD
-                           COMMAND ${CMAKE_COMMAND} -E make_directory $<TARGET_FILE_DIR:${PROJECT_NAME}>/Headers
-                           COMMAND ${CMAKE_COMMAND} -E copy_directory ${PROJECT_SOURCE_DIR}/include/TGUI $<TARGET_FILE_DIR:${PROJECT_NAME}>/Headers
-                           COMMAND ${CMAKE_COMMAND} -E create_symlink Versions/${MAJOR_VERSION}.${MINOR_VERSION}.${PATCH_VERSION}/Headers $<TARGET_FILE_DIR:${PROJECT_NAME}>/../../Headers)
+                           COMMAND ${CMAKE_COMMAND} -E make_directory $<TARGET_FILE_DIR:tgui>/Headers
+                           COMMAND ${CMAKE_COMMAND} -E copy_directory ${PROJECT_SOURCE_DIR}/include/TGUI $<TARGET_FILE_DIR:tgui>/Headers
+                           COMMAND ${CMAKE_COMMAND} -E create_symlink Versions/${TGUI_VERSION_MAJOR}.${TGUI_VERSION_MINOR}.${TGUI_VERSION_PATCH}/Headers $<TARGET_FILE_DIR:tgui>/../../Headers)
 
         # The framework has to be with a capital letter (because it includes the header files which must be found in a "TGUI" directory)
-        set_target_properties(${PROJECT_NAME} PROPERTIES OUTPUT_NAME TGUI)
+        set_target_properties(tgui PROPERTIES OUTPUT_NAME TGUI)
     endif()
 
     # Adapt install directory to allow distributing dylibs/frameworks in user’s frameworks/application bundle but only if cmake rpath options aren't set
-    if (NOT CMAKE_SKIP_RPATH AND NOT CMAKE_SKIP_INSTALL_RPATH AND NOT CMAKE_INSTALL_RPATH AND NOT CMAKE_INSTALL_RPATH_USE_LINK_PATH AND NOT CMAKE_INSTALL_NAME_DIR)
-        set_target_properties(${PROJECT_NAME} PROPERTIES INSTALL_NAME_DIR "@rpath")
-        if (NOT CMAKE_SKIP_BUILD_RPATH)
-            if (CMAKE_VERSION VERSION_LESS 3.9)
-                set_target_properties(${PROJECT_NAME} PROPERTIES BUILD_WITH_INSTALL_RPATH TRUE)
+    if(NOT CMAKE_SKIP_RPATH AND NOT CMAKE_SKIP_INSTALL_RPATH AND NOT CMAKE_INSTALL_RPATH AND NOT CMAKE_INSTALL_RPATH_USE_LINK_PATH AND NOT CMAKE_INSTALL_NAME_DIR)
+        set_target_properties(tgui PROPERTIES INSTALL_NAME_DIR "@rpath")
+        if(NOT CMAKE_SKIP_BUILD_RPATH)
+            if(CMAKE_VERSION VERSION_LESS 3.9)
+                set_target_properties(tgui PROPERTIES BUILD_WITH_INSTALL_RPATH TRUE)
             else()
-                set_target_properties(${PROJECT_NAME} PROPERTIES BUILD_WITH_INSTALL_NAME_DIR TRUE)
+                set_target_properties(tgui PROPERTIES BUILD_WITH_INSTALL_NAME_DIR TRUE)
             endif()
         endif()
     endif()
 endif()
 
+# Build tgui-activity on android
+if(TGUI_OS_ANDROID)
+    add_subdirectory(Android)
+endif()
+
 # Install library
-install(TARGETS ${PROJECT_NAME}
+install(TARGETS tgui EXPORT TGUIConfigExport
         RUNTIME DESTINATION bin COMPONENT bin
         LIBRARY DESTINATION lib${LIB_SUFFIX} COMPONENT bin
         ARCHIVE DESTINATION lib${LIB_SUFFIX} COMPONENT devel
-        FRAMEWORK DESTINATION ${CMAKE_INSTALL_FRAMEWORK_PREFIX} COMPONENT bin
+        FRAMEWORK DESTINATION . COMPONENT devel
 )
-
-# Build tgui-activity on android
-if (SFML_OS_ANDROID)
-    add_subdirectory(Android)
-endif()
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 7a52cac3..91224d17 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -83,25 +83,19 @@ if (TGUI_OPTIMIZE_SINGLE_BUILD OR TGUI_OPTIMIZE_TESTS_SINGLE_BUILD)
             endforeach()
         endforeach()
 
-        if (SFML_COMPILER_MSVC)
-            add_compile_options("/bigobj")
-        endif()
-
         set(TEST_SOURCES ${NEW_TEST_SOURCES})
     endif()
 endif()
 
 add_executable(tests ${TEST_SOURCES})
 target_include_directories(tests PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}")
-target_link_libraries(tests ${PROJECT_NAME} ${TGUI_EXT_LIBS})
+target_link_libraries(tests PRIVATE tgui)
 
-# For gcc >= 4.0 on Windows, apply the SFML_USE_STATIC_STD_LIBS option if it is enabled
-if(SFML_OS_WINDOWS AND SFML_COMPILER_GCC AND NOT SFML_GCC_VERSION VERSION_LESS "4")
-    if(SFML_USE_STATIC_STD_LIBS AND NOT SFML_COMPILER_GCC_TDM)
-        set_target_properties(tests PROPERTIES LINK_FLAGS "-static-libgcc -static-libstdc++")
-    elseif(NOT SFML_USE_STATIC_STD_LIBS AND SFML_COMPILER_GCC_TDM)
-        set_target_properties(tests PROPERTIES LINK_FLAGS "-shared-libgcc -shared-libstdc++")
-    endif()
+tgui_set_global_compile_flags(tests)
+tgui_set_stdlib(tests)
+
+if(TGUI_OPTIMIZE_SINGLE_BUILD AND TGUI_COMPILER_MSVC)
+    target_compile_options(tests PRIVATE /bigobj)
 endif()
 
 # Copy the resources folder to the build directory to execute the tests without installing them
@@ -115,13 +109,13 @@ add_custom_command(TARGET tests
 
 # Add the install rule for the executable
 install(TARGETS tests
-        RUNTIME DESTINATION ${INSTALL_MISC_DIR}/tests/ COMPONENT tests
-        BUNDLE DESTINATION ${INSTALL_MISC_DIR}/tests/ COMPONENT tests)
+        RUNTIME DESTINATION ${TGUI_MISC_INSTALL_PREFIX}/tests/ COMPONENT tests
+        BUNDLE DESTINATION ${TGUI_MISC_INSTALL_PREFIX}/tests/ COMPONENT tests)
 
 # Install the tests
 install(DIRECTORY "${CMAKE_SOURCE_DIR}/tests/resources"
-        DESTINATION "${INSTALL_MISC_DIR}/tests"
+        DESTINATION "${TGUI_MISC_INSTALL_PREFIX}/tests"
         COMPONENT tests)
 install(DIRECTORY "${CMAKE_SOURCE_DIR}/themes/"
-        DESTINATION "${INSTALL_MISC_DIR}/tests/resources"
+        DESTINATION "${TGUI_MISC_INSTALL_PREFIX}/tests/resources"
         COMPONENT tests)
diff --git a/tests/cmake/CMakeLists.txt b/tests/cmake/CMakeLists.txt
new file mode 100644
index 00000000..1b14f94b
--- /dev/null
+++ b/tests/cmake/CMakeLists.txt
@@ -0,0 +1,8 @@
+cmake_minimum_required(VERSION 3.5)
+project(TGUI-CMake-test)
+
+add_executable(TguiTest main.cpp)
+
+find_package(SFML 2 COMPONENTS graphics window system REQUIRED)
+find_package(TGUI REQUIRED)
+target_link_libraries(TguiTest PRIVATE tgui sfml-graphics)
diff --git a/tests/cmake/main.cpp b/tests/cmake/main.cpp
new file mode 100644
index 00000000..75a529b2
--- /dev/null
+++ b/tests/cmake/main.cpp
@@ -0,0 +1,7 @@
+#include <TGUI/TGUI.hpp>
+
+int main()
+{
+    sf::RenderTexture target;
+    tgui::Gui gui{target};
+}
diff --git a/tests/travis_linux.sh b/tests/travis_linux.sh
index e07085b1..d8e7b465 100644
--- a/tests/travis_linux.sh
+++ b/tests/travis_linux.sh
@@ -1,6 +1,7 @@
 set -e
 
 export SFML_ROOT=$HOME/SFML_LINUX
+export BUILD_FOLDER=build_gcc-$CXX
 
 git clone --depth 1 https://github.com/SFML/SFML
 cd SFML
@@ -24,8 +25,14 @@ else
 fi
 cd ..
 
-mkdir build_gcc-$CXX
-cd build_gcc-$CXX
+mkdir $BUILD_FOLDER
+cd $BUILD_FOLDER
 cmake -DCMAKE_BUILD_TYPE=Release -DTGUI_BUILD_EXAMPLES=TRUE -DTGUI_BUILD_GUI_BUILDER=TRUE -DTGUI_OPTIMIZE_SINGLE_BUILD=TRUE -DTGUI_OPTIMIZE_SINGLE_BUILD_THREADS=2 ..
 make -j2
 cd ..
+
+# Test the TGUIConfig.cmake file
+cd tests/cmake
+cmake -DSFML_DIR=$SFML_ROOT -DTGUI_DIR=$TRAVIS_BUILD_DIR/$BUILD_FOLDER .
+./TguiTest
+cd ../..