pax_global_header00006660000000000000000000000064135176024050014515gustar00rootroot0000000000000052 comment=d041cd5bd5527926ca1217c751b9e7878eed1283 cmake-vala-r3/000077500000000000000000000000001351760240500134045ustar00rootroot00000000000000cmake-vala-r3/.gitlab-ci.yml000066400000000000000000000007151351760240500160430ustar00rootroot00000000000000stages: - build before_script: - mkdir -p _ccache - export CCACHE_BASEDIR=${PWD} - export CCACHE_DIR=${PWD}/_ccache cache: paths: - _ccache/ build-main: image: alpine:edge stage: build script: - apk add --update cmake make musl-dev gcc - mkdir build && cd build && cmake .. -DCMAKE_INSTALL_PREFIX=/usr - make - make install - make dist artifacts: paths: - "build/vala-cmake-modules*.tar.xz" expire_in: 1 week cmake-vala-r3/CMakeLists.txt000066400000000000000000000042451351760240500161510ustar00rootroot00000000000000cmake_minimum_required (VERSION 3.3) cmake_policy (VERSION 3.3) project (VCM LANGUAGES NONE) enable_testing () include(GNUInstallDirs) include(FeatureSummary) set(PROJECT_VERSION 1) set(PACKAGE_INSTALL_DIR ${CMAKE_INSTALL_FULL_DATAROOTDIR}/${CMAKE_PROJECT_NAME}) set(FIND_MODULE_DIR ${PACKAGE_INSTALL_DIR}/Find/) set(GIT_VERSION_MODULE_DIR ${PACKAGE_INSTALL_DIR}/GitVersion/) set(GLIB_MODULE_DIR ${PACKAGE_INSTALL_DIR}/GLib/) set(UTILITY_MODULE_DIR ${PACKAGE_INSTALL_DIR}/Utility/) set(VALA_MODULE_DIR ${PACKAGE_INSTALL_DIR}/Vala/) install(DIRECTORY Find DESTINATION ${PACKAGE_INSTALL_DIR} USE_SOURCE_PERMISSIONS) install(DIRECTORY GitVersion DESTINATION ${PACKAGE_INSTALL_DIR} USE_SOURCE_PERMISSIONS) install(DIRECTORY GLib DESTINATION ${PACKAGE_INSTALL_DIR} USE_SOURCE_PERMISSIONS) install(DIRECTORY Utility DESTINATION ${PACKAGE_INSTALL_DIR} USE_SOURCE_PERMISSIONS) install(DIRECTORY Vala DESTINATION ${PACKAGE_INSTALL_DIR} USE_SOURCE_PERMISSIONS) # # Config.cmake file # include(CMakePackageConfigHelpers) configure_package_config_file( VCMConfig.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/VCMConfig.cmake INSTALL_DESTINATION ${PACKAGE_INSTALL_DIR} PATH_VARS FIND_MODULE_DIR GIT_VERSION_MODULE_DIR GLIB_MODULE_DIR UTILITY_MODULE_DIR VALA_MODULE_DIR ) write_basic_package_version_file( ${CMAKE_CURRENT_BINARY_DIR}/VCMConfigVersion.cmake VERSION "${PROJECT_VERSION}" COMPATIBILITY AnyNewerVersion ) install( FILES ${CMAKE_CURRENT_BINARY_DIR}/VCMConfig.cmake ${CMAKE_CURRENT_BINARY_DIR}/VCMConfigVersion.cmake DESTINATION ${PACKAGE_INSTALL_DIR} ) # # Packaging # set (CPACK_PACKAGE_NAME vala-cmake-modules) set (CPACK_PACKAGE_RELEASE ${PROJECT_VERSION}) set (CPACK_SOURCE_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}-r${CPACK_PACKAGE_RELEASE}") set (CPACK_SOURCE_IGNORE_FILES "/VCMSubmodule.cmake;/build/;/.gitmodules;/.git;/.gitignore;~$;${CPACK_SOURCE_IGNORE_FILES}") set (CPACK_SOURCE_GENERATOR "TXZ") include (CPack) add_custom_target (dist COMMAND ${CMAKE_MAKE_PROGRAM} package_source) # # Feature summary # feature_summary( FATAL_ON_MISSING_REQUIRED_PACKAGES WHAT ALL ) cmake-vala-r3/Find/000077500000000000000000000000001351760240500142645ustar00rootroot00000000000000cmake-vala-r3/Find/FindBAMF.cmake000066400000000000000000000074451351760240500166060ustar00rootroot00000000000000# - Try to find Libbamf and its GTK component # # Copyright (C) 2018 Konstantin Pugin # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions # are met: # 1. Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # 2. Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND ITS CONTRIBUTORS ``AS # IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, # THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR ITS # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; # OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, # WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR # OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF # ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. INCLUDE(FindPackageHandleStandardArgs) include(GNUInstallDirs) FIND_PACKAGE(PkgConfig QUIET) PKG_CHECK_MODULES(PC_BAMF QUIET libbamf3) FIND_LIBRARY(BAMF_LIB_LIBRARY NAMES bamf3 HINTS ${PC_BAMF_LIBDIR} ${PC_BAMF_LIBRARY_DIRS} ) FIND_PATH(BAMF_LIB_INCLUDE NAMES libbamf/libbamf.h HINTS ${PC_BAMF_INCLUDEDIR} ${PC_BAMF_INCLUDE_DIRS} PATH_SUFFIXES libbamf3 ) SET(BAMF_LIB_INCLUDE_DIRS ${BAMF_LIB_INCLUDE}) # Version detection SET(BAMF_LIB_VERSION "${PC_BAMF_VERSION}") SET(BAMF_VERSION "${BAMF_LIB_VERSION}") if(BAMF_LIB_LIBRARY AND BAMF_LIB_INCLUDE_DIRS) set(BAMF_LIB_FOUND TRUE) else() set(BAMF_LIB_FOUND FALSE) endif() mark_as_advanced( BAMF_LIB_LIBRARY BAMF_LIB_INCLUDE_DIRS ) if(BAMF_LIB_FOUND) list(APPEND BAMF_LIBRARIES "${BAMF_LIB_LIBRARY}") list(APPEND BAMF_INCLUDE_DIRS "${BAMF_LIB_INCLUDE_DIRS}") set(BAMF_DEFINITIONS ${BAMF_DEFINITIONS} ${PC_BAMF_DEFINITIONS}) if(NOT TARGET BAMF::LIB) add_library(BAMF::LIB UNKNOWN IMPORTED) set_target_properties(BAMF::LIB PROPERTIES IMPORTED_LOCATION "${BAMF_LIB_LIBRARY}" INTERFACE_COMPILE_OPTIONS "${PC_BAMF_DEFINITIONS}" INTERFACE_INCLUDE_DIRECTORIES "${BAMF_LIB_INCLUDE_DIRS}" ) endif() list(APPEND BAMF_TARGETS "BAMF::LIB") endif() get_filename_component(BAMF_LIBDIR ${BAMF_LIB_LIBRARY} DIRECTORY) find_program(BAMF_DAEMON_EXECUTABLE bamfdaemon HINTS ${CMAKE_INSTALL_FULL_LIBDIR} ${CMAKE_INSTALL_FULL_LIBEXECDIR} ${BAMF_LIBDIR} PATH_SUFFIXES bamf ) SET(BAMF_DAEMON_VERSION "${BAMF_VERSION}") if(BAMF_DAEMON_EXECUTABLE) set(BAMF_DAEMON_FOUND TRUE) else() set(BAMF_DAEMON_FOUND FALSE) endif() mark_as_advanced( BAMF_DAEMON_EXECUTABLE ) if(BAMF_DAEMON_FOUND) if(NOT TARGET BAMF::DAEMON) add_executable(BAMF::DAEMON IMPORTED) endif() list(APPEND BAMF_TARGETS "BAMF::DAEMON") endif() if(BAMF_DAEMON_FOUND OR BAMF_LIB_FOUND) set(BAMF_EXISTS TRUE) endif() FIND_PACKAGE_HANDLE_STANDARD_ARGS(BAMF REQUIRED_VARS BAMF_EXISTS HANDLE_COMPONENTS VERSION_VAR BAMF_VERSION) if(BAMF_LIBRARIES) list(REMOVE_DUPLICATES BAMF_LIBRARIES) endif() if(BAMF_INCLUDE_DIRS) list(REMOVE_DUPLICATES BAMF_INCLUDE_DIRS) endif() if(BAMF_DEFINITIONS) list(REMOVE_DUPLICATES BAMF_DEFINITIONS) endif() if(BAMF_TARGETS) list(REMOVE_DUPLICATES BAMF_TARGETS) endif() cmake-vala-r3/Find/FindGTK.cmake000066400000000000000000000253741351760240500165270ustar00rootroot00000000000000# - Try to find GTK and its components adn platforms # # Copyright (C) 2012 Raphael Kubo da Costa # Copyright (C) 2018 Konstantin Pugin # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions # are met: # 1. Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # 2. Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND ITS CONTRIBUTORS ``AS # IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, # THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR ITS # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; # OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, # WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR # OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF # ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #defined components: set(GTK_COMP_LIBRARIES GDK GTK UNIX_PRINT) set(GTK_COMP_TOOLS BUILDER_TOOL ENCODE_SYMBOLIC_SVG) set(GTK_COMP_PLATFORMS X11 BROADWAY WAYLAND) set(GTK_VERSION_MAX_SUPPORTED 3) INCLUDE(FindPackageHandleStandardArgs) FIND_PACKAGE(PkgConfig QUIET) #Version checker - sets seachable version if (${GTK_FIND_VERSION_MAJOR}) set(_module_name GTK${GTK_FIND_VERSION_MAJOR}) set(_version_num ${GTK_FIND_VERSION_MAJOR}.0) set(_version_short ${GTK_FIND_VERSION_MAJOR}) else() set(_module_name GTK${GTK_VERSION_MAX_SUPPORTED}) set(_version_num ${GTK_VERSION_MAX_SUPPORTED}.0) set(_version_short ${GTK_VERSION_MAX_SUPPORTED}) endif() #Search for GDK and dependencies in include files PKG_CHECK_MODULES(PC_GDK QUIET gdk-${_version_num}) find_library(${_module_name}_GDK_LIBRARY NAMES gdk-${_version_short} gdk-x11-${_version_num} HINTS ${PC_GDK_LIBRARY_DIRS} ) GET_FILENAME_COMPONENT(_GDK_LIBRARY_DIR ${${_module_name}_GDK_LIBRARY} PATH) FIND_PATH(${_module_name}_GDK_CONFIG_INCLUDE_DIR NAMES gdkconfig.h HINTS ${PC_GDK_LIBDIR} ${PC_GDK_LIBRARY_DIRS} ${_GDK_LIBRARY_DIR} ${PC_GDK_INCLUDE_DIRS} PATH_SUFFIXES gdk-${_version_num}/include gtk-${_version_num}/gdk ) PKG_CHECK_MODULES(PC_HB QUIET harfbuzz) find_path(${_module_name}_INCLUDE_HB NAMES hb.h HINTS ${PC_HB_INCLUDE_DIRS} PATH_SUFFIXES harfbuzz ) PKG_CHECK_MODULES(PC_PANGO QUIET pango) find_path(${_module_name}_INCLUDE_PANGO NAMES pango/pango.h HINTS ${PC_PANGO_INCLUDE_DIRS} PATH_SUFFIXES pango-1.0 ) PKG_CHECK_MODULES(PC_CAIRO QUIET cairo) find_path(${_module_name}_INCLUDE_CAIRO NAMES cairo.h HINTS ${PC_CAIRO_INCLUDE_DIRS} PATH_SUFFIXES cairo ) PKG_CHECK_MODULES(PC_PIXBUF QUIET gdk-pixbuf-2.0) find_path(${_module_name}_INCLUDE_GDK_PIXBUF NAMES gdk-pixbuf/gdk-pixbuf.h HINTS ${PC_PIXBUF_INCLUDE_DIRS} PATH_SUFFIXES gdk-pixbuf-2.0 ) find_path(${_module_name}_INCLUDE_GDK NAMES gdk/gdk.h HINTS ${PC_GDK_INCLUDE_DIRS} PATH_SUFFIXES gdk-${_version_num} ) set(${_module_name}_GDK_INCLUDE_DIR ${${_module_name}_INCLUDE_GDK} ${${_module_name}_INCLUDE_PANGO} ${${_module_name}_INCLUDE_HB} ${${_module_name}_INCLUDE_CAIRO} ${${_module_name}_INCLUDE_GDK_PIXBUF} ${${_module_name}_GDK_CONFIG_INCLUDE_DIR}) if(${_module_name}_GDK_INCLUDE_DIR AND ${_module_name}_GDK_LIBRARY) set(${_module_name}_GDK_FOUND TRUE) else() set(${_module_name}_GDK_FOUND FALSE) endif() set(GTK_GDK_FOUND ${${_module_name}_GDK_FOUND}) mark_as_advanced( ${_module_name}_GDK_LIBRARY ${_module_name}_GDK_INCLUDE_DIR ) if(${_module_name}_GDK_FOUND) list(APPEND ${_module_name}_LIBRARIES "${${_module_name}_GDK_LIBRARY}") list(APPEND ${_module_name}_INCLUDE_DIRS "${${_module_name}_GDK_INCLUDE_DIR}") set(${_module_name}_DEFINITIONS ${${_module_name}_DEFINITIONS} ${PC_GDK_DEFINITIONS}) if(NOT TARGET ${_module_name}::GDK) add_library(${_module_name}::GDK UNKNOWN IMPORTED) set_target_properties(${_module_name}::GDK PROPERTIES IMPORTED_LOCATION "${${_module_name}_GDK_LIBRARY}" INTERFACE_COMPILE_OPTIONS "${PC_GDK_DEFINITIONS}" INTERFACE_INCLUDE_DIRECTORIES "${${_module_name}_GDK_INCLUDE_DIR}" ) endif() list(APPEND ${_module_name}_TARGETS "${_module_name}::GDK") endif() if(${_module_name}_GDK_FOUND) # Platforms detection FILE(READ "${${_module_name}_GDK_CONFIG_INCLUDE_DIR}/gdkconfig.h" GDKCONFIG_H_CONTENTS) foreach(_platform ${GTK_COMP_PLATFORMS}) STRING(FIND "${GDKCONFIG_H_CONTENTS}" "#define GDK_WINDOWING_${_platform}" _INT) if(_INT LESS 0) set(${_module_name}_${_platform}_FOUND FALSE) else() set(${_module_name}_${_platform}_FOUND TRUE) endif() set(GTK_${_platform}_FOUND ${${_module_name}_${_platform}_FOUND}) endforeach() else() foreach(_platform ${GTK_COMP_PLATFORMS}) set(${_module_name}_${_platform}_FOUND FALSE) endforeach() endif() #Search for GTK and dependencies in include files PKG_CHECK_MODULES(PC_${_module_name} QUIET gtk+-${_version_num}) FIND_LIBRARY(${_module_name}_GTK_LIBRARY NAMES gtk-${_version_short} gtk-x11-${_version_num} HINTS ${PC_${_module_name}_LIBDIR} ${PC_${_module_name}_LIBRARY_DIRS} ) FIND_PATH(${_module_name}_GTK_INCLUDE NAMES gtk/gtk.h HINTS ${PC_${_module_name}_INCLUDEDIR} ${PC_${_module_name}_INCLUDE_DIRS} PATH_SUFFIXES gtk-${_version_num} ) PKG_CHECK_MODULES(PC_ATK QUIET atk-1.0) FIND_PATH(${_module_name}_ATK_INCLUDE NAMES atk/atk.h HINTS ${PC_ATK_INCLUDEDIR} ${PC_ATK_INCLUDE_DIRS} PATH_SUFFIXES atk-1.0 ) set(${_module_name}_GTK_INCLUDE_DIRS ${${_module_name}_ATK_INCLUDE} ${${_module_name}_GTK_INCLUDE}) if(${_module_name}_GTK_INCLUDE_DIRS AND ${_module_name}_GTK_LIBRARY) set(${_module_name}_GTK_FOUND TRUE) else() set(${_module_name}_GTK_FOUND FALSE) endif() set(GTK_GTK_FOUND ${${_module_name}_GTK_FOUND}) if(${_module_name}_GTK_FOUND) # Version detection FILE(READ "${${_module_name}_GTK_INCLUDE}/gtk/gtkversion.h" GTKVERSION_H_CONTENTS) STRING(REGEX MATCH "#define GTK_MAJOR_VERSION([ \t]+)\\(([0-9]+)\\)" _dummy "${GTKVERSION_H_CONTENTS}") SET(${_module_name}_VERSION_MAJOR "${CMAKE_MATCH_2}") STRING(REGEX MATCH "#define GTK_MINOR_VERSION([ \t]+)\\(([0-9]+)\\)" _dummy "${GTKVERSION_H_CONTENTS}") SET(${_module_name}_VERSION_MINOR "${CMAKE_MATCH_2}") STRING(REGEX MATCH "#define GTK_MICRO_VERSION([ \t]+)\\(([0-9]+)\\)" _dummy "${GTKVERSION_H_CONTENTS}") SET(${_module_name}_VERSION_MICRO "${CMAKE_MATCH_2}") SET(${_module_name}_VERSION "${${_module_name}_VERSION_MAJOR}.${${_module_name}_VERSION_MINOR}.${${_module_name}_VERSION_MICRO}") SET(GTK_VERSION "${${_module_name}_VERSION}") else() set(GTK_VERSION "0.0.0-NOTFOUND") endif() mark_as_advanced( ${_module_name}_GTK_LIBRARY ${_module_name}_GTK_INCLUDE_DIRS ) if(${_module_name}_GTK_FOUND) list(APPEND ${_module_name}_LIBRARIES "${${_module_name}_GTK_LIBRARY}") list(APPEND ${_module_name}_INCLUDE_DIRS "${${_module_name}_GTK_INCLUDE_DIRS}") set(${_module_name}_DEFINITIONS ${${_module_name}_DEFINITIONS} ${PC_${_module_name}_DEFINITIONS}) if(NOT TARGET ${_module_name}::GTK) add_library(${_module_name}::GTK UNKNOWN IMPORTED) set_target_properties(${_module_name}::GTK PROPERTIES IMPORTED_LOCATION "${${_module_name}_GTK_LIBRARY}" INTERFACE_COMPILE_OPTIONS "${PC_${_module_name}_DEFINITIONS}" INTERFACE_INCLUDE_DIRECTORIES "${${_module_name}_GTK_INCLUDE_DIRS}" INTERFACE_LINK_LIBRARIES "${_module_name}::GDK" ) endif() list(APPEND ${_module_name}_TARGETS "${_module_name}::GTK") endif() #Search for unix-print in include files PKG_CHECK_MODULES(PC_UNIX_PRINT QUIET gtk+-unix-print-${_version_num}) find_path(${_module_name}_UNIX_PRINT_INCLUDE NAMES gtk/gtkunixprint.h HINTS ${PC_UNIX_PRINT_INCLUDE_DIRS} PATH_SUFFIXES gtk-${_version_num}/unix-print ) if(${_module_name}_UNIX_PRINT_INCLUDE) set(${_module_name}_UNIX_PRINT_FOUND TRUE) else() set(${_module_name}_UNIX_PRINT_FOUND FALSE) endif() set(GTK_UNIX_PRINT_FOUND ${${_module_name}_UNIX_PRINT_FOUND}) if(${_module_name}_UNIX_PRINT_FOUND) list(APPEND ${_module_name}_INCLUDE_DIRS "${${_module_name}_UNIX_PRINT_INCLUDE}") set(${_module_name}_DEFINITIONS ${${_module_name}_DEFINITIONS} ${PC_UNIX_PRINT_DEFINITIONS}) if(NOT TARGET ${_module_name}::UNIX_PRINT) add_library(${_module_name}::UNIX_PRINT UNKNOWN IMPORTED) set_target_properties(${_module_name}::UNIX_PRINT PROPERTIES INTERFACE_COMPILE_OPTIONS "${PC_UNIX_PRINT_DEFINITIONS}" INTERFACE_INCLUDE_DIRECTORIES "${${_module_name}_UNIX_PRINT_INCLUDE}" INTERFACE_LINK_LIBRARIES "${_module_name}::GTK" ) endif() list(APPEND ${_module_name}_TARGETS "${_module_name}::UNIX_PRINT") endif() #Search for executables FOREACH (_component ${GTK_COMP_TOOLS}) string(TOLOWER "${_component}" _lc_comp) string(REPLACE "_" "-" _rep_comp "${_lc_comp}") set(_program_name gtk-${_rep_comp}) find_program(${_module_name}_${_component}_EXECUTABLE ${_program_name} ) if(${_module_name}_${_component}_EXECUTABLE) set(${_module_name}_${_component}_FOUND TRUE) else() set(${_module_name}_${_component}_FOUND FALSE) endif() set(GTK_${_component}_FOUND ${${_module_name}_${_component}_FOUND}) mark_as_advanced( ${_module_name}_${_component}_EXECUTABLE ) if(${_module_name}_${_component}_FOUND) if(NOT TARGET ${_module_name}::${_component}) add_executable(${_module_name}::${_component} IMPORTED) endif() list(APPEND ${_module_name}_TARGETS "${_module_name}::${_component}") endif() endforeach() FIND_PACKAGE_HANDLE_STANDARD_ARGS(GTK REQUIRED_VARS ${_module_name}_LIBRARIES ${_module_name}_INCLUDE_DIRS HANDLE_COMPONENTS VERSION_VAR ${_module_name}_VERSION) if(${_module_name}_LIBRARIES) list(REMOVE_DUPLICATES ${_module_name}_LIBRARIES) endif() if(${_module_name}_INCLUDE_DIRS) list(REMOVE_DUPLICATES ${_module_name}_INCLUDE_DIRS) endif() if(${_module_name}_DEFINITIONS) list(REMOVE_DUPLICATES ${_module_name}_DEFINITIONS) endif() if(${_module_name}_TARGETS) list(REMOVE_DUPLICATES ${_module_name}_TARGETS) endif() cmake-vala-r3/Find/FindPEAS.cmake000066400000000000000000000112311351760240500166150ustar00rootroot00000000000000# - Try to find Libpeas and its GTK component # # Copyright (C) 2018 Konstantin Pugin # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions # are met: # 1. Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # 2. Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND ITS CONTRIBUTORS ``AS # IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, # THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR ITS # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; # OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, # WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR # OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF # ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. INCLUDE(FindPackageHandleStandardArgs) FIND_PACKAGE(PkgConfig QUIET) PKG_CHECK_MODULES(PC_PEAS QUIET libpeas-1.0) FIND_LIBRARY(PEAS_PEAS_LIBRARY NAMES peas-1.0 HINTS ${PC_PEAS_LIBDIR} ${PC_PEAS_LIBRARY_DIRS} ) PKG_CHECK_MODULES(PC_INT QUIET gobject-introspection-1.0) FIND_PATH(PEAS_INTROSPECTION_INCLUDE NAMES girepository.h HINTS ${PC_INT_INCLUDEDIR} ${PC_INT_INCLUDE_DIRS} PATH_SUFFIXES gobject-introspection-1.0 ) FIND_PATH(PEAS_PEAS_INCLUDE NAMES libpeas/peas.h HINTS ${PC_PEAS_INCLUDEDIR} ${PC_PEAS_INCLUDE_DIRS} PATH_SUFFIXES libpeas-1.0 ) SET(PEAS_PEAS_INCLUDE_DIRS ${PEAS_PEAS_INCLUDE} ${PEAS_INTROSPECTION_INCLUDE}) # Version detection SET(PEAS_PEAS_VERSION "${PC_PEAS_VERSION}") SET(PEAS_VERSION "${PEAS_PEAS_VERSION}") if(PEAS_PEAS_LIBRARY AND PEAS_PEAS_INCLUDE_DIRS) set(PEAS_PEAS_FOUND TRUE) else() set(PEAS_PEAS_FOUND FALSE) endif() mark_as_advanced( PEAS_PEAS_LIBRARY PEAS_PEAS_INCLUDE_DIRS ) if(PEAS_PEAS_FOUND) list(APPEND PEAS_LIBRARIES "${PEAS_PEAS_LIBRARY}") list(APPEND PEAS_INCLUDE_DIRS "${PEAS_PEAS_INCLUDE_DIRS}") set(PEAS_DEFINITIONS ${PEAS_DEFINITIONS} ${PC_PEAS_DEFINITIONS}) if(NOT TARGET PEAS::PEAS) add_library(PEAS::PEAS UNKNOWN IMPORTED) set_target_properties(PEAS::PEAS PROPERTIES IMPORTED_LOCATION "${PEAS_PEAS_LIBRARY}" INTERFACE_COMPILE_OPTIONS "${PC_PEAS_DEFINITIONS}" INTERFACE_INCLUDE_DIRECTORIES "${PEAS_PEAS_INCLUDE_DIRS}" ) endif() list(APPEND PEAS_TARGETS "PEAS::PEAS") endif() if(PEAS_PEAS_FOUND) PKG_CHECK_MODULES(PC_PEAS_GTK QUIET libpeas-gtk-1.0) FIND_LIBRARY(PEAS_GTK_LIBRARY NAMES peas-gtk-1.0 HINTS ${PC_PEAS_GTK_LIBDIR} ${PC_PEAS_GTK_LIBRARY_DIRS} ) FIND_PATH(PEAS_GTK_INCLUDE NAMES libpeas-gtk/peas-gtk.h HINTS ${PC_PEAS_GTK_INCLUDEDIR} ${PC_PEAS_GTK_INCLUDE_DIRS} PATH_SUFFIXES libpeas-1.0 ) SET(PEAS_GTK_INCLUDE_DIRS ${PEAS_GTK_INCLUDE}) if(PEAS_GTK_LIBRARY AND PEAS_GTK_INCLUDE_DIRS) set(PEAS_GTK_FOUND TRUE) else() set(PEAS_GTK_FOUND FALSE) endif() mark_as_advanced( PEAS_GTK_LIBRARY PEAS_GTK_INCLUDE_DIRS ) if(PEAS_GTK_FOUND) list(APPEND PEAS_LIBRARIES "${PEAS_GTK_LIBRARY}") list(APPEND PEAS_INCLUDE_DIRS "${PEAS_GTK_INCLUDE_DIRS}") set(PEAS_DEFINITIONS ${PEAS_DEFINITIONS} ${PC_PEAS_GTK_DEFINITIONS}) if(NOT TARGET PEAS::GTK) add_library(PEAS::GTK UNKNOWN IMPORTED) set_target_properties(PEAS::GTK PROPERTIES IMPORTED_LOCATION "${PEAS_GTK_LIBRARY}" INTERFACE_COMPILE_OPTIONS "${PC_PEAS_GTK_DEFINITIONS}" INTERFACE_INCLUDE_DIRECTORIES "${PEAS_GTK_INCLUDE_DIRS}" ) endif() list(APPEND PEAS_TARGETS "PEAS::GTK") endif() endif() FIND_PACKAGE_HANDLE_STANDARD_ARGS(PEAS REQUIRED_VARS PEAS_LIBRARIES PEAS_INCLUDE_DIRS HANDLE_COMPONENTS VERSION_VAR PEAS_VERSION) if(PEAS_LIBRARIES) list(REMOVE_DUPLICATES PEAS_LIBRARIES) endif() if(PEAS_INCLUDE_DIRS) list(REMOVE_DUPLICATES PEAS_INCLUDE_DIRS) endif() if(PEAS_DEFINITIONS) list(REMOVE_DUPLICATES PEAS_DEFINITIONS) endif() if(PEAS_TARGETS) list(REMOVE_DUPLICATES PEAS_TARGETS) endif() cmake-vala-r3/Find/FindWNCK.cmake000066400000000000000000000054151351760240500166360ustar00rootroot00000000000000# FindWNCK.cmake, Finds libwnck # Copyright (C) 2018 Konstantin Pugin # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions # are met: # 1. Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # 2. Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND ITS CONTRIBUTORS ``AS # IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, # THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR ITS # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; # OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, # WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR # OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF # ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. INCLUDE(FindPackageHandleStandardArgs) FIND_PACKAGE(PkgConfig QUIET) set(WNCK_VERSION_MAX_SUPPORTED 3) if (${WNCK_FIND_VERSION_MAJOR}) set(_version_num ${WNCK_FIND_VERSION_MAJOR}.0) set(_version_short ${WNCK_FIND_VERSION_MAJOR}) else() set(_version_num ${WNCK_VERSION_MAX_SUPPORTED}.0) set(_version_short ${WNCK_VERSION_MAX_SUPPORTED}) endif() PKG_CHECK_MODULES(PC_WNCK QUIET libwnck-${_version_num}) FIND_LIBRARY(WNCK_LIBRARY NAMES wnck-${_version_short} HINTS ${PC_WNCK_LIBDIR} ${PC_WNCK_LIBRARY_DIRS} ) FIND_PATH(WNCK_INCLUDE NAMES libwnck/version.h HINTS ${PC_WNCK_INCLUDEDIR} ${PC_WNCK_INCLUDE_DIRS} PATH_SUFFIXES libwnck-${_version_num} ) set(WNCK_VERSION ${PC_WNCK_VERSION}) set(WNCK_INCLUDE_DIRS ${WNCK_INCLUDE}) find_package_handle_standard_args(WNCK REQUIRED_VARS WNCK_LIBRARY WNCK_INCLUDE VERSION_VAR WNCK_VERSION ) mark_as_advanced( WNCK_LIBRARY WNCK_INCLUDE ) if(WNCK_FOUND) set(WNCK_DEFINITIONS ${WNCK_DEFINITIONS} ${PC_WNCK_DEFINITIONS} -DWNCK_I_KNOW_THIS_IS_UNSTABLE ) if(NOT TARGET WNCK::WNCK) add_library(WNCK::WNCK UNKNOWN IMPORTED) set_target_properties(WNCK::WNCK PROPERTIES IMPORTED_LOCATION "${WNCK_LIBRARY}" INTERFACE_COMPILE_OPTIONS "${WNCK_DEFINITIONS}" INTERFACE_INCLUDE_DIRECTORIES "${WNCK_INCLUDE}" ) endif() endif() cmake-vala-r3/Find/FindX11.cmake000066400000000000000000000262501351760240500164450ustar00rootroot00000000000000# Distributed under the OSI-approved BSD 3-Clause License. See accompanying # file Copyright.txt or https://cmake.org/licensing for details. #.rst: # FindX11 # ------- # # Find X11 installation # # Try to find X11 on UNIX systems. The following values are defined # # :: # # X11_FOUND - True if X11 is available # X11_INCLUDE_DIR - include directories to use X11 # X11_LIBRARIES - link against these to use X11 # # and also the following more fine grained variables: # # :: # # X11_ICE_INCLUDE_PATH, X11_ICE_LIB, X11_ICE_FOUND # X11_SM_INCLUDE_PATH, X11_SM_LIB, X11_SM_FOUND # X11_X11_INCLUDE_PATH, X11_X11_LIB # X11_Xaccessrules_INCLUDE_PATH, X11_Xaccess_FOUND # X11_Xaccessstr_INCLUDE_PATH, X11_Xaccess_FOUND # X11_Xau_INCLUDE_PATH, X11_Xau_LIB, X11_Xau_FOUND # X11_Xcomposite_INCLUDE_PATH, X11_Xcomposite_LIB, X11_Xcomposite_FOUND # X11_Xcursor_INCLUDE_PATH, X11_Xcursor_LIB, X11_Xcursor_FOUND # X11_Xdamage_INCLUDE_PATH, X11_Xdamage_LIB, X11_Xdamage_FOUND # X11_Xdmcp_INCLUDE_PATH, X11_Xdmcp_LIB, X11_Xdmcp_FOUND # X11_Xext_LIB, X11_Xext_FOUND # X11_dpms_INCLUDE_PATH, (in X11_Xext_LIB), X11_dpms_FOUND # X11_XShm_INCLUDE_PATH, (in X11_Xext_LIB), X11_XShm_FOUND # X11_Xshape_INCLUDE_PATH, (in X11_Xext_LIB), X11_Xshape_FOUND # X11_xf86misc_INCLUDE_PATH, X11_Xxf86misc_LIB, X11_xf86misc_FOUND # X11_xf86vmode_INCLUDE_PATH, X11_Xxf86vm_LIB X11_xf86vmode_FOUND # X11_Xfixes_INCLUDE_PATH, X11_Xfixes_LIB, X11_Xfixes_FOUND # X11_Xft_INCLUDE_PATH, X11_Xft_LIB, X11_Xft_FOUND # X11_Xi_INCLUDE_PATH, X11_Xi_LIB, X11_Xi_FOUND # X11_Xinerama_INCLUDE_PATH, X11_Xinerama_LIB, X11_Xinerama_FOUND # X11_Xinput_INCLUDE_PATH, X11_Xinput_LIB, X11_Xinput_FOUND # X11_Xkb_INCLUDE_PATH, X11_Xkb_FOUND # X11_Xkblib_INCLUDE_PATH, X11_Xkb_FOUND # X11_Xkbfile_INCLUDE_PATH, X11_Xkbfile_LIB, X11_Xkbfile_FOUND # X11_Xmu_INCLUDE_PATH, X11_Xmu_LIB, X11_Xmu_FOUND # X11_Xpm_INCLUDE_PATH, X11_Xpm_LIB, X11_Xpm_FOUND # X11_XTest_INCLUDE_PATH, X11_XTest_LIB, X11_XTest_FOUND # X11_Xrandr_INCLUDE_PATH, X11_Xrandr_LIB, X11_Xrandr_FOUND # X11_Xrender_INCLUDE_PATH, X11_Xrender_LIB, X11_Xrender_FOUND # X11_Xscreensaver_INCLUDE_PATH, X11_Xscreensaver_LIB, X11_Xscreensaver_FOUND # X11_Xt_INCLUDE_PATH, X11_Xt_LIB, X11_Xt_FOUND # X11_Xutil_INCLUDE_PATH, X11_Xutil_FOUND # X11_Xv_INCLUDE_PATH, X11_Xv_LIB, X11_Xv_FOUND # X11_XSync_INCLUDE_PATH, (in X11_Xext_LIB), X11_XSync_FOUND #components list: # ICE SM Xaccess Xauth Xcomposite XCursor XDamage Xdmcp dpms # xf86misc xf86vmode Xfixes Xft XInput Xkblib Xkbfile Xmu Xpm # Xscreensaver Xshape XShm Xt XTest Xv Xsync if (UNIX) set(X11_FOUND 0) # X11 is never a framework and some header files may be # found in tcl on the mac set(CMAKE_FIND_FRAMEWORK_SAVE ${CMAKE_FIND_FRAMEWORK}) set(CMAKE_FIND_FRAMEWORK NEVER) set(X11_INC_SEARCH_PATH /usr/pkg/xorg/include /usr/X11R6/include /usr/X11R7/include /usr/include/X11 /usr/openwin/include /usr/openwin/share/include /opt/graphics/OpenGL/include /opt/X11/include ) set(X11_LIB_SEARCH_PATH /usr/pkg/xorg/lib /usr/X11R6/lib /usr/X11R7/lib /usr/openwin/lib /opt/X11/lib ) find_path(X11_X11_INCLUDE_PATH X11/X.h ${X11_INC_SEARCH_PATH}) find_path(X11_Xlib_INCLUDE_PATH X11/Xlib.h ${X11_INC_SEARCH_PATH}) find_path(X11_Xutil_INCLUDE_PATH X11/Xutil.h ${X11_INC_SEARCH_PATH}) # Solaris lacks XKBrules.h, so we should skip kxkbd there. Is this relevant for modern Solaris? find_library(X11_X11_LIB X11 ${X11_LIB_SEARCH_PATH}) get_filename_component(X11_REALPATH ${X11_X11_LIB} REALPATH) get_filename_component(X11_SO_VERSION ${X11_REALPATH} EXT) string(SUBSTRING ${X11_SO_VERSION} 4 -1 X11_VERSION) set(X11_X11_VERSION ${X11_VERSION}) find_package_handle_standard_args(X11_X11 REQUIRED_VARS X11_X11_LIB X11_X11_INCLUDE_PATH X11_Xlib_INCLUDE_PATH X11_Xutil_INCLUDE_PATH VERSION_VAR X11_X11_VERSION ) mark_as_advanced( X11_X11_LIB X11_X11_INCLUDE_PATH X11_Xlib_INCLUDE_PATH X11_Xutil_INCLUDE_PATH ) set(X11_X11_INCLUDE_DIR "${X11_X11_INCLUDE_PATH}" "${X11_Xlib_INCLUDE_PATH}" "${X11_Xutil_INCLUDE_PATH}") if(X11_X11_FOUND) include(CheckFunctionExists) include(CheckLibraryExists) # Translated from an autoconf-generated configure script. # See libs.m4 in autoconf's m4 directory. if($ENV{ISC} MATCHES "^yes$") set(X11_X_EXTRA_LIBS -lnsl_s -linet) else() set(X11_X_EXTRA_LIBS "") # See if XOpenDisplay in X11 works by itself. CHECK_LIBRARY_EXISTS("${X11_LIBRARIES}" "XOpenDisplay" "${X11_LIBRARY_DIR}" X11_LIB_X11_SOLO) if(NOT X11_LIB_X11_SOLO) # Find library needed for dnet_ntoa. CHECK_LIBRARY_EXISTS("dnet" "dnet_ntoa" "" X11_LIB_DNET_HAS_DNET_NTOA) if (X11_LIB_DNET_HAS_DNET_NTOA) set (X11_X_EXTRA_LIBS ${X11_X_EXTRA_LIBS} -ldnet) else () CHECK_LIBRARY_EXISTS("dnet_stub" "dnet_ntoa" "" X11_LIB_DNET_STUB_HAS_DNET_NTOA) if (X11_LIB_DNET_STUB_HAS_DNET_NTOA) set (X11_X_EXTRA_LIBS ${X11_X_EXTRA_LIBS} -ldnet_stub) endif () endif () endif() # Find library needed for gethostbyname. CHECK_FUNCTION_EXISTS("gethostbyname" CMAKE_HAVE_GETHOSTBYNAME) if(NOT CMAKE_HAVE_GETHOSTBYNAME) CHECK_LIBRARY_EXISTS("nsl" "gethostbyname" "" CMAKE_LIB_NSL_HAS_GETHOSTBYNAME) if (CMAKE_LIB_NSL_HAS_GETHOSTBYNAME) set (X11_X_EXTRA_LIBS ${X11_X_EXTRA_LIBS} -lnsl) else () CHECK_LIBRARY_EXISTS("bsd" "gethostbyname" "" CMAKE_LIB_BSD_HAS_GETHOSTBYNAME) if (CMAKE_LIB_BSD_HAS_GETHOSTBYNAME) set (X11_X_EXTRA_LIBS ${X11_X_EXTRA_LIBS} -lbsd) endif () endif () endif() # Find library needed for connect. CHECK_FUNCTION_EXISTS("connect" CMAKE_HAVE_CONNECT) if(NOT CMAKE_HAVE_CONNECT) CHECK_LIBRARY_EXISTS("socket" "connect" "" CMAKE_LIB_SOCKET_HAS_CONNECT) if (CMAKE_LIB_SOCKET_HAS_CONNECT) set (X11_X_EXTRA_LIBS -lsocket ${X11_X_EXTRA_LIBS}) endif () endif() # Find library needed for remove. CHECK_FUNCTION_EXISTS("remove" CMAKE_HAVE_REMOVE) if(NOT CMAKE_HAVE_REMOVE) CHECK_LIBRARY_EXISTS("posix" "remove" "" CMAKE_LIB_POSIX_HAS_REMOVE) if (CMAKE_LIB_POSIX_HAS_REMOVE) set (X11_X_EXTRA_LIBS ${X11_X_EXTRA_LIBS} -lposix) endif () endif() # Find library needed for shmat. CHECK_FUNCTION_EXISTS("shmat" CMAKE_HAVE_SHMAT) if(NOT CMAKE_HAVE_SHMAT) CHECK_LIBRARY_EXISTS("ipc" "shmat" "" CMAKE_LIB_IPS_HAS_SHMAT) if (CMAKE_LIB_IPS_HAS_SHMAT) set (X11_X_EXTRA_LIBS ${X11_X_EXTRA_LIBS} -lipc) endif () endif() endif() list(APPEND X11_LIBRARIES "${X11_X11_LIB}") list(APPEND X11_INCLUDE_DIR "${X11_X11_INCLUDE_PATH}" "${X11_Xlib_INCLUDE_PATH}" "${X11_Xutil_INCLUDE_PATH}") if(NOT TARGET X11::X11) add_library(X11::X11 UNKNOWN IMPORTED) set_target_properties(X11::X11 PROPERTIES IMPORTED_LOCATION "${X11_X11_LIB}" INTERFACE_INCLUDE_DIRECTORIES "${X11_X11_INCLUDE_DIR}" INTERFACE_COMPILE_OPTIONS "${X11_X_EXTRA_LIBS}" ) endif() list(APPEND X11_TARGETS "X11::X11") endif () # All X11 components. FOREACH (_component ${X11_FIND_COMPONENTS}) string(TOLOWER "${_component}" _lc_comp) set(X11_${_component}_VERSION "${X11_VERSION}") list(APPEND _comp_deps "X11::X11") list(APPEND _comp_dep_vars "X11_X11_FOUND") if (${_component} STREQUAL "Xaccess") set(_comp_header XKBstr.h) set(_library_name Xext) elseif (${_component} STREQUAL "Xauth") set(_library_name Xau) elseif (${_component} STREQUAL "dpms") set(_library_name Xext) elseif (${_component} STREQUAL "xf86vmode") set(_library_name Xxf86vm) elseif (${_component} STREQUAL "XInput") set(_library_name Xi) elseif (${_component} STREQUAL "Xkb") set(_comp_header XKB.h) set(_library_name Xext) elseif (${_component} STREQUAL "Xkblib") list(APPEND _comp_deps "X11::Xaccess") list(APPEND _comp_dep_vars "X11_Xaccess_FOUND") set(_comp_header XKBlib.h) set(_library_name Xext) elseif (${_component} STREQUAL "Xkbfile") set(_comp_header XKBfile.h) elseif (${_component} STREQUAL "Xscreensaver") set(_comp_header scrnsaver.h) set(_library_name Xss) elseif (${_component} STREQUAL "Xshape") set(_comp_header shape.h) set(_library_name Xext) elseif (${_component} STREQUAL "XShm") set(_library_name Xext) elseif (${_component} STREQUAL "Xt") set(_comp_header Intrinsic.h) elseif (${_component} STREQUAL "XTest") set(_library_name Xtst) elseif (${_component} STREQUAL "Xv") set(_comp_header Xvlib.h) elseif (${_component} STREQUAL "Xsync") set(_comp_header sync.h) elseif (${_component} STREQUAL "X11") continue() endif() find_path(X11_${_component}_INCLUDE_PATH NAMES ${_comp_header} ${_component}.h ${_lc_comp}.h HINTS ${X11_INC_SEARCH_PATH} PATH_SUFFIXES X11 X11/extensions X11/${_component} ) find_library(X11_${_component}_LIB NAMES ${_library_name} ${_component} ${_lc_comp} X${_component} HINTS ${X11_LIB_SEARCH_PATH} ) find_package_handle_standard_args(X11_${_component} REQUIRED_VARS X11_${_component}_LIB X11_${_component}_INCLUDE_PATH ${_comp_dep_vars} VERSION_VAR X11_${_component}_VERSION ) mark_as_advanced( X11_${_component}_LIB X11_${_component}_INCLUDE_PATH ) if(X11_${_component}_FOUND) list(APPEND X11_LIBRARIES "${X11_${_component}_LIB}") list(APPEND X11_INCLUDE_DIR "${X11_${_component}_INCLUDE_PATH}") if(NOT TARGET X11::${_component}) add_library(X11::${_component} UNKNOWN IMPORTED) set_target_properties(X11::${_component} PROPERTIES IMPORTED_LOCATION "${X11_${_component}_LIB}" INTERFACE_INCLUDE_DIRECTORIES "${X11_${_component}_INCLUDE_PATH}" INTERFACE_LINK_LIBRARIES "${_comp_deps}" ) endif() list(APPEND X11_TARGETS "X11::${_component}") endif() ENDFOREACH () FIND_PACKAGE_HANDLE_STANDARD_ARGS(X11 REQUIRED_VARS X11_LIBRARIES X11_INCLUDE_DIR HANDLE_COMPONENTS VERSION_VAR X11_VERSION) if(X11_LIBRARIES) list(REMOVE_DUPLICATES X11_LIBRARIES) endif() if(X11_INCLUDE_DIR) list(REMOVE_DUPLICATES X11_INCLUDE_DIR) endif() if(X11_TARGETS) list(REMOVE_DUPLICATES X11_TARGETS) endif() set(CMAKE_FIND_FRAMEWORK ${CMAKE_FIND_FRAMEWORK_SAVE}) set(CMAKE_REQUIRED_QUIET ${CMAKE_REQUIRED_QUIET_SAVE}) endif () # X11_FIND_REQUIRED_ could be checked too cmake-vala-r3/GLib/000077500000000000000000000000001351760240500142215ustar00rootroot00000000000000cmake-vala-r3/GLib/FindGLIB2.cmake000066400000000000000000000202721351760240500166260ustar00rootroot00000000000000# - Try to find Glib and its components (gio, gobject etc) # # Copyright (C) 2012 Raphael Kubo da Costa # Copyright (C) 2018 Konstantin Pugin # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions # are met: # 1. Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # 2. Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND ITS CONTRIBUTORS ``AS # IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, # THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR ITS # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; # OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, # WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR # OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF # ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #defined components: #GLIB GIO GIO_UNIX GOBJECT GMODULE GTHREAD set(GLIB2_COMP_LIBRARIES GLIB GIO GIO_UNIX GOBJECT GMODULE GTHREAD) #GENMARSHAL CODEGEN MKENUMS COMPILE_SCHEMAS COMPILE_RESOURCES GTESTER set(GLIB2_COMP_TOOLS GENMARSHAL CODEGEN MKENUMS COMPILE_SCHEMAS COMPILE_RESOURCES GTESTER) INCLUDE(FindPackageHandleStandardArgs) FIND_PACKAGE(PkgConfig QUIET) PKG_CHECK_MODULES(PC_GLIB QUIET glib-2.0) FIND_LIBRARY(GLIB2_GLIB_LIBRARY NAMES glib-2.0 HINTS ${PC_GLIB_LIBDIR} ${PC_GLIB_LIBRARY_DIRS} ) # Files in glib's main include path may include glibconfig.h, which, # for some odd reason, is normally in $LIBDIR/glib-2.0/include. GET_FILENAME_COMPONENT(_GLIB_LIBRARY_DIR ${GLIB2_GLIB_LIBRARY} PATH) FIND_PATH(GLIBCONFIG_INCLUDE_DIR NAMES glibconfig.h HINTS ${PC_LIBDIR} ${PC_LIBRARY_DIRS} ${_GLIB_LIBRARY_DIR} PATH_SUFFIXES glib-2.0/include ) FIND_PATH(GLIB2_GLIB_INCLUDE NAMES glib.h HINTS ${PC_GLIB_INCLUDEDIR} ${PC_GLIB_INCLUDE_DIRS} PATH_SUFFIXES glib-2.0 ) SET(GLIB2_GLIB_INCLUDE_DIRS ${GLIB2_GLIB_INCLUDE} ${GLIBCONFIG_INCLUDE_DIR}) # Version detection FILE(READ "${GLIBCONFIG_INCLUDE_DIR}/glibconfig.h" GLIBCONFIG_H_CONTENTS) STRING(REGEX MATCH "#define GLIB_MAJOR_VERSION ([0-9]+)" _dummy "${GLIBCONFIG_H_CONTENTS}") SET(GLIB_VERSION_MAJOR "${CMAKE_MATCH_1}") STRING(REGEX MATCH "#define GLIB_MINOR_VERSION ([0-9]+)" _dummy "${GLIBCONFIG_H_CONTENTS}") SET(GLIB_VERSION_MINOR "${CMAKE_MATCH_1}") STRING(REGEX MATCH "#define GLIB_MICRO_VERSION ([0-9]+)" _dummy "${GLIBCONFIG_H_CONTENTS}") SET(GLIB_VERSION_MICRO "${CMAKE_MATCH_1}") SET(GLIB2_GLIB_VERSION "${GLIB_VERSION_MAJOR}.${GLIB_VERSION_MINOR}.${GLIB_VERSION_MICRO}") SET(GLIB2_VERSION "${GLIB2_GLIB_VERSION}") if(GLIB2_GLIB_LIBRARY AND GLIB2_GLIB_INCLUDE_DIRS) set(GLIB2_GLIB_FOUND TRUE) else() set(GLIB2_GLIB_FOUND FALSE) endif() mark_as_advanced( GLIB2_GLIB_LIBRARY GLIB2_GLIB_INCLUDE_DIRS ) if(GLIB2_GLIB_FOUND) list(APPEND GLIB2_LIBRARIES "${GLIB2_GLIB_LIBRARY}") list(APPEND GLIB2_INCLUDE_DIRS "${GLIB2_GLIB_INCLUDE_DIRS}") set(GLIB2_DEFINITIONS ${GLIB2_DEFINITIONS} ${PC_GLIB_DEFINITIONS}) if(NOT TARGET GLIB2::GLIB) add_library(GLIB2::GLIB UNKNOWN IMPORTED) set_target_properties(GLIB2::GLIB PROPERTIES IMPORTED_LOCATION "${GLIB2_GLIB_LIBRARY}" INTERFACE_COMPILE_OPTIONS "${PC_GLIB_DEFINITIONS}" INTERFACE_INCLUDE_DIRECTORIES "${GLIB2_GLIB_INCLUDE_DIRS}" ) endif() list(APPEND GLIB2_TARGETS "GLIB2::GLIB") endif() # Additional Glib components. FOREACH (_component ${GLIB2_FIND_COMPONENTS}) string(TOLOWER "${_component}" _lc_comp) string(REPLACE "_" "-" _rep_comp "${_lc_comp}") if(_component IN_LIST GLIB2_COMP_LIBRARIES) PKG_CHECK_MODULES(PC_${_component} QUIET ${_rep_comp}-2.0) list(APPEND _comp_deps "GLIB2::GLIB") list(APPEND _comp_dep_vars "GLIB2_GLIB_FOUND") set(_path_suffix glib-2.0) set(_library_name ${_rep_comp}-2.0) if (${_component} STREQUAL "GIO_UNIX") list(APPEND _comp_deps "GLIB2::GIO") list(APPEND _comp_dep_vars "GLIB2_GIO_FOUND") set(_comp_header gio/gdesktopappinfo.h) set(_path_suffix gio-unix-2.0) set(_library_name gio-2.0) elseif (${_component} STREQUAL "GIO") list(APPEND _comp_deps "GLIB2::GOBJECT") list(APPEND _comp_dep_vars "GLIB2_GOBJECT_FOUND") set(_comp_header gio/gio.h) list(APPEND PC_${_component}_DEFINITIONS -DG_SETTINGS_ENABLE_BACKEND) elseif (${_component} STREQUAL "GOBJECT") set(_comp_header glib-object.h) elseif (${_component} STREQUAL "GMODULE") set(_comp_header gmodule.h) elseif (${_component} STREQUAL "GTHREAD") set(_comp_header glib/gthread.h) elseif (${_component} STREQUAL "GLIB") continue() endif() find_path(GLIB2_${_component}_INCLUDE_DIR NAMES ${_comp_header} HINTS ${PC_${_component}_INCLUDE_DIRS} PATH_SUFFIXES ${_path_suffix} ) find_library(GLIB2_${_component}_LIBRARY NAMES ${_library_name} HINTS ${PC_${_component}_LIBRARY_DIRS} ) if(GLIB2_${_component}_LIBRARY AND GLIB2_${_component}_INCLUDE_DIR) set(GLIB2_${_component}_FOUND TRUE) foreach(_CURRENT_VAR ${_comp_dep_vars}) if(NOT ${_CURRENT_VAR}) set(GLIB2_${_component}_FOUND FALSE) endif() endforeach() else() set(GLIB2_${_component}_FOUND FALSE) endif() mark_as_advanced( GLIB2_${_component}_LIBRARY GLIB2_${_component}_INCLUDE_DIR ) if(GLIB2_${_component}_FOUND) list(APPEND GLIB2_LIBRARIES "${GLIB2_${_component}_LIBRARY}") list(APPEND GLIB2_INCLUDE_DIRS "${GLIB2_${_component}_INCLUDE_DIR}") set(GLIB2_DEFINITIONS ${GLIB2_DEFINITIONS} ${PC_${_component}_DEFINITIONS}) if(NOT TARGET GLIB2::${_component}) add_library(GLIB2::${_component} UNKNOWN IMPORTED) set_target_properties(GLIB2::${_component} PROPERTIES IMPORTED_LOCATION "${GLIB2_${_component}_LIBRARY}" INTERFACE_COMPILE_OPTIONS "${PC_${_component}_DEFINITIONS}" INTERFACE_INCLUDE_DIRECTORIES "${GLIB2_${_component}_INCLUDE_DIR}" INTERFACE_LINK_LIBRARIES "${_comp_deps}" ) endif() list(APPEND GLIB2_TARGETS "GLIB2::${_component}") endif() elseif(_component IN_LIST GLIB2_COMP_TOOLS) set(_program_name glib-${_rep_comp}) if (${_component} STREQUAL "CODEGEN") set(_program_name gdbus-${_rep_comp}) elseif (${_component} STREQUAL "GTESTER") set(_program_name ${_rep_comp}) endif() find_program(GLIB2_${_component}_EXECUTABLE ${_program_name} ) if(GLIB2_${_component}_EXECUTABLE) set(GLIB2_${_component}_FOUND TRUE) else() set(GLIB2_${_component}_FOUND FALSE) endif() mark_as_advanced( GLIB2_${_component}_EXECUTABLE ) if(GLIB2_${_component}_FOUND) if(NOT TARGET GLIB2::${_component}) add_executable(GLIB2::${_component} IMPORTED) endif() list(APPEND GLIB2_TARGETS "GLIB2::${_component}") endif() endif() ENDFOREACH () FIND_PACKAGE_HANDLE_STANDARD_ARGS(GLIB2 REQUIRED_VARS GLIB2_LIBRARIES GLIB2_INCLUDE_DIRS HANDLE_COMPONENTS VERSION_VAR GLIB2_VERSION) if(GLIB2_LIBRARIES) list(REMOVE_DUPLICATES GLIB2_LIBRARIES) endif() if(GLIB2_INCLUDE_DIRS) list(REMOVE_DUPLICATES GLIB2_INCLUDE_DIRS) endif() if(GLIB2_DEFINITIONS) list(REMOVE_DUPLICATES GLIB2_DEFINITIONS) endif() if(GLIB2_TARGETS) list(REMOVE_DUPLICATES GLIB2_TARGETS) endif() cmake-vala-r3/GLib/FindGirCompiler.cmake000066400000000000000000000050061351760240500202410ustar00rootroot00000000000000## # Copyright 2009-2010 Jakob Westhoff. All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are met: # # 1. Redistributions of source code must retain the above copyright notice, # this list of conditions and the following disclaimer. # # 2. Redistributions in binary form must reproduce the above copyright notice, # this list of conditions and the following disclaimer in the documentation # and/or other materials provided with the distribution. # # THIS SOFTWARE IS PROVIDED BY JAKOB WESTHOFF ``AS IS'' AND ANY EXPRESS OR # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF # MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO # EVENT SHALL JAKOB WESTHOFF OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR # PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF # LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE # OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF # ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # # The views and conclusions contained in the software and documentation are those # of the authors and should not be interpreted as representing official policies, # either expressed or implied, of Jakob Westhoff ## ## # Find module for the Gir compiler (g-ir-compiler) # # This module determines wheter a Gir compiler is installed on the current # system and where its executable is. # # Call the module using "find_package(GirCompiler) from within your CMakeLists.txt. # # The following variables will be set after an invocation: # # G_IR_COMPILER_FOUND Whether the g-ir-compiler compiler has been found or not # G_IR_COMPILER_EXECUTABLE Full path to the g-ir-compiler executable if it has been found ## # Search for the g-ir-compiler executable in the usual system paths. find_program (G_IR_COMPILER_EXECUTABLE NAMES g-ir-compiler) # Handle the QUIETLY and REQUIRED arguments, which may be given to the find call. # Furthermore set G_IR_COMPILER_FOUND to TRUE if the g-ir-compiler has been found (aka. # G_IR_COMPILER_EXECUTABLE is set) include (FindPackageHandleStandardArgs) find_package_handle_standard_args (GirCompiler DEFAULT_MSG G_IR_COMPILER_EXECUTABLE) mark_as_advanced (G_IR_COMPILER_EXECUTABLE) cmake-vala-r3/GLib/GLibProgramHandlers.cmake000066400000000000000000000224431351760240500210560ustar00rootroot00000000000000# Copyright (C) 2018 Konstantin Pugin # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions # are met: # 1. Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # 2. Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND ITS CONTRIBUTORS ``AS # IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, # THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR ITS # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; # OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, # WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR # OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF # ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. INCLUDE(CMakeParseArguments) find_package(GLIB2 QUIET COMPONENTS CODEGEN MKENUMS GENMARSHAL COMPILE_SCHEMAS COMPILE_RESOURCES GTESTER) option (GSETTINGS_LOCALINSTALL "Install GSettings Schemas locally instead of to the GLib prefix" ON) option (GSETTINGS_COMPILE "Compile GSettings Schemas after installation" ${GSETTINGS_LOCALINSTALL}) macro(add_schema SCHEMA_NAME) set(PKG_CONFIG_EXECUTABLE pkg-config) # Have an option to not install the schema into where GLib is SET (GSETTINGS_DIR "${CMAKE_INSTALL_DATAROOTDIR}/glib-2.0/schemas/") if (GSETTINGS_LOCALINSTALL) SET (GSETTINGS_PREFIX "${CMAKE_INSTALL_PREFIX}") else () execute_process (COMMAND ${PKG_CONFIG_EXECUTABLE} glib-2.0 --variable prefix OUTPUT_VARIABLE _glib_prefix OUTPUT_STRIP_TRAILING_WHITESPACE) SET (GSETTINGS_PREFIX "${_glib_prefix}") endif () # Run the validator and error if it fails execute_process (COMMAND ${GLIB2_COMPILE_SCHEMAS_EXECUTABLE} --dry-run --schema-file=${CMAKE_CURRENT_SOURCE_DIR}/${SCHEMA_NAME} ERROR_VARIABLE _schemas_invalid OUTPUT_STRIP_TRAILING_WHITESPACE) if (_schemas_invalid) message (SEND_ERROR "Schema validation error: ${_schemas_invalid}") endif (_schemas_invalid) # Actually install and recomple schemas message (STATUS "GSettings schemas will be installed into ${GSETTINGS_PREFIX}/${GSETTINGS_DIR}") install (FILES ${CMAKE_CURRENT_SOURCE_DIR}/${SCHEMA_NAME} DESTINATION ${GSETTINGS_PREFIX}/${GSETTINGS_DIR} COMPONENT ${ARGV1} OPTIONAL) if (GSETTINGS_COMPILE) install (CODE "message (STATUS \"Compiling GSettings schemas\")") install (CODE "execute_process (COMMAND ${GLIB2_COMPILE_SCHEMAS_EXECUTABLE} ${GSETTINGS_PREFIX}/${GSETTINGS_DIR})") endif () endmacro() macro(add_glib_marshal outsources outincludes name prefix) add_custom_command( OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${name}.h" COMMAND ${GLIB2_GENMARSHAL_EXECUTABLE} --header "--prefix=${prefix}" "${CMAKE_CURRENT_SOURCE_DIR}/${name}.list" > "${CMAKE_CURRENT_BINARY_DIR}/${name}.h" DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/${name}.list" ) add_custom_command( OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${name}.c" COMMAND ${GLIB2_GENMARSHAL_EXECUTABLE} --body "--prefix=${prefix}" "${CMAKE_CURRENT_SOURCE_DIR}/${name}.list" > "${CMAKE_CURRENT_BINARY_DIR}/${name}.c" DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/${name}.list" "${CMAKE_CURRENT_BINARY_DIR}/${name}.h" ) list(APPEND ${outsources} "${CMAKE_CURRENT_BINARY_DIR}/${name}.c") list(APPEND ${outincludes} "${CMAKE_CURRENT_BINARY_DIR}/${name}.h") endmacro(add_glib_marshal) macro(add_glib_enumtypes outsources outheaders name) set(files ${ARGN}) add_custom_command( OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${name}.h" COMMAND ${GLIB2_MKENUMS_EXECUTABLE} ARGS --template ${name}".h.template" ${files} > "${CMAKE_CURRENT_BINARY_DIR}/${name}.h" WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/${name}.h.template" ${files} ) add_custom_command( OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${name}.c" COMMAND ${GLIB2_MKENUMS_EXECUTABLE} ARGS --template ${name}".c.template" ${files} > "${CMAKE_CURRENT_BINARY_DIR}/${name}.c" WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/${name}.c.template" ${files} ) list(APPEND ${outsources} "${CMAKE_CURRENT_BINARY_DIR}/${name}.c") list(APPEND ${outheaders} "${CMAKE_CURRENT_BINARY_DIR}/${name}.h") endmacro(add_glib_enumtypes) #.rst: #.. command:: add_gdbus_codegen # # Generates C code and header file from XML service description, and # appends the sources to the SOURCES list provided. # # add_gdbus_codegen( [NAMESPACE]) # # For example: # # .. code-block:: cmake # # set(MY_SOURCES foo.c) # # add_gdbus_codegen(MY_SOURCES # dbus-proxy # org.freedesktop # org.freedesktop.DBus.xml # ) # function(ADD_GDBUS_CODEGEN _SOURCES _NAME _PREFIX SERVICE_XML) set(_options ALL) set(_oneValueArgs NAMESPACE) cmake_parse_arguments(_ARG "${_options}" "${_oneValueArgs}" "" ${ARGN}) get_filename_component(_ABS_SERVICE_XML ${SERVICE_XML} ABSOLUTE) set(_NAMESPACE "") if(_ARG_NAMESPACE) set(_NAMESPACE "--c-namespace=${_ARG_NAMESPACE}") endif() set(_OUTPUT_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/${_NAME}") set(_OUTPUT_FILES "${_OUTPUT_PREFIX}.c" "${_OUTPUT_PREFIX}.h") # for backwards compatibility set("${_SOURCES}_SOURCES" "${_OUTPUT_FILES}" PARENT_SCOPE) list(APPEND ${_SOURCES} ${_OUTPUT_FILES}) set(${_SOURCES} ${${_SOURCES}} PARENT_SCOPE) add_custom_command( OUTPUT ${_OUTPUT_FILES} COMMAND ${GLIB2_CODEGEN_EXECUTABLE} --interface-prefix ${_PREFIX} --generate-c-code="${_NAME}" --c-generate-autocleanup=all ${_NAMESPACE} ${_ABS_SERVICE_XML} WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} DEPENDS ${_ABS_SERVICE_XML} ) endfunction() FUNCTION(GLIB_COMPILE_RESOURCES output) CMAKE_PARSE_ARGUMENTS(ARGS "" "SOURCE" ${ARGN}) SET(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) SET(out_files "") FOREACH(src ${ARGS_SOURCE} ${ARGS_UNPARSED_ARGUMENTS}) SET(in_file "${CMAKE_CURRENT_SOURCE_DIR}/${src}") GET_FILENAME_COMPONENT(WORKING_DIR ${in_file} PATH) STRING(REPLACE ".xml" ".c" src ${src}) SET(out_file "${DIRECTORY}/${src}") GET_FILENAME_COMPONENT(OUPUT_DIR ${out_file} PATH) FILE(MAKE_DIRECTORY ${OUPUT_DIR}) LIST(APPEND out_files "${DIRECTORY}/${src}") #FIXME implicit depends currently not working EXECUTE_PROCESS( COMMAND ${GLIB2_COMPILE_RESOURCES_EXECUTABLE} "--generate-dependencies" ${in_file} WORKING_DIRECTORY ${WORKING_DIR} OUTPUT_VARIABLE in_file_dep ) STRING(REGEX REPLACE "(\r?\n)" ";" in_file_dep "${in_file_dep}") SET(in_file_dep_path "") FOREACH(dep ${in_file_dep}) LIST(APPEND in_file_dep_path "${WORKING_DIR}/${dep}") ENDFOREACH(dep ${in_file_dep}) ADD_CUSTOM_COMMAND( OUTPUT ${out_file} WORKING_DIRECTORY ${WORKING_DIR} COMMAND ${GLIB2_COMPILE_RESOURCES_EXECUTABLE} ARGS "--generate-source" "--target=${out_file}" ${in_file} DEPENDS ${in_file};${in_file_dep_path} ) ENDFOREACH(src ${ARGS_SOURCES} ${ARGS_UNPARSED_ARGUMENTS}) SET(${output} ${out_files} PARENT_SCOPE) ENDFUNCTION(GLIB_COMPILE_RESOURCES) FUNCTION(GLIB_COMPILE_RESOURCES_FULLPATH output) CMAKE_PARSE_ARGUMENTS(ARGS "" "SOURCE" ${ARGN}) SET(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) SET(out_files "") FOREACH(src ${ARGS_SOURCE} ${ARGS_UNPARSED_ARGUMENTS}) SET(in_file "${src}") GET_FILENAME_COMPONENT(WORKING_DIR ${in_file} PATH) STRING(REPLACE ".xml" ".c" src ${src}) SET(out_file "${DIRECTORY}/${src}") GET_FILENAME_COMPONENT(OUPUT_DIR ${out_file} PATH) FILE(MAKE_DIRECTORY ${OUPUT_DIR}) LIST(APPEND out_files "${DIRECTORY}/${src}") #FIXME implicit depends currently not working EXECUTE_PROCESS( COMMAND ${GLIB2_COMPILE_RESOURCES_EXECUTABLE} "--generate-dependencies" ${in_file} WORKING_DIRECTORY ${WORKING_DIR} OUTPUT_VARIABLE in_file_dep ) STRING(REGEX REPLACE "(\r?\n)" ";" in_file_dep "${in_file_dep}") SET(in_file_dep_path "") FOREACH(dep ${in_file_dep}) LIST(APPEND in_file_dep_path "${WORKING_DIR}/${dep}") ENDFOREACH(dep ${in_file_dep}) ADD_CUSTOM_COMMAND( OUTPUT ${out_file} WORKING_DIRECTORY ${WORKING_DIR} COMMAND ${GLIB2_COMPILE_RESOURCES_EXECUTABLE} ARGS "--generate-source" "--target=${out_file}" ${in_file} DEPENDS ${in_file};${in_file_dep_path} ) ENDFOREACH(src ${ARGS_SOURCES} ${ARGS_UNPARSED_ARGUMENTS}) SET(${output} ${out_files} PARENT_SCOPE) ENDFUNCTION(GLIB_COMPILE_RESOURCES_FULLPATH) macro(add_test_executable EXE_NAME) add_test(${EXE_NAME} ${GLIB2_GTESTER_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/${EXE_NAME}) endmacro() cmake-vala-r3/GLib/GObjectIntrospectionMacros.cmake000066400000000000000000000043111351760240500224650ustar00rootroot00000000000000macro(add_target_gir TARGET_NAME GIR_NAME HEADER CFLAGS GRANITE_VERSION) set(PACKAGES "") foreach(PKG ${ARGN}) set(PACKAGES ${PACKAGES} --include=${PKG}) endforeach() install(CODE "set(ENV{LD_LIBRARY_PATH} \"${CMAKE_CURRENT_BINARY_DIR}:\$ENV{LD_LIBRARY_PATH}\") execute_process(COMMAND g-ir-scanner ${CFLAGS} -n ${GIR_NAME} --quiet --library ${TARGET_NAME} ${PACKAGES} -o ${CMAKE_CURRENT_BINARY_DIR}/${GIR_NAME}-${GRANITE_VERSION}.gir -L${CMAKE_CURRENT_BINARY_DIR} --nsversion=${GRANITE_VERSION} ${HEADER})") install(CODE "execute_process(COMMAND g-ir-compiler ${CMAKE_CURRENT_BINARY_DIR}/${GIR_NAME}-${GRANITE_VERSION}.gir -o ${CMAKE_CURRENT_BINARY_DIR}/${GIR_NAME}-${GRANITE_VERSION}.typelib)") install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${GIR_NAME}-${GRANITE_VERSION}.gir DESTINATION share/gir-1.0/ COMPONENT ${ARGV5}) install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${GIR_NAME}-${GRANITE_VERSION}.typelib DESTINATION lib/girepository-1.0/ COMPONENT ${ARGV5}) endmacro() macro(add_target_gir_with_executable TARGET_NAME EXE_NAME GIR_NAME HEADER EXE_HEADER CFLAGS GRANITE_VERSION) set(PACKAGES "") foreach(PKG ${ARGN}) set(PACKAGES ${PACKAGES} --include=${PKG}) endforeach() install(CODE "set(ENV{LD_LIBRARY_PATH} \"${CMAKE_CURRENT_BINARY_DIR}:\$ENV{LD_LIBRARY_PATH}\") execute_process(COMMAND g-ir-scanner ${CFLAGS} -n ${GIR_NAME} --quiet --library ${TARGET_NAME} --program ${EXE_NAME} ${PACKAGES} -o ${CMAKE_CURRENT_BINARY_DIR}/${GIR_NAME}-${GRANITE_VERSION}.gir -L${CMAKE_CURRENT_BINARY_DIR} -I${CMAKE_CURRENT_BINARY_DIR} --nsversion=${GRANITE_VERSION} ${HEADER} ${EXE_HEADER})") install(CODE "execute_process(COMMAND g-ir-compiler ${CMAKE_CURRENT_BINARY_DIR}/${GIR_NAME}-${GRANITE_VERSION}.gir -o ${CMAKE_CURRENT_BINARY_DIR}/${GIR_NAME}-${GRANITE_VERSION}.typelib)") install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${GIR_NAME}-${GRANITE_VERSION}.gir DESTINATION share/gir-1.0/ COMPONENT ${ARGV5}) install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${GIR_NAME}-${GRANITE_VERSION}.typelib DESTINATION lib/girepository-1.0/ COMPONENT ${ARGV5}) endmacro() cmake-vala-r3/GitVersion/000077500000000000000000000000001351760240500154755ustar00rootroot00000000000000cmake-vala-r3/GitVersion/GetGitRevisionDescription.cmake000066400000000000000000000100261351760240500236040ustar00rootroot00000000000000# - Returns a version string from Git # # These functions force a re-configure on each git commit so that you can # trust the values of the variables in your build system. # # get_git_head_revision( [ ...]) # # Returns the refspec and sha hash of the current head revision # # git_describe( [ ...]) # # Returns the results of git describe on the source tree, and adjusting # the output so that it tests false if an error occurs. # # git_get_exact_tag( [ ...]) # # Returns the results of git describe --exact-match on the source tree, # and adjusting the output so that it tests false if there was no exact # matching tag. # # Requires CMake 2.6 or newer (uses the 'function' command) # # Original Author: # 2009-2010 Ryan Pavlik # http://academic.cleardefinition.com # Iowa State University HCI Graduate Program/VRAC # # Copyright Iowa State University 2009-2010. # Distributed under the Boost Software License, Version 1.0. # (See accompanying file LICENSE_1_0.txt or copy at # http://www.boost.org/LICENSE_1_0.txt) if(__get_git_revision_description) return() endif() set(__get_git_revision_description YES) # We must run the following at "include" time, not at function call time, # to find the path to this module rather than the path to a calling list file get_filename_component(_gitdescmoddir ${CMAKE_CURRENT_LIST_FILE} PATH) function(get_git_head_revision _refspecvar _hashvar) set(GIT_PARENT_DIR "${CMAKE_CURRENT_SOURCE_DIR}") set(GIT_DIR "${GIT_PARENT_DIR}/.git") while(NOT EXISTS "${GIT_DIR}") # .git dir not found, search parent directories set(GIT_PREVIOUS_PARENT "${GIT_PARENT_DIR}") get_filename_component(GIT_PARENT_DIR ${GIT_PARENT_DIR} PATH) if(GIT_PARENT_DIR STREQUAL GIT_PREVIOUS_PARENT) # We have reached the root directory, we are not in git set(${_refspecvar} "GITDIR-NOTFOUND" PARENT_SCOPE) set(${_hashvar} "GITDIR-NOTFOUND" PARENT_SCOPE) return() endif() set(GIT_DIR "${GIT_PARENT_DIR}/.git") endwhile() # check if this is a submodule if(NOT IS_DIRECTORY ${GIT_DIR}) file(READ ${GIT_DIR} submodule) string(REGEX REPLACE "gitdir: (.*)\n$" "\\1" GIT_DIR_RELATIVE ${submodule}) get_filename_component(SUBMODULE_DIR ${GIT_DIR} PATH) get_filename_component(GIT_DIR ${SUBMODULE_DIR}/${GIT_DIR_RELATIVE} ABSOLUTE) endif() set(GIT_DATA "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/git-data") if(NOT EXISTS "${GIT_DATA}") file(MAKE_DIRECTORY "${GIT_DATA}") endif() if(NOT EXISTS "${GIT_DIR}/HEAD") return() endif() set(HEAD_FILE "${GIT_DATA}/HEAD") configure_file("${GIT_DIR}/HEAD" "${HEAD_FILE}" COPYONLY) configure_file("${_gitdescmoddir}/GetGitRevisionDescription.cmake.in" "${GIT_DATA}/grabRef.cmake" @ONLY) include("${GIT_DATA}/grabRef.cmake") set(${_refspecvar} "${HEAD_REF}" PARENT_SCOPE) set(${_hashvar} "${HEAD_HASH}" PARENT_SCOPE) endfunction() function(git_describe _var) if(NOT GIT_FOUND) find_package(Git QUIET) endif() get_git_head_revision(refspec hash) if(NOT GIT_FOUND) set(${_var} "GIT-NOTFOUND" PARENT_SCOPE) return() endif() if(NOT hash) set(${_var} "HEAD-HASH-NOTFOUND" PARENT_SCOPE) return() endif() # TODO sanitize #if((${ARGN}" MATCHES "&&") OR # (ARGN MATCHES "||") OR # (ARGN MATCHES "\\;")) # message("Please report the following error to the project!") # message(FATAL_ERROR "Looks like someone's doing something nefarious with git_describe! Passed arguments ${ARGN}") #endif() #message(STATUS "Arguments to execute_process: ${ARGN}") execute_process(COMMAND "${GIT_EXECUTABLE}" describe ${hash} ${ARGN} WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}" RESULT_VARIABLE res OUTPUT_VARIABLE out ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE) if(NOT res EQUAL 0) set(out "${out}-${res}-NOTFOUND") endif() set(${_var} "${out}" PARENT_SCOPE) endfunction() function(git_get_exact_tag _var) git_describe(out --exact-match ${ARGN}) set(${_var} "${out}" PARENT_SCOPE) endfunction() cmake-vala-r3/GitVersion/GetGitRevisionDescription.cmake.in000066400000000000000000000024031351760240500242110ustar00rootroot00000000000000# # Internal file for GetGitRevisionDescription.cmake # # Requires CMake 2.6 or newer (uses the 'function' command) # # Original Author: # 2009-2010 Ryan Pavlik # http://academic.cleardefinition.com # Iowa State University HCI Graduate Program/VRAC # # Copyright Iowa State University 2009-2010. # Distributed under the Boost Software License, Version 1.0. # (See accompanying file LICENSE_1_0.txt or copy at # http://www.boost.org/LICENSE_1_0.txt) set(HEAD_HASH) file(READ "@HEAD_FILE@" HEAD_CONTENTS LIMIT 1024) string(STRIP "${HEAD_CONTENTS}" HEAD_CONTENTS) if(HEAD_CONTENTS MATCHES "ref") # named branch string(REPLACE "ref: " "" HEAD_REF "${HEAD_CONTENTS}") if(EXISTS "@GIT_DIR@/${HEAD_REF}") configure_file("@GIT_DIR@/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY) else() configure_file("@GIT_DIR@/packed-refs" "@GIT_DATA@/packed-refs" COPYONLY) file(READ "@GIT_DATA@/packed-refs" PACKED_REFS) if(${PACKED_REFS} MATCHES "([0-9a-z]*) ${HEAD_REF}") set(HEAD_HASH "${CMAKE_MATCH_1}") endif() endif() else() # detached HEAD configure_file("@GIT_DIR@/HEAD" "@GIT_DATA@/head-ref" COPYONLY) endif() if(NOT HEAD_HASH) file(READ "@GIT_DATA@/head-ref" HEAD_HASH LIMIT 1024) string(STRIP "${HEAD_HASH}" HEAD_HASH) endif() cmake-vala-r3/GitVersion/GitVersion.cmake000066400000000000000000000031771351760240500206000ustar00rootroot00000000000000macro(determine_fallback_version CMAKE_VERSION_MODULE_PATH) determine_fallback_version_for_subproject(${CMAKE_VERSION_MODULE_PATH} ${CMAKE_SOURCE_DIR}) endmacro() macro(determine_fallback_version_for_subproject CMAKE_VERSION_MODULE_PATH CMAKE_VERSION_GIT_DIR) if(EXISTS ${CMAKE_VERSION_GIT_DIR}/.git) # # Make a version containing the current version from git. # include(GetGitRevisionDescription) git_describe(VERSION_LONG --tags) #parsing Debian regex in CMake 3.9+ #string(REGEX MATCH "([^/]+)/([0-9]+)\\.([0-9]+)\\.([0-9]+)-([0-9]+)" _ "${VERSION_LONG}") #set(GIT_VERSION_MAJOR ${CMAKE_MATCH_2}) #set(GIT_VERSION_MINOR ${CMAKE_MATCH_3}) #set(GIT_VERSION_PATCH ${CMAKE_MATCH_4}) #set(GIT_VERSION_DISTRO ${CMAKE_MATCH_1}) #set(GIT_VERSION_RELEASE ${CMAKE_MATCH_5}) #parse the version information into pieces. string(REGEX REPLACE "^v*([0-9]+)\\..*" "\\1" GIT_VERSION_MAJOR "${VERSION_LONG}") string(REGEX REPLACE "^v*[0-9]+\\.([0-9]+).*" "\\1" GIT_VERSION_MINOR "${VERSION_LONG}") string(REGEX REPLACE "^v*[0-9]+\\.[0-9]+\\.([0-9]+).*" "\\1" GIT_VERSION_PATCH "${VERSION_LONG}") string(REGEX REPLACE "^v*[0-9]+\\.[0-9]+\\.[0-9]+(.*)" "\\1" GIT_VERSION_SHA1 "${VERSION_LONG}") set(VERSION_GIT "${GIT_VERSION_MAJOR}.${GIT_VERSION_MINOR}.${GIT_VERSION_PATCH}") file(WRITE ${CMAKE_VERSION_MODULE_PATH}/FallbackVersion.cmake "set(VERSION ${VERSION_GIT})\nset(VERSION_MAJOR ${GIT_VERSION_MAJOR})\nset(VERSION_MINOR ${GIT_VERSION_MINOR})\nset(VERSION_PATCH ${GIT_VERSION_PATCH})") endif() endmacro() cmake-vala-r3/LICENSE000066400000000000000000000027551351760240500144220ustar00rootroot00000000000000BSD 3-Clause License Copyright (c) 2018, ValaPanel Project All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. cmake-vala-r3/README.Vala.rst000066400000000000000000000116611351760240500157620ustar00rootroot00000000000000========== Vala CMake ========== :Author: Jakob Westhoff :Version: Draft Overview ======== Vala CMake is a collection of macros for the CMake_ build system to allow the creation and management of projects developed using the Vala_ programming language or its "Genie" flavor (less tested). Installation ============ To use the Vala macros in your own project you need to copy the macro files to an arbitrary folder in your projects directory and reference them in your ``CMakeLists.txt`` file. Assuming the macros are stored under ``cmake/vala`` in your projects folder you need to add the following information to your base ``CMakeLists.txt``:: list(APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/vala ) After the new module path as been added you can simply include the provided modules or use the provided find routines. Finding Vala ============ The find module for vala works like any other Find module in CMake. You can use it by simply calling the usual ``find_package`` function. Default parameters like ``REQUIRED`` and ``QUIETLY`` are supported. :: find_package(Vala REQUIRED) After a successful call to the find_package function the following variables will be set: VALA_FOUND Whether the vala compiler has been found or not VALA_EXECUTABLE Full path to the valac executable if it has been found VALA_VERSION Version number of the available valac Precompiling Vala sources ========================= CMake is mainly supposed to handle c or c++ based projects. Luckily every vala program is translated into plain c code using the vala compiler, followed by normal compilation of the generated c program using gcc. The macro ``vala_precompile`` uses that fact to create c files from your .vala sources for further CMake processing. The first parameter provided is a variable, which will be filled with a list of c files outputted by the vala compiler. This list can than be used in conjunction with functions like ``add_executable`` or others to create the necessary compile rules with CMake. The initial variable is followed by a list of .vala files to be compiled. Please take care to add every vala file belonging to the currently compiled project or library as Vala will otherwise not be able to resolve all dependencies. The following sections may be specified afterwards to provide certain options to the vala compiler: PACKAGES A list of vala packages/libraries to be used during the compile cycle. The package names are exactly the same, as they would be passed to the valac "--pkg=" option. OPTIONS A list of optional options to be passed to the valac executable. This can be used to pass "--thread" for example to enable multi-threading support. DIRECTORY Specify the directory where the output source files will be stored. If ommitted, the source files will be stored in CMAKE_CURRENT_BINARY_DIR. CUSTOM_VAPIS A list of custom vapi files to be included for compilation. This can be useful to include freshly created vala libraries without having to install them in the system. GENERATE_VAPI Pass all the needed flags to the compiler to create an internal vapi for the compiled library. The provided name will be used for this and a .vapi file will be created. GENERATE_HEADER Let the compiler generate a header file for the compiled code. There will be a header file as well as an internal header file being generated called .h and _internal.h The following call is a simple example to the vala_precompile macro showing an example to every of the optional sections:: vala_precompile(VALA_C source1.vala source2.vala source3.vala PACKAGES gtk+-2.0 gio-1.0 posix OPTIONS --thread CUSTOM_VAPIS some_vapi.vapi GENERATE_VAPI myvapi GENERATE_HEADER myheader ) Most important is the variable VALA_C which will contain all the generated c file names after the call. The easiest way to use this information is to tell CMake to create an executable out of it. :: add_executable(myexecutable ${VALA_C}) Further reading =============== The `Pdf Presenter Console`__ , which is a vala based project of mine, makes heavy usage of the here described macros. To look at a real world example of these macros the mentioned project is the right place to take a look. The svn trunk of it can be found at:: svn://pureenergy.cc/pdf_presenter_console/trunk __ http://westhoffswelt.de/projects/pdf_presenter_console.html Acknowledgments =============== Thanks go out to Florian Sowade, a fellow local PHP-Usergroupie, who helped me a lot with the initial version of this macros and always answered my mostly dumb CMake questions. .. _CMake: http://cmake.org .. _Vala: http://live.gnome.org/Vala .. _Genie: http://live.gnome.org/Genie .. Local Variables: mode: rst fill-column: 79 End: vim: et syn=rst tw=79 cmake-vala-r3/README.md000066400000000000000000000005131351760240500146620ustar00rootroot00000000000000#Elementary CMake modules This is a set of CMake modules: Translations, GSettings, and Vala modules. For all the Vala related modules see README.Vala.rst: * ParseArguments.cmake * ValaPrecompile.cmake * ValaVersion.cmake * FindVala.cmake By Athor: * Modified Translations.cmake to support desktop files. * Added GResource.cmakecmake-vala-r3/Utility/000077500000000000000000000000001351760240500150475ustar00rootroot00000000000000cmake-vala-r3/Utility/Format.cmake000066400000000000000000000005431351760240500173030ustar00rootroot00000000000000# additional target to perform clang-format run, requires clang-format # get all project files function(use_format) find_program(CLANG_FORMAT clang-format) file(GLOB_RECURSE ALL_SOURCE_FILES *.c *.h) add_custom_target( clangformat COMMAND ${CLANG_FORMAT} -style=file -i ${ALL_SOURCE_FILES} ) endfunction() use_format() cmake-vala-r3/Utility/Translations.cmake000066400000000000000000000360201351760240500205330ustar00rootroot00000000000000# Translations.cmake, CMake macros written for Marlin, feel free to re-use them # Copyright (C) 2018 Konstantin Pugin # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions # are met: # 1. Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # 2. Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND ITS CONTRIBUTORS ``AS # IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, # THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR ITS # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; # OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, # WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR # OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF # ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. find_package(Gettext REQUIRED) macro (add_translations_directory NLS_PACKAGE) add_custom_target (i18n ALL COMMENT “Building i18n messages.”) # be sure that all languages are present # Using all usual languages code from https://www.gnu.org/software/gettext/manual/html_node/Language-Codes.html#Language-Codes # Rare language codes should be added on-demand. if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/LINGUAS) file (STRINGS ${CMAKE_CURRENT_SOURCE_DIR}/LINGUAS LANGUAGES_NEEDED}) configure_file (${CMAKE_CURRENT_SOURCE_DIR}/LINGUAS ${CMAKE_CURRENT_BINARY_DIR}/LINGUAS) else() set (LANGUAGES_NEEDED aa ab ae af ak am an ar as ast av ay az ba be bg bh bi bm bn bo br bs ca ce ch ckb co cr cs cu cv cy da de dv dz ee el en_AU en_CA en_GB eo es et eu fa ff fi fj fo fr fr_CA fy ga gd gl gn gu gv ha he hi ho hr ht hu hy hz ia id ie ig ii ik io is it iu ja jv ka kg ki kj kk kl km kn ko kr ks ku kv kw ky la lb lg li ln lo lt lu lv mg mh mi mk ml mn mo mr ms mt my na nb nd ne ng nl nn nb nr nv ny oc oj om or os pa pi pl ps pt pt_BR qu rm rn ro ru rue rw sa sc sd se sg si sk sl sm sma sn so sq sr ss st su sv sw ta te tg th ti tk tl tn to tr ts tt tw ty ug uk ur uz ve vi vo wa wo xh yi yo za zh zh_CN zh_HK zh_TW zu) string (REPLACE ";" " " LINGUAS "${LANGUAGES_NEEDED}") configure_file (${CMAKE_CURRENT_SOURCE_DIR}/LINGUAS.in ${CMAKE_CURRENT_BINARY_DIR}/LINGUAS) endif() foreach (LANGUAGE_NEEDED ${LANGUAGES_NEEDED}) create_po_file (${LANGUAGE_NEEDED}) endforeach (LANGUAGE_NEEDED ${LANGUAGES_NEEDED}) # generate .mo from .po file (GLOB PO_FILES ${CMAKE_CURRENT_SOURCE_DIR}/*.po) foreach (PO_INPUT ${PO_FILES}) get_filename_component (PO_INPUT_BASE ${PO_INPUT} NAME_WE) set (MO_OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${PO_INPUT_BASE}.mo) set (PO_COPY ${CMAKE_CURRENT_BINARY_DIR}/${PO_INPUT_BASE}.po) file (COPY ${PO_INPUT} DESTINATION ${CMAKE_CURRENT_BINARY_DIR}) add_custom_command (TARGET i18n COMMAND ${GETTEXT_MSGFMT_EXECUTABLE} -o ${MO_OUTPUT} ${PO_INPUT}) install (FILES ${MO_OUTPUT} DESTINATION share/locale/${PO_INPUT_BASE}/LC_MESSAGES RENAME ${NLS_PACKAGE}.mo COMPONENT ${ARGV1}) endforeach (PO_INPUT ${PO_FILES}) #Create *.desktop files file (GLOB_RECURSE SOURCE_FILES RELATIVE ${CMAKE_SOURCE_DIR}/ ${CMAKE_SOURCE_DIR}/*.desktop.plugin.in) foreach(PLUGIN_DESKTOP_IN_FILE ${SOURCE_FILES}) get_filename_component( BASE_NAME ${PLUGIN_DESKTOP_IN_FILE} NAME ) string(REGEX REPLACE ".desktop.plugin.in$" "" PLUGIN_FILE ${BASE_NAME}) get_filename_component( BASE_DIRECTORY ${PLUGIN_DESKTOP_IN_FILE} PATH ) file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/${BASE_DIRECTORY}) add_custom_command (TARGET i18n COMMAND ${GETTEXT_MSGFMT_EXECUTABLE} --desktop --keyword=Name --keyword=Description --keyword=Help -d ${CMAKE_CURRENT_BINARY_DIR} --template ${CMAKE_SOURCE_DIR}/${PLUGIN_DESKTOP_IN_FILE} -o ${CMAKE_BINARY_DIR}/${BASE_DIRECTORY}/${PLUGIN_FILE}.plugin) endforeach() file (GLOB_RECURSE SOURCE_FILES RELATIVE ${CMAKE_SOURCE_DIR}/ ${CMAKE_SOURCE_DIR}/*.desktop.in) foreach(DESKTOP_IN_FILE ${SOURCE_FILES}) get_filename_component( BASE_NAME ${DESKTOP_IN_FILE} NAME ) string(REGEX REPLACE ".desktop.in$" "" PLUGIN_FILE ${BASE_NAME}) get_filename_component( BASE_DIRECTORY ${DESKTOP_IN_FILE} PATH ) file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/${BASE_DIRECTORY}) add_custom_command (TARGET i18n COMMAND ${GETTEXT_MSGFMT_EXECUTABLE} --desktop --keyword=Name --keyword=GenericName --keyword=Comment --keyword=Description --keyword=Help --keyword=Keywords -d ${CMAKE_CURRENT_BINARY_DIR} --template ${CMAKE_SOURCE_DIR}/${DESKTOP_IN_FILE} -o ${CMAKE_BINARY_DIR}/${BASE_DIRECTORY}/${PLUGIN_FILE}.desktop) endforeach() file (GLOB_RECURSE SOURCE_FILES RELATIVE ${CMAKE_SOURCE_DIR}/ ${CMAKE_SOURCE_DIR}/*.desktop.xfce.in) foreach(XFCE_DESKTOP_IN_FILE ${SOURCE_FILES}) get_filename_component( BASE_NAME ${XFCE_DESKTOP_IN_FILE} NAME ) string(REGEX REPLACE ".desktop.xfce.in$" "" PLUGIN_FILE ${BASE_NAME}) get_filename_component( BASE_DIRECTORY ${XFCE_DESKTOP_IN_FILE} PATH ) file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/${BASE_DIRECTORY}) add_custom_command (TARGET i18n COMMAND ${GETTEXT_MSGFMT_EXECUTABLE} --desktop --keyword=Name --keyword=Comment --keyword=Help -d ${CMAKE_CURRENT_BINARY_DIR} --template ${CMAKE_SOURCE_DIR}/${XFCE_DESKTOP_IN_FILE} -o ${CMAKE_BINARY_DIR}/${BASE_DIRECTORY}/${PLUGIN_FILE}.desktop) endforeach() file (GLOB_RECURSE SOURCE_FILES RELATIVE ${CMAKE_SOURCE_DIR}/ ${CMAKE_SOURCE_DIR}/*.appdata.xml.in) foreach(APPDATA_XML_IN_FILE ${SOURCE_FILES}) get_filename_component( BASE_NAME ${APPDATA_XML_IN_FILE} NAME ) string(REGEX REPLACE ".appdata.xml.in$" "" PLUGIN_FILE ${BASE_NAME}) get_filename_component( BASE_DIRECTORY ${APPDATA_XML_IN_FILE} PATH ) file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/${BASE_DIRECTORY}) add_custom_command (TARGET i18n COMMAND ${GETTEXT_MSGFMT_EXECUTABLE} --xml -Lappdata -d ${CMAKE_CURRENT_BINARY_DIR} --template ${CMAKE_SOURCE_DIR}/${APPDATA_XML_IN_FILE} -o ${CMAKE_BINARY_DIR}/${BASE_DIRECTORY}/${PLUGIN_FILE}.appdata.xml) endforeach() endmacro (add_translations_directory) # Apply the right default template. macro (create_po_file LANGUAGE_NEEDED) set (FILE ${CMAKE_CURRENT_SOURCE_DIR}/${LANGUAGE_NEEDED}.po) if (NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LANGUAGE_NEEDED}.po) file (APPEND ${FILE} "msgid \"\"\n") file (APPEND ${FILE} "msgstr \"\"\n") file (APPEND ${FILE} "\"MIME-Version: 1.0\\n\"\n") file (APPEND ${FILE} "\"Content-Type: text/plain; charset=UTF-8\\n\"\n") if ("${LANGUAGE_NEEDED}" STREQUAL "ja" OR "${LANGUAGE_NEEDED}" STREQUAL "vi" OR "${LANGUAGE_NEEDED}" STREQUAL "ko") file (APPEND ${FILE} "\"Plural-Forms: nplurals=2; plural=n == 1 ? 0 : 1;\\n\"\n") elseif ("${LANGUAGE_NEEDED}" STREQUAL "en" OR "${LANGUAGE_NEEDED}" STREQUAL "de" OR "${LANGUAGE_NEEDED}" STREQUAL "nl" OR "${LANGUAGE_NEEDED}" STREQUAL "sv" OR "${LANGUAGE_NEEDED}" STREQUAL "nb" OR "${LANGUAGE_NEEDED}" STREQUAL "nn" OR "${LANGUAGE_NEEDED}" STREQUAL "nb" OR "${LANGUAGE_NEEDED}" STREQUAL "no" OR "${LANGUAGE_NEEDED}" STREQUAL "fo" OR "${LANGUAGE_NEEDED}" STREQUAL "es" OR "${LANGUAGE_NEEDED}" STREQUAL "pt" OR "${LANGUAGE_NEEDED}" STREQUAL "it" OR "${LANGUAGE_NEEDED}" STREQUAL "bg" OR "${LANGUAGE_NEEDED}" STREQUAL "he" OR "${LANGUAGE_NEEDED}" STREQUAL "fi" OR "${LANGUAGE_NEEDED}" STREQUAL "et" OR "${LANGUAGE_NEEDED}" STREQUAL "eo" OR "${LANGUAGE_NEEDED}" STREQUAL "hu" OR "${LANGUAGE_NEEDED}" STREQUAL "tr" OR "${LANGUAGE_NEEDED}" STREQUAL "es") file (APPEND ${FILE} "\"Plural-Forms: nplurals=2; plural=n != 1;\\n\"\n") elseif ("${LANGUAGE_NEEDED}" STREQUAL "fr" OR "${LANGUAGE_NEEDED}" STREQUAL "fr_CA" OR "${LANGUAGE_NEEDED}" STREQUAL "pt_BR") file (APPEND ${FILE} "\"Plural-Forms: nplurals=2; plural=n>1;\\n\"\n") elseif ("${LANGUAGE_NEEDED}" STREQUAL "lv") file (APPEND ${FILE} "\"Plural-Forms: nplurals=3; plural=n%10==1 && n%100!=11 ? 0 : n != 0 ? 1 : 2;\\n\"\n") elseif ("${LANGUAGE_NEEDED}" STREQUAL "ro") file (APPEND ${FILE} "\"Plural-Forms: nplurals=3; plural=n==1 ? 0 : (n==0 || (n%100 > 0 && n%100 < 20)) ? 1 : 2;\\n\"\n") elseif ("${LANGUAGE_NEEDED}" STREQUAL "lt") file (APPEND ${FILE} "\"Plural-Forms: nplurals=3; plural=n%10==1 && n%100!=11 ? 0 : n%10>=2 && (n%100<10 || n%100>=20) ? 1 : 2;\\n\"\n") elseif ("${LANGUAGE_NEEDED}" STREQUAL "ru" OR "${LANGUAGE_NEEDED}" STREQUAL "uk" OR "${LANGUAGE_NEEDED}" STREQUAL "be" OR "${LANGUAGE_NEEDED}" STREQUAL "sr" OR "${LANGUAGE_NEEDED}" STREQUAL "hr") file (APPEND ${FILE} "\"Plural-Forms: nplurals=3; plural=n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2;\\n\"\n") elseif ("${LANGUAGE_NEEDED}" STREQUAL "cs" OR "${LANGUAGE_NEEDED}" STREQUAL "sk") file (APPEND ${FILE} "\"Plural-Forms: nplurals=3; plural=(n==1) ? 0 : (n>=2 && n<=4) ? 1 : 2;\\n\"\n") elseif ("${LANGUAGE_NEEDED}" STREQUAL "pl") file (APPEND ${FILE} "\"Plural-Forms: nplurals=3; plural=n==1 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2;\\n\"\n") elseif ("${LANGUAGE_NEEDED}" STREQUAL "sl") file (APPEND ${FILE} "\"Plural-Forms: nplurals=4; plural=n%100==1 ? 0 : n%100==2 ? 1 : n%100==3 || n%100==4 ? 2 : 3;\\n\"\n") endif () endif () endmacro (create_po_file) macro (add_translations_catalog NLS_PACKAGE) add_custom_target (pot COMMENT “Building translation catalog.”) find_program (XGETTEXT_EXECUTABLE xgettext) set(C_SOURCE "") set(VALA_SOURCE "") set(GLADE_SOURCE "") set(PLUGIN_DESKTOP_SOURCE "") set(DESKTOP_SOURCE "") set(GSETTINGS_SOURCE "") set(APPDATA_SOURCE "") foreach(FILES_INPUT ${ARGN}) set(BASE_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/${FILES_INPUT}) file (GLOB_RECURSE SOURCE_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/ ${BASE_DIRECTORY}/*.c) foreach(C_FILE ${SOURCE_FILES}) set(C_SOURCE ${C_SOURCE} ${C_FILE}) endforeach() file (GLOB_RECURSE SOURCE_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/ ${BASE_DIRECTORY}/*.vala) foreach(VALA_C_FILE ${SOURCE_FILES}) set(VALA_SOURCE ${VALA_SOURCE} ${VALA_C_FILE}) endforeach() file (GLOB_RECURSE SOURCE_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/ ${BASE_DIRECTORY}/*.ui) foreach(GLADE_C_FILE ${SOURCE_FILES}) set(GLADE_SOURCE ${GLADE_SOURCE} ${GLADE_C_FILE}) endforeach() file (GLOB_RECURSE SOURCE_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/ ${BASE_DIRECTORY}/*.desktop.plugin.in) foreach(PLUGIN_DESKTOP_IN_FILE ${SOURCE_FILES}) set(PLUGIN_DESKTOP_SOURCE ${PLUGIN_DESKTOP_SOURCE} ${PLUGIN_DESKTOP_IN_FILE}) endforeach() file (GLOB_RECURSE SOURCE_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/ ${BASE_DIRECTORY}/*.desktop.xfce.in) foreach(XFCE_DESKTOP_IN_FILE ${SOURCE_FILES}) set(XFCE_DESKTOP_SOURCE ${XFCE_DESKTOP_SOURCE} ${XFCE_DESKTOP_IN_FILE}) endforeach() file (GLOB_RECURSE SOURCE_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/ ${BASE_DIRECTORY}/*.gschema.xml.in) foreach(GSETTINGS_IN_FILE ${SOURCE_FILES}) set(GSETTINGS_SOURCE ${GSETTINGS_SOURCE} ${GSETTINGS_IN_FILE}) endforeach() file (GLOB_RECURSE SOURCE_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/ ${BASE_DIRECTORY}/*.appdata.xml.in) foreach(APPDATA_IN_FILE ${SOURCE_FILES}) set(APPDATA_SOURCE ${APPDATA_SOURCE} ${APPDATA_IN_FILE}) endforeach() file (GLOB_RECURSE SOURCE_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/ ${BASE_DIRECTORY}/*.desktop.in) foreach(DESKTOP_IN_FILE ${SOURCE_FILES}) set(DESKTOP_SOURCE ${DESKTOP_SOURCE} ${DESKTOP_IN_FILE}) endforeach() endforeach() set(BASE_XGETTEXT_COMMAND ${XGETTEXT_EXECUTABLE} -d ${NLS_PACKAGE} -o ${CMAKE_CURRENT_SOURCE_DIR}/${NLS_PACKAGE}.pot --add-comments="/" --keyword="_" --keyword="N_" --keyword="C_:1c,2" --keyword="NC_:1c,2" --keyword="ngettext:1,2" --keyword="Q_:1g" --from-code=UTF-8) set(CONTINUE_FLAG "") IF(NOT "${C_SOURCE}" STREQUAL "") add_custom_command(TARGET pot WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${BASE_XGETTEXT_COMMAND} ${C_SOURCE}) set(CONTINUE_FLAG "-j") ENDIF() IF(NOT "${VALA_SOURCE}" STREQUAL "") add_custom_command(TARGET pot WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${BASE_XGETTEXT_COMMAND} ${CONTINUE_FLAG} -Lvala ${VALA_SOURCE}) set(CONTINUE_FLAG "-j") ENDIF() IF(NOT "${GLADE_SOURCE}" STREQUAL "") add_custom_command (TARGET pot WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${BASE_XGETTEXT_COMMAND} ${CONTINUE_FLAG} -LGlade ${GLADE_SOURCE}) set(CONTINUE_FLAG "-j") ENDIF() IF(NOT "${APPDATA_SOURCE}" STREQUAL "") add_custom_command (TARGET pot WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${BASE_XGETTEXT_COMMAND} ${CONTINUE_FLAG} -Lappdata ${APPDATA_SOURCE}) set(CONTINUE_FLAG "-j") ENDIF() IF(NOT "${PLUGIN_DESKTOP_SOURCE}" STREQUAL "") add_custom_command (TARGET pot WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${BASE_XGETTEXT_COMMAND} ${CONTINUE_FLAG} -Ldesktop -kName -kDescription -kHelp ${PLUGIN_DESKTOP_SOURCE}) set(CONTINUE_FLAG "-j") ENDIF() IF(NOT "${XFCE_DESKTOP_SOURCE}" STREQUAL "") add_custom_command (TARGET pot WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${BASE_XGETTEXT_COMMAND} ${CONTINUE_FLAG} -Ldesktop -kName -kComment -kHelp ${XFCE_DESKTOP_SOURCE}) set(CONTINUE_FLAG "-j") ENDIF() IF(NOT "${DESKTOP_SOURCE}" STREQUAL "") add_custom_command (TARGET pot WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${BASE_XGETTEXT_COMMAND} ${CONTINUE_FLAG} -Ldesktop -kName -kGenericName -kComment -kDescription -kHelp -kKeywords ${DESKTOP_SOURCE}) set(CONTINUE_FLAG "-j") ENDIF() IF(NOT "${GSETTINGS_SOURCE}" STREQUAL "") add_custom_command (TARGET pot WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${BASE_XGETTEXT_COMMAND} ${CONTINUE_FLAG} -LGsettings ${XML_SOURCE}) ENDIF() endmacro () cmake-vala-r3/Utility/UseRPMTools.cmake000066400000000000000000000147431351760240500202160ustar00rootroot00000000000000# Copyright (C) 2003-2008 TSP Developer Team # Copyright (C) 2018 Konstantin Pugin # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, either version 2.1 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see . # # - Find tools needed for building RPM Packages # on Linux systems and defines macro that helps to # build source or binary RPM, the MACRO assumes # CMake 2.4.x which includes CPack support. # CPack is used to build tar.gz source tarball # which may be used by a custom user-made spec file. # # - Define RPMTools_ADD_RPM_TARGETS which defines # two (top-level) CUSTOM targets for building # source and binary RPMs # IF (WIN32) MESSAGE(STATUS "RPM tools not available on Win32 systems") ENDIF(WIN32) IF (UNIX) # Look for RPM builder executable FIND_PROGRAM(RPMTools_RPMBUILD_EXECUTABLE NAMES rpmbuild PATHS "/usr/bin;/usr/lib/rpm" PATH_SUFFIXES bin DOC "The RPM builder tool") IF (RPMTools_RPMBUILD_EXECUTABLE) MESSAGE(STATUS "Looking for RPMTools... - found rpmuild is ${RPMTools_RPMBUILD_EXECUTABLE}") SET(RPMTools_RPMBUILD_FOUND "YES") GET_FILENAME_COMPONENT(RPMTools_BINARY_DIRS ${RPMTools_RPMBUILD_EXECUTABLE} PATH) ELSE (RPMTools_RPMBUILD_EXECUTABLE) SET(RPMTools_RPMBUILD_FOUND "NO") MESSAGE(STATUS "Looking for RPMTools... - rpmbuild NOT FOUND") ENDIF (RPMTools_RPMBUILD_EXECUTABLE) # Detect if CPack was included or not IF (NOT DEFINED "CPACK_PACKAGE_NAME") MESSAGE(FATAL_ERROR "CPack was not included, you should include CPack before Using RPMTools") ENDIF (NOT DEFINED "CPACK_PACKAGE_NAME") IF (RPMTools_RPMBUILD_FOUND) SET(RPMTools_FOUND TRUE) # # - first arg (ARGV0) is RPM name # - second arg (ARGV1) is the RPM spec file path [optional] # - third arg (ARGV2) is the RPM ROOT DIRECTORY used to build RPMs [optional] # MACRO(RPMTools_ADD_RPM_TARGETS RPMNAME) # # If no spec file is provided create a minimal one # IF ("${ARGV1}" STREQUAL "") SET(SPECFILE_PATH "${CMAKE_BINARY_DIR}/${RPMNAME}.spec") ELSE ("${ARGV1}" STREQUAL "") SET(SPECFILE_PATH "${ARGV1}") ENDIF("${ARGV1}" STREQUAL "") # Verify whether if RPM_ROOTDIR was provided or not IF("${ARGV2}" STREQUAL "") SET(RPM_ROOTDIR ${CMAKE_BINARY_DIR}/RPM) ELSE ("${ARGV2}" STREQUAL "") SET(RPM_ROOTDIR "${ARGV2}") ENDIF("${ARGV2}" STREQUAL "") MESSAGE(STATUS "RPMTools:: Using RPM_ROOTDIR=${RPM_ROOTDIR}") # Prepare RPM build tree FILE(MAKE_DIRECTORY ${RPM_ROOTDIR}) FILE(MAKE_DIRECTORY ${RPM_ROOTDIR}/tmp) FILE(MAKE_DIRECTORY ${RPM_ROOTDIR}/BUILD) FILE(MAKE_DIRECTORY ${RPM_ROOTDIR}/RPMS) FILE(MAKE_DIRECTORY ${RPM_ROOTDIR}/SOURCES) FILE(MAKE_DIRECTORY ${RPM_ROOTDIR}/SPECS) FILE(MAKE_DIRECTORY ${RPM_ROOTDIR}/SRPMS) # # We check whether if the provided spec file is # to be configure or not. # IF ("${ARGV1}" STREQUAL "") SET(SPECFILE_PATH "${RPM_ROOTDIR}/SPECS/${RPMNAME}.spec") SET(SPECFILE_NAME "${RPMNAME}.spec") MESSAGE(STATUS "No Spec file given generate a minimal one --> ${RPM_ROOTDIR}/SPECS/${RPMNAME}.spec") FILE(WRITE ${RPM_ROOTDIR}/SPECS/${RPMNAME}.spec "# -*- rpm-spec -*- Summary: ${RPMNAME} Name: ${RPMNAME} Version: ${PACKAGE_VERSION} Release: 1 License: Unknown Group: Unknown Source: ${CPACK_SOURCE_PACKAGE_FILE_NAME}.tar.gz BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root BuildRequires: cmake %define prefix /opt/${RPMNAME}-%{version} %define rpmprefix $RPM_BUILD_ROOT%{prefix} %define srcdirname %{name}-%{version}-Source %description ${RPMNAME} : No description for now %prep %setup -q -n %{srcdirname} %build cd .. rm -rf build_tree mkdir build_tree cd build_tree cmake -DCMAKE_INSTALL_PREFIX=%{rpmprefix} ../%{srcdirname} make %install cd ../build_tree make install %clean rm -rf %{srcdirname} rm -rf build_tree %files %defattr(-,root,root,-) %dir %{prefix} %{prefix}/* %changelog * Wed Feb 28 2007 Erk Generated by CMake UseRPMTools macros" ) ELSE ("${ARGV1}" STREQUAL "") SET(SPECFILE_PATH "${ARGV1}") GET_FILENAME_COMPONENT(SPECFILE_EXT ${SPECFILE_PATH} EXT) IF ("${SPECFILE_EXT}" STREQUAL ".spec") # This is a 'ready-to-use' spec file which does not need to be CONFIGURED GET_FILENAME_COMPONENT(SPECFILE_NAME ${SPECFILE_PATH} NAME) MESSAGE(STATUS "Simple copy spec file <${SPECFILE_PATH}> --> <${RPM_ROOTDIR}/SPECS/${SPECFILE_NAME}>") CONFIGURE_FILE( ${SPECFILE_PATH} ${RPM_ROOTDIR}/SPECS/${SPECFILE_NAME} COPYONLY) ELSE ("${SPECFILE_EXT}" STREQUAL ".spec") # This is a to-be-configured spec file GET_FILENAME_COMPONENT(SPECFILE_NAME ${SPECFILE_PATH} NAME_WE) SET(SPECFILE_NAME "${SPECFILE_NAME}.spec") MESSAGE(STATUS "Configuring spec file <${SPECFILE_PATH}> --> <${RPM_ROOTDIR}/SPECS/${SPECFILE_NAME}>") CONFIGURE_FILE( ${SPECFILE_PATH} ${RPM_ROOTDIR}/SPECS/${SPECFILE_NAME} @ONLY) ENDIF ("${SPECFILE_EXT}" STREQUAL ".spec") ENDIF("${ARGV1}" STREQUAL "") ADD_CUSTOM_TARGET(${RPMNAME}_srpm COMMAND cpack -G TGZ --config CPackSourceConfig.cmake COMMAND ${CMAKE_COMMAND} -E copy ${CPACK_SOURCE_PACKAGE_FILE_NAME}.tar.gz ${RPM_ROOTDIR}/SOURCES COMMAND ${RPMTools_RPMBUILD_EXECUTABLE} -bs --define=\"_topdir ${RPM_ROOTDIR}\" --buildroot=${RPM_ROOTDIR}/tmp ${RPM_ROOTDIR}/SPECS/${SPECFILE_NAME} ) ADD_CUSTOM_TARGET(${RPMNAME}_rpm COMMAND cpack -G TGZ --config CPackSourceConfig.cmake COMMAND ${CMAKE_COMMAND} -E copy ${CPACK_SOURCE_PACKAGE_FILE_NAME}.tar.gz ${RPM_ROOTDIR}/SOURCES COMMAND ${RPMTools_RPMBUILD_EXECUTABLE} -bb --define=\"_topdir ${RPM_ROOTDIR}\" --buildroot=${RPM_ROOTDIR}/tmp ${RPM_ROOTDIR}/SPECS/${SPECFILE_NAME} ) ENDMACRO(RPMTools_ADD_RPM_TARGETS) ELSE (RPMTools_RPMBUILD_FOUND) SET(RPMTools FALSE) ENDIF (RPMTools_RPMBUILD_FOUND) ENDIF (UNIX) cmake-vala-r3/VCMConfig.cmake.in000066400000000000000000000007441351760240500165730ustar00rootroot00000000000000@PACKAGE_INIT@ set(VCM_FIND_MODULE_DIR "@PACKAGE_FIND_MODULE_DIR@") set(VCM_GIT_VERSION_MODULE_DIR "@PACKAGE_GIT_VERSION_MODULE_DIR@") set(VCM_GLIB_MODULE_DIR "@PACKAGE_GLIB_MODULE_DIR@") set(VCM_UTILITY_MODULE_DIR "@PACKAGE_UTILITY_MODULE_DIR@") set(VCM_VALA_MODULE_DIR "@PACKAGE_VALA_MODULE_DIR@") set(VCM_MODULE_PATH "${VCM_FIND_MODULE_DIR}" "${VCM_GIT_VERSION_MODULE_DIR}" "${VCM_GLIB_MODULE_DIR}" "${VCM_UTILITY_MODULE_DIR}" "${VCM_VALA_MODULE_DIR}" ) cmake-vala-r3/VCMSubmodule.cmake000066400000000000000000000002341351760240500167120ustar00rootroot00000000000000macro(use_vcm VCM_DIR) list (APPEND CMAKE_MODULE_PATH ${VCM_DIR}/GitVersion ${VCM_DIR}/Find ${VCM_DIR}/Vala ${VCM_DIR}/Utility ${VCM_DIR}/GLib) endmacro() cmake-vala-r3/Vala/000077500000000000000000000000001351760240500142675ustar00rootroot00000000000000cmake-vala-r3/Vala/FindVala.cmake000066400000000000000000000054231351760240500167610ustar00rootroot00000000000000## # Copyright 2009-2010 Jakob Westhoff. All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are met: # # 1. Redistributions of source code must retain the above copyright notice, # this list of conditions and the following disclaimer. # # 2. Redistributions in binary form must reproduce the above copyright notice, # this list of conditions and the following disclaimer in the documentation # and/or other materials provided with the distribution. # # THIS SOFTWARE IS PROVIDED BY JAKOB WESTHOFF ``AS IS'' AND ANY EXPRESS OR # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF # MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO # EVENT SHALL JAKOB WESTHOFF OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR # PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF # LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE # OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF # ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # # The views and conclusions contained in the software and documentation are those # of the authors and should not be interpreted as representing official policies, # either expressed or implied, of Jakob Westhoff ## ## # Find module for the Vala compiler (valac) # # This module determines wheter a Vala compiler is installed on the current # system and where its executable is. # # Call the module using "find_package(Vala) from within your CMakeLists.txt. # # The following variables will be set after an invocation: # # VALA_FOUND Whether the vala compiler has been found or not # VALA_EXECUTABLE Full path to the valac executable if it has been found # VALA_VERSION Version number of the available valac ## # Search for the valac executable in the usual system paths. find_program(VALA_EXECUTABLE NAMES valac valac-0.38 valac-0.36 valac-0.34) execute_process(COMMAND ${VALA_EXECUTABLE} "--version" OUTPUT_VARIABLE "VALA_VERSION") string(REPLACE "Vala" "" "VALA_VERSION" ${VALA_VERSION}) string(STRIP ${VALA_VERSION} "VALA_VERSION") # Handle the QUIETLY and REQUIRED arguments, which may be given to the find call. # Furthermore set VALA_FOUND to TRUE if Vala has been found (aka. # VALA_EXECUTABLE is set) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(Vala REQUIRED_VARS VALA_EXECUTABLE VERSION_VAR VALA_VERSION ) mark_as_advanced(VALA_EXECUTABLE) cmake-vala-r3/Vala/ValaPrecompile.cmake000066400000000000000000000230041351760240500201730ustar00rootroot00000000000000## # Copyright 2009-2010 Jakob Westhoff. All rights reserved. # Copyright 2012 elementary. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are met: # # 1. Redistributions of source code must retain the above copyright notice, # this list of conditions and the following disclaimer. # # 2. Redistributions in binary form must reproduce the above copyright notice, # this list of conditions and the following disclaimer in the documentation # and/or other materials provided with the distribution. # # THIS SOFTWARE IS PROVIDED BY JAKOB WESTHOFF ``AS IS'' AND ANY EXPRESS OR # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF # MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO # EVENT SHALL JAKOB WESTHOFF OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR # PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF # LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE # OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF # ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # # The views and conclusions contained in the software and documentation are those # of the authors and should not be interpreted as representing official policies, # either expressed or implied, of Jakob Westhoff ## include(CMakeParseArguments) find_package(Vala QUIET) ## # Compile vala files to their c equivalents for further processing. # # The "vala_precompile" macro takes care of calling the valac executable on the # given source to produce c files which can then be processed further using # default cmake functions. # # The first parameter provided is a variable, which will be filled with a list # of c files outputted by the vala compiler. This list can than be used in # conjuction with functions like "add_executable" or others to create the # neccessary compile rules with CMake. # # The initial variable is followed by a list of .vala files to be compiled. # Please take care to add every vala file belonging to the currently compiled # project or library as Vala will otherwise not be able to resolve all # dependencies. # # The following sections may be specified afterwards to provide certain options # to the vala compiler: # # PACKAGES # A list of vala packages/libraries to be used during the compile cycle. The # package names are exactly the same, as they would be passed to the valac # "--pkg=" option. # # OPTIONS # A list of optional options to be passed to the valac executable. This can be # used to pass "--thread" for example to enable multi-threading support. # # CUSTOM_VAPIS # A list of custom vapi files to be included for compilation. This can be # useful to include freshly created vala libraries without having to install # them in the system. # # GENERATE_VAPI # Pass all the needed flags to the compiler to create an internal vapi for # the compiled library. The provided name will be used for this and a # .vapi file will be created. # # GENERATE_HEADER # Let the compiler generate a header file for the compiled code. There will # be a header file as well as an internal header file being generated called # .h and _internal.h # # GENERATE_GIR # Have the compiler generate a GObject-Introspection repository file with # name: .gir. This can be later used to create a binary typelib # using the GI compiler. # # GENERATE_SYMBOLS # Output a .symbols file containing all the exported symbols. # # The following call is a simple example to the vala_precompile macro showing # an example to every of the optional sections: # # vala_precompile(VALA_C mytargetname # source1.vala # source2.vala # source3.vala # PACKAGES # gtk+-2.0 # gio-1.0 # posix # DIRECTORY # gen # OPTIONS # --thread # CUSTOM_VAPIS # some_vapi.vapi # GENERATE_VAPI # myvapi # GENERATE_HEADER # myheader # GENERATE_GIR # mygir # GENERATE_SYMBOLS # mysymbols # ) # # Most important is the variable VALA_C which will contain all the generated c # file names after the call. ## include(CMakeParseArguments) macro(vala_precompile output target_name) cmake_parse_arguments(ARGS "" "DIRECTORY;GENERATE_GIR;GENERATE_HEADER;GENERATE_VAPI" "TARGET;PACKAGES;OPTIONS;GENERATE_SYMBOLS;CUSTOM_VAPIS" "" ${ARGN}) if(ARGS_DIRECTORY) set(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/${ARGS_DIRECTORY}) else(ARGS_DIRECTORY) set(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) endif(ARGS_DIRECTORY) include_directories(${DIRECTORY}) set(vala_pkg_opts "") foreach(pkg ${ARGS_PACKAGES}) list(APPEND vala_pkg_opts "--pkg=${pkg}") endforeach(pkg ${ARGS_PACKAGES}) set(in_files "") set(out_files "") set(out_files_display "") set(${output} "") foreach(src ${ARGS_UNPARSED_ARGUMENTS}) string(REGEX MATCH "^/" IS_MATCHED ${src}) if(${IS_MATCHED} MATCHES "/") set(src_file_path ${src}) else() set(src_file_path ${CMAKE_CURRENT_SOURCE_DIR}/${src}) endif() list(APPEND in_files ${src_file_path}) string(REPLACE ".vala" ".c" src ${src}) string(REPLACE ".gs" ".c" src ${src}) if(${IS_MATCHED} MATCHES "/") get_filename_component(VALA_FILE_NAME ${src} NAME) set(out_file "${CMAKE_CURRENT_BINARY_DIR}/${VALA_FILE_NAME}") list(APPEND out_files "${CMAKE_CURRENT_BINARY_DIR}/${VALA_FILE_NAME}") else() set(out_file "${DIRECTORY}/${src}") list(APPEND out_files "${DIRECTORY}/${src}") endif() list(APPEND ${output} ${out_file}) list(APPEND out_files_display "${src}") endforeach(src ${ARGS_DEFAULT_ARGS}) set(custom_vapi_arguments "") if(ARGS_CUSTOM_VAPIS) foreach(vapi ${ARGS_CUSTOM_VAPIS}) if(${vapi} MATCHES ${CMAKE_SOURCE_DIR} OR ${vapi} MATCHES ${CMAKE_BINARY_DIR}) list(APPEND custom_vapi_arguments ${vapi}) else (${vapi} MATCHES ${CMAKE_SOURCE_DIR} OR ${vapi} MATCHES ${CMAKE_BINARY_DIR}) list(APPEND custom_vapi_arguments ${CMAKE_CURRENT_SOURCE_DIR}/${vapi}) endif(${vapi} MATCHES ${CMAKE_SOURCE_DIR} OR ${vapi} MATCHES ${CMAKE_BINARY_DIR}) endforeach(vapi ${ARGS_CUSTOM_VAPIS}) endif(ARGS_CUSTOM_VAPIS) set(vapi_arguments "") if(ARGS_GENERATE_VAPI) list(APPEND out_files "${DIRECTORY}/${ARGS_GENERATE_VAPI}.vapi") list(APPEND out_files_display "${ARGS_GENERATE_VAPI}.vapi") set(vapi_arguments "--library=${ARGS_GENERATE_VAPI}" "--vapi=${ARGS_GENERATE_VAPI}.vapi") # Header and internal header is needed to generate internal vapi if (NOT ARGS_GENERATE_HEADER) set(ARGS_GENERATE_HEADER ${ARGS_GENERATE_VAPI}) endif(NOT ARGS_GENERATE_HEADER) endif(ARGS_GENERATE_VAPI) set(header_arguments "") if(ARGS_GENERATE_HEADER) list(APPEND out_files "${DIRECTORY}/${ARGS_GENERATE_HEADER}.h") list(APPEND out_files_display "${ARGS_GENERATE_HEADER}.h") list(APPEND header_arguments "--header=${ARGS_GENERATE_HEADER}.h") endif(ARGS_GENERATE_HEADER) set(gir_arguments "") set(gircomp_command "") if(ARGS_GENERATE_GIR) list(APPEND out_files "${DIRECTORY}/${ARGS_GENERATE_GIR}.gir") list(APPEND out_files_display "${ARGS_GENERATE_GIR}.gir") set(gir_arguments "--gir=${ARGS_GENERATE_GIR}.gir") include (FindGirCompiler) find_package(GirCompiler REQUIRED) set(gircomp_command COMMAND ${G_IR_COMPILER_EXECUTABLE} ARGS "${DIRECTORY}/${ARGS_GENERATE_GIR}.gir" -o "${DIRECTORY}/${ARGS_GENERATE_GIR}.typelib") endif(ARGS_GENERATE_GIR) set(symbols_arguments "") if(ARGS_GENERATE_SYMBOLS) list(APPEND out_files "${DIRECTORY}/${ARGS_GENERATE_SYMBOLS}.symbols") list(APPEND out_files_display "${ARGS_GENERATE_SYMBOLS}.symbols") set(symbols_arguments "--symbols=${ARGS_GENERATE_SYMBOLS}.symbols") endif(ARGS_GENERATE_SYMBOLS) # Workaround for a bug that would make valac run twice. This file is written # after the vala compiler generates C source code. set(STAMP_TARGET ${target_name}_valac) set(OUTPUT_STAMP ${CMAKE_CURRENT_BINARY_DIR}/${target_name}_valac.stamp) add_custom_command( OUTPUT ${OUTPUT_STAMP} COMMAND ${VALA_EXECUTABLE} ARGS "-C" ${header_arguments} ${vapi_arguments} ${gir_arguments} ${symbols_arguments} "-b" ${CMAKE_CURRENT_SOURCE_DIR} "-d" ${DIRECTORY} ${vala_pkg_opts} ${ARGS_OPTIONS} "-g" ${in_files} ${custom_vapi_arguments} COMMAND touch ARGS ${OUTPUT_STAMP} DEPENDS ${in_files} ${ARGS_CUSTOM_VAPIS} COMMENT "Generating ${out_files_display}" ${gircomp_command} ) add_custom_target(${STAMP_TARGET} DEPENDS ${in_files}) # This command will be run twice for some reason (pass a non-empty string to COMMENT # in order to see it). Since valac is not executed from here, this won't be a problem. add_custom_command(OUTPUT ${out_files} DEPENDS ${OUTPUT_STAMP} COMMENT "") endmacro(vala_precompile)