remove cmake support

1 year ago · 7b8bab847d
--- a/.configure-custom.sh
+++ b/.configure-custom.sh
@ -1,9 +0,0 @@
 #!/bin/bash

 ENABLE_VARS="kde-tray|ON|KDE_TRAY update-desktop|ON|ENABLE_UPDATE_ICON hamburger|ON|ENABLE_HAMBURGER"
 ENABLE_KDE_TRAY_DOC="build with kde tray and appindicator instead of gtk3 tray"
 ENABLE_ENABLE_UPDATE_ICON_DOC="install the update desktop entry"
 ENABLE_ENABLE_HAMBURGER_DOC="build with the classic hamburger menu"
 DISABLE_VARS="aur|ON|DISABLE_AUR icon-update|OFF|ICON_UPDATE"
 DISABLE_DISABLE_AUR_DOC="disable the AUR in pamac"
 DISABLE_ICON_UPDATE_DOC="disable the update of the icon cache after installing"
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -1,100 +0,0 @@
 ### CMakeLists automatically created with AutoVala
 ### Do not edit

 project (pamac)
 cmake_minimum_required (VERSION 2.6)
 cmake_policy (VERSION 2.8)
 list (APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake)
 enable_testing ()
 option(ICON_UPDATE "Update the icon cache after installing" ON)
 option(BUILD_VALADOC "Build API documentation if Valadoc is available" OFF)
 option(ENABLE_UPDATE_ICON "ENABLE_UPDATE_ICON" OFF)
 option(ENABLE_HAMBURGER "ENABLE_HAMBURGER" OFF)
 option(KDE_TRAY "KDE_TRAY" OFF)
 option(DISABLE_AUR "DISABLE_AUR" OFF)

 if( NOT CMAKE_BUILD_TYPE )
 	set(CMAKE_BUILD_TYPE Release)
 endif()

 include(GNUInstallDirs)
 if( ( ${CMAKE_INSTALL_PREFIX} MATCHES "^/usr/local" ) )
 	# A workaround to ensure that works 'out of the box' in Debian-based systems
 	set(CMAKE_INSTALL_LIBDIR lib)
 endif()

 set(HAVE_VALADOC OFF)
 if(BUILD_VALADOC)
 	find_package(Valadoc)
 	if(VALADOC_FOUND)
 		set(HAVE_VALADOC ON)
 		include(Valadoc)
 	else()
 		message("Valadoc not found, will not build documentation")
 	endif()
 endif()

 find_package(PkgConfig)

 set(MODULES_TO_CHECK ${MODULES_TO_CHECK} gdk-3.0)
 set(MODULES_TO_CHECK ${MODULES_TO_CHECK} gtk+-3.0)
 set(MODULES_TO_CHECK ${MODULES_TO_CHECK} json-glib-1.0)
 set(MODULES_TO_CHECK ${MODULES_TO_CHECK} libalpm)
 set(MODULES_TO_CHECK ${MODULES_TO_CHECK} libcurl)
 set(MODULES_TO_CHECK ${MODULES_TO_CHECK} libnotify)
 set(MODULES_TO_CHECK ${MODULES_TO_CHECK} libsoup-2.4)
 set(MODULES_TO_CHECK ${MODULES_TO_CHECK} polkit-gobject-1)
 set(MODULES_TO_CHECK ${MODULES_TO_CHECK} vte-2.91)
 if (KDE_TRAY)
 	set(MODULES_TO_CHECK ${MODULES_TO_CHECK} appindicator3-0.1)
 endif ()
 set(MODULES_TO_CHECK ${MODULES_TO_CHECK} gio-2.0)
 set(MODULES_TO_CHECK ${MODULES_TO_CHECK} glib-2.0)
 set(MODULES_TO_CHECK ${MODULES_TO_CHECK} gobject-2.0)

 pkg_check_modules(DEPS REQUIRED ${MODULES_TO_CHECK})


 find_program ( WHERE_glib_compile_resources glib-compile-resources )
 if ( NOT WHERE_glib_compile_resources )
 	MESSAGE(FATAL_ERROR "Error! external program 'glib-compile-resources' is not installed.")
 endif()

 find_program ( WHERE_gtk_update_icon_cache gtk-update-icon-cache )
 if ( NOT WHERE_gtk_update_icon_cache )
 	find_program ( WHERE_gtk_update_icon_cache gtk-update-icon-cache.3.0 )
 	if ( NOT WHERE_gtk_update_icon_cache )
 		MESSAGE(FATAL_ERROR "Error! none of the external programs 'gtk-update-icon-cache', 'gtk-update-icon-cache.3.0',  are installed.")
 	endif()
 endif()

 find_program ( WHERE_glib_compile_schemas glib-compile-schemas )
 if ( NOT WHERE_glib_compile_schemas )
 	MESSAGE(FATAL_ERROR "Error! external program 'glib-compile-schemas' is not installed.")
 endif()

 find_program ( WHERE_g_ir_compiler g-ir-compiler )
 if ( NOT WHERE_g_ir_compiler )
 	MESSAGE(FATAL_ERROR "Error! external program 'g-ir-compiler' is not installed.")
 endif()

 add_subdirectory(src/vapis)
 add_subdirectory(po)
 add_subdirectory(data/pixmaps)
 add_subdirectory(data/mime)
 add_subdirectory(data/polkit)
 add_subdirectory(data/systemd)
 add_subdirectory(data)
 add_subdirectory(data/dbus)
 add_subdirectory(data/icons/24x24/status)
 add_subdirectory(data/icons/16x16/apps)
 add_subdirectory(data/icons/32x32/apps)
 add_subdirectory(data/interface)
 add_subdirectory(src)
 add_subdirectory(src/pamac-user-daemon)
 add_subdirectory(src/pamac-tray)
 add_subdirectory(src/pamac-clean-cache)
 add_subdirectory(src/pamac-install)
 add_subdirectory(src/pamac-manager)
 add_subdirectory(src/pamac-system-daemon)

