CMakeLists.txt

   1 # This is the cmake-based build system for Quassel IRC.
   2 #
   3 # You may pass various options to cmake:
   4 # -DWANT_(CORE|QTCLIENT|MONO)=(ON|OFF)
   5 #                        : select binaries to build
   6 # -DWITH_OPENSSL=OFF     : Disable OpenSSL support
   7 # -DWITH_DBUS=OFF        : Disable D-Bus support (dbus notifications)
   8 # -DWITH_WEBKIT=OFF      : Disable WebKit support (link previews)
   9 # -DWITH_PHONON=OFF      : Disable Phonon support (audio notifications)
  10 # -DWITH_LIBINDICATE=OFF : Disable libindicate support (Ayatana notifications)
  11 # -DWITH_KDE=ON          : Enable KDE4 support
  12 # -DWITH_CRYPT=OFF       : Disable encryption support
  13 # -DWITH_OXYGEN=(ON|OFF) : Whether to install Oxygen icons (default: yes, unless KDE > 4.3.0 is present and enabled)
  14 #
  15 # -DEMBED_DATA=ON        : Embed all data files in icons the binary, rather than installing them separately
  16 #
  17 # -DQT=/path/to/qt       : Choose a Qt4 installation to use instead of the system Qt4
  18 # -DSTATIC=ON            : Enable static building of Quassel. Use with care.
  19 # -DDEPLOY=ON            : Mac OS X only. Use only for creating Quassel Packages!
  20 #
  21 # NOTE: You should remove CMakeCache.txt if you plan to change any of these values!
  22
  23 project(QuasselIRC)
  24
  25 # cmake 2.6.2 is required for KDE >=4.2 and should be widespread enough now
  26 cmake_minimum_required(VERSION 2.6.2 FATAL_ERROR)
  27
  28 if(COMMAND cmake_policy)
  29    cmake_policy(SET CMP0003 NEW)
  30 endif(COMMAND cmake_policy)
  31
  32 # Use our own (well, and KDE's) version of some modules
  33 # In particular cmake's own FindQt4 and FindOpenSSL are quite buggy
  34 set(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/modules)
  35 include(QuasselMacros)
  36
  37 # Various options and variables that can be set on the command line
  38 option(WANT_CORE     "Build the core (server) binary"           ON)
  39 option(WANT_QTCLIENT "Build the Qt4 GUI client binary"          ON)
  40 option(WANT_MONO     "Build the monolithic (all-in-one) binary" ON)
  41
  42 option(WITH_OPENSSL  "Enable OpenSSL support if present on the system"  ON)
  43 option(WITH_DBUS     "Enable D-Bus support if present on the system"    ON)
  44 option(WITH_WEBKIT   "Enable WebKit support (for link previews)"        ON)
  45 option(WITH_PHONON   "Enable Phonon support (for audio notifications)"  ON)
  46 option(WITH_LIBINDICATE "Enable Ayatana notification support"           ON)
  47 option(WITH_KDE      "Enable KDE4 integration"                          OFF)
  48 option(WITH_CRYPT    "Enable encryption support if present on system"   ON)
  49
  50 # We use icon paths from KDE 4.3.x, which are partially invalid on older and possibly
  51 # even on newer KDE versions. Do not disable this unless you are sure that your Quassel will
  52 # run on a matching KDE version only.
  53 set(WITH_OXYGEN AUTO CACHE STRING "Install Oxygen icons (default is \"AUTO\" to install when KDE 4.3 or later is present")
  54
  55 option(STATIC        "Enable static building (might not be portable)" OFF)
  56
  57 if(APPLE)
  58   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)
  59 endif(APPLE)
  60
  61 # Default to embedding data in the static case
  62 if(STATIC OR WIN32)
  63   set(EMBED_DEFAULT ON)
  64 else(STATIC OR WIN32)
  65   set(EMBED_DEFAULT ON) # should be OFF as soon as everything works
  66 endif(STATIC OR WIN32)
  67
  68 option(EMBED_DATA    "Embed all data files in the binary (rather than installing them separately)"   ${EMBED_DEFAULT})
  69
  70 set(QT "" CACHE STRING "Path to a Qt installation to use instead of the system Qt (e.g. for static builds)")
  71
  72 # Some settings imply others
  73 if(STATIC)
  74   add_definitions(-DSTATIC)
  75   set(WITH_KDE OFF CACHE BOOL "Static building with KDE is not supported")
  76 endif(STATIC)
  77
  78 if(WIN32)
  79   # We don't support separately installed resources yet on Win32
  80   set(EMBED_DATA ON)
  81 endif(WIN32)
  82
  83 # For static builds, arbitrary extra libs might need to be linked
  84 # Define a comma-separated list here
  85 # e.g. for pgsql, we need -DLINK_EXTRA=pq;crypt
  86 set(LINK_EXTRA "" CACHE STRING "Semicolon-separated list of libraries to be linked")
  87 if(LINK_EXTRA)
  88   string(REPLACE "," ";" LINK_EXTRA ${LINK_EXTRA})
  89   link_libraries(${LINK_EXTRA})
  90 endif(LINK_EXTRA)
  91
  92 # Build Type
  93 # We need to make sure it's not empty
  94 # Supported: Release, RelWithDebugInfo, Debug, Debugfull
  95
  96 # On WIN32, only Release seems to work correctly (?)
  97 if(WIN32)
  98   set(DEFAULT_BUILD_TYPE "Release")
  99 else(WIN32)
 100   set(DEFAULT_BUILD_TYPE "RelWithDebugInfo")
 101 endif(WIN32)
 102
 103 set(CMAKE_BUILD_TYPE ${DEFAULT_BUILD_TYPE} CACHE STRING "CMake Build Type")
 104 if(NOT CMAKE_BUILD_TYPE)
 105   set(CMAKE_BUILD_TYPE ${DEFAULT_BUILD_TYPE} CACHE STRING "CMake Build Type" FORCE)
 106 endif(NOT CMAKE_BUILD_TYPE)
 107
 108 # Enable various flags on gcc
 109 if(CMAKE_COMPILER_IS_GNUCXX)
 110   # Let's just hope that all gccs support these options and skip the tests...
 111   # -fno-strict-aliasing is needed apparently for Qt < 4.6
 112   set(CMAKE_CXX_FLAGS                  "${CMAKE_CXX_FLAGS} -ansi -Wall -Wextra -Wnon-virtual-dtor -fno-strict-aliasing")
 113   set(CMAKE_CXX_FLAGS_RELEASE          "-O2 ${CMAKE_CXX_FLAGS}")
 114   set(CMAKE_CXX_FLAGS_RELWITHDEBUGINFO "-g -O2 ${CMAKE_CXX_FLAGS}")
 115   set(CMAKE_CXX_FLAGS_DEBUG            "-g -ggdb -fno-reorder-blocks -fno-schedule-insns -fno-inline ${CMAKE_CXX_FLAGS}")
 116   set(CMAKE_CXX_FLAGS_DEBUGFULL        "-g3 ${CMAKE_CXX_FLAGS_DEBUG}")
 117 endif(CMAKE_COMPILER_IS_GNUCXX)
 118
 119 string(TOUPPER ${CMAKE_BUILD_TYPE} upper_build_type)
 120 if(upper_build_type STREQUAL "RELEASE" OR upper_build_type STREQUAL "RELWITHDEBUGINFO")
 121   add_definitions(-DNDEBUG -DQT_NO_DEBUG)
 122 else(upper_build_type STREQUAL "RELEASE" OR upper_build_type STREQUAL "RELWITHDEBUGINFO")
 123   set(DEBUG 1)
 124 endif(upper_build_type STREQUAL "RELEASE" OR upper_build_type STREQUAL "RELWITHDEBUGINFO")
 125
 126 if(WANT_MONO OR WANT_QTCLIENT)
 127   set(QT_MIN_VERSION "4.6.0")
 128 else(WANT_MONO OR WANT_QTCLIENT)
 129   set(QT_MIN_VERSION "4.4.0")
 130 endif(WANT_MONO OR WANT_QTCLIENT)
 131
 132 if(APPLE AND DEPLOY)
 133   set(CMAKE_OSX_ARCHITECTURES "i386;ppc")
 134   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mmacosx-version-min=10.4")
 135   set(CMAKE_OSX_SYSROOT "/Developer/SDKs/MacOSX10.4u.sdk/")
 136   add_definitions(-DMAC_10_4_SDK)
 137 endif(APPLE AND DEPLOY)
 138
 139 # Execinfo is needed for generating backtraces
 140 find_package(ExecInfo)
 141 if(EXECINFO_FOUND)
 142   add_definitions(-DHAVE_EXECINFO)
 143   include_directories(${EXECINFO_INCLUDES})
 144   link_libraries(${EXECINFO_LIBRARIES})
 145 endif(EXECINFO_FOUND)
 146
 147 # Select a Qt installation here, if you don't want to use system Qt
 148 if(QT)
 149   # FindQt4 will look for the qmake binary in $PATH, so we just prepend the Qt dir
 150   set(ENV{PATH} ${QT}/bin:$ENV{PATH})
 151 endif(QT)
 152
 153 # Now that we have the correct $PATH, lets find Qt!
 154 find_package(Qt4 REQUIRED)
 155
 156 set(QT_DONT_USE_QTGUI 1)
 157 include(${QT_USE_FILE})
 158 include_directories(${QT_INCLUDES})
 159
 160 # Setup OpenSSL
 161 # We don't link to or include OpenSSL ourselves, but use exclusively the Qt API.
 162 # Thus, we simply check if OpenSSL support is present in Qt's config and enable our
 163 # own SSL stuff in this case. Qt should care for adding what it needs itself.
 164 if(WITH_OPENSSL)
 165   if(QT_QCONFIG MATCHES "openssl")
 166     message(STATUS "Found OpenSSL support in Qt, enabling SSL")
 167     add_definitions(-DHAVE_SSL)
 168     set(HAVE_SSL true)
 169   else(QT_QCONFIG MATCHES "openssl")
 170     message(STATUS "No OpenSSL support found in Qt, disabling SSL")
 171     add_definitions(-DQT_NO_OPENSSL)
 172   endif(QT_QCONFIG MATCHES "openssl")
 173 else(WITH_OPENSSL)
 174   message(STATUS "Not enabling OpenSSL support")
 175 endif(WITH_OPENSSL)
 176
 177 # Setup D-Bus support
 178 if(WITH_DBUS)
 179   if(QT_QTDBUS_FOUND)
 180     message(STATUS "Found QtDBus, enabling D-Bus support")
 181     add_definitions(-DHAVE_DBUS)
 182     set(CLIENT_QT4_VARS ${CLIENT_QT4_VARS} DBUS)
 183     set(CLIENT_COMPILE_FLAGS "${CLIENT_COMPILE_FLAGS} -DQT_DBUS_LIB")
 184     set(HAVE_DBUS true)
 185   else(QT_QTDBUS_FOUND)
 186     message(STATUS "QtDBus not found, disabling D-Bus support")
 187   endif(QT_QTDBUS_FOUND)
 188 else(WITH_DBUS)
 189   message(STATUS "Not enabling D-Bus support")
 190 endif(WITH_DBUS)
 191
 192 # Setup QtWebKit support
 193 if(WITH_WEBKIT)
 194   if(QT_QTWEBKIT_FOUND)
 195     message(STATUS "Found QtWebKit, enabling WebKit support")
 196     add_definitions(-DHAVE_WEBKIT)
 197     set(CLIENT_QT4_VARS ${CLIENT_QT4_VARS} WEBKIT XMLPATTERNS)
 198     set(CLIENT_COMPILE_FLAGS "${CLIENT_COMPILE_FLAGS} -DQT_WEBKIT_LIB -DQT_XMLPATTERNS_LIB")
 199     set(HAVE_WEBKIT true)
 200   else(QT_QTWEBKIT_FOUND)
 201     message(STATUS "QtWebKit not found, disabling WebKit support")
 202   endif(QT_QTWEBKIT_FOUND)
 203 else(WITH_WEBKIT)
 204   message(STATUS "Not enabling WebKit support")
 205 endif(WITH_WEBKIT)
 206
 207 # Setup KDE4 support
 208 if(WITH_KDE)
 209   find_package(KDE4)
 210   if(KDE4_FOUND)
 211     message(STATUS "Enabling KDE4 integration")
 212     include_directories(${KDE4_INCLUDES})
 213     add_definitions(-DHAVE_KDE ${KDE4_DEFINITIONS})
 214     set(HAVE_KDE 1)
 215     set(QUASSEL_KDE_LIBRARIES ${KDE4_KDECORE_LIBS} ${KDE4_KDEUI_LIBRARY} ${KDE4_SOLID_LIBS} knotifyconfig)
 216     # We always use external icons for KDE4 support, since we use its iconloader rather than our own
 217     set(EMBED_DATA OFF)
 218   else(KDE4_FOUND)
 219     message(STATUS "KDE4 not found, disabling KDE integration")
 220   endif(KDE4_FOUND)
 221 else(WITH_KDE)
 222   message(STATUS "Not enabling KDE4 integration")
 223 endif(WITH_KDE)
 224
 225 # needed to compile with mingw without kde
 226 if(MINGW AND NOT HAVE_KDE)
 227     add_definitions(-D_WIN32_WINNT=0x0500)
 228     message(STATUS "Added _WIN32_WINNT=0x0500 definition for MinGW")
 229 # workaround for bug in mingw gcc 4.0
 230     add_definitions(-U__STRICT_ANSI__)
 231 endif(MINGW AND NOT HAVE_KDE)
 232
 233 # Setup Phonon support - we only need this if we don't have or want KDE4
 234 if(NOT HAVE_KDE)
 235   if(WITH_PHONON)
 236     find_package(Phonon)
 237     if(PHONON_FOUND)
 238       message(STATUS "Enabling Phonon support")
 239       add_definitions(-DHAVE_PHONON)
 240       set(HAVE_PHONON true)
 241     else(PHONON_FOUND)
 242       message(STATUS "Phonon not found, disabling audio notifications")
 243     endif(PHONON_FOUND)
 244   else(WITH_PHONON)
 245     message(STATUS "Not enabling Phonon support")
 246   endif(WITH_PHONON)
 247 endif(NOT HAVE_KDE)
 248
 249 # Setup libindicate-qt support
 250 if(WITH_LIBINDICATE)
 251   find_package(PkgConfig QUIET)
 252   if(PKG_CONFIG_FOUND)
 253     pkg_check_modules(INDICATEQT indicate-qt>=0.2.1)
 254     if(INDICATEQT_FOUND)
 255       message(STATUS "Enabling Ayatana notification support")
 256       set(HAVE_INDICATEQT true)
 257       add_definitions(-DHAVE_INDICATEQT)
 258     else(INDICATEQT_FOUND)
 259       message(STATUS "Disabling Ayatana notification support")
 260     endif(INDICATEQT_FOUND)
 261   endif(PKG_CONFIG_FOUND)
 262 else(WITH_LIBINDICATE)
 263   message(STATUS "Not enabling Ayatana notification support")
 264   # We don't want to link against it even if another package has found it
 265   set(INDICATEQT_LIBRARIES "")
 266 endif(WITH_LIBINDICATE)
 267
 268 # Setup encyption support
 269 if(WITH_CRYPT)
 270   find_package(QCA2)
 271   if(QCA2_FOUND)
 272     message(STATUS "Found QCA2, enabling encryption support")
 273     add_definitions(-DHAVE_QCA2)
 274     set(LINK_QCA2 QCA2)
 275     set(HAVE_QCA2 true)
 276     set(MOC_DEFINES ${MOC_DEFINES} -DHAVE_QCA2)
 277   else(QCA2_FOUND)
 278     message(STATUS "QCA2 not found, disabling encryption support")
 279   endif(QCA2_FOUND)
 280 else(WITH_CRYPT)
 281   message(STATUS "Not enabling encryption support")
 282 endif(WITH_CRYPT)
 283
 284 # Now set up install locations; those are set by KDE if integration is enabled
 285 if(NOT HAVE_KDE)
 286   if(WIN32)
 287     set(BIN_INSTALL_DIR ${CMAKE_INSTALL_PREFIX} CACHE FILEPATH "Install path for binaries")
 288     set(DATA_INSTALL_DIR $ENV{APPDATA}/quassel-irc.org/share/apps CACHE FILEPATH "Install path for data files")
 289     set(ICON_INSTALL_DIR $ENV{APPDATA}/quassel-irc.org/share/icons CACHE FILEPATH "Global icon install path")
 290     set(XDG_APPS_INSTALL_DIR $ENV{APPDATA}/quassel-irc.org/share/applications CACHE FILEPATH "Install path for .desktop files")
 291   else(WIN32)
 292     set(BIN_INSTALL_DIR ${CMAKE_INSTALL_PREFIX}/bin CACHE FILEPATH "Install path for binaries")
 293     set(DATA_INSTALL_DIR ${CMAKE_INSTALL_PREFIX}/share/apps CACHE FILEPATH "Install path for data files")
 294     set(ICON_INSTALL_DIR ${CMAKE_INSTALL_PREFIX}/share/icons CACHE FILEPATH "Global icon install path")
 295     set(XDG_APPS_INSTALL_DIR ${CMAKE_INSTALL_PREFIX}/share/applications CACHE FILEPATH "Install path for .desktop files")
 296   endif(WIN32)
 297 endif(NOT HAVE_KDE)
 298
 299 if(EMBED_DATA)
 300   message(STATUS "Embedding data files into the binary")
 301 else(EMBED_DATA)
 302   message(STATUS "Installing data files separately")
 303 endif(EMBED_DATA)
 304
 305 # RPATH needs to be set correctly
 306 # Do this down here, since otherwise KDE wants to handle it itself, and fails
 307 set(CMAKE_INSTALL_RPATH_USE_LINK_PATH 1)
 308 set(CMAKE_BUILD_WITH_INSTALL_RPATH 1)
 309
 310 # Set global buildflags
 311 # This is very much non-portable, so don't use -DSTATIC until you know what
 312 # you do.
 313 if(STATIC AND CMAKE_COMPILER_IS_GNUCXX)
 314   set(CMAKE_CXX_FLAGS "-static-libgcc ${CMAKE_CXX_FLAGS}")
 315   link_directories(${CMAKE_BINARY_DIR}/staticlibs) # override dynamic libs
 316   if(HAVE_SSL)
 317     set(QUASSEL_SSL_LIBRARIES ssl crypto)  # these miss in static builds
 318   endif(HAVE_SSL)
 319 endif(STATIC AND CMAKE_COMPILER_IS_GNUCXX)
 320
 321 if(WIN32)
 322   link_libraries(imm32 winmm dbghelp Secur32)  # missing by default :/
 323   if(MSVC)
 324     set(CMAKE_EXE_LINKER_FLAGS_RELWITHDEBUGINFO "/debug /INCREMENTAL:YES /NODEFAULTLIB:libcmt /DEFAULTLIB:msvcrt")
 325     set(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBUGINFO}")
 326     set(CMAKE_EXE_LINKER_FLAGS_DEBUGFULL "${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBUGINFO}")
 327     link_libraries(Version dwmapi shlwapi)
 328   endif(MSVC)
 329   if(HAVE_SSL AND STATIC)
 330      find_package(OpenSSL REQUIRED)
 331      link_libraries(${OPENSSL_LIBRARIES} ${OPENSSL_EAY_LIBRARIES})
 332   endif(HAVE_SSL AND STATIC)
 333 endif(WIN32)
 334
 335 if(HAVE_INDICATEQT)
 336   add_definitions(-DXDG_APPS_INSTALL_DIR=${XDG_APPS_INSTALL_DIR})
 337 endif(HAVE_INDICATEQT)
 338
 339 # We need to create a version.gen
 340 # For this, we create our genversion binary and make sure it is run every time.
 341 add_executable(genversion ${CMAKE_SOURCE_DIR}/src/common/genversion.cpp)
 342 target_link_libraries(genversion ${QT_LIBRARIES} ${QT_CORE_LIB_DEPENDENCIES})
 343
 344 get_target_property(GENVERSION_EXECUTABLE genversion LOCATION)
 345 add_custom_target(genversion_run ALL ${GENVERSION_EXECUTABLE}
 346                   ${CMAKE_SOURCE_DIR} ${CMAKE_BINARY_DIR}/src/version.gen)
 347 add_dependencies(genversion_run genversion)
 348
 349 # These variables will be added to the main targets (CORE, QTCLIENT, MONO)
 350 set(COMMON_DEPS ${RC_WIN32})
 351 set(CORE_DEPS )
 352 set(CLIENT_DEPS )
 353
 354 # Add needed subdirs - the order is important, since src needs some vars set by other dirs
 355 add_subdirectory(data)
 356 add_subdirectory(icons)
 357 add_subdirectory(pics)
 358 add_subdirectory(po)
 359 add_subdirectory(src)