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