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