--- a/autogen.sh
+++ b/autogen.sh
@ -12,6 +12,5 @@ popd
 autovala refresh
 # Remove unused folders and files made by autovala
 rm -rf ./{install,packages,doc} ./data/{local,bash_completion} ./.hgignore ./.bzrignore
 # Generate the cmake and meson build files
 autovala cmake
 # Generate the meson build files
 autovala meson
--- a/cmake/CMakeLists.txt
+++ b/cmake/CMakeLists.txt
@ -1,17 +0,0 @@
 ### CMakeLists automatically created with AutoVala
 ### Do not edit

 IF(IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/)
 	install(DIRECTORY
 		${CMAKE_CURRENT_SOURCE_DIR}/
 	DESTINATION
 		share/autovala/cmake
 	)
 ELSE()
 	install(FILES
 		${CMAKE_CURRENT_SOURCE_DIR}/
 	DESTINATION
 		share/autovala/cmake
 	)
 ENDIF()

--- a/cmake/FindVala.cmake
+++ b/cmake/FindVala.cmake
@ -1,80 +0,0 @@
 ##
 # Copyright 2009-2010 Jakob Westhoff, 2014 Raster Software Vigo
 # 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)

 if (VALA_EXECUTABLE STREQUAL "VALA_EXECUTABLE-NOTFOUND")

 # if valac executable is not found, it can be that valac is not installed, or
 # that the OS is source-based (like gentoo), and doesn't do a link from
 # valac-X.YY to valac. In that case, search for the specific valac binary after

 	if (NOT VALA_DEFERRING_COMPILER_SEARCH)
 		message (STATUS "VALAC not found. Deferring compiler search")
 	endif(NOT VALA_DEFERRING_COMPILER_SEARCH)
 	set(VALA_DEFERRING_COMPILER_SEARCH TRUE)
 	unset(VALA_EXECUTABLE)
 	unset(VALA_VERSION)

 else(VALA_EXECUTABLE STREQUAL "VALA_EXECUTABLE-NOTFOUND")

 # 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 DEFAULT_MSG VALA_EXECUTABLE)

 	mark_as_advanced(VALA_EXECUTABLE)

 # Determine the valac version
 	if(VALA_FOUND)
 	    execute_process(COMMAND ${VALA_EXECUTABLE} "--version" OUTPUT_VARIABLE "VALA_VERSION")
 	    string(REPLACE "Vala" "" "VALA_VERSION" ${VALA_VERSION})
 	    string(STRIP ${VALA_VERSION} "VALA_VERSION")
 	endif(VALA_FOUND)
 endif(VALA_EXECUTABLE STREQUAL "VALA_EXECUTABLE-NOTFOUND")
