kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge topic 'FindGTK2-targets' 

7efef02 FindGTK2: Add tests for components and targets in gtk and gtkmm modules
95fc47a FindGTK2: Make pangocairo and cairo optional dependencies
26f790f FindGTK2: Change extra includes -> optional
24e0272 FindGTK2: do not skip target creation if optional dependencies are not found
d5f130c FindGTK2: Refactor _GTK2_ADJUST_LIB_VARS into _GTK2_ADD_TARGET
fffbd72 FindGTK2: Do not add freetype includes if they are not found
b69720d FindGTK2: Add libraries to the GTK2_LIBRARIES variable only when found
425ec40 FindGTK2: Do not link libfreetype
e9f46df FindGTK2: Add config directories only if different from include ones
56a79e1 FindGTK2: Set INTERFACE_COMPILE_DEFINITIONS target property only if not empty
4b47586 FindGTK2: Add check to ensure that target exists
61242cc FindGTK2: Fix gmodule, glibmm, pangoft2, and pangoxft targets
4b876de FindGTK2: Link freetype libs to targets including freetype includes
67e761f FindGTK2: Small cleanup
682eea3 FindGTK2: Do not require the GTK_ prefix in all the internal functions
0bc3763 FindGTK2: Better handling of include directories
...
This commit is contained in:
Brad King 2013-10-09 10:23:31 -04:00 committed by CMake Topic Stage
parent 1c1a904328 7efef02df2
commit e5f17214a5
49 changed files with 1304 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

372
Modules/FindGTK2.cmake
View File

