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