--- a/cmake/FindValadoc.cmake
+++ b/cmake/FindValadoc.cmake
@ -1,20 +0,0 @@

 # Search for the valadocc executable in the usual system paths.
 find_program(VALADOC_EXECUTABLE NAMES valadoc)

 # 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(Valadoc DEFAULT_MSG VALADOC_EXECUTABLE)

 mark_as_advanced(VALADOC_EXECUTABLE)

 # Determine the valac version
 if(VALA_FOUND)
    execute_process(COMMAND ${VALA_EXECUTABLE} "--version" 
                    OUTPUT_VARIABLE "VALA_VERSION")
    string(REPLACE "Vala" "" "VALA_VERSION" ${VALA_VERSION})
    string(STRIP ${VALA_VERSION} "VALA_VERSION")
 endif(VALA_FOUND)
--- a/cmake/GObjectIntrospectionMacros.cmake
+++ b/cmake/GObjectIntrospectionMacros.cmake
@ -1,34 +0,0 @@
 macro(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/)
    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${GIR_NAME}-${GRANITE_VERSION}.typelib DESTINATION lib/girepository-1.0/)
 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/)
    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${GIR_NAME}-${GRANITE_VERSION}.typelib DESTINATION lib/girepository-1.0/)
 endmacro()
--- a/cmake/GSettings.cmake
+++ b/cmake/GSettings.cmake
@ -1,42 +0,0 @@
 # GSettings.cmake, CMake macros written for Marlin, feel free to re-use them.

 option (GSETTINGS_LOCALINSTALL "Install GSettings Schemas locally instead of to the GLib prefix" ON)

 option (GSETTINGS_COMPILE "Compile GSettings Schemas after installation" ${GSETTINGS_LOCALINSTALL})

 if(GSETTINGS_LOCALINSTALL)
    message(STATUS "GSettings schemas will be installed locally.")
 endif()

 if(GSETTINGS_COMPILE)
    message(STATUS "GSettings shemas will be compiled.")
 endif()

 macro(add_schema SCHEMA_NAME)

    set(PKG_CONFIG_EXECUTABLE pkg-config)
    # Have an option to not install the schema into where GLib is
    if (GSETTINGS_LOCALINSTALL)
        SET (GSETTINGS_DIR "${CMAKE_INSTALL_PREFIX}/share/glib-2.0/schemas/")
    else (GSETTINGS_LOCALINSTALL)
        execute_process (COMMAND ${PKG_CONFIG_EXECUTABLE} glib-2.0 --variable prefix OUTPUT_VARIABLE _glib_prefix OUTPUT_STRIP_TRAILING_WHITESPACE)
        SET (GSETTINGS_DIR "${_glib_prefix}/share/glib-2.0/schemas/")
    endif (GSETTINGS_LOCALINSTALL)

    # Run the validator and error if it fails
    execute_process (COMMAND ${PKG_CONFIG_EXECUTABLE} gio-2.0 --variable glib_compile_schemas  OUTPUT_VARIABLE _glib_comple_schemas OUTPUT_STRIP_TRAILING_WHITESPACE)
    execute_process (COMMAND ${_glib_comple_schemas} --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_DIR}")
    install (FILES ${CMAKE_CURRENT_SOURCE_DIR}/${SCHEMA_NAME} DESTINATION ${GSETTINGS_DIR} OPTIONAL)

    if (GSETTINGS_COMPILE)
        install (CODE "message (STATUS \"Compiling GSettings schemas\")")
        install (CODE "execute_process (COMMAND ${_glib_comple_schemas} ${GSETTINGS_DIR})")
    endif ()
 endmacro()