@ -66,7 +66,10 @@
# (To distribute this file outside of CMake, substitute the full # (To distribute this file outside of CMake, substitute the full
# License text for the above reference.) # License text for the above reference.)
# Version 1.5 (UNRELEASED) (CMake 2.8.12) # Version 1.6 (CMake 2.8.13)
# * Create targets for each library
# * Do not link libfreetype
# Version 1.5 (CMake 2.8.12)
# * 14236: Detect gthread library # * 14236: Detect gthread library
# Detect pangocairo on windows # Detect pangocairo on windows
# Detect pangocairo with gtk module instead of with gtkmm # Detect pangocairo with gtk module instead of with gtkmm
@ -130,6 +133,7 @@
#============================================================= #=============================================================
include(${CMAKE_CURRENT_LIST_DIR}/SelectLibraryConfigurations.cmake) include(${CMAKE_CURRENT_LIST_DIR}/SelectLibraryConfigurations.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/CMakeParseArguments.cmake)
function(_GTK2_GET_VERSION _OUT_major _OUT_minor _OUT_micro _gtkversion_hdr) function(_GTK2_GET_VERSION _OUT_major _OUT_minor _OUT_micro _gtkversion_hdr)
file(STRINGS ${_gtkversion_hdr} _contents REGEX "#define GTK_M[A-Z]+_VERSION[ \t]+") file(STRINGS ${_gtkversion_hdr} _contents REGEX "#define GTK_M[A-Z]+_VERSION[ \t]+")
@ -214,7 +218,7 @@ function(_GTK2_FIND_INCLUDE_DIR _var _hdr)
message(STATUS "Adding ${_gtk2_arch_dir} to search path for multiarch support") message(STATUS "Adding ${_gtk2_arch_dir} to search path for multiarch support")
endif() endif()
endif() endif()
find_path(${_var}_INCLUDE_DIR ${_hdr} find_path(GTK2_${_var}_INCLUDE_DIR ${_hdr}
PATHS PATHS
${_gtk2_arch_dir} ${_gtk2_arch_dir}
/usr/local/lib64 /usr/local/lib64
@ -242,8 +246,8 @@ function(_GTK2_FIND_INCLUDE_DIR _var _hdr)
) )
mark_as_advanced(GTK2_${_var}_INCLUDE_DIR) mark_as_advanced(GTK2_${_var}_INCLUDE_DIR)
if(${_var}_INCLUDE_DIR) if(GTK2_${_var}_INCLUDE_DIR)
set(GTK2_INCLUDE_DIRS ${GTK2_INCLUDE_DIRS} ${${_var}_INCLUDE_DIR} PARENT_SCOPE) set(GTK2_INCLUDE_DIRS ${GTK2_INCLUDE_DIRS} ${GTK2_${_var}_INCLUDE_DIR} PARENT_SCOPE)
endif() endif()
endfunction() endfunction()
@ -333,10 +337,10 @@ function(_GTK2_FIND_LIBRARY _var _lib _expand_vc _append_version)
if(GTK2_DEBUG) if(GTK2_DEBUG)
message(STATUS "[FindGTK2.cmake:${CMAKE_CURRENT_LIST_LINE}] " message(STATUS "[FindGTK2.cmake:${CMAKE_CURRENT_LIST_LINE}] "
"While searching for ${_var}_LIBRARY, our proposed library list is ${_lib_list}") "While searching for GTK2_${_var}_LIBRARY, our proposed library list is ${_lib_list}")
endif() endif()
find_library(${_var}_LIBRARY_RELEASE find_library(GTK2_${_var}_LIBRARY_RELEASE
NAMES ${_lib_list} NAMES ${_lib_list}
PATHS PATHS
/opt/gnome/lib /opt/gnome/lib
@ -350,10 +354,10 @@ function(_GTK2_FIND_LIBRARY _var _lib _expand_vc _append_version)
if(_expand_vc AND MSVC) if(_expand_vc AND MSVC)
if(GTK2_DEBUG) if(GTK2_DEBUG)
message(STATUS "[FindGTK2.cmake:${CMAKE_CURRENT_LIST_LINE}] " message(STATUS "[FindGTK2.cmake:${CMAKE_CURRENT_LIST_LINE}] "
"While searching for ${_var}_LIBRARY_DEBUG our proposed library list is ${_libd_list}") "While searching for GTK2_${_var}_LIBRARY_DEBUG our proposed library list is ${_libd_list}")
endif() endif()
find_library(${_var}_LIBRARY_DEBUG find_library(GTK2_${_var}_LIBRARY_DEBUG
NAMES ${_libd_list} NAMES ${_libd_list}
PATHS PATHS
$ENV{GTKMM_BASEPATH}/lib $ENV{GTKMM_BASEPATH}/lib
@ -362,24 +366,148 @@ function(_GTK2_FIND_LIBRARY _var _lib _expand_vc _append_version)
) )
endif() endif()
select_library_configurations(${_var}) select_library_configurations(GTK2_${_var})
set(${_var}_LIBRARY ${${_var}_LIBRARY} PARENT_SCOPE) set(GTK2_${_var}_LIBRARY ${GTK2_${_var}_LIBRARY} PARENT_SCOPE)
set(GTK2_${_var}_FOUND ${GTK2_${_var}_FOUND} PARENT_SCOPE)
set(GTK2_LIBRARIES ${GTK2_LIBRARIES} ${${_var}_LIBRARY}) if(GTK2_${_var}_FOUND)
set(GTK2_LIBRARIES ${GTK2_LIBRARIES} PARENT_SCOPE) set(GTK2_LIBRARIES ${GTK2_LIBRARIES} ${GTK2_${_var}_LIBRARY})
set(GTK2_LIBRARIES ${GTK2_LIBRARIES} PARENT_SCOPE)
endif()
if(GTK2_DEBUG) if(GTK2_DEBUG)
message(STATUS "[FindGTK2.cmake:${CMAKE_CURRENT_LIST_LINE}] " message(STATUS "[FindGTK2.cmake:${CMAKE_CURRENT_LIST_LINE}] "
"${_var}_LIBRARY_RELEASE = \"${${_var}_LIBRARY_RELEASE}\"") "GTK2_${_var}_LIBRARY_RELEASE = \"${GTK2_${_var}_LIBRARY_RELEASE}\"")
message(STATUS "[FindGTK2.cmake:${CMAKE_CURRENT_LIST_LINE}] " message(STATUS "[FindGTK2.cmake:${CMAKE_CURRENT_LIST_LINE}] "
"${_var}_LIBRARY_DEBUG = \"${${_var}_LIBRARY_DEBUG}\"") "GTK2_${_var}_LIBRARY_DEBUG = \"${GTK2_${_var}_LIBRARY_DEBUG}\"")
message(STATUS "[FindGTK2.cmake:${CMAKE_CURRENT_LIST_LINE}] " message(STATUS "[FindGTK2.cmake:${CMAKE_CURRENT_LIST_LINE}] "
"${_var}_LIBRARY = \"${${_var}_LIBRARY}\"") "GTK2_${_var}_LIBRARY = \"${GTK2_${_var}_LIBRARY}\"")
message(STATUS "[FindGTK2.cmake:${CMAKE_CURRENT_LIST_LINE}] "
"GTK2_${_var}_FOUND = \"${GTK2_${_var}_FOUND}\"")
endif() endif()
endfunction() endfunction()
function(_GTK2_ADD_TARGET_DEPENDS_INTERNAL _var _property)
if(GTK2_DEBUG)
message(STATUS "[FindGTK2.cmake:${CMAKE_CURRENT_LIST_LINE}] "
"_GTK2_ADD_TARGET_DEPENDS_INTERNAL( ${_var} ${_property} )")
endif()
string(TOLOWER "${_var}" _basename)
if (TARGET GTK2::${_basename})
foreach(_depend ${ARGN})
set(_valid_depends)
if (TARGET GTK2::${_depend})
list(APPEND _valid_depends GTK2::${_depend})
endif()
if (_valid_depends)
set_property(TARGET GTK2::${_basename} APPEND PROPERTY ${_property} "${_valid_depends}")
endif()
set(_valid_depends)
endforeach()
endif()
endfunction()
function(_GTK2_ADD_TARGET_DEPENDS _var)
if(GTK2_DEBUG)
message(STATUS "[FindGTK2.cmake:${CMAKE_CURRENT_LIST_LINE}] "
"_GTK2_ADD_TARGET_DEPENDS( ${_var} )")
endif()
string(TOLOWER "${_var}" _basename)
if(TARGET GTK2::${_basename})
get_target_property(_configs GTK2::${_basename} IMPORTED_CONFIGURATIONS)
_GTK2_ADD_TARGET_DEPENDS_INTERNAL(${_var} INTERFACE_LINK_LIBRARIES ${ARGN})
foreach(_config ${_configs})
_GTK2_ADD_TARGET_DEPENDS_INTERNAL(${_var} IMPORTED_LINK_INTERFACE_LIBRARIES_${_config} ${ARGN})
endforeach()
endif()
endfunction()
function(_GTK2_ADD_TARGET_INCLUDE_DIRS _var)
if(GTK2_DEBUG)
message(STATUS "[FindGTK2.cmake:${CMAKE_CURRENT_LIST_LINE}] "
"_GTK2_ADD_TARGET_INCLUDE_DIRS( ${_var} )")
endif()
string(TOLOWER "${_var}" _basename)
if(TARGET GTK2::${_basename})
foreach(_include ${ARGN})
set_property(TARGET GTK2::${_basename} APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES "${_include}")
endforeach()
endif()
endfunction()
#=============================================================
# _GTK2_ADD_TARGET
# Internal function to create targets for GTK2
# _var = target to create
#=============================================================
function(_GTK2_ADD_TARGET _var)
if(GTK2_DEBUG)
message(STATUS "[FindGTK2.cmake:${CMAKE_CURRENT_LIST_LINE}] "
"_GTK2_ADD_TARGET( ${_var} )")
endif()
string(TOLOWER "${_var}" _basename)
cmake_parse_arguments(_${_var} "" "" "GTK2_DEPENDS;GTK2_OPTIONAL_DEPENDS;OPTIONAL_INCLUDES" ${ARGN})
if(GTK2_${_var}_FOUND AND NOT TARGET GTK2::${_basename})
# Do not create the target if dependencies are missing
foreach(_dep ${_${_var}_GTK2_DEPENDS})
if(NOT TARGET GTK2::${_dep})
return()
endif()
endforeach()
add_library(GTK2::${_basename} UNKNOWN IMPORTED)
if(GTK2_${_var}_LIBRARY_RELEASE)
set_property(TARGET GTK2::${_basename} APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_property(TARGET GTK2::${_basename} PROPERTY IMPORTED_LOCATION_RELEASE "${GTK2_${_var}_LIBRARY_RELEASE}" )
endif()
if(GTK2_${_var}_LIBRARY_DEBUG)
set_property(TARGET GTK2::${_basename} APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG)
set_property(TARGET GTK2::${_basename} PROPERTY IMPORTED_LOCATION_DEBUG "${GTK2_${_var}_LIBRARY_DEBUG}" )
endif()
if(GTK2_${_var}_INCLUDE_DIR)
set_property(TARGET GTK2::${_basename} APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES "${GTK2_${_var}_INCLUDE_DIR}")
endif()
if(GTK2_${_var}CONFIG_INCLUDE_DIR AND NOT "${GTK2_${_var}CONFIG_INCLUDE_DIR}" STREQUAL "GTK2_${_var}_INCLUDE_DIR")
set_property(TARGET GTK2::${_basename} APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES "${GTK2_${_var}CONFIG_INCLUDE_DIR}")
endif()
if(GTK2_DEFINITIONS)
set_property(TARGET GTK2::${_basename} PROPERTY INTERFACE_COMPILE_DEFINITIONS "${GTK2_DEFINITIONS}")
endif()
if(_${_var}_GTK2_DEPENDS)
_GTK2_ADD_TARGET_DEPENDS(${_var} ${_${_var}_GTK2_DEPENDS} ${_${_var}_GTK2_OPTIONAL_DEPENDS})
endif()
if(_${_var}_OPTIONAL_INCLUDES)
_GTK2_ADD_TARGET_INCLUDE_DIRS(${_var} ${_${_var}_OPTIONAL_INCLUDES})
endif()
if(GTK2_USE_IMPORTED_TARGETS)
set(GTK2_${_var}_LIBRARY GTK2::${_basename} PARENT_SCOPE)
endif()
endif()
endfunction()
#============================================================= #=============================================================
# #
@ -406,7 +534,7 @@ if(GTK2_FIND_VERSION)
message(STATUS "[FindGTK2.cmake:${CMAKE_CURRENT_LIST_LINE}] " message(STATUS "[FindGTK2.cmake:${CMAKE_CURRENT_LIST_LINE}] "
"Searching for version ${GTK2_FIND_VERSION}") "Searching for version ${GTK2_FIND_VERSION}")
endif() endif()
_GTK2_FIND_INCLUDE_DIR(GTK2_GTK gtk/gtk.h) _GTK2_FIND_INCLUDE_DIR(GTK gtk/gtk.h)
if(GTK2_GTK_INCLUDE_DIR) if(GTK2_GTK_INCLUDE_DIR)
_GTK2_GET_VERSION(GTK2_MAJOR_VERSION _GTK2_GET_VERSION(GTK2_MAJOR_VERSION
GTK2_MINOR_VERSION GTK2_MINOR_VERSION
@ -446,105 +574,163 @@ if(GTK2_FIND_VERSION)
endif() endif()
endif() endif()
#
# On MSVC, according to https://wiki.gnome.org/gtkmm/MSWindows, the /vd2 flag needs to be
# passed to the compiler in order to use gtkmm
#
if(MSVC)
foreach(_GTK2_component ${GTK2_FIND_COMPONENTS})
if(_GTK2_component STREQUAL "gtkmm")
set(GTK2_DEFINITIONS "/vd2")
elseif(_GTK2_component STREQUAL "glademm")
set(GTK2_DEFINITIONS "/vd2")
endif()
endforeach()
endif()
# #
# Find all components # Find all components
# #
find_package(Freetype QUIET) find_package(Freetype QUIET)
list(APPEND GTK2_INCLUDE_DIRS ${FREETYPE_INCLUDE_DIRS}) if(FREETYPE_INCLUDE_DIR_ft2build AND FREETYPE_INCLUDE_DIR_freetype2)
list(APPEND GTK2_LIBRARIES ${FREETYPE_LIBRARIES}) list(APPEND GTK2_INCLUDE_DIRS ${FREETYPE_INCLUDE_DIR_ft2build} ${FREETYPE_INCLUDE_DIR_freetype2})
endif()
foreach(_GTK2_component ${GTK2_FIND_COMPONENTS}) foreach(_GTK2_component ${GTK2_FIND_COMPONENTS})
if(_GTK2_component STREQUAL "gtk") if(_GTK2_component STREQUAL "gtk")
_GTK2_FIND_INCLUDE_DIR(GTK2_GTK gtk/gtk.h) _GTK2_FIND_INCLUDE_DIR(GLIB glib.h)
_GTK2_FIND_INCLUDE_DIR(GLIBCONFIG glibconfig.h)
_GTK2_FIND_LIBRARY (GLIB glib false true)
_GTK2_ADD_TARGET (GLIB)
_GTK2_FIND_INCLUDE_DIR(GOBJECT glib-object.h)
_GTK2_FIND_LIBRARY (GOBJECT gobject false true)
_GTK2_ADD_TARGET (GOBJECT GTK2_DEPENDS glib)
_GTK2_FIND_INCLUDE_DIR(ATK atk/atk.h)
_GTK2_FIND_LIBRARY (ATK atk false true)
_GTK2_ADD_TARGET (ATK GTK2_DEPENDS gobject glib)
_GTK2_FIND_LIBRARY (GIO gio false true)
_GTK2_ADD_TARGET (GIO GTK2_DEPENDS gobject glib)
_GTK2_FIND_LIBRARY (GTHREAD gthread false true)
_GTK2_ADD_TARGET (GTHREAD GTK2_DEPENDS glib)
_GTK2_FIND_LIBRARY (GMODULE gmodule false true)
_GTK2_ADD_TARGET (GMODULE GTK2_DEPENDS glib)
_GTK2_FIND_INCLUDE_DIR(GDK_PIXBUF gdk-pixbuf/gdk-pixbuf.h)
_GTK2_FIND_LIBRARY (GDK_PIXBUF gdk_pixbuf false true)
_GTK2_ADD_TARGET (GDK_PIXBUF GTK2_DEPENDS gobject glib)
_GTK2_FIND_INCLUDE_DIR(CAIRO cairo.h)
_GTK2_FIND_LIBRARY (CAIRO cairo false false)
_GTK2_ADD_TARGET (CAIRO)
_GTK2_FIND_INCLUDE_DIR(PANGO pango/pango.h)
_GTK2_FIND_LIBRARY (PANGO pango false true)
_GTK2_ADD_TARGET (PANGO GTK2_DEPENDS gobject glib)
_GTK2_FIND_LIBRARY (PANGOCAIRO pangocairo false true)
_GTK2_ADD_TARGET (PANGOCAIRO GTK2_DEPENDS pango cairo gobject glib)
_GTK2_FIND_LIBRARY (PANGOFT2 pangoft2 false true)
_GTK2_ADD_TARGET (PANGOFT2 GTK2_DEPENDS pango gobject glib
OPTIONAL_INCLUDES ${FREETYPE_INCLUDE_DIR_ft2build} ${FREETYPE_INCLUDE_DIR_freetype2})
_GTK2_FIND_LIBRARY (PANGOXFT pangoxft false true)
_GTK2_ADD_TARGET (PANGOXFT GTK2_DEPENDS pangoft2 pango gobject glib
OPTIONAL_INCLUDES ${FREETYPE_INCLUDE_DIR_ft2build} ${FREETYPE_INCLUDE_DIR_freetype2})
_GTK2_FIND_INCLUDE_DIR(GDK gdk/gdk.h)
_GTK2_FIND_INCLUDE_DIR(GDKCONFIG gdkconfig.h)
if(UNIX) if(UNIX)
_GTK2_FIND_LIBRARY (GTK2_GTK gtk-x11 false true) _GTK2_FIND_LIBRARY (GDK gdk-x11 false true)
_GTK2_FIND_LIBRARY (GTK2_GDK gdk-x11 false true)
else() else()
_GTK2_FIND_LIBRARY (GTK2_GTK gtk-win32 false true) _GTK2_FIND_LIBRARY (GDK gdk-win32 false true)
_GTK2_FIND_LIBRARY (GTK2_GDK gdk-win32 false true)
endif() endif()
_GTK2_ADD_TARGET (GDK GTK2_DEPENDS pango gdk_pixbuf gobject glib
GTK2_OPTIONAL_DEPENDS pangocairo cairo)
_GTK2_FIND_INCLUDE_DIR(GTK2_GDK gdk/gdk.h) _GTK2_FIND_INCLUDE_DIR(GTK gtk/gtk.h)
_GTK2_FIND_INCLUDE_DIR(GTK2_GDKCONFIG gdkconfig.h) if(UNIX)
_GTK2_FIND_LIBRARY (GTK gtk-x11 false true)
else()
_GTK2_FIND_LIBRARY (GTK gtk-win32 false true)
endif()
_GTK2_ADD_TARGET (GTK GTK2_DEPENDS gdk atk pangoft2 pango gdk_pixbuf gthread gobject glib
GTK2_OPTIONAL_DEPENDS gio pangocairo cairo)
_GTK2_FIND_INCLUDE_DIR(GTK2_CAIRO cairo.h) # Left for compatibility with previous versions. It doesn't seem to be required
_GTK2_FIND_LIBRARY (GTK2_CAIRO cairo false false) _GTK2_FIND_INCLUDE_DIR(FONTCONFIG fontconfig/fontconfig.h)
_GTK2_FIND_INCLUDE_DIR(GTK2_FONTCONFIG fontconfig/fontconfig.h)
_GTK2_FIND_INCLUDE_DIR(GTK2_PANGO pango/pango.h)
_GTK2_FIND_LIBRARY (GTK2_PANGO pango false true)
_GTK2_FIND_LIBRARY (GTK2_PANGOCAIRO pangocairo false true)
_GTK2_FIND_LIBRARY (GTK2_PANGOFT2 pangoft2 false true)
_GTK2_FIND_LIBRARY (GTK2_PANGOXFT pangoxft false true)
_GTK2_FIND_INCLUDE_DIR(GTK2_GDK_PIXBUF gdk-pixbuf/gdk-pixbuf.h)
_GTK2_FIND_LIBRARY (GTK2_GDK_PIXBUF gdk_pixbuf false true)
_GTK2_FIND_LIBRARY (GTK2_GTHREAD gthread false true)
_GTK2_FIND_LIBRARY (GTK2_GMODULE gmodule false true)
_GTK2_FIND_LIBRARY (GTK2_GIO gio false true)
_GTK2_FIND_INCLUDE_DIR(GTK2_ATK atk/atk.h)
_GTK2_FIND_LIBRARY (GTK2_ATK atk false true)
_GTK2_FIND_INCLUDE_DIR(GTK2_GOBJECT gobject/gobject.h)
_GTK2_FIND_LIBRARY (GTK2_GOBJECT gobject false true)
_GTK2_FIND_INCLUDE_DIR(GTK2_GLIB glib.h)
_GTK2_FIND_INCLUDE_DIR(GTK2_GLIBCONFIG glibconfig.h)
_GTK2_FIND_LIBRARY (GTK2_GLIB glib false true)
elseif(_GTK2_component STREQUAL "gtkmm") elseif(_GTK2_component STREQUAL "gtkmm")
_GTK2_FIND_INCLUDE_DIR(GTK2_GTKMM gtkmm.h) _GTK2_FIND_INCLUDE_DIR(SIGC++ sigc++/sigc++.h)
_GTK2_FIND_INCLUDE_DIR(GTK2_GTKMMCONFIG gtkmmconfig.h) _GTK2_FIND_INCLUDE_DIR(SIGC++CONFIG sigc++config.h)
_GTK2_FIND_LIBRARY (GTK2_GTKMM gtkmm true true) _GTK2_FIND_LIBRARY (SIGC++ sigc true true)
_GTK2_ADD_TARGET (SIGC++)
_GTK2_FIND_INCLUDE_DIR(GTK2_GDKMM gdkmm.h) _GTK2_FIND_INCLUDE_DIR(GLIBMM glibmm.h)
_GTK2_FIND_INCLUDE_DIR(GTK2_GDKMMCONFIG gdkmmconfig.h) _GTK2_FIND_INCLUDE_DIR(GLIBMMCONFIG glibmmconfig.h)
_GTK2_FIND_LIBRARY (GTK2_GDKMM gdkmm true true) _GTK2_FIND_LIBRARY (GLIBMM glibmm true true)
_GTK2_ADD_TARGET (GLIBMM GTK2_DEPENDS gobject sigc++ glib)
_GTK2_FIND_INCLUDE_DIR(GTK2_PANGOMM pangomm.h) _GTK2_FIND_INCLUDE_DIR(GIOMM giomm.h)
_GTK2_FIND_INCLUDE_DIR(GTK2_PANGOMMCONFIG pangommconfig.h) _GTK2_FIND_INCLUDE_DIR(GIOMMCONFIG giommconfig.h)
_GTK2_FIND_LIBRARY (GTK2_PANGOMM pangomm true true) _GTK2_FIND_LIBRARY (GIOMM giomm true true)
_GTK2_ADD_TARGET (GIOMM GTK2_DEPENDS gio glibmm gobject sigc++ glib)
_GTK2_FIND_INCLUDE_DIR(GTK2_CAIROMM cairomm/cairomm.h) _GTK2_FIND_INCLUDE_DIR(ATKMM atkmm.h)
_GTK2_FIND_INCLUDE_DIR(GTK2_CAIROMMCONFIG cairommconfig.h) _GTK2_FIND_LIBRARY (ATKMM atkmm true true)
_GTK2_FIND_LIBRARY (GTK2_CAIROMM cairomm true true) _GTK2_ADD_TARGET (ATKMM GTK2_DEPENDS atk glibmm gobject sigc++ glib)
_GTK2_FIND_INCLUDE_DIR(GTK2_GIOMM giomm.h) _GTK2_FIND_INCLUDE_DIR(CAIROMM cairomm/cairomm.h)
_GTK2_FIND_INCLUDE_DIR(GTK2_GIOMMCONFIG giommconfig.h) _GTK2_FIND_INCLUDE_DIR(CAIROMMCONFIG cairommconfig.h)
_GTK2_FIND_LIBRARY (GTK2_GIOMM giomm true true) _GTK2_FIND_LIBRARY (CAIROMM cairomm true true)
_GTK2_ADD_TARGET (CAIROMM GTK2_DEPENDS cairo sigc++
OPTIONAL_INCLUDES ${FREETYPE_INCLUDE_DIR_ft2build} ${FREETYPE_INCLUDE_DIR_freetype2})
_GTK2_FIND_INCLUDE_DIR(GTK2_ATKMM atkmm.h) _GTK2_FIND_INCLUDE_DIR(PANGOMM pangomm.h)
_GTK2_FIND_LIBRARY (GTK2_ATKMM atkmm true true) _GTK2_FIND_INCLUDE_DIR(PANGOMMCONFIG pangommconfig.h)
_GTK2_FIND_LIBRARY (PANGOMM pangomm true true)
_GTK2_ADD_TARGET (PANGOMM GTK2_DEPENDS glibmm sigc++ pango gobject glib
GTK2_OPTIONAL_DEPENDS cairomm pangocairo cairo
OPTIONAL_INCLUDES ${FREETYPE_INCLUDE_DIR_ft2build} ${FREETYPE_INCLUDE_DIR_freetype2})
_GTK2_FIND_INCLUDE_DIR(GTK2_GLIBMM glibmm.h)
_GTK2_FIND_INCLUDE_DIR(GTK2_GLIBMMCONFIG glibmmconfig.h)
_GTK2_FIND_LIBRARY (GTK2_GLIBMM glibmm true true)
_GTK2_FIND_INCLUDE_DIR(GTK2_SIGC++ sigc++/sigc++.h) _GTK2_FIND_INCLUDE_DIR(GDKMM gdkmm.h)
_GTK2_FIND_INCLUDE_DIR(GTK2_SIGC++CONFIG sigc++config.h) _GTK2_FIND_INCLUDE_DIR(GDKMMCONFIG gdkmmconfig.h)
_GTK2_FIND_LIBRARY (GTK2_SIGC++ sigc true true) _GTK2_FIND_LIBRARY (GDKMM gdkmm true true)
_GTK2_ADD_TARGET (GDKMM GTK2_DEPENDS pangomm gtk glibmm sigc++ gdk atk pangoft2 gdk_pixbuf pango gobject glib
GTK2_OPTIONAL_DEPENDS giomm cairomm gio pangocairo cairo
OPTIONAL_INCLUDES ${FREETYPE_INCLUDE_DIR_ft2build} ${FREETYPE_INCLUDE_DIR_freetype2})
_GTK2_FIND_INCLUDE_DIR(GTKMM gtkmm.h)
_GTK2_FIND_INCLUDE_DIR(GTKMMCONFIG gtkmmconfig.h)
_GTK2_FIND_LIBRARY (GTKMM gtkmm true true)
_GTK2_ADD_TARGET (GTKMM GTK2_DEPENDS atkmm gdkmm pangomm gtk glibmm sigc++ gdk atk pangoft2 gdk_pixbuf pango gthread gobject glib
GTK2_OPTIONAL_DEPENDS giomm cairomm gio pangocairo cairo
OPTIONAL_INCLUDES ${FREETYPE_INCLUDE_DIR_ft2build} ${FREETYPE_INCLUDE_DIR_freetype2})
elseif(_GTK2_component STREQUAL "glade") elseif(_GTK2_component STREQUAL "glade")
_GTK2_FIND_INCLUDE_DIR(GTK2_GLADE glade/glade.h) _GTK2_FIND_INCLUDE_DIR(GLADE glade/glade.h)
_GTK2_FIND_LIBRARY (GTK2_GLADE glade false true) _GTK2_FIND_LIBRARY (GLADE glade false true)
_GTK2_ADD_TARGET (GLADE GTK2_DEPENDS gtk gdk atk gio pangoft2 gdk_pixbuf pango gobject glib
GTK2_OPTIONAL_DEPENDS pangocairo cairo
OPTIONAL_INCLUDES ${FREETYPE_INCLUDE_DIR_ft2build} ${FREETYPE_INCLUDE_DIR_freetype2})
elseif(_GTK2_component STREQUAL "glademm") elseif(_GTK2_component STREQUAL "glademm")
_GTK2_FIND_INCLUDE_DIR(GTK2_GLADEMM libglademm.h) _GTK2_FIND_INCLUDE_DIR(GLADEMM libglademm.h)
_GTK2_FIND_INCLUDE_DIR(GTK2_GLADEMMCONFIG libglademmconfig.h) _GTK2_FIND_INCLUDE_DIR(GLADEMMCONFIG libglademmconfig.h)
_GTK2_FIND_LIBRARY (GTK2_GLADEMM glademm true true) _GTK2_FIND_LIBRARY (GLADEMM glademm true true)
_GTK2_ADD_TARGET (GLADEMM GTK2_DEPENDS gtkmm glade atkmm gdkmm giomm pangomm glibmm sigc++ gtk gdk atk pangoft2 gdk_pixbuf pango gthread gobject glib
GTK2_OPTIONAL_DEPENDS giomm cairomm gio pangocairo cairo
OPTIONAL_INCLUDES ${FREETYPE_INCLUDE_DIR_ft2build} ${FREETYPE_INCLUDE_DIR_freetype2})
else() else()
message(FATAL_ERROR "Unknown GTK2 component ${_component}") message(FATAL_ERROR "Unknown GTK2 component ${_component}")
@ -562,20 +748,6 @@ if(NOT GTK2_FIND_VERSION AND GTK2_GTK_INCLUDE_DIR)
set(GTK2_VERSION ${GTK2_MAJOR_VERSION}.${GTK2_MINOR_VERSION}.${GTK2_PATCH_VERSION}) set(GTK2_VERSION ${GTK2_MAJOR_VERSION}.${GTK2_MINOR_VERSION}.${GTK2_PATCH_VERSION})
endif() endif()
#
# On MSVC, according to https://wiki.gnome.org/gtkmm/MSWindows, the /vd2 flag needs to be
# passed to the compiler in order to use gtkmm
#
if(MSVC)
foreach(_GTK2_component ${GTK2_FIND_COMPONENTS})
if(_GTK2_component STREQUAL "gtkmm")
set(GTK2_DEFINITIONS "/vd2")
elseif(_GTK2_component STREQUAL "glademm")
set(GTK2_DEFINITIONS "/vd2")
endif()
endforeach()
endif()
# #
# Try to enforce components # Try to enforce components
# #
@ -616,6 +788,8 @@ foreach(_GTK2_component ${GTK2_FIND_COMPONENTS})
GTK2_GLIBMMCONFIG_INCLUDE_DIR GTK2_GLIBMMCONFIG_INCLUDE_DIR
GTK2_GLIBMM_LIBRARY GTK2_GLIBMM_LIBRARY
FREETYPE_INCLUDE_DIR_ft2build
FREETYPE_INCLUDE_DIR_freetype2
) )
elseif(_GTK2_component STREQUAL "glade") elseif(_GTK2_component STREQUAL "glade")
FIND_PACKAGE_HANDLE_STANDARD_ARGS(GTK2_${_COMPONENT_UPPER} "The glade library was not found." FIND_PACKAGE_HANDLE_STANDARD_ARGS(GTK2_${_COMPONENT_UPPER} "The glade library was not found."

5
Tests/CMakeLists.txt
View File

@ -1072,6 +1072,11 @@ ${CMake_BINARY_DIR}/bin/cmake -DVERSION=master -P ${CMake_SOURCE_DIR}/Utilities/
endif() endif()
endif() endif()
find_package(GTK2 QUIET)
if(GTK2_FOUND)
add_subdirectory(FindGTK2)
endif()
add_test(ExternalProject ${CMAKE_CTEST_COMMAND} add_test(ExternalProject ${CMAKE_CTEST_COMMAND}
--build-and-test --build-and-test
"${CMake_SOURCE_DIR}/Tests/ExternalProject" "${CMake_SOURCE_DIR}/Tests/ExternalProject"

317
Tests/FindGTK2/CMakeLists.txt Normal file
View File

@ -0,0 +1,317 @@
find_package(GTK2 COMPONENTS gtk glade gtkmm glademm QUIET)
# Test GTK2 components
if(GTK2_GTK_FOUND)
add_test(GTK2Components.gtk ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/FindGTK2/gtk"
"${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Components/gtk"
${build_generator_args}
--build-target gtk-all-libs
--build-exe-dir "${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Components/gtk"
--force-new-ctest-process
--test-command ${CMAKE_CTEST_COMMAND} -V
)
endif()
if(GTK2_GTKMM_FOUND)
add_test(GTK2Components.gtkmm ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/FindGTK2/gtkmm"
"${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Components/gtkmm"
${build_generator_args}
--build-target gtkmm-all-libs
--build-exe-dir "${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Components/gtkmm"
--force-new-ctest-process
--test-command ${CMAKE_CTEST_COMMAND} -V
)
endif()
# Test GTK2 targets
if(TARGET GTK2::glib)
add_test(GTK2Targets.glib ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/FindGTK2/glib"
"${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/glib"
${build_generator_args}
--build-project glib
--build-exe-dir "${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/glib"
--force-new-ctest-process
--test-command ${CMAKE_CTEST_COMMAND} -V
)
endif()
if(TARGET GTK2::gobject)
add_test(GTK2Targets.gobject ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/FindGTK2/gobject"
"${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/gobject"
${build_generator_args}
--build-project gobject
--build-exe-dir "${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/gobject"
--force-new-ctest-process
--test-command ${CMAKE_CTEST_COMMAND} -V
)
endif()
if(TARGET GTK2::gio)
add_test(GTK2Targets.gio ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/FindGTK2/gio"
"${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/gio"
${build_generator_args}
--build-project gio
--build-exe-dir "${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/gio"
--force-new-ctest-process
--test-command ${CMAKE_CTEST_COMMAND} -V
)
endif()
if(TARGET GTK2::gmodule)
add_test(GTK2Targets.gmodule ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/FindGTK2/gmodule"
"${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/gmodule"
${build_generator_args}
--build-project gmodule
--build-exe-dir "${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/gmodule"
--force-new-ctest-process
--test-command ${CMAKE_CTEST_COMMAND} -V
)
endif()
if(TARGET GTK2::gthread)
add_test(GTK2Targets.gthread ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/FindGTK2/gthread"
"${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/gthread"
${build_generator_args}
--build-project gthread
--build-exe-dir "${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/gthread"
--force-new-ctest-process
--test-command ${CMAKE_CTEST_COMMAND} -V
)
endif()
if(TARGET GTK2::atk)
add_test(GTK2Targets.atk ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/FindGTK2/atk"
"${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/atk"
${build_generator_args}
--build-project atk
--build-exe-dir "${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/atk"
--force-new-ctest-process
--test-command ${CMAKE_CTEST_COMMAND} -V
)
endif()
if(TARGET GTK2::gdk_pixbuf)
add_test(GTK2Targets.gdk_pixbuf ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/FindGTK2/gdk_pixbuf"
"${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/gdk_pixbuf"
${build_generator_args}
--build-project gdk_pixbuf
--build-exe-dir "${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/gdk_pixbuf"
--force-new-ctest-process
--test-command ${CMAKE_CTEST_COMMAND} -V
)
endif()
if(TARGET GTK2::cairo)
add_test(GTK2Targets.cairo ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/FindGTK2/cairo"
"${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/cairo"
${build_generator_args}
--build-project cairo
--build-exe-dir "${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/cairo"
--force-new-ctest-process
--test-command ${CMAKE_CTEST_COMMAND} -V
)
endif()
if(TARGET GTK2::pango)
add_test(GTK2Targets.pango ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/FindGTK2/pango"
"${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/pango"
${build_generator_args}
--build-project pango
--build-exe-dir "${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/pango"
--force-new-ctest-process
--test-command ${CMAKE_CTEST_COMMAND} -V
)
endif()
if(TARGET GTK2::pangocairo)
add_test(GTK2Targets.pangocairo ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/FindGTK2/pangocairo"
"${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/pangocairo"
${build_generator_args}
--build-project pangocairo
--build-exe-dir "${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/pangocairo"
--force-new-ctest-process
--test-command ${CMAKE_CTEST_COMMAND} -V
)
endif()
if(TARGET GTK2::pangoxft)
add_test(GTK2Targets.pangoxft ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/FindGTK2/pangoxft"
"${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/pangoxft"
${build_generator_args}
--build-project pangoxft
--build-exe-dir "${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/pangoxft"
--force-new-ctest-process
--test-command ${CMAKE_CTEST_COMMAND} -V
)
endif()
if(TARGET GTK2::pangoft2)
add_test(GTK2Targets.pangoft2 ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/FindGTK2/pangoft2"
"${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/pangoft2"
${build_generator_args}
--build-project pangoft2
--build-exe-dir "${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/pangoft2"
--force-new-ctest-process
--test-command ${CMAKE_CTEST_COMMAND} -V
)
endif()
if(TARGET GTK2::gdk)
add_test(GTK2Targets.gdk ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/FindGTK2/gdk"
"${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/gdk"
${build_generator_args}
--build-project gdk
--build-exe-dir "${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/gdk"
--force-new-ctest-process
--test-command ${CMAKE_CTEST_COMMAND} -V
)
endif()
if(TARGET GTK2::gtk)
add_test(GTK2Targets.gtk ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/FindGTK2/gtk"
"${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/gtk"
${build_generator_args}
--build-project gtk
--build-exe-dir "${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/gtk"
--force-new-ctest-process
--test-command ${CMAKE_CTEST_COMMAND} -V
)
endif()
if(TARGET GTK2::sigc++)
add_test(GTK2Targets.sigc++ ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/FindGTK2/sigc++"
"${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/sigc++"
${build_generator_args}
--build-project sigc++
--build-exe-dir "${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/sigc++"
--force-new-ctest-process
--test-command ${CMAKE_CTEST_COMMAND} -V
)
endif()
if(TARGET GTK2::glibmm)
add_test(GTK2Targets.glibmm ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/FindGTK2/glibmm"
"${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/glibmm"
${build_generator_args}
--build-project glibmm
--build-exe-dir "${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/glibmm"
--force-new-ctest-process
--test-command ${CMAKE_CTEST_COMMAND} -V
)
endif()
if(TARGET GTK2::giomm)
add_test(GTK2Targets.giomm ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/FindGTK2/giomm"
"${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/giomm"
${build_generator_args}
--build-project giomm
--build-exe-dir "${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/giomm"
--force-new-ctest-process
--test-command ${CMAKE_CTEST_COMMAND} -V
)
endif()
if(TARGET GTK2::atkmm)
add_test(GTK2Targets.atkmm ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/FindGTK2/atkmm"
"${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/atkmm"
${build_generator_args}
--build-project atkmm
--build-exe-dir "${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/atkmm"
--force-new-ctest-process
--test-command ${CMAKE_CTEST_COMMAND} -V
)
endif()
if(TARGET GTK2::cairomm)
add_test(GTK2Targets.cairomm ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/FindGTK2/cairomm"
"${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/cairomm"
${build_generator_args}
--build-project cairomm
--build-exe-dir "${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/cairomm"
--force-new-ctest-process
--test-command ${CMAKE_CTEST_COMMAND} -V
)
endif()
if(TARGET GTK2::pangomm)
add_test(GTK2Targets.pangomm ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/FindGTK2/pangomm"
"${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/pangomm"
${build_generator_args}
--build-project pangomm
--build-exe-dir "${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/pangomm"
--force-new-ctest-process
--test-command ${CMAKE_CTEST_COMMAND} -V
)
endif()
if(TARGET GTK2::gdkmm)
add_test(GTK2Targets.gdkmm ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/FindGTK2/gdkmm"
"${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/GTK2Targets/gdkmm"
${build_generator_args}
--build-project gdkmm
--build-exe-dir "${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/GTK2Targets/gdkmm"
--force-new-ctest-process
--test-command ${CMAKE_CTEST_COMMAND} -V
)
endif()
if(TARGET GTK2::gtkmm)
add_test(GTK2Targets.gtkmm ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/FindGTK2/gtkmm"
"${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/gtkmm"
${build_generator_args}
--build-target gtkmm-target
--build-exe-dir "${CMake_BINARY_DIR}/Tests/FindGTK2/GTK2Targets/gtkmm"
--force-new-ctest-process
--test-command ${CMAKE_CTEST_COMMAND} -V
)
endif()

10
Tests/FindGTK2/atk/CMakeLists.txt Normal file
View File

@ -0,0 +1,10 @@
cmake_minimum_required(VERSION 2.8)
project(atk C)
find_package(GTK2 COMPONENTS gtk REQUIRED)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
add_executable(atk WIN32 main.c)
target_link_libraries(atk GTK2::atk)

7
Tests/FindGTK2/atk/main.c Normal file
View File

@ -0,0 +1,7 @@
#include <atk/atk.h>
int main(int argc, char *argv[])
{
const gchar *name = atk_get_toolkit_name();
return 0;
}

10
Tests/FindGTK2/atkmm/CMakeLists.txt Normal file
View File

@ -0,0 +1,10 @@
cmake_minimum_required(VERSION 2.8)
project(atkmm CXX)
find_package(GTK2 COMPONENTS gtk gtkmm REQUIRED)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
add_executable(atkmm WIN32 main.cpp)
target_link_libraries(atkmm GTK2::atkmm)

8
Tests/FindGTK2/atkmm/main.cpp Normal file
View File

@ -0,0 +1,8 @@
#include <atkmm.h>
#include <atkmm/init.h>
int main(int argc, char *argv[])
{
Atk::init();
return 0;
}

10
Tests/FindGTK2/cairo/CMakeLists.txt Normal file
View File

@ -0,0 +1,10 @@
cmake_minimum_required(VERSION 2.8)
project(cairo C)
find_package(GTK2 COMPONENTS gtk REQUIRED)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
add_executable(cairo WIN32 main.c)
target_link_libraries(cairo GTK2::cairo)

52
Tests/FindGTK2/cairo/main.c Normal file
View File

@ -0,0 +1,52 @@
/* Taken from http://cairographics.org/samples/ */
#include <cairo.h>
#include <math.h>
#include <stdio.h>
int main(int argc, char *argv[])
{
char *filename;
if (argc != 2)
{
fprintf (stderr, "Usage: %s OUTPUT_FILENAME\n", argv[0]);
return 1;
}
filename = argv[1];
double xc = 128.0;
double yc = 128.0;
double radius = 100.0;
double angle1 = 45.0 * (M_PI/180.0); /* angles are specified */
double angle2 = 180.0 * (M_PI/180.0); /* in radians */
cairo_surface_t *im = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, xc * 2, yc * 2);
cairo_t *cr = cairo_create(im);
cairo_set_line_width (cr, 10.0);
cairo_arc (cr, xc, yc, radius, angle1, angle2);
cairo_stroke (cr);
/* draw helping lines */
cairo_set_source_rgba (cr, 1, 0.2, 0.2, 0.6);
cairo_set_line_width (cr, 6.0);
cairo_arc (cr, xc, yc, 10.0, 0, 2*M_PI);
cairo_fill (cr);
cairo_arc (cr, xc, yc, radius, angle1, angle1);
cairo_line_to (cr, xc, yc);
cairo_arc (cr, xc, yc, radius, angle2, angle2);
cairo_line_to (cr, xc, yc);
cairo_stroke (cr);
cairo_status_t status = cairo_surface_write_to_png (im, filename);
cairo_surface_destroy (im);
if (status != CAIRO_STATUS_SUCCESS) {
fprintf(stderr, "Could not save png to '%s'\n", filename);
}
cairo_destroy(cr);
return 0;
}

10
Tests/FindGTK2/cairomm/CMakeLists.txt Normal file
View File

@ -0,0 +1,10 @@
cmake_minimum_required(VERSION 2.8)
project(cairomm CXX)
find_package(GTK2 COMPONENTS gtk gtkmm REQUIRED)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
add_executable(cairomm WIN32 main.cpp)
target_link_libraries(cairomm GTK2::cairomm)

62
Tests/FindGTK2/cairomm/main.cpp Normal file
View File

@ -0,0 +1,62 @@
// Taken from http://cgit.freedesktop.org/cairomm/plain/examples/surfaces/image-surface.cc
/* M_PI is defined in math.h in the case of Microsoft Visual C++, Solaris,
* et. al.
*/
#if defined(_MSC_VER)
#define _USE_MATH_DEFINES
#endif
#include <string>
#include <iostream>
#include <cairommconfig.h>
#include <cairomm/context.h>
#include <cairomm/surface.h>
#include <cmath>
int main()
{
Cairo::RefPtr<Cairo::ImageSurface> surface =
Cairo::ImageSurface::create(Cairo::FORMAT_ARGB32, 600, 400);
Cairo::RefPtr<Cairo::Context> cr = Cairo::Context::create(surface);
cr->save(); // save the state of the context
cr->set_source_rgb(0.86, 0.85, 0.47);
cr->paint(); // fill image with the color
cr->restore(); // color is back to black now
cr->save();
// draw a border around the image
cr->set_line_width(20.0); // make the line wider
cr->rectangle(0.0, 0.0, surface->get_width(), surface->get_height());
cr->stroke();
cr->set_source_rgba(0.0, 0.0, 0.0, 0.7);
// draw a circle in the center of the image
cr->arc(surface->get_width() / 2.0, surface->get_height() / 2.0,
surface->get_height() / 4.0, 0.0, 2.0 * M_PI);
cr->stroke();
// draw a diagonal line
cr->move_to(surface->get_width() / 4.0, surface->get_height() / 4.0);
cr->line_to(surface->get_width() * 3.0 / 4.0, surface->get_height() * 3.0 / 4.0);
cr->stroke();
cr->restore();
#ifdef CAIRO_HAS_PNG_FUNCTIONS
std::string filename = "image.png";
surface->write_to_png(filename);
std::cout << "Wrote png file \"" << filename << "\"" << std::endl;
#else
std::cout << "You must compile cairo with PNG support for this example to work."
<< std::endl;
#endif
}

10
Tests/FindGTK2/gdk/CMakeLists.txt Normal file
View File

@ -0,0 +1,10 @@
cmake_minimum_required(VERSION 2.8)
project(gdk C)
find_package(GTK2 COMPONENTS gtk REQUIRED)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
add_executable(gdk WIN32 main.c)
target_link_libraries(gdk GTK2::gdk)

7
Tests/FindGTK2/gdk/main.c Normal file
View File

@ -0,0 +1,7 @@
#include <gdk/gdk.h>
int main(int argc, char *argv[])
{
gdk_init(argc, argv);
return 0;
}

10
Tests/FindGTK2/gdk_pixbuf/CMakeLists.txt Normal file
View File

@ -0,0 +1,10 @@
cmake_minimum_required(VERSION 2.8)
project(gdk_pixbuf C)
find_package(GTK2 COMPONENTS gtk REQUIRED)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
add_executable(gdk_pixbuf WIN32 main.c)
target_link_libraries(gdk_pixbuf GTK2::gdk_pixbuf)

10
Tests/FindGTK2/gdk_pixbuf/main.c Normal file
View File

@ -0,0 +1,10 @@
#include <gdk-pixbuf/gdk-pixbuf.h>
int main(int argc, char *argv[])
{
const char *version = gdk_pixbuf_version;
const guint major = gdk_pixbuf_major_version;
const guint minor = gdk_pixbuf_minor_version;
const guint micro = gdk_pixbuf_micro_version;
return 0;
}

10
Tests/FindGTK2/gdkmm/CMakeLists.txt Normal file
View File

@ -0,0 +1,10 @@
cmake_minimum_required(VERSION 2.8)
project(gdkmm CXX)
find_package(GTK2 COMPONENTS gtk gtkmm REQUIRED)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
add_executable(gdkmm WIN32 main.cpp)
target_link_libraries(gdkmm GTK2::gdkmm)

7
Tests/FindGTK2/gdkmm/main.cpp Normal file
View File

@ -0,0 +1,7 @@
#include <gdkmm.h>
int main(int argc, char *argv[])
{
Gdk::Color red = Gdk::Color("red");
return 0;
}

10
Tests/FindGTK2/gio/CMakeLists.txt Normal file
View File

@ -0,0 +1,10 @@
cmake_minimum_required(VERSION 2.8)
project(gio C)
find_package(GTK2 COMPONENTS gtk REQUIRED)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
add_executable(gio WIN32 main.c)
target_link_libraries(gio GTK2::gio)

8
Tests/FindGTK2/gio/main.c Normal file
View File

@ -0,0 +1,8 @@
#include <gio/gio.h>
int main(int argc, char *argv[])
{
GFile *file = g_file_new_for_path("path");
g_object_unref(file);
return 0;
}

10
Tests/FindGTK2/giomm/CMakeLists.txt Normal file
View File

@ -0,0 +1,10 @@
cmake_minimum_required(VERSION 2.8)
project(giomm CXX)
find_package(GTK2 COMPONENTS gtk gtkmm REQUIRED)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
add_executable(giomm WIN32 main.cpp)
target_link_libraries(giomm GTK2::giomm)

7
Tests/FindGTK2/giomm/main.cpp Normal file
View File

@ -0,0 +1,7 @@
#include <giomm.h>
int main(int argc, char *argv[])
{
Glib::RefPtr<Gio::File> f = Gio::File::create_for_path("path");
return 0;
}

10
Tests/FindGTK2/glib/CMakeLists.txt Normal file
View File

@ -0,0 +1,10 @@
cmake_minimum_required(VERSION 2.8)
project(glib C)
find_package(GTK2 COMPONENTS gtk REQUIRED)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
add_executable(glib WIN32 main.c)
target_link_libraries(glib GTK2::glib)

11
Tests/FindGTK2/glib/main.c Normal file
View File

@ -0,0 +1,11 @@
#include <glib.h>
int main(int argc, char *argv[])
{
if (!g_file_test("file", G_FILE_TEST_EXISTS)) {
g_print("File not found. \n");
} else {
g_print("File found. \n");
}
return 0;
}

10
Tests/FindGTK2/glibmm/CMakeLists.txt Normal file
View File

@ -0,0 +1,10 @@
cmake_minimum_required(VERSION 2.8)
project(glibmm CXX)
find_package(GTK2 COMPONENTS gtk gtkmm REQUIRED)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
add_executable(glibmm WIN32 main.cpp)
target_link_libraries(glibmm GTK2::glibmm)

7
Tests/FindGTK2/glibmm/main.cpp Normal file
View File

@ -0,0 +1,7 @@
#include <glibmm/init.h>
int main(int, char**)
{
Glib::init();
return 0;
}

10
Tests/FindGTK2/gmodule/CMakeLists.txt Normal file
View File

@ -0,0 +1,10 @@
cmake_minimum_required(VERSION 2.8)
project(gmodule C)
find_package(GTK2 COMPONENTS gtk REQUIRED)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
add_executable(gmodule WIN32 main.c)
target_link_libraries(gmodule GTK2::gmodule)

7
Tests/FindGTK2/gmodule/main.c Normal file
View File

@ -0,0 +1,7 @@
#include <gmodule.h>
int main(int argc, char *argv[])
{
gboolean b = g_module_supported();
return 0;
}

10
Tests/FindGTK2/gobject/CMakeLists.txt Normal file
View File

@ -0,0 +1,10 @@
cmake_minimum_required(VERSION 2.8)
project(gobject C)
find_package(GTK2 COMPONENTS gtk REQUIRED)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
add_executable(gobject WIN32 main.c)
target_link_libraries(gobject GTK2::gobject)

72
Tests/FindGTK2/gobject/main.c Normal file
View File

@ -0,0 +1,72 @@
/* Taken from https://developer.gnome.org/gobject/stable/chapter-gobject.html */
#include <glib-object.h>
#define MAMAN_TYPE_BAR (maman_bar_get_type ())
#define MAMAN_BAR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MAMAN_TYPE_BAR, MamanBar))
#define MAMAN_IS_BAR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MAMAN_TYPE_BAR))
#define MAMAN_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MAMAN_TYPE_BAR, MamanBarClass))
#define MAMAN_IS_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MAMAN_TYPE_BAR))
#define MAMAN_BAR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MAMAN_TYPE_BAR, MamanBarClass))
typedef struct _MamanBar MamanBar;
typedef struct _MamanBarClass MamanBarClass;
struct _MamanBar
{
GObject parent_instance;
/* instance members */
};
struct _MamanBarClass
{
GObjectClass parent_class;
/* class members */
};
/* will create maman_bar_get_type and set maman_bar_parent_class */
G_DEFINE_TYPE (MamanBar, maman_bar, G_TYPE_OBJECT);
static GObject *
maman_bar_constructor (GType gtype,
guint n_properties,
GObjectConstructParam *properties)
{
GObject *obj;
{
/* Always chain up to the parent constructor */
obj = G_OBJECT_CLASS (maman_bar_parent_class)->constructor (gtype, n_properties, properties);
}
/* update the object state depending on constructor properties */
return obj;
}
static void
maman_bar_class_init (MamanBarClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
gobject_class->constructor = maman_bar_constructor;
}
static void
maman_bar_init (MamanBar *self)
{
/* initialize the object */
}
int
main(int argc, char *argv[])
{
MamanBar *bar = g_object_new (MAMAN_TYPE_BAR, NULL);
g_object_unref(bar);
return 0;
}

10
Tests/FindGTK2/gthread/CMakeLists.txt Normal file
View File

@ -0,0 +1,10 @@
cmake_minimum_required(VERSION 2.8)
project(gthread C)
find_package(GTK2 COMPONENTS gtk REQUIRED)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
add_executable(gthread WIN32 main.c)
target_link_libraries(gthread GTK2::gthread)

7
Tests/FindGTK2/gthread/main.c Normal file
View File

@ -0,0 +1,7 @@
#include <glib.h>
int main(int argc, char *argv[])
{
g_thread_init(NULL);
return 0;
}

14
Tests/FindGTK2/gtk/CMakeLists.txt Normal file
View File

@ -0,0 +1,14 @@
cmake_minimum_required(VERSION 2.8)
project(gtk C)
find_package(GTK2 COMPONENTS gtk REQUIRED)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
add_executable(gtk WIN32 main.c)
target_link_libraries(gtk GTK2::gtk)
add_executable(gtk-all-libs WIN32 main.c)
target_link_libraries(gtk-all-libs ${GTK2_LIBRARIES})
target_include_directories(gtk-all-libs PRIVATE ${GTK2_INCLUDE_DIRS})

15
Tests/FindGTK2/gtk/main.c Normal file
View File

@ -0,0 +1,15 @@
#include <gtk/gtk.h>
int main(int argc, char *argv[])
{
GtkWidget *window;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_show (window);
gtk_main ();
return 0;
}

14
Tests/FindGTK2/gtkmm/CMakeLists.txt Normal file
View File

@ -0,0 +1,14 @@
cmake_minimum_required(VERSION 2.8)
project(gtkmm CXX)
find_package(GTK2 COMPONENTS gtk gtkmm REQUIRED)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
add_executable(gtkmm-target WIN32 main.cpp helloworld.cpp helloworld.h)
target_link_libraries(gtkmm-target GTK2::gtkmm)
add_executable(gtkmm-all-libs WIN32 main.cpp helloworld.cpp helloworld.h)
target_link_libraries(gtkmm-all-libs ${GTK2_LIBRARIES})
target_include_directories(gtkmm-all-libs PRIVATE ${GTK2_INCLUDE_DIRS})

29
Tests/FindGTK2/gtkmm/helloworld.cpp Normal file
View File

@ -0,0 +1,29 @@
#include "helloworld.h"
#include <iostream>
HelloWorld::HelloWorld()
: m_button("Hello World") // creates a new button with label "Hello World".
{
// Sets the border width of the window.
set_border_width(10);
// When the button receives the "clicked" signal, it will call the
// on_button_clicked() method defined below.
m_button.signal_clicked().connect(sigc::mem_fun(*this,
&HelloWorld::on_button_clicked));
// This packs the button into the Window (a container).
add(m_button);
// The final step is to display this newly created widget...
m_button.show();
}
HelloWorld::~HelloWorld()
{
}
void HelloWorld::on_button_clicked()
{
std::cout << "Hello World" << std::endl;
}

20
Tests/FindGTK2/gtkmm/helloworld.h Normal file
View File

@ -0,0 +1,20 @@
#ifndef GTKMM_EXAMPLE_HELLOWORLD_H
#define GTKMM_EXAMPLE_HELLOWORLD_H
#include <gtkmm.h>
class HelloWorld : public Gtk::Window
{
public:
HelloWorld();
virtual ~HelloWorld();
protected:
//Signal handlers:
void on_button_clicked();
//Member widgets:
Gtk::Button m_button;
};
#endif // GTKMM_EXAMPLE_HELLOWORLD_H

13
Tests/FindGTK2/gtkmm/main.cpp Normal file
View File

@ -0,0 +1,13 @@
#include <gtkmm.h>
#include "helloworld.h"
int main(int argc, char *argv[])
{
Gtk::Main kit(argc, argv);
HelloWorld helloworld;
//Shows the window and returns when it is closed.
Gtk::Main::run(helloworld);
return 0;
}

10
Tests/FindGTK2/pango/CMakeLists.txt Normal file
View File

@ -0,0 +1,10 @@
cmake_minimum_required(VERSION 2.8)
project(pango C)
find_package(GTK2 COMPONENTS gtk REQUIRED)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
add_executable(pango WIN32 main.c)
target_link_libraries(pango GTK2::pango)

7
Tests/FindGTK2/pango/main.c Normal file
View File

@ -0,0 +1,7 @@
#include <pango/pango.h>
int main(int argc, char *argv[])
{
gboolean ret = pango_color_parse(NULL, "#ffffff");
return 0;
}

10
Tests/FindGTK2/pangocairo/CMakeLists.txt Normal file
View File

@ -0,0 +1,10 @@
cmake_minimum_required(VERSION 2.8)
project(pangocairo C)
find_package(GTK2 COMPONENTS gtk REQUIRED)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
add_executable(pangocairo WIN32 main.c)
target_link_libraries(pangocairo GTK2::pangocairo m)

72
Tests/FindGTK2/pangocairo/main.c Normal file
View File

@ -0,0 +1,72 @@
/* Taken from https://developer.gnome.org/pango/stable/pango-Cairo-Rendering.html */
#include <math.h>
#include <pango/pangocairo.h>
static void
draw_text (cairo_t *cr)
{
#define RADIUS 150
#define N_WORDS 10
#define FONT "Sans Bold 27"
PangoLayout *layout;
PangoFontDescription *desc;
int i;
/* Center coordinates on the middle of the region we are drawing
*/
cairo_translate (cr, RADIUS, RADIUS);
/* Create a PangoLayout, set the font and text */
layout = pango_cairo_create_layout (cr);
pango_layout_set_text (layout, "Text", -1);
desc = pango_font_description_from_string (FONT);
pango_layout_set_font_description (layout, desc);
pango_font_description_free (desc);
/* Draw the layout N_WORDS times in a circle */
for (i = 0; i < N_WORDS; i++)
{
int width, height;
double angle = (360. * i) / N_WORDS;
double red;
cairo_save (cr);
/* Gradient from red at angle == 60 to blue at angle == 240 */
red = (1 + cos ((angle - 60) * G_PI / 180.)) / 2;
cairo_set_source_rgb (cr, red, 0, 1.0 - red);
cairo_rotate (cr, angle * G_PI / 180.);
/* Inform Pango to re-layout the text with the new transformation */
pango_cairo_update_layout (cr, layout);
pango_layout_get_size (layout, &width, &height);
cairo_move_to (cr, - ((double)width / PANGO_SCALE) / 2, - RADIUS);
pango_cairo_show_layout (cr, layout);
cairo_restore (cr);
}
/* free the layout object */
g_object_unref (layout);
}
int main (int argc, char **argv)
{
cairo_t *cr;
char *filename;
cairo_status_t status;
cairo_surface_t *surface;
if (argc != 2)
{
g_printerr ("Usage: cairosimple OUTPUT_FILENAME\n");
return 1;
}
filename = argv[1];
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
2 * RADIUS, 2 * RADIUS);
cr = cairo_create (surface);
cairo_set_source_rgb (cr, 1.0, 1.0, 1.0);
cairo_paint (cr);
draw_text (cr);
cairo_destroy (cr);
status = cairo_surface_write_to_png (surface, filename);
cairo_surface_destroy (surface);
if (status != CAIRO_STATUS_SUCCESS)
{
g_printerr ("Could not save png to '%s'\n", filename);
return 1;
}
return 0;
}

10
Tests/FindGTK2/pangoft2/CMakeLists.txt Normal file
View File

@ -0,0 +1,10 @@
cmake_minimum_required(VERSION 2.8)
project(pangoft2 C)
find_package(GTK2 COMPONENTS gtk REQUIRED)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
add_executable(pangoft2 WIN32 main.c)
target_link_libraries(pangoft2 GTK2::pangoft2)

8
Tests/FindGTK2/pangoft2/main.c Normal file
View File

@ -0,0 +1,8 @@
#include <pango/pangoft2.h>
int main(int argc, char *argv[])
{
PangoFontMap* pfm = pango_ft2_font_map_new();
g_object_unref(pfm);
return 0;
}

10
Tests/FindGTK2/pangomm/CMakeLists.txt Normal file
View File

@ -0,0 +1,10 @@
cmake_minimum_required(VERSION 2.8)
project(pangomm CXX)
find_package(GTK2 COMPONENTS gtk gtkmm REQUIRED)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
add_executable(pangomm WIN32 main.cpp)
target_link_libraries(pangomm GTK2::pangomm)

8
Tests/FindGTK2/pangomm/main.cpp Normal file
View File

@ -0,0 +1,8 @@
#include <pangomm.h>
#include <pangomm/init.h>
int main(int argc, char *argv[])
{
Pango::init();
return 0;
}

10
Tests/FindGTK2/pangoxft/CMakeLists.txt Normal file
View File

@ -0,0 +1,10 @@
cmake_minimum_required(VERSION 2.8)
project(pangoxft C)
find_package(GTK2 COMPONENTS gtk REQUIRED)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
add_executable(pangoxft WIN32 main.c)
target_link_libraries(pangoxft GTK2::pangoxft)

7
Tests/FindGTK2/pangoxft/main.c Normal file
View File

@ -0,0 +1,7 @@
#include <pango/pangoxft.h>
int main(int argc, char *argv[])
{
pango_xft_get_context(NULL, 0);
return 0;
}

10
Tests/FindGTK2/sigc++/CMakeLists.txt Normal file
View File

@ -0,0 +1,10 @@
cmake_minimum_required(VERSION 2.8)
project(sigc++ CXX)
find_package(GTK2 COMPONENTS gtk gtkmm REQUIRED)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
add_executable(sigc++ WIN32 main.cpp)
target_link_libraries(sigc++ GTK2::sigc++)

30
Tests/FindGTK2/sigc++/main.cpp Normal file
View File

@ -0,0 +1,30 @@
// Taken from https://developer.gnome.org/libsigc++-tutorial/stable/ch02.html
#include <sigc++/sigc++.h>
#include <iostream>
class AlienDetector
{
public:
AlienDetector() {}
void run() {}
sigc::signal<void> signal_detected;
};
void warn_people()
{
std::cout << "There are aliens in the carpark!" << std::endl;
}
int main()
{
AlienDetector mydetector;
mydetector.signal_detected.connect( sigc::ptr_fun(warn_people) );
mydetector.run();
return 0;
}