build/tizen/CMakeLists.txt

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