--- a/cmake/Makefile
+++ b/cmake/Makefile
@ -1,286 +0,0 @@
 # CMAKE generated file: DO NOT EDIT!
 # Generated by "Unix Makefiles" Generator, CMake Version 2.8

 # Default target executed when no arguments are given to make.
 default_target: all
 .PHONY : default_target

 #=============================================================================
 # Special targets provided by cmake.

 # Disable implicit rules so canoncical targets will work.
 .SUFFIXES:

 # Remove some rules from gmake that .SUFFIXES does not remove.
 SUFFIXES =

 .SUFFIXES: .hpux_make_needs_suffix_list

 # Suppress display of executed commands.
 $(VERBOSE).SILENT:

 # A target that is always out of date.
 cmake_force:
 .PHONY : cmake_force

 #=============================================================================
 # Set environment variables for the build.

 # The shell in which to execute make rules.
 SHELL = /bin/sh

 # The CMake executable.
 CMAKE_COMMAND = /usr/bin/cmake

 # The command to remove a file.
 RM = /usr/bin/cmake -E remove -f

 # The top-level source directory on which CMake was run.
 CMAKE_SOURCE_DIR = /home/mefrio/Scrivania/cmake

 # The top-level build directory on which CMake was run.
 CMAKE_BINARY_DIR = /home/mefrio/Scrivania/cmake/cmake

 #=============================================================================
 # Targets provided globally by CMake.

 # Special rule for the target edit_cache
 edit_cache:
 	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Running interactive CMake command-line interface..."
 	/usr/bin/cmake -i .
 .PHONY : edit_cache

 # Special rule for the target edit_cache
 edit_cache/fast: edit_cache
 .PHONY : edit_cache/fast

 # Special rule for the target install
 install: preinstall
 	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Install the project..."
 	/usr/bin/cmake -P cmake_install.cmake
 .PHONY : install

 # Special rule for the target install
 install/fast: preinstall/fast
 	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Install the project..."
 	/usr/bin/cmake -P cmake_install.cmake
 .PHONY : install/fast

 # Special rule for the target install/local
 install/local: preinstall
 	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Installing only the local directory..."
 	/usr/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
 .PHONY : install/local

 # Special rule for the target install/local
 install/local/fast: install/local
 .PHONY : install/local/fast

 # Special rule for the target install/strip
 install/strip: preinstall
 	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Installing the project stripped..."
 	/usr/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
 .PHONY : install/strip

 # Special rule for the target install/strip
 install/strip/fast: install/strip
 .PHONY : install/strip/fast

 # Special rule for the target list_install_components
 list_install_components:
 	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Available install components are: \"Unspecified\""
 .PHONY : list_install_components

 # Special rule for the target list_install_components
 list_install_components/fast: list_install_components
 .PHONY : list_install_components/fast

 # Special rule for the target rebuild_cache
 rebuild_cache:
 	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Running CMake to regenerate build system..."
 	/usr/bin/cmake -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
 .PHONY : rebuild_cache

 # Special rule for the target rebuild_cache
 rebuild_cache/fast: rebuild_cache
 .PHONY : rebuild_cache/fast

 # The main all target
 all: cmake_check_build_system
 	$(CMAKE_COMMAND) -E cmake_progress_start /home/mefrio/Scrivania/cmake/cmake/CMakeFiles /home/mefrio/Scrivania/cmake/cmake/CMakeFiles/progress.marks
 	$(MAKE) -f CMakeFiles/Makefile2 all
 	$(CMAKE_COMMAND) -E cmake_progress_start /home/mefrio/Scrivania/cmake/cmake/CMakeFiles 0
 .PHONY : all

 # The main clean target
 clean:
 	$(MAKE) -f CMakeFiles/Makefile2 clean
 .PHONY : clean

 # The main clean target
 clean/fast: clean
 .PHONY : clean/fast

 # Prepare targets for installation.
 preinstall: all
 	$(MAKE) -f CMakeFiles/Makefile2 preinstall
 .PHONY : preinstall

 # Prepare targets for installation.
 preinstall/fast:
 	$(MAKE) -f CMakeFiles/Makefile2 preinstall
 .PHONY : preinstall/fast

 # clear depends
 depend:
 	$(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1
 .PHONY : depend

 #=============================================================================
 # Target rules for targets named scratch

 # Build rule for target.
 scratch: cmake_check_build_system
 	$(MAKE) -f CMakeFiles/Makefile2 scratch
 .PHONY : scratch

 # fast build rule for target.
 scratch/fast:
 	$(MAKE) -f CMakeFiles/scratch.dir/build.make CMakeFiles/scratch.dir/build
 .PHONY : scratch/fast

 src/entry.o: src/entry.c.o
 .PHONY : src/entry.o

 # target to build an object file
 src/entry.c.o:
 	$(MAKE) -f CMakeFiles/scratch.dir/build.make CMakeFiles/scratch.dir/src/entry.c.o
 .PHONY : src/entry.c.o

 src/entry.i: src/entry.c.i
 .PHONY : src/entry.i

 # target to preprocess a source file
 src/entry.c.i:
 	$(MAKE) -f CMakeFiles/scratch.dir/build.make CMakeFiles/scratch.dir/src/entry.c.i
 .PHONY : src/entry.c.i

 src/entry.s: src/entry.c.s
 .PHONY : src/entry.s

 # target to generate assembly for a file
 src/entry.c.s:
 	$(MAKE) -f CMakeFiles/scratch.dir/build.make CMakeFiles/scratch.dir/src/entry.c.s
 .PHONY : src/entry.c.s

 src/main_window.o: src/main_window.c.o
 .PHONY : src/main_window.o

 # target to build an object file
 src/main_window.c.o:
 	$(MAKE) -f CMakeFiles/scratch.dir/build.make CMakeFiles/scratch.dir/src/main_window.c.o
 .PHONY : src/main_window.c.o

 src/main_window.i: src/main_window.c.i
 .PHONY : src/main_window.i

 # target to preprocess a source file
 src/main_window.c.i:
 	$(MAKE) -f CMakeFiles/scratch.dir/build.make CMakeFiles/scratch.dir/src/main_window.c.i
 .PHONY : src/main_window.c.i

 src/main_window.s: src/main_window.c.s
 .PHONY : src/main_window.s

 # target to generate assembly for a file
 src/main_window.c.s:
 	$(MAKE) -f CMakeFiles/scratch.dir/build.make CMakeFiles/scratch.dir/src/main_window.c.s
 .PHONY : src/main_window.c.s

 src/menu.o: src/menu.c.o
 .PHONY : src/menu.o

 # target to build an object file
 src/menu.c.o:
 	$(MAKE) -f CMakeFiles/scratch.dir/build.make CMakeFiles/scratch.dir/src/menu.c.o
 .PHONY : src/menu.c.o

 src/menu.i: src/menu.c.i
 .PHONY : src/menu.i

 # target to preprocess a source file
 src/menu.c.i:
 	$(MAKE) -f CMakeFiles/scratch.dir/build.make CMakeFiles/scratch.dir/src/menu.c.i
 .PHONY : src/menu.c.i

 src/menu.s: src/menu.c.s
 .PHONY : src/menu.s

 # target to generate assembly for a file
 src/menu.c.s:
 	$(MAKE) -f CMakeFiles/scratch.dir/build.make CMakeFiles/scratch.dir/src/menu.c.s
 .PHONY : src/menu.c.s

 src/notebook.o: src/notebook.c.o
 .PHONY : src/notebook.o

 # target to build an object file
 src/notebook.c.o:
 	$(MAKE) -f CMakeFiles/scratch.dir/build.make CMakeFiles/scratch.dir/src/notebook.c.o
 .PHONY : src/notebook.c.o

 src/notebook.i: src/notebook.c.i
 .PHONY : src/notebook.i

 # target to preprocess a source file
 src/notebook.c.i:
 	$(MAKE) -f CMakeFiles/scratch.dir/build.make CMakeFiles/scratch.dir/src/notebook.c.i
 .PHONY : src/notebook.c.i

 src/notebook.s: src/notebook.c.s
 .PHONY : src/notebook.s

 # target to generate assembly for a file
 src/notebook.c.s:
 	$(MAKE) -f CMakeFiles/scratch.dir/build.make CMakeFiles/scratch.dir/src/notebook.c.s
 .PHONY : src/notebook.c.s

 # Help Target
 help:
 	@echo "The following are some of the valid targets for this Makefile:"
 	@echo "... all (the default if no target is provided)"
 	@echo "... clean"
 	@echo "... depend"
 	@echo "... edit_cache"
 	@echo "... install"
 	@echo "... install/local"
 	@echo "... install/strip"
 	@echo "... list_install_components"
 	@echo "... rebuild_cache"
 	@echo "... scratch"
 	@echo "... src/entry.o"
 	@echo "... src/entry.i"
 	@echo "... src/entry.s"
 	@echo "... src/main_window.o"
 	@echo "... src/main_window.i"
 	@echo "... src/main_window.s"
 	@echo "... src/menu.o"
 	@echo "... src/menu.i"
 	@echo "... src/menu.s"
 	@echo "... src/notebook.o"
 	@echo "... src/notebook.i"
 	@echo "... src/notebook.s"
 .PHONY : help



 #=============================================================================
 # Special targets to cleanup operation of make.

 # Special rule to run CMake to check the build system integrity.
 # No rule that depends on this can have commands that come from listfiles
 # because they might be regenerated.
 cmake_check_build_system:
 	$(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
 .PHONY : cmake_check_build_system

--- a/cmake/ParseArguments.cmake
+++ b/cmake/ParseArguments.cmake
@ -1,36 +0,0 @@
 ##
 # This is a helper Macro to parse optional arguments in Macros/Functions
 # It has been taken from the public CMake wiki.  
 # See http://www.cmake.org/Wiki/CMakeMacroParseArguments for documentation and
 # licensing.
 ##
 macro(parse_arguments prefix arg_names option_names)
  set(DEFAULT_ARGS)
  foreach(arg_name ${arg_names})
    set(${prefix}_${arg_name})
  endforeach(arg_name)
  foreach(option ${option_names})
    set(${prefix}_${option} FALSE)
  endforeach(option)

  set(current_arg_name DEFAULT_ARGS)
  set(current_arg_list)
  foreach(arg ${ARGN})
    set(larg_names ${arg_names})
    list(FIND larg_names "${arg}" is_arg_name)
    if(is_arg_name GREATER -1)
      set(${prefix}_${current_arg_name} ${current_arg_list})
      set(current_arg_name ${arg})
      set(current_arg_list)
    else(is_arg_name GREATER -1)
      set(loption_names ${option_names})
      list(FIND loption_names "${arg}" is_option)
      if(is_option GREATER -1)
 	    set(${prefix}_${arg} TRUE)
      else(is_option GREATER -1)
 	    set(current_arg_list ${current_arg_list} ${arg})
      endif(is_option GREATER -1)
    endif(is_arg_name GREATER -1)
  endforeach(arg)
  set(${prefix}_${current_arg_name} ${current_arg_list})
 endmacro(parse_arguments)
--- a/cmake/README
+++ b/cmake/README
@ -1,10 +0,0 @@
        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

--- a/cmake/README.Vala.rst
+++ b/cmake/README.Vala.rst
@ -1,173 +0,0 @@
 ==========
 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
    <provided_name>.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
    <provided_name>.h and <provided_name>_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
--- a/cmake/Tests.cmake
+++ b/cmake/Tests.cmake
@ -1,5 +0,0 @@
 # Test macros for Marlin, feel free to re-use them.

 macro(add_test_executable EXE_NAME)
    add_test(${EXE_NAME} gtester ${CMAKE_CURRENT_BINARY_DIR}/${EXE_NAME})
 endmacro()
--- a/cmake/Translations.cmake
+++ b/cmake/Translations.cmake
@ -1,66 +0,0 @@
 # Translations.cmake, CMake macros written for Marlin, feel free to re-use them

 macro(add_translations_directory NLS_PACKAGE)
    add_custom_target (i18n ALL COMMENT “Building i18n messages.”)
    find_program (MSGFMT_EXECUTABLE msgfmt)
    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)
        add_custom_command (TARGET i18n COMMAND ${MSGFMT_EXECUTABLE} -o ${MO_OUTPUT} ${PO_INPUT})

        install (FILES ${MO_OUTPUT} DESTINATION
            share/locale/${PO_INPUT_BASE}/LC_MESSAGES
            RENAME ${NLS_PACKAGE}.mo)
    endforeach (PO_INPUT ${PO_FILES})
 endmacro(add_translations_directory)


 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 "")

    foreach(FILES_INPUT ${ARGN})
        set(BASE_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/${FILES_INPUT})

        file (GLOB_RECURSE SOURCE_FILES ${BASE_DIRECTORY}/*.c)
        foreach(C_FILE ${SOURCE_FILES})
            set(C_SOURCE ${C_SOURCE} ${C_FILE})
        endforeach()

        file (GLOB_RECURSE SOURCE_FILES ${BASE_DIRECTORY}/*.vala)
        foreach(VALA_C_FILE ${SOURCE_FILES})
            set(VALA_SOURCE ${VALA_SOURCE} ${VALA_C_FILE})
        endforeach()

        file (GLOB_RECURSE SOURCE_FILES ${BASE_DIRECTORY}/*.ui)
        foreach(GLADE_C_FILE ${SOURCE_FILES})
            set(GLADE_SOURCE ${GLADE_SOURCE} ${GLADE_C_FILE})
        endforeach()
    endforeach()

    set(BASE_XGETTEXT_COMMAND
        ${XGETTEXT_EXECUTABLE} -d ${NLS_PACKAGE}
        -o ${CMAKE_CURRENT_SOURCE_DIR}/${NLS_PACKAGE}.pot
        --keyword="_" --keyword="N_" --from-code=UTF-8)

   set(CONTINUE_FLAG "")

    IF(NOT "${C_SOURCE}" STREQUAL "")
        add_custom_command(TARGET pot COMMAND ${BASE_XGETTEXT_COMMAND} ${C_SOURCE})
        set(CONTINUE_FLAG "-j")
    ENDIF()

    IF(NOT "${VALA_SOURCE}" STREQUAL "")
        add_custom_command(TARGET pot COMMAND ${BASE_XGETTEXT_COMMAND} ${CONTINUE_FLAG} -LC\# ${VALA_SOURCE})
        set(CONTINUE_FLAG "-j")
    ENDIF()

    IF(NOT "${GLADE_SOURCE}" STREQUAL "")
        add_custom_command (TARGET pot COMMAND ${BASE_XGETTEXT_COMMAND} ${CONTINUE_FLAG} -LGlade ${GLADE_SOURCE})
    ENDIF()  
 endmacro()
--- a/cmake/ValaPrecompile.cmake
+++ b/cmake/ValaPrecompile.cmake
@ -1,243 +0,0 @@
 ##
 # 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(ParseArguments)
 find_package(Vala REQUIRED)

 ##
 # 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
 #   <provided_name>.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
 #   <provided_name>.h and <provided_name>_internal.h
 #
 # GENERATE_GIR
 #   Have the compiler generate a GObject-Introspection repository file with
 #   name: <provided_name>.gir. This can be later used to create a binary typelib
 #   using the GI compiler.
 #
 # GENERATE_SYMBOLS
 #   Output a <provided_name>.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.
 ##

 macro(vala_precompile output target_name)
    parse_arguments(ARGS "TARGET;PACKAGES;OPTIONS;DIRECTORY;GENERATE_GIR;GENERATE_SYMBOLS;GENERATE_HEADER;GENERATE_VAPI;CUSTOM_VAPIS" "" ${ARGN})

    if(ARGS_DIRECTORY)
        set(DIRECTORY ${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_DEFAULT_ARGS})
        string(REGEX MATCH "^([a-zA-Z]:)?/" 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 "${DIRECTORY}/${VALA_FILE_NAME}")
            list(APPEND out_files "${DIRECTORY}/${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 "")
    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")
    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)

    set(os_defines "")
    if(WIN32)
        list(APPEND os_defines "-D" "\"G_OS_WIN32\"")
    endif(WIN32)

    # Workaround for a bug that would make valac run twice. This file is written
    # after the vala compiler generates C source code.
    set (extra_name ${extra_name}_ )
    set(OUTPUT_STAMP ${CMAKE_CURRENT_BINARY_DIR}/${target_name}${extra_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}
        ${os_defines}
        ${vala_pkg_opts}
        ${ARGS_OPTIONS}
        ${in_files}
        ${custom_vapi_arguments}
    COMMAND
        touch
    ARGS
        ${OUTPUT_STAMP}
    DEPENDS
        ${in_files}
        ${ARGS_CUSTOM_VAPIS}
    COMMENT
        "Generating ${out_files_display}"
    )

    # 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)
--- a/cmake/ValaVersion.cmake
+++ b/cmake/ValaVersion.cmake
@ -1,153 +0,0 @@
 ##
 # Copyright (C) 2014 Raster Software Vigo
 # Autovala is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by the
 # Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
 #
 # Autovala 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 General Public License along
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # Copyright (C) 2013, Valama development team
 #
 # 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
 ##

 include(ParseArguments)
 find_package(Vala REQUIRED)

 ##
 # Ensure a certain valac version is available
 #
 # The initial argument is the version to check for
 # 
 # It may be followed by a optional parameter to specifiy a version range. The
 # following options are valid:
 # 
 # EXACT
 #   Vala needs to be available in the exact version given
 # 
 # MINIMUM
 #   The provided version is the minimum version. Therefore Vala needs to be
 #   available in the given version or any higher version
 #
 # MAXIMUM
 #   The provided version is the maximum. Therefore Vala needs to be available
 #   in the given version or any version older than this
 #
 # If no option is specified the version will be treated as a minimal version.
 ##
 macro(ensure_vala_version ensure_version)

 	if (USE_VALA_BINARY)
 		message(STATUS "Forced use of vala binary ${USE_VALA_BINARY}")
 		set(VALA_EXECUTABLE ${USE_VALA_BINARY})
 	else (USE_VALA_BINARY)

 		message(STATUS "checking for Vala version of valac-${ensure_version}")
 	
 		unset(version_accepted)
 		execute_process(COMMAND "valac-${ensure_version}" "--version"
 			OUTPUT_VARIABLE "VALA_VERSION" OUTPUT_STRIP_TRAILING_WHITESPACE)
 		if (NOT VALA_VERSION)
 	
 			find_program(VALA_EXECUTABLE "valac")
 	
 			# If the specific version asked for this project is not found,
 			# try to use the one pointed by the valac link
 	
 			parse_arguments(ARGS "" "MINIMUM;MAXIMUM;EXACT" ${ARGN})
 			set(compare_message "")
 			set(error_message "")
 			if(ARGS_MINIMUM)
 				set(compare_message "a minimum ")
 				set(error_message "or greater ")
 			elseif(ARGS_MAXIMUM)
 				set(compare_message "a maximum ")
 				set(error_message "or less ")
 			endif(ARGS_MINIMUM)
 	
 			message(STATUS "checking for ${compare_message}Vala version of ${ensure_version}" )
 	
 			execute_process(COMMAND ${VALA_EXECUTABLE} "--version"
 				OUTPUT_VARIABLE "VALA_VERSION" OUTPUT_STRIP_TRAILING_WHITESPACE)
 		else(NOT VALA_VERSION)
 			set(VALA_EXECUTABLE "valac-${ensure_version}")
 		endif(NOT VALA_VERSION)

 		# this code allows to identify development versions as the right version
 		# e.g. 0.19.1 -> 0.20 ; 0.20.1 -> 0.20 ;
 		# But this code seems to not be fine 0.24.0.2-2235 -> 0.26
 		# Thanks to Yannick Inizan
 		string(REPLACE "Vala" "" "VALA_VERSION" ${VALA_VERSION})
 		string(STRIP ${VALA_VERSION} "VALA_VERSION")
 		string(REPLACE "." ";" VALA_LIST "${VALA_VERSION}")
 		list(GET VALA_LIST 0 maj_ver)
 		list(GET VALA_LIST 1 min_ver)
 		list(GET VALA_LIST 2 rev_ver)
 		math(EXPR is_odd "${min_ver} % 2")
 		list(LENGTH VALA_LIST len)
 		#if((${is_odd} EQUAL 1))
 		#	math(EXPR min_ver "${min_ver} + 1")
 		#elseif(len GREATER 3)
 		#	math(EXPR min_ver "${min_ver} + 2")
 		#endif()

 		set(VALA_SVERSION "${maj_ver}.${min_ver}" CACHE INTERNAL "")

 		# MINIMUM is the default if no option is specified
 		if(ARGS_EXACT)
 			if(${VALA_SVERSION} VERSION_EQUAL ${ensure_version} )
 				set(version_accepted TRUE)
 			endif(${VALA_SVERSION} VERSION_EQUAL ${ensure_version})
 		elseif(ARGS_MAXIMUM)
 			if(${VALA_SVERSION} VERSION_LESS ${ensure_version} OR ${VALA_SVERSION} VERSION_EQUAL ${ensure_version})
 				set(version_accepted TRUE)
 			endif(${VALA_SVERSION} VERSION_LESS ${ensure_version} OR ${VALA_SVERSION} VERSION_EQUAL ${ensure_version})
 		else(ARGS_MAXIMUM)
 			if(${VALA_SVERSION} VERSION_GREATER ${ensure_version} OR ${VALA_SVERSION} VERSION_EQUAL ${ensure_version})
 				set(version_accepted TRUE)
 			endif(${VALA_SVERSION} VERSION_GREATER ${ensure_version} OR ${VALA_SVERSION} VERSION_EQUAL ${ensure_version})
 		endif(ARGS_EXACT)
 	
 		if (NOT version_accepted)
 			message(FATAL_ERROR 
 				"Vala version ${ensure_version} ${error_message}is required."
 			)
 		endif(NOT version_accepted)