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