build/tizen/CMakeLists.txt

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