build/tizen/CMakeLists.txt

   1 CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
   2 CMAKE_POLICY(SET CMP0012 NEW) # Prevent dereferencing of OFF/ON as variables
   3
   4 SET(name "dali-toolkit")
   5
   6 PROJECT(${name})
   7 SET(PKG_NAME ${name})
   8
   9 SET(GCC_COMPILER_VERSION_REQUIRED "6")
  10 if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
  11   if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS GCC_COMPILER_VERSION_REQUIRED)
  12     message(FATAL_ERROR "The GCC required compiler version is " ${GCC_COMPILER_VERSION_REQUIRED})
  13   endif()
  14 endif()
  15
  16 # API VERSION (Not DALi release version)
  17 SET(${name}_VERSION_MAJOR 0)
  18 SET(${name}_VERSION_MINOR 0)
  19 SET(${name}_VERSION_PATCH 0)
  20 SET(${name}_VERSION ${${name}_VERSION_MAJOR}.${${name}_VERSION_MINOR}.${${name}_VERSION_PATCH} )
  21
  22 SET(DALI_TOOLKIT_VERSION ${${name}_VERSION} )
  23
  24 # Define options to CMake
  25 OPTION(ENABLE_EXPORTALL          "Enable Export all symbols" OFF)
  26 OPTION(ENABLE_DEBUG              "Enable Debug" OFF)
  27 OPTION(ENABLE_TRACE              "Enable Trace" OFF)
  28 OPTION(ENABLE_I18N               "Turns on internationalisation" OFF)
  29 OPTION(ENABLE_COVERAGE           "Coverage" OFF)
  30 OPTION(ENABLE_PKG_CONFIGURE      "Use pkgconfig" ON)
  31 OPTION(ENABLE_LINK_TEST          "Enable the link test" ON)
  32 OPTION(INSTALL_DOXYGEN_DOC       "Install doxygen doc" ON)
  33 OPTION(CONFIGURE_AUTOMATED_TESTS "Configure automated tests" ON)
  34
  35 IF( ENABLE_PKG_CONFIGURE )
  36   FIND_PACKAGE( PkgConfig REQUIRED )
  37
  38   PKG_CHECK_MODULES(DALICORE REQUIRED dali-core)
  39   PKG_CHECK_MODULES(DALIADAPTOR REQUIRED dali-adaptor)
  40 ENDIF()
  41
  42 IF( INSTALL_DOXYGEN_DOC )
  43   FIND_PACKAGE( Doxygen QUIET )
  44 ENDIF()
  45
  46 IF( WIN32 ) # WIN32 includes x64 as well according to the cmake doc.
  47   FIND_PACKAGE( dali-windows-dependencies REQUIRED)
  48   FIND_PACKAGE( dali-core REQUIRED)
  49   FIND_PACKAGE( dali-adaptor REQUIRED)
  50   FIND_PATH( SYSTEM_INCLUDE_DIR "dali-windows-dependencies.h" )
  51 ENDIF()
  52
  53 # Define non-boolean options to CMake
  54 SET(WITH_STYLE               "480x800" CACHE STRING "Select the style folder to use")
  55
  56 # from root/build/tizen, get back to root
  57 SET(ROOT_SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../)
  58
  59 # Make sure the path is absolute
  60 GET_FILENAME_COMPONENT(ROOT_SRC_DIR ${ROOT_SRC_DIR} ABSOLUTE)
  61
  62 # Set DALi style
  63 SET( dali_style ${WITH_STYLE} )
  64
  65 # Style folder
  66 SET( STYLE_BASE_DIR ${ROOT_SRC_DIR}/dali-toolkit/styles )
  67 SET( STYLE_DIR ${STYLE_BASE_DIR}/${dali_style} )
  68
  69 SET( toolkit_styles_base_dir ${STYLE_BASE_DIR} )
  70 SET( toolkit_styles_dir ${STYLE_DIR} )
  71 SET( toolkit_style_images_dir ${STYLE_DIR}/images )
  72
  73 IF( DEFINED ENV{DALI_DATA_RW_DIR} )
  74   SET( dataReadWriteDir $ENV{DALI_DATA_RW_DIR} )
  75 ELSE()
  76   SET( dataReadWriteDir ${CMAKE_INSTALL_PREFIX}/share/dali/ )
  77 ENDIF()
  78
  79 IF( DEFINED ENV{DALI_DATA_RO_DIR} )
  80   SET( dataReadOnlyDir $ENV{DALI_DATA_RO_DIR} )
  81 ELSE()
  82   SET( dataReadOnlyDir ${CMAKE_INSTALL_PREFIX}/share/dali/ )
  83 ENDIF()
  84
  85 # Set up compiler definitions
  86 IF(CMAKE_BUILD_TYPE MATCHES Debug)
  87   MESSAGE( STATUS "CMAKE_BUILD_TYPE: " Debug )
  88   SET( ENABLE_DEBUG ON )
  89 ELSE()
  90   MESSAGE( STATUS "CMAKE_BUILD_TYPE: " Release )
  91 ENDIF()
  92
  93 IF( ENABLE_DEBUG )
  94   ADD_DEFINITIONS( "-DDEBUG_ENABLED" )
  95   SET( ENABLE_EXPORTALL ON )
  96 ENDIF( ENABLE_DEBUG )
  97
  98 IF( ENABLE_I18N )
  99   ADD_DEFINITIONS( "-DDGETTEXT_ENABLED" )
 100 ENDIF( ENABLE_I18N )
 101
 102 IF( SET_VCPKG_INSTALL_PREFIX )
 103   ADD_DEFINITIONS( "-DBUILDING_DALI_TOOLKIT" )
 104   ADD_DEFINITIONS( -DDALI_IMAGE_DIR=\"${VCPKG_INSTALLED_DIR}/share/dali/toolkit/images/\"
 105                    -DDALI_SOUND_DIR=\"${VCPKG_INSTALLED_DIR}/share/dali/toolkit/sounds/\"
 106                    -DDALI_STYLE_DIR=\"${VCPKG_INSTALLED_DIR}/share/dali/toolkit/styles/\"
 107                    -DDALI_STYLE_IMAGE_DIR=\"${VCPKG_INSTALLED_DIR}/share/dali/toolkit/styles/images/\"
 108                    -DDALI_DATA_READ_ONLY_DIR=\"${VCPKG_INSTALLED_DIR}/share/\" )
 109 ELSE()
 110   ADD_DEFINITIONS(-DPIC -DSTDC_HEADERS)
 111   ADD_DEFINITIONS(-DDALI_IMAGE_DIR=\"${dataReadOnlyDir}/toolkit/images/\"
 112                   -DDALI_SOUND_DIR=\"${dataReadOnlyDir}/toolkit/sounds/\"
 113                   -DDALI_STYLE_DIR=\"${dataReadOnlyDir}/toolkit/styles/\"
 114                   -DDALI_STYLE_IMAGE_DIR=\"${dataReadOnlyDir}/toolkit/styles/images/\"
 115                   -DDALI_DATA_READ_ONLY_DIR=\"${dataReadOnlyDir}\" )
 116
 117   IF("${ARCH}" STREQUAL "arm")
 118     ADD_DEFINITIONS("-DTARGET")
 119   ENDIF("${ARCH}" STREQUAL "arm")
 120
 121   IF( NOT ${ENABLE_EXPORTALL} )
 122     ADD_DEFINITIONS( "-fvisibility=hidden -DHIDE_DALI_INTERNALS" )
 123   ENDIF( NOT ${ENABLE_EXPORTALL} )
 124 ENDIF()
 125
 126 IF( ENABLE_TRACE )
 127   ADD_DEFINITIONS("-DTRACE_ENABLED")
 128 ENDIF()
 129
 130 # Platforms with highp shader support can use vector based text
 131 IF( "${PROFILE}" STREQUAL "UBUNTU" )
 132   SET( ENABLE_VECTOR_BASED_TEXT_RENDERING 1 )
 133 ENDIF()
 134
 135 # Deployment folder should come from spec file or command line:
 136 SET( PREFIX ${CMAKE_INSTALL_PREFIX})
 137 SET( EXEC_PREFIX ${CMAKE_INSTALL_PREFIX})
 138
 139 # Set paths
 140 SET( toolkit_images_dir  ${ROOT_SRC_DIR}/dali-toolkit/styles/images-common )
 141 SET( toolkit_sounds_dir  ${ROOT_SRC_DIR}/dali-toolkit/sounds )
 142 SET( toolkit_src_dir     ${ROOT_SRC_DIR}/dali-toolkit/internal )
 143 SET( public_api_src_dir  ${ROOT_SRC_DIR}/dali-toolkit/public-api )
 144 SET( devel_api_src_dir   ${ROOT_SRC_DIR}/dali-toolkit/devel-api )
 145 SET( third_party_src_dir ${ROOT_SRC_DIR}/dali-toolkit/third-party )
 146 SET( package_doxy_dir    ${ROOT_SRC_DIR}/doc )
 147
 148 # Set up the include dir
 149 SET( INCLUDE_DIR $ENV{includedir} )
 150 IF( NOT INCLUDE_DIR )
 151   SET( INCLUDE_DIR ${CMAKE_INSTALL_INCLUDEDIR} )
 152 ENDIF()
 153 IF( NOT INCLUDE_DIR )
 154   SET( INCLUDE_DIR ${PREFIX}/include )
 155 ENDIF()
 156
 157 # Set up the lib dir
 158 IF( SET_VCPKG_INSTALL_PREFIX )
 159   SET( LIB_DIR ${PREFIX}/lib )
 160   SET( BIN_DIR ${PREFIX}/bin )
 161 ELSE()
 162   SET( LIB_DIR $ENV{libdir} )
 163   IF( NOT LIB_DIR )
 164     SET( LIB_DIR ${CMAKE_INSTALL_LIBDIR} )
 165   ENDIF()
 166   IF( NOT LIB_DIR )
 167     SET( LIB_DIR ${PREFIX}/lib )
 168   ENDIF()
 169 ENDIF()
 170
 171 IF( ENABLE_PKG_CONFIGURE )
 172   # Configure the pkg-config file
 173   # Requires the following variables to be setup:
 174   # @PREFIX@ @EXEC_PREFIX@ @DALI_VERSION@ @LIB_DIR@ @DEV_INCLUDE_PATH@
 175   SET( DEV_INCLUDE_PATH ${INCLUDE_DIR} )
 176   SET( CORE_PKG_CFG_FILE dali-toolkit.pc )
 177   CONFIGURE_FILE( ${CORE_PKG_CFG_FILE}.in ${CORE_PKG_CFG_FILE} @ONLY )
 178 ENDIF()
 179
 180 IF( WIN32 )
 181   ADD_COMPILE_OPTIONS( /FIdali-windows-dependencies.h ) # Adds missing definitions.
 182   ADD_COMPILE_OPTIONS( /vmg )                           # Avoids a 'reinterpret_cast' compile error while compiling signals and callbacks.
 183 ELSE()
 184   # Set up compiler flags and warnings
 185   ADD_COMPILE_OPTIONS( -std=c++11 )
 186   ADD_COMPILE_OPTIONS( -Wno-ignored-qualifiers )
 187
 188   # TODO: Clang is a lot more strict with warnings, we should address
 189   # those issues at some point.
 190   IF( NOT "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" )
 191     ADD_COMPILE_OPTIONS( -Werror )
 192   ENDIF()
 193
 194   ADD_COMPILE_OPTIONS( -Wall -Wno-unused-parameter -Wno-float-equal -Wno-class-memaccess )
 195
 196   IF( ENABLE_COVERAGE OR "$ENV{CXXFLAGS}" MATCHES --coverage )
 197     ADD_COMPILE_OPTIONS( --coverage )
 198     SET(ENABLE_COVERAGE ON)
 199     SET(COVERAGE --coverage)
 200   ENDIF()
 201 ENDIF()
 202
 203
 204 INCLUDE_DIRECTORIES(
 205   ${SYSTEM_INCLUDE_DIR}
 206   ${ROOT_SRC_DIR}
 207   ${DALICORE_INCLUDE_DIRS}
 208   ${DALIADAPTOR_INCLUDE_DIRS}
 209 )
 210
 211 SET(SOURCE_DIR "${ROOT_SRC_DIR}/dali")
 212 SET(PACKAGE_DOXY_SRC_DIR "${ROOT_SRC_DIR}/doc")
 213
 214 SET(SOURCES "")
 215
 216 # could use INCLUDE to get the source lists a different way;
 217 # would then need to specify a build folder somehow...
 218 INCLUDE( ${ROOT_SRC_DIR}/dali-toolkit/sounds/file.list )
 219 INCLUDE( ${ROOT_SRC_DIR}/dali-toolkit/styles/file.list )
 220 INCLUDE( ${ROOT_SRC_DIR}/dali-toolkit/styles/images-common/file.list )
 221 INCLUDE( ${ROOT_SRC_DIR}/dali-toolkit/internal/file.list )
 222 INCLUDE( ${ROOT_SRC_DIR}/dali-toolkit/public-api/file.list )
 223 INCLUDE( ${ROOT_SRC_DIR}/dali-toolkit/devel-api/file.list )
 224 INCLUDE( ${ROOT_SRC_DIR}/dali-toolkit/third-party/file.list )
 225 INCLUDE( ${ROOT_SRC_DIR}/doc/file.list )
 226
 227 SET(LIBTYPE SHARED)
 228 IF(DEFINED STATIC)
 229   SET(LIBTYPE STATIC)
 230 ENDIF()
 231
 232 IF( WIN32 )
 233   SET( DALICORE_LDFLAGS
 234         "${DALICORE_LDFLAGS}"
 235         dali-core::dali-core )
 236
 237   FIND_PACKAGE( pthreads REQUIRED )
 238   FIND_PACKAGE( curl REQUIRED )
 239   FIND_LIBRARY( GETOPT_LIBRARY NAMES getopt )
 240   FIND_LIBRARY( EXIF_LIBRARY NAMES libexif )
 241
 242   FIND_PACKAGE( png REQUIRED )
 243   FIND_PACKAGE( gif REQUIRED )
 244   FIND_PACKAGE( jpeg REQUIRED )
 245   FIND_LIBRARY( TURBO_JPEG_LIBRARY NAMES turbojpeg )
 246
 247   FIND_PACKAGE( fontconfig REQUIRED )
 248   FIND_PACKAGE( freetype REQUIRED )
 249   FIND_PACKAGE( harfbuzz REQUIRED )
 250   FIND_LIBRARY( FRIBIDI_LIBRARY NAMES fribidi )
 251
 252   FIND_PACKAGE( unofficial-angle REQUIRED )
 253   FIND_PACKAGE( unofficial-cairo REQUIRED )
 254
 255   SET( DALIADAPTOR_LDFLAGS
 256        "${DALIADAPTOR_LDFLAGS}"
 257        dali-adaptor::dali-adaptor )
 258 ENDIF()
 259
 260
 261 ADD_LIBRARY( ${name} ${LIBTYPE} ${SOURCES} )
 262 TARGET_LINK_LIBRARIES( ${name}
 263   ${DALICORE_LDFLAGS}
 264   ${DALIADAPTOR_LDFLAGS}
 265   ${COVERAGE}
 266 )
 267
 268 IF( ANDROID )
 269   TARGET_LINK_LIBRARIES( ${name} log )
 270 ENDIF()
 271
 272 SET_TARGET_PROPERTIES( ${name}
 273   PROPERTIES
 274   VERSION ${DALI_TOOLKIT_VERSION}
 275   SOVERSION ${${name}_VERSION_MAJOR}
 276   CLEAN_DIRECT_OUPUT 1
 277 )
 278
 279 # Install the library so file and symlinks
 280 IF( INSTALL_CMAKE_MODULES )
 281   INSTALL( TARGETS ${name}
 282     EXPORT ${name}-targets
 283     LIBRARY DESTINATION ${LIB_DIR}
 284     ARCHIVE DESTINATION ${LIB_DIR}
 285     RUNTIME DESTINATION ${BIN_DIR}
 286   )
 287
 288   INSTALL(
 289     EXPORT ${name}-targets
 290     NAMESPACE ${name}::
 291     FILE ${name}-targets.cmake
 292     DESTINATION share/${name}
 293   )
 294
 295   FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}/${name}-config.cmake "
 296     include(CMakeFindDependencyMacro)
 297     include(\${CMAKE_CURRENT_LIST_DIR}/${name}-targets.cmake)
 298   ")
 299   install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${name}-config.cmake DESTINATION share/${name})
 300 ELSE()
 301   INSTALL( TARGETS ${name} DESTINATION ${LIB_DIR} )
 302 ENDIF()
 303
 304 # Install the pkg-config file
 305 IF( ENABLE_PKG_CONFIGURE )
 306   INSTALL( FILES ${CMAKE_CURRENT_BINARY_DIR}/${CORE_PKG_CFG_FILE} DESTINATION ${LIB_DIR}/pkgconfig )
 307 ENDIF()
 308
 309 # Glob for resources
 310 MACRO( COPY_RESOURCES FILE_LIST SRC_RELATIVE_DIRECTORY DESTINATION EXPLICIT_DESTINATION )
 311   FOREACH( PATTERN ${FILE_LIST} )
 312     FILE(GLOB FILES ${PATTERN} )
 313     FOREACH( FILE ${FILES} )
 314       STRING(REPLACE ${SRC_RELATIVE_DIRECTORY} ${DESTINATION} NEWFILE ${FILE} )
 315       GET_FILENAME_COMPONENT(NEWDIR ${NEWFILE} DIRECTORY)
 316       IF( "${EXPLICIT_DESTINATION}" STREQUAL "" )
 317         STRING( REPLACE "dali-toolkit" "toolkit" NEWDIR2 ${NEWDIR} )
 318         INSTALL( FILES ${FILE} DESTINATION ${NEWDIR2} )
 319       ELSE()
 320         INSTALL( FILES ${FILE} DESTINATION ${DESTINATION}/${EXPLICIT_DESTINATION} )
 321       ENDIF()
 322     ENDFOREACH()
 323   ENDFOREACH()
 324 ENDMACRO()
 325
 326 # macro for installing headers by replacing prefix. (TODO, investigate
 327 # if there is a CMAKE way of doing this automatically)
 328 MACRO(INSTALL_HEADERS_WITH_DIRECTORY HEADER_LIST STRIP_PREFIX REPLACE_PREFIX)
 329   GET_FILENAME_COMPONENT( SPREFIX ${STRIP_PREFIX} ABSOLUTE )
 330   FOREACH(HEADER ${${HEADER_LIST}})
 331     STRING(REGEX MATCH "(.*)[/]" DIR ${HEADER})
 332     STRING(REPLACE ${SPREFIX} ${REPLACE_PREFIX} NEWDIR ${DIR})
 333     INSTALL(FILES ${HEADER} DESTINATION ${INCLUDE_DIR}/${NEWDIR})
 334   ENDFOREACH(HEADER)
 335 ENDMACRO(INSTALL_HEADERS_WITH_DIRECTORY)
 336
 337 # Install headers using lists defined by ADD_SUBDIRECTORY
 338 INSTALL_HEADERS_WITH_DIRECTORY(PUBLIC_API_HEADERS ${ROOT_SRC_DIR}/dali-toolkit "dali-toolkit")
 339 INSTALL_HEADERS_WITH_DIRECTORY(DEVEL_API_HEADERS ${ROOT_SRC_DIR}/dali-toolkit "dali-toolkit")
 340 INSTALL_HEADERS_WITH_DIRECTORY(INTEGRATION_API_HEADERS ${ROOT_SRC_DIR}/dali-toolkit "dali-toolkit")
 341 INSTALL_HEADERS_WITH_DIRECTORY(PACKAGE_DOXY_HEADERS ${PACKAGE_DOXY_SRC_DIR} "dali-toolkit/doc" )
 342
 343 # Install dali-toolkit.h
 344 INSTALL( FILES ${ROOT_SRC_DIR}/dali-toolkit/dali-toolkit.h DESTINATION ${INCLUDE_DIR}/dali-toolkit )
 345
 346 # package doxygen file (contains doxygen grouping information)
 347 INSTALL( FILES ${package_doxy_files} DESTINATION ${DEV_INCLUDE_PATH}/dali-toolkit/doc )
 348
 349 # On some platforms we want to install the data files to different location compare to
 350 # the data location used runtime. For example, on Android we want the toolkit library to load
 351 # the files from /data/data/com.sec.dali_demo/files but to install the files into ${PREFIX}/files
 352 # for SDK to pick them up for the archive.
 353 IF( DEFINED ENV{DALI_DATA_RW_INSTALL_DIR} )
 354   SET( dataReadWriteInstallDir $ENV{DALI_DATA_RW_INSTALL_DIR} )
 355 ELSE()
 356   SET( dataReadWriteInstallDir ${dataReadWriteDir} )
 357 ENDIF()
 358
 359 IF( DEFINED ENV{DALI_DATA_RO_INSTALL_DIR} )
 360   SET( dataReadOnlyInstallDir $ENV{DALI_DATA_RO_INSTALL_DIR} )
 361 ELSE()
 362   SET( dataReadOnlyInstallDir ${dataReadOnlyDir} )
 363 ENDIF()
 364
 365 COPY_RESOURCES( "${dali_toolkit_style_files}" "${ROOT_SRC_DIR}" "${dataReadOnlyInstallDir}" "./toolkit/styles" )
 366 COPY_RESOURCES( "${dali_toolkit_image_files}" "${ROOT_SRC_DIR}" "${dataReadOnlyInstallDir}" "./toolkit/images" )
 367 COPY_RESOURCES( "${dali_toolkit_sound_files}" "${ROOT_SRC_DIR}" "${dataReadOnlyInstallDir}" "./toolkit/sounds" )
 368 COPY_RESOURCES( "${dali_toolkit_style_images}" "${ROOT_SRC_DIR}" "${dataReadOnlyInstallDir}" "./toolkit/styles/images" )
 369
 370 # The DALI_TOOLKIT_PREFIX must be set if this CMakeLists.txt is executed
 371 # from the top-level CMake script using ADD_SUBDIRECTORY() to avoid
 372 # target names duplication with other DALi modules.
 373 IF( ENABLE_COVERAGE )
 374   FIND_PROGRAM( LCOV_BIN "lcov" )
 375   IF( LCOV_BIN )
 376
 377     # Define custom rules for coverage
 378     SET(COVERAGE_DIR .cov)
 379     SET(COVERAGE_OUTPUT_DIR doc/coverage)
 380
 381     # lcov prior to 1.10 doesn't have -rc option; this and subsequent version don't output
 382     # branch coverage. Determine the lcov version, and enable branch coverage accordingly.
 383     EXECUTE_PROCESS( COMMAND bash -c "${LCOV_BIN} --version | cut -d' ' -f4" OUTPUT_VARIABLE LCOV_VERSION )
 384     STRING( REPLACE "." ";" LCOV_VLIST ${LCOV_VERSION})
 385     IF( NOT $<VERSION_LESS:${LCOV_VERSION},"1.10"> )
 386       SET(LCOV_OPTS --rc lcov_branch_coverage=1)
 387     ENDIF()
 388
 389     ADD_CUSTOM_TARGET( ${DALI_TOOLKIT_PREFIX}rename_cov_data ./rename-cov-data )
 390
 391     ADD_CUSTOM_TARGET( ${DALI_TOOLKIT_PREFIX}cov_data ${LCOV_BIN} ${LCOV_OPTS} --base-directory . --directory . -c -o dali.info
 392       COMMAND ${LCOV_BIN} ${LCOV_OPTS} --remove dali.info \"*/dali-env/*\" \"/usr/include/*\" "*/dali-env/*" "*solid-color-actor*" "*/dali-toolkit/third-party/*" -o dali.info )
 393
 394     ADD_CUSTOM_TARGET( ${DALI_TOOLKIT_PREFIX}coverage genhtml ${LCOV_OPTS} -o ${COVERAGE_OUTPUT_DIR} dali.info
 395       DEPENDS cov_data )
 396
 397     ADD_CUSTOM_TARGET( ${DALI_TOOLKIT_PREFIX}reset_coverage @${LCOV_BIN} -z --directory `pwd` )
 398
 399     # Define custom rule for distclean
 400     ADD_CUSTOM_TARGET( ${DALI_TOOLKIT_PREFIX}distclean @echo cleaning for source distribution )
 401     ADD_CUSTOM_COMMAND(
 402           DEPENDS ${DALI_TOOLKIT_PREFIX}clean
 403           COMMENT "distribution clean"
 404           COMMAND find
 405           ARGS    .
 406           -not -name config.cmake -and \(
 407           -name tester.c -or
 408           -name Testing -or
 409           -name CMakeFiles -or
 410           -name doc -or
 411           -name cmake.depends -or
 412           -name cmake.check_depends -or
 413           -name CMakeCache.txt -or
 414           -name cmake.check_cache -or
 415           -name *.cmake -or
 416           -name Makefile -or
 417           -name core -or
 418           -name core.* -or
 419           -name gmon.out -or
 420           -name install_manifest.txt -or
 421           -name *.pc -or
 422           -name *.gcov -or
 423           -name *.gcno -or
 424           -name *.gcda -or
 425           -name *~ -or
 426           -name libdali*.so* \)
 427           | grep -v TC | xargs rm -rf
 428           TARGET  ${DALI_TOOLKIT_PREFIX}distclean
 429           VERBATIM
 430           )
 431
 432   ENDIF( LCOV_BIN )
 433 ENDIF()
 434
 435 # Build documentation if doxygen tool is available
 436 SET( doxygenEnabled OFF )
 437 IF( DOXYGEN_FOUND )
 438   SET( doxygenEnabled ON )
 439   # 'prefix' is used by doxygen in-files.
 440   SET( prefix ${PREFIX} )
 441   SET( DOXYGEN_DOCS_DIR ${ROOT_SRC_DIR}/docs )
 442   SET( DOXYGEN_ROOT_DIR ${ROOT_SRC_DIR} )
 443   SET( DOXYGEN_SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/docs )
 444   SET( DOXYGEN_INTERNAL_SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/docs-internal )
 445   CONFIGURE_FILE( ${DOXYGEN_SRC_DIR}/dali.doxy.in ${DOXYGEN_SRC_DIR}/dali.doxy @ONLY )
 446   CONFIGURE_FILE( ${DOXYGEN_INTERNAL_SRC_DIR}/dali-internal.doxy.in ${DOXYGEN_INTERNAL_SRC_DIR}/dali-internal.doxy @ONLY )
 447   ADD_CUSTOM_TARGET( doc_doxygen ALL
 448                      DEPENDS ${name}
 449                      COMMAND ${DOXYGEN_EXECUTABLE} -u ${DOXYGEN_SRC_DIR}/dali.doxy
 450                      COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYGEN_SRC_DIR}/dali.doxy
 451                      COMMAND ${CMAKE_COMMAND} -P ${DOXYGEN_SRC_DIR}/check_for_errors.cmake
 452                      COMMENT "Generating API documentation with Doxygen"
 453                      WORKING_DIRECTORY ${DOXYGEN_SRC_DIR}
 454                      VERBATIM )
 455   ADD_CUSTOM_TARGET( doc_doxygen_internal
 456                      COMMAND ${DOXYGEN_EXECUTABLE} -u ${DOXYGEN_INTERNAL_SRC_DIR}/dali-internal.doxy
 457                      COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYGEN_INTERNAL_SRC_DIR}/dali-internal.doxy
 458                      COMMENT "Generating Internal API documentation with Doxygen"
 459                      VERBATIM )
 460
 461 ENDIF()
 462
 463 IF( CONFIGURE_AUTOMATED_TESTS )
 464   # Configure automated tests
 465   CONFIGURE_FILE( ${ROOT_SRC_DIR}/automated-tests/CMakeLists.txt.in
 466                   ${ROOT_SRC_DIR}/automated-tests/CMakeLists.txt @ONLY )
 467 ENDIF()
 468
 469 # Configuration Messages
 470 MESSAGE( STATUS "Configuration:\n" )
 471 MESSAGE( STATUS "Prefix:                        " ${PREFIX} )
 472 MESSAGE( STATUS "Lib Dir:                       " ${LIB_DIR} )
 473 MESSAGE( STATUS "Include Dir:                   " ${INCLUDE_DIR} )
 474 MESSAGE( STATUS "Debug build:                   " ${ENABLE_DEBUG} )
 475 MESSAGE( STATUS "Export all symbols:            " ${ENABLE_EXPORTALL} )
 476 MESSAGE( STATUS "Coverage:                      " ${ENABLE_COVERAGE} )
 477 MESSAGE( STATUS "Trace:                         " ${ENABLE_TRACE} )
 478 MESSAGE( STATUS "Doxygen:                       " ${doxygenEnabled} )
 479 MESSAGE( STATUS "Data Dir (Read/Write):         " ${dataReadWriteDir} )
 480 MESSAGE( STATUS "Data Dir (Read Only):          " ${dataReadOnlyDir} )
 481 MESSAGE( STATUS "Data Install Dir (Read/Write): " ${dataReadWriteInstallDir} )
 482 MESSAGE( STATUS "Data Install Dir (Read Only):  " ${dataReadOnlyInstallDir} )
 483 MESSAGE( STATUS "Style Dir:                     " ${STYLE_DIR} )
 484 MESSAGE( STATUS "Style:                         " ${dali_style} )
 485 MESSAGE( STATUS "i18n:                          " ${ENABLE_I18N} )
 486 MESSAGE( STATUS "Use pkg configure:             " ${ENABLE_PKG_CONFIGURE} )
 487 MESSAGE( STATUS "Enable link test:              " ${ENABLE_LINK_TEST} )
 488 MESSAGE( STATUS "Configure automated tests:     " ${CONFIGURE_AUTOMATED_TESTS} )
 489 MESSAGE( STATUS "CXXFLAGS:                      " ${CMAKE_CXX_FLAGS} )
 490 MESSAGE( STATUS "LDFLAGS:                       " ${CMAKE_SHARED_LINKER_FLAGS_INIT}${CMAKE_SHARED_LINKER_FLAGS} )