X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=CMakeLists.txt;h=cb351652ea431160563b1c522ab6a66740655668;hp=bc148063047bab765a730b0832ac9fb4df41800c;hb=37643ad5af930908188fd34683d0ec3a8929f604;hpb=cb1918d94b5d8ec9f05a192c96fab938782dabf5 diff --git a/CMakeLists.txt b/CMakeLists.txt index bc148063..cb351652 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,84 +1,152 @@ # This is the cmake-based build system for Quassel IRC. +# # You may pass various options to cmake: -# -DBUILD= : Select binaries to build. may contain any combination -# of "core", "client", "mono" or "all". -# -DQT=/path/to/qt : Choose a Qt4 installation to use instead of the system Qt4 -# -DSTATIC=1 : Enable static building of Quassel, most useful with a static Qt. -# -DSTATICWIN=1 : Enable static building for Windows. -# -DSPUTDEV : Do not use. +# -DWANT_(CORE|QTCLIENT|MONO)=(ON|OFF) +# : select binaries to build +# -DWITH_OPENSSL=OFF : Disable OpenSSL support +# -DWITH_DBUS=OFF : Disable D-Bus support (dbus notifications) +# -DWITH_WEBKIT=OFF : Disable WebKit support (link previews) +# -DWITH_PHONON=OFF : Disable Phonon support (audio notifications) +# -DWITH_LIBINDICATE=OFF : Disable libindicate support (Ayatana notifications) +# -DWITH_KDE=ON : Enable KDE4 support +# -DWITH_OXYGEN=(ON|OFF) : Whether to install Oxygen icons (default: yes, unless KDE > 4.3.0 is present and enabled) +# +# -DEMBED_DATA=ON : Embed all data files in icons the binary, rather than installing them separately +# +# -DQT=/path/to/qt : Choose a Qt4 installation to use instead of the system Qt4 +# -DSTATIC=ON : Enable static building of Quassel. Use with care. +# -DDEPLOY=ON : Mac OS X only. Use only for creating Quassel Packages! # -# NOTE: You need to remove CMakeCache.txt if you plan to change any of these values! +# NOTE: You should remove CMakeCache.txt if you plan to change any of these values! project(QuasselIRC) -cmake_minimum_required(VERSION 2.4.5) +# cmake 2.6.2 is required for KDE >=4.2 and should be widespread enough now +cmake_minimum_required(VERSION 2.6.2 FATAL_ERROR) + +if(COMMAND cmake_policy) + cmake_policy(SET CMP0003 NEW) +endif(COMMAND cmake_policy) + +# Use our own (well, and KDE's) version of some modules +# In particular cmake's own FindQt4 and FindOpenSSL are quite buggy +set(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/modules) +include(QuasselMacros) + +# Various options and variables that can be set on the command line +option(WANT_CORE "Build the core (server) binary" ON) +option(WANT_QTCLIENT "Build the Qt4 GUI client binary" ON) +option(WANT_MONO "Build the monolithic (all-in-one) binary" ON) + +option(WITH_OPENSSL "Enable OpenSSL support if present on the system" ON) +option(WITH_DBUS "Enable D-Bus support if present on the system" ON) +option(WITH_WEBKIT "Enable WebKit support (for link previews)" ON) +option(WITH_PHONON "Enable Phonon support (for audio notifications)" ON) +option(WITH_LIBINDICATE "Enable Ayatana notification support" ON) +option(WITH_KDE "Enable KDE4 integration" OFF) + +# We use icon paths from KDE 4.3.x, which are partially invalid on older and possibly +# even on newer KDE versions. Do not disable this unless you are sure that your Quassel will +# run on a matching KDE version only. +set(WITH_OXYGEN AUTO CACHE STRING "Install Oxygen icons (default is \"AUTO\" to install when KDE 4.3 or later is present") + +option(STATIC "Enable static building (might not be portable)" OFF) + +if(APPLE) + option(DEPLOY "Mac OS X only! Adds required libs to bundle resources and create a dmg. Note: requires Qt to be built with 10.4u SDK" OFF) +endif(APPLE) + +# Default to embedding data in the static case +if(STATIC OR WIN32) + set(EMBED_DEFAULT ON) +else(STATIC OR WIN32) + set(EMBED_DEFAULT ON) # should be OFF as soon as everything works +endif(STATIC OR WIN32) + +option(EMBED_DATA "Embed all data files in the binary (rather than installing them separately)" ${EMBED_DEFAULT}) + +set(QT "" CACHE STRING "Path to a Qt installation to use instead of the system Qt (e.g. for static builds)") + +# Some settings imply others +if(STATIC) + add_definitions(-DSTATIC) + set(WITH_KDE OFF CACHE BOOL "Static building with KDE is not supported") +endif(STATIC) + +if(WIN32) + # We don't support separately installed resources yet on Win32 + set(EMBED_DATA ON) +endif(WIN32) + +# For static builds, arbitrary extra libs might need to be linked +# Define a comma-separated list here +# e.g. for pgsql, we need -DLINK_EXTRA=pq;crypt +set(LINK_EXTRA "" CACHE STRING "Semicolon-separated list of libraries to be linked") +if(LINK_EXTRA) + string(REPLACE "," ";" LINK_EXTRA ${LINK_EXTRA}) + link_libraries(${LINK_EXTRA}) +endif(LINK_EXTRA) + +# Build Type +# We need to make sure it's not empty +# Supported: Release, RelWithDebugInfo, Debug, Debugfull -# This would suppress annoying warnings on cmake-2.6, but we can't use it -# with 2.4, so... DUH! -# cmake_policy(SET CMP0003 OLD) # suppress linker warnings +# On WIN32, only Release seems to work correctly (?) +if(WIN32) + set(DEFAULT_BUILD_TYPE "Release") +else(WIN32) + set(DEFAULT_BUILD_TYPE "RelWithDebugInfo") +endif(WIN32) -if(STATICWIN) - set(CMAKE_BUILD_TYPE Release) -endif(STATICWIN) +set(CMAKE_BUILD_TYPE ${DEFAULT_BUILD_TYPE} CACHE STRING "CMake Build Type") +if(NOT CMAKE_BUILD_TYPE) + set(CMAKE_BUILD_TYPE ${DEFAULT_BUILD_TYPE} CACHE STRING "CMake Build Type" FORCE) +endif(NOT CMAKE_BUILD_TYPE) # Enable various flags on gcc -include(CheckCXXCompilerFlag) -check_cxx_compiler_flag(-Wall Wall) -if(Wall) - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall") -endif(Wall) -check_cxx_compiler_flag(-Wextra Wextra) -if(Wextra) - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wextra") -endif(Wextra) -check_cxx_compiler_flag(-ansi ansi) -if(ansi) - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ansi") -endif(ansi) - -set(QT_MIN_VERSION "4.4.0") - -# By default, we build all binaries -if(NOT DEFINED BUILD) - set(BUILD all) -endif(NOT DEFINED BUILD) - -# User might define which binaries to build by invoking cmake -DBUILD=, -# where might contain any combination of "core", "client", "mono" or "all" -if(BUILD MATCHES all) - set(BUILD_CORE true) - set(BUILD_QTCLIENT true) - set(BUILD_MONO true) - message(STATUS "Building Quassel Client, Quassel Core and monolithic Quassel.") -else(BUILD MATCHES all) - if(BUILD MATCHES core) - set(BUILD_CORE true) - message(STATUS "Building Quassel Core") - endif(BUILD MATCHES core) - if(BUILD MATCHES client) - set(BUILD_QTCLIENT true) - message(STATUS "Building Quassel Client") - endif(BUILD MATCHES client) - if(BUILD MATCHES mono) - set(BUILD_MONO true) - message(STATUS "Building monolithic Quassel") - endif(BUILD MATCHES mono) -endif(BUILD MATCHES all) - -# Enable mostly b0rked stuff (new ChatView), do not enable this unless you know what you do... -if(SPUTDEV) - add_definitions(-DSPUTDEV) -endif(SPUTDEV) - -# Set up OpenSSL -find_package(OpenSSL) +if(CMAKE_COMPILER_IS_GNUCXX) + # Let's just hope that all gccs support these options and skip the tests... + # -fno-strict-aliasing is needed apparently for Qt < 4.6 + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ansi -Wall -Wextra -Wnon-virtual-dtor -fno-strict-aliasing") + set(CMAKE_CXX_FLAGS_RELEASE "-O2 ${CMAKE_CXX_FLAGS}") + set(CMAKE_CXX_FLAGS_RELWITHDEBUGINFO "-g -O2 ${CMAKE_CXX_FLAGS}") + set(CMAKE_CXX_FLAGS_DEBUG "-g -ggdb -fno-reorder-blocks -fno-schedule-insns -fno-inline ${CMAKE_CXX_FLAGS}") + set(CMAKE_CXX_FLAGS_DEBUGFULL "-g3 ${CMAKE_CXX_FLAGS_DEBUG}") +endif(CMAKE_COMPILER_IS_GNUCXX) + +string(TOUPPER ${CMAKE_BUILD_TYPE} upper_build_type) +if(upper_build_type STREQUAL "RELEASE" OR upper_build_type STREQUAL "RELWITHDEBUGINFO") + add_definitions(-DNDEBUG -DQT_NO_DEBUG) +else(upper_build_type STREQUAL "RELEASE" OR upper_build_type STREQUAL "RELWITHDEBUGINFO") + set(DEBUG 1) +endif(upper_build_type STREQUAL "RELEASE" OR upper_build_type STREQUAL "RELWITHDEBUGINFO") + +if(WANT_MONO OR WANT_QTCLIENT) + set(QT_MIN_VERSION "4.5.0") +else(WANT_MONO OR WANT_QTCLIENT) + set(QT_MIN_VERSION "4.4.0") +endif(WANT_MONO OR WANT_QTCLIENT) + +if(APPLE AND DEPLOY) + set(CMAKE_OSX_ARCHITECTURES "i386;ppc") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mmacosx-version-min=10.4") + set(CMAKE_OSX_SYSROOT "/Developer/SDKs/MacOSX10.4u.sdk/") + add_definitions(-DMAC_10_4_SDK) +endif(APPLE AND DEPLOY) + +# Execinfo is needed for generating backtraces +find_package(ExecInfo) +if(EXECINFO_FOUND) + add_definitions(-DHAVE_EXECINFO) + include_directories(${EXECINFO_INCLUDES}) + link_libraries(${EXECINFO_LIBRARIES}) +endif(EXECINFO_FOUND) # Select a Qt installation here, if you don't want to use system Qt -if(DEFINED QT) +if(QT) # FindQt4 will look for the qmake binary in $PATH, so we just prepend the Qt dir set(ENV{PATH} ${QT}/bin:$ENV{PATH}) - #SET(QT_QMAKE_EXECUTABLE ${QT}/bin/qmake CACHE FILEPATH "" FORCE) -endif(DEFINED QT) +endif(QT) # Now that we have the correct $PATH, lets find Qt! find_package(Qt4 REQUIRED) @@ -87,104 +155,179 @@ set(QT_DONT_USE_QTGUI 1) include(${QT_USE_FILE}) include_directories(${QT_INCLUDES}) -# We need to create a version.gen -# For this, we create our genversion binary and make sure it is run every time. -add_executable(genversion ${CMAKE_SOURCE_DIR}/src/common/genversion.cpp) -target_link_libraries(genversion ${QT_LIBRARIES}) +# Setup OpenSSL +# We don't link to or include OpenSSL ourselves, but use exclusively the Qt API. +# Thus, we simply check if OpenSSL support is present in Qt's config and enable our +# own SSL stuff in this case. Qt should care for adding what it needs itself. +if(WITH_OPENSSL) + if(QT_QCONFIG MATCHES "openssl") + message(STATUS "Found OpenSSL support in Qt, enabling SSL") + add_definitions(-DHAVE_SSL) + set(HAVE_SSL true) + else(QT_QCONFIG MATCHES "openssl") + message(STATUS "No OpenSSL support found in Qt, disabling SSL") + add_definitions(-DQT_NO_OPENSSL) + endif(QT_QCONFIG MATCHES "openssl") +else(WITH_OPENSSL) + message(STATUS "Not enabling OpenSSL support") +endif(WITH_OPENSSL) -add_custom_target(genversion_run ALL ${CMAKE_BINARY_DIR}/genversion - ${CMAKE_SOURCE_DIR} ${CMAKE_BINARY_DIR}/src/common/version.gen) -add_dependencies(genversion_run genversion) +# Setup D-Bus support +if(WITH_DBUS) + if(QT_QTDBUS_FOUND) + message(STATUS "Found QtDBus, enabling D-Bus support") + add_definitions(-DHAVE_DBUS) + set(LINK_DBUS DBUS) + set(HAVE_DBUS true) + else(QT_QTDBUS_FOUND) + message(STATUS "QtDBus not found, disabling D-Bus support") + endif(QT_QTDBUS_FOUND) +else(WITH_DBUS) + message(STATUS "Not enabling D-Bus support") +endif(WITH_DBUS) + +# Setup QtWebKit support +if(WITH_WEBKIT) + if(QT_QTWEBKIT_FOUND) + message(STATUS "Found QtWebKit, enabling WebKit support") + add_definitions(-DHAVE_WEBKIT) + set(LINK_WEBKIT WEBKIT) + set(HAVE_WEBKIT true) + else(QT_QTWEBKIT_FOUND) + message(STATUS "QtWebKit not found, disabling WebKit support") + endif(QT_QTWEBKIT_FOUND) +else(WITH_WEBKIT) + message(STATUS "Not enabling WebKit support") +endif(WITH_WEBKIT) + +# Setup KDE4 support +if(WITH_KDE) + find_package(KDE4) + if(KDE4_FOUND) + message(STATUS "Enabling KDE4 integration") + include_directories(${KDE4_INCLUDES}) + add_definitions(-DHAVE_KDE ${KDE4_DEFINITIONS}) + set(HAVE_KDE 1) + set(QUASSEL_KDE_LIBRARIES ${KDE4_KDECORE_LIBS} ${KDE4_KDEUI_LIBRARY} ${KDE4_SOLID_LIBS} knotifyconfig) + # We always use external icons for KDE4 support, since we use its iconloader rather than our own + set(EMBED_DATA OFF) + else(KDE4_FOUND) + message(STATUS "KDE4 not found, disabling KDE integration") + endif(KDE4_FOUND) +else(WITH_KDE) + message(STATUS "Not enabling KDE4 integration") +endif(WITH_KDE) + +# needed to compile with mingw without kde +if(MINGW AND NOT HAVE_KDE) + add_definitions(-D_WIN32_WINNT=0x0500) + message(STATUS "Added _WIN32_WINNT=0x0500 definition for MinGW") +# workaround for bug in mingw gcc 4.0 + add_definitions(-U__STRICT_ANSI__) +endif(MINGW AND NOT HAVE_KDE) + +# Setup Phonon support - we only need this if we don't have or want KDE4 +if(NOT HAVE_KDE) + if(WITH_PHONON) + find_package(Phonon) + if(PHONON_FOUND) + message(STATUS "Enabling Phonon support") + add_definitions(-DHAVE_PHONON) + set(HAVE_PHONON true) + else(PHONON_FOUND) + message(STATUS "Phonon not found, disabling audio notifications") + endif(PHONON_FOUND) + else(WITH_PHONON) + message(STATUS "Not enabling Phonon support") + endif(WITH_PHONON) +endif(NOT HAVE_KDE) + +# Setup libindicate-qt support +if(WITH_LIBINDICATE) + find_package(PkgConfig QUIET) + if(PKG_CONFIG_FOUND) + pkg_check_modules(INDICATEQT indicate-qt>=0.2.1) + if(INDICATEQT_FOUND) + message(STATUS "Enabling Ayatana notification support") + add_definitions(-DHAVE_INDICATEQT) + else(INDICATEQT_FOUND) + message(STATUS "Disabling Ayatana notification support") + endif(INDICATEQT_FOUND) + endif(PKG_CONFIG_FOUND) +else(WITH_LIBINDICATE) + message(STATUS "Not enabling Ayatana notification support") +endif(WITH_LIBINDICATE) -# Add needed subdirs -add_subdirectory(src/common) -include_directories(src/common) -if(BUILD_CORE OR BUILD_MONO) - add_subdirectory(src/core) - include_directories(src/core) -endif(BUILD_CORE OR BUILD_MONO) -if(BUILD_QTCLIENT OR BUILD_MONO) - add_subdirectory(src/client) - add_subdirectory(src/uisupport) - add_subdirectory(src/qtui) - include_directories(src/client) - include_directories(src/uisupport) - include_directories(src/qtui) -endif(BUILD_QTCLIENT OR BUILD_MONO) - -# Make sure version.gen exists before building mod_common -add_dependencies(mod_common genversion_run) - -# Add resources -qt4_add_resources(RC_I18N i18n/i18n.qrc) -qt4_add_resources(RC_ICONS src/icons/icons.qrc) -qt4_add_resources(RC_QUASSEL_ICONS src/icons/quassel-icons.qrc) -qt4_add_resources(RC_SQL src/core/sql.qrc) +# Now set up install locations; those are set by KDE if integration is enabled +if(NOT HAVE_KDE) + if(WIN32) + set(BIN_INSTALL_DIR ${CMAKE_INSTALL_PREFIX} CACHE FILEPATH "Install path for binaries") + set(DATA_INSTALL_DIR $ENV{APPDATA}/quassel-irc.org/share/apps CACHE FILEPATH "Install path for data files") + set(ICON_INSTALL_DIR $ENV{APPDATA}/quassel-irc.org/share/icons CACHE FILEPATH "Global icon install path") + set(XDG_APPS_INSTALL_DIR $ENV{APPDATA}/quassel-irc.org/share/applications CACHE FILEPATH "Install path for .desktop files") + else(WIN32) + set(BIN_INSTALL_DIR ${CMAKE_INSTALL_PREFIX}/bin CACHE FILEPATH "Install path for binaries") + set(DATA_INSTALL_DIR ${CMAKE_INSTALL_PREFIX}/share/apps CACHE FILEPATH "Install path for data files") + set(ICON_INSTALL_DIR ${CMAKE_INSTALL_PREFIX}/share/icons CACHE FILEPATH "Global icon install path") + set(XDG_APPS_INSTALL_DIR ${CMAKE_INSTALL_PREFIX}/share/applications CACHE FILEPATH "Install path for .desktop files") + endif(WIN32) +endif(NOT HAVE_KDE) + +if(EMBED_DATA) + message(STATUS "Embedding data files into the binary") +else(EMBED_DATA) + message(STATUS "Installing data files separately") +endif(EMBED_DATA) + +# RPATH needs to be set correctly +# Do this down here, since otherwise KDE wants to handle it itself, and fails +set(CMAKE_INSTALL_RPATH_USE_LINK_PATH 1) +set(CMAKE_BUILD_WITH_INSTALL_RPATH 1) # Set global buildflags -if(DEFINED STATIC) - set(CMAKE_EXE_LINKER_FLAGS "-static-libgcc ${CMAKE_EXE_LINKER_FLAGS}") - link_directories(${CMAKE_BINARY_DIR}/staticlibs) -endif(DEFINED STATIC) - -if(STATICWIN AND WIN32) - link_libraries(imm32 winmm) # missing by default :/ - if(OPENSSL_FOUND) - link_libraries(${OPENSSL_LIBRARIES} libeay32MD) - endif(OPENSSL_FOUND) -endif(STATICWIN AND WIN32) +# This is very much non-portable, so don't use -DSTATIC until you know what +# you do. +if(STATIC AND CMAKE_COMPILER_IS_GNUCXX) + set(CMAKE_CXX_FLAGS "-static-libgcc ${CMAKE_CXX_FLAGS}") + link_directories(${CMAKE_BINARY_DIR}/staticlibs) # override dynamic libs + if(HAVE_SSL) + set(QUASSEL_SSL_LIBRARIES ssl crypto) # these miss in static builds + endif(HAVE_SSL) +endif(STATIC AND CMAKE_COMPILER_IS_GNUCXX) if(WIN32) - set(WIN32_RC src/icons/win32.rc) # for app icons on windows + link_libraries(imm32 winmm dbghelp Secur32) # missing by default :/ + if(MSVC) + link_libraries(Version dwmapi shlwapi) + endif(MSVC) + if(HAVE_SSL AND STATIC) + find_package(OpenSSL REQUIRED) + link_libraries(${OPENSSL_LIBRARIES}) + endif(HAVE_SSL AND STATIC) endif(WIN32) -# Here comes the dirty part. Our targets need different Qt4 modules, i.e. different libs -# and defines. We can't simply include UseQt4 several times, since definitions add up. -# We workaround this by using our own macro to figure out what to add. - -# This macro sets variables for additional Qt modules. -macro(setup_qt4_variables) - set(QUASSEL_QT_LIBRARIES ) - foreach(qtmod CORE ${ARGV}) - set(QUASSEL_QT_LIBRARIES ${QUASSEL_QT_LIBRARIES} ${QT_QT${qtmod}_LIBRARY} ${QT_${qtmod}_LIB_DEPENDENCIES}) - endforeach(qtmod ${ARGV}) - set(QUASSEL_QT_LIBRARIES ${QUASSEL_QT_LIBRARIES} ${QT_LIBRARIES}) -endmacro(setup_qt4_variables) - -# Now we have everything, so just glue the right pieces together :) -if(BUILD_CORE) - setup_qt4_variables(NETWORK SCRIPT SQL) - add_executable(quasselcore ${CMAKE_SOURCE_DIR}/src/common/main.cpp - ${RC_SQL} ${RC_I18N} ${WIN32_RC}) - set_target_properties(quasselcore PROPERTIES - COMPILE_FLAGS "-DQT_NETWORK_LIB -DQT_SCRIPT_LIB -DQT_SQL_LIB -DBUILD_CORE") - target_link_libraries(quasselcore mod_core mod_common ${QUASSEL_QT_LIBRARIES}) -endif(BUILD_CORE) - -if(BUILD_QTCLIENT) - setup_qt4_variables(GUI NETWORK) - add_executable(quasselclient ${CMAKE_SOURCE_DIR}/src/common/main.cpp - ${RC_ICONS} ${RC_QUASSEL_ICONS} ${RC_I18N} ${WIN32_RC}) - set_target_properties(quasselclient PROPERTIES - COMPILE_FLAGS "-DQT_GUI_LIB -DQT_NETWORK_LIB -DBUILD_QTUI") - target_link_libraries(quasselclient mod_qtui mod_uisupport mod_client mod_common ${QUASSEL_QT_LIBRARIES}) -endif(BUILD_QTCLIENT) - -if(BUILD_MONO) - setup_qt4_variables(GUI NETWORK SCRIPT SQL) - add_executable(quassel ${CMAKE_SOURCE_DIR}/src/common/main.cpp - ${RC_ICONS} ${RC_QUASSEL_ICONS} ${RC_SQL} ${RC_I18N} ${WIN32_RC}) - set_target_properties(quassel PROPERTIES - COMPILE_FLAGS "-DQT_GUI_LIB -DQT_NETWORK_LIB -DQT_SCRIPT_LIB -DQT_SQL_LIB -DBUILD_MONO") - target_link_libraries(quassel mod_qtui mod_uisupport mod_client mod_core mod_common ${QUASSEL_QT_LIBRARIES}) -endif(BUILD_MONO) - -# Build bundles for MacOSX -if(APPLE) - add_custom_command(TARGET quasselclient POST_BUILD - COMMAND ${CMAKE_SOURCE_DIR}/scripts/build/macosx_makebundle.py - ${CMAKE_SOURCE_DIR} "Quassel Client" quasselclient) - add_custom_command(TARGET quassel POST_BUILD - COMMAND ${CMAKE_SOURCE_DIR}/scripts/build/macosx_makebundle.py - ${CMAKE_SOURCE_DIR} "Quassel" quassel) -endif(APPLE) +if(INDICATEQT_FOUND) + add_definitions(-DXDG_APPS_INSTALL_DIR=${XDG_APPS_INSTALL_DIR}) +endif(INDICATEQT_FOUND) + +# We need to create a version.gen +# For this, we create our genversion binary and make sure it is run every time. +add_executable(genversion ${CMAKE_SOURCE_DIR}/src/common/genversion.cpp) +target_link_libraries(genversion ${QT_LIBRARIES} ${QT_CORE_LIB_DEPENDENCIES}) + +get_target_property(GENVERSION_EXECUTABLE genversion LOCATION) +add_custom_target(genversion_run ALL ${GENVERSION_EXECUTABLE} + ${CMAKE_SOURCE_DIR} ${CMAKE_BINARY_DIR}/src/version.gen) +add_dependencies(genversion_run genversion) + +# These variables will be added to the main targets (CORE, QTCLIENT, MONO) +set(COMMON_DEPS ${RC_WIN32}) +set(CORE_DEPS ) +set(CLIENT_DEPS ) + +# Add needed subdirs - the order is important, since src needs some vars set by other dirs +add_subdirectory(data) +add_subdirectory(icons) +add_subdirectory(pics) +add_subdirectory(po) +add_subdirectory(src)