IF(WIN32)
cmake_minimum_required(VERSION 2.6.0)
ENDIF(WIN32)
PROJECT(UI)

# set the install directory to the UI directory on Windows
IF( WIN32 AND CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT AND NOT H3D_CMAKE_INSTALL_PREFIX_ALREADY_SET ) 
  SET( CMAKE_INSTALL_PREFIX ${UI_SOURCE_DIR}/.. CACHE PATH "Install path prefix, prepended onto install directories." FORCE )
  SET( H3D_CMAKE_INSTALL_PREFIX_ALREADY_SET TRUE )
ENDIF( WIN32 AND CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT AND NOT H3D_CMAKE_INSTALL_PREFIX_ALREADY_SET ) 

# Add a cache variable GENERATE_CPACK_PROJECT to have the choice of generating a project
# for packaging UI. Default is NO since most people will not use this.
IF( NOT DEFINED GENERATE_CPACK_PROJECT )
  SET( GENERATE_CPACK_PROJECT "NO" CACHE BOOL "Decides if a cpack project should be generated. The project in the first loaded CMakeLists will configure CPack." )
  MARK_AS_ADVANCED(GENERATE_CPACK_PROJECT)
ENDIF( NOT DEFINED GENERATE_CPACK_PROJECT )

INCLUDE( "${UI_SOURCE_DIR}/UISourceFiles.txt" )

SET( UI_MAJOR_VERSION 2 )
SET( UI_MINOR_VERSION 3 )
SET( UI_BUILD_VERSION 0 )

# Set here already in case a special NSIS template needs to be used by cpack.
# Needed to convert from \ to / on windows. Not needed in the FindModules since
# call to macro takes care of that there.
SET( CONVERTED_H3D_ROOT "" )
IF( EXISTS $ENV{H3D_ROOT} )
  FILE( TO_CMAKE_PATH $ENV{H3D_ROOT} CONVERTED_H3D_ROOT )
ENDIF( EXISTS $ENV{H3D_ROOT} )
SET(CMAKE_MODULE_PATH  ${UI_SOURCE_DIR}/modules ${CONVERTED_H3D_ROOT}/build/modules ${UI_SOURCE_DIR}/../../H3DAPI/build/modules )
IF( COMMAND cmake_policy )
  IF( POLICY CMP0011 )
    cmake_policy( SET CMP0011 NEW )
  ENDIF( POLICY CMP0011 )
ENDIF( COMMAND cmake_policy )
INCLUDE( StripAndAddLibraryDirectories )

# If cpack should be configured.

SET( UI_FULL_VERSION
${UI_MAJOR_VERSION}.${UI_MINOR_VERSION}.${UI_BUILD_VERSION} ) 

# add the UI.rc resource file if Visual Studio
IF(MSVC)
  SET( UI_SRCS ${UI_SRCS} ${CMAKE_CURRENT_BINARY_DIR}/UI.rc )
ENDIF(MSVC)

# Add the directory to INCLUDE_DIRECTORIES before any other statement to make sure that this header file is found first.
# This assumes that we always use "#include <path/include_header.h>" in our code even if the file is actually found in
# the same directory as the file that contains the include statement.
INCLUDE_DIRECTORIES( ${CMAKE_CURRENT_BINARY_DIR}/include )
SET( UI_INCLUDE_DIR ${CMAKE_CURRENT_BINARY_DIR}/include ${UI_SOURCE_DIR}/../include CACHE INTERNAL "Set to internal to propagate change" )

# add all optional libraries to this variable
SET(optionalLibs)

# add all required libraries to this variable
SET(requiredLibs)

INCLUDE_DIRECTORIES( ../include )

IF(WIN32)
  SET(requiredLibs ${requiredLibs} )
ENDIF(WIN32)

IF( H3D_USE_DEPENDENCIES_ONLY )
  # The variables set here must be set by the CMakeLists.txt that sets H3D_USE_DEPENDENCIES_ONLY to true.
  INCLUDE_DIRECTORIES( ${EXTERNAL_INCLUDE_DIR} ) 
  INCLUDE_DIRECTORIES( ${H3DUTIL_INCLUDE_DIR} ) 
  INCLUDE_DIRECTORIES( ${HAPI_INCLUDE_DIR} ) 
  INCLUDE_DIRECTORIES( ${H3DAPI_INCLUDE_DIR} ) 
  
  SET( requiredLibs ${requiredLibs} H3DUtil HAPI H3DAPI )
ELSE( H3D_USE_DEPENDENCIES_ONLY )
  #H3DUtil
  FIND_PACKAGE(H3DUtil REQUIRED)

  IF(H3DUTIL_FOUND)
    INCLUDE_DIRECTORIES( ${H3DUTIL_INCLUDE_DIR} ) 
    SET(requiredLibs ${requiredLibs} ${H3DUTIL_LIBRARIES} )
  ENDIF(H3DUTIL_FOUND)

  #HAPI
  FIND_PACKAGE(HAPI REQUIRED)

  IF(HAPI_FOUND)
    INCLUDE_DIRECTORIES( ${HAPI_INCLUDE_DIR} ) 
    SET(requiredLibs ${requiredLibs} ${HAPI_LIBRARIES} )
  ENDIF(HAPI_FOUND)

  #H3DAPI
  FIND_PACKAGE(H3DAPI REQUIRED)

  IF(H3DAPI_FOUND)
    INCLUDE_DIRECTORIES( ${H3DAPI_INCLUDE_DIR} ) 
    SET(requiredLibs ${requiredLibs} ${H3DAPI_LIBRARIES} )
  ENDIF(H3DAPI_FOUND)
ENDIF( H3D_USE_DEPENDENCIES_ONLY )

FIND_PACKAGE(Xerces)

IF(XERCES_FOUND)
  INCLUDE_DIRECTORIES( ${XERCES_INCLUDE_DIR} ) 
  SET(optionalLibs ${optionalLibs} ${XERCES_LIBRARIES} )
ENDIF(XERCES_FOUND)

FIND_PACKAGE(FTGL)
IF(FTGL_FOUND)
  INCLUDE_DIRECTORIES( ${FTGL_INCLUDE_DIR} ) 
  IF(WIN32)
    STRIP_AND_ADD_LIBRARY_DIRECTORIES( ${FTGL_LIBRARIES})
  ELSE(WIN32)
    SET(optionalLibs ${optionalLibs} ${FTGL_LIBRARIES} )
  ENDIF(WIN32)
ENDIF(FTGL_FOUND)

FIND_PACKAGE(H3DFreetype)
IF(FREETYPE_FOUND)
  INCLUDE_DIRECTORIES( ${FREETYPE_INCLUDE_DIRS} ) 
  SET(optionalLibs ${optionalLibs} ${FREETYPE_LIBRARIES} )
ENDIF(FREETYPE_FOUND)

# UI shared library definition
ADD_LIBRARY(UI SHARED ${UI_SRCS} ${UI_HEADERS})

# make sure that the UI.rc contains the correct svn-version
IF( MSVC )
  SET( UI_SVN_VERSION "0" )
  # Find SubWCRev.exe
  FIND_FILE( SubWCRev
             NAMES "SubWCRev.exe"
             DOC   "Set to SubWCRev.exe that comes with TortoiseSVN. Used to find svn revision number." )

  SET( UI_is_working_copy 10 )
  IF( SubWCRev )
    EXECUTE_PROCESS( COMMAND ${SubWCRev} ${UI_SOURCE_DIR}/../
                     RESULT_VARIABLE UI_is_working_copy )
    IF( ${UI_is_working_copy} EQUAL 0 )
      SET( UI_SVN_VERSION "$WCREV$" )
    ENDIF( ${UI_is_working_copy} EQUAL 0 )
  ENDIF( SubWCRev )

  # autogenerate UI.rc depending on the version
  CONFIGURE_FILE( UI.rc.cmake ${CMAKE_CURRENT_BINARY_DIR}/UI.rc )
  
  ADD_CUSTOM_COMMAND( TARGET UI
											PRE_BUILD
											COMMAND ${UI_SOURCE_DIR}/UpdateResourceFile 
											ARGS UI ${CMAKE_CURRENT_BINARY_DIR}/UI.rc ${UI_SOURCE_DIR}/UI.rc.cmake
											${UI_MAJOR_VERSION} ${UI_MINOR_VERSION}
											${UI_BUILD_VERSION} "${UI_SVN_VERSION}"
											"UI_Output_Name"
											"$(TargetFileName)" )

  IF( SubWCRev AND ${UI_is_working_copy} EQUAL 0 )
    # Update SVN revision in file.
    EXECUTE_PROCESS( COMMAND ${SubWCRev} ${UI_SOURCE_DIR}/../ ${CMAKE_CURRENT_BINARY_DIR}/UI.rc ${CMAKE_CURRENT_BINARY_DIR}/UI.rc )

    ADD_CUSTOM_COMMAND( TARGET UI 
                        PRE_BUILD 
                        COMMAND ${SubWCRev} 
                        ARGS ${UI_SOURCE_DIR}/../ ${CMAKE_CURRENT_BINARY_DIR}/UI.rc ${CMAKE_CURRENT_BINARY_DIR}/UI.rc )
  ENDIF( SubWCRev AND ${UI_is_working_copy} EQUAL 0 )
ENDIF(MSVC)

# make sure symbols are exported.
SET( UI_COMPILE_FLAGS "-DUI_EXPORTS" )

# add the libraries needed for linking
TARGET_LINK_LIBRARIES( UI ${requiredLibs} ${optionalLibs} )

foreach( H3DUTIL_INCLUDE_DIR_TMP ${H3DUTIL_INCLUDE_DIR} )
  IF( EXISTS ${H3DUTIL_INCLUDE_DIR_TMP}/H3DUtil/H3DUtil.h )
    FILE( STRINGS ${H3DUTIL_INCLUDE_DIR_TMP}/H3DUtil/H3DUtil.h list_of_defines REGEX "#define THREAD_LOCK_DEBUG"  )
    LIST( LENGTH list_of_defines list_of_defines_length )
    IF( list_of_defines_length )
      if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
        execute_process( COMMAND ${CMAKE_CXX_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
        if (GCC_VERSION VERSION_GREATER 4.7 OR GCC_VERSION VERSION_EQUAL 4.7)
          add_definitions("-std=gnu++11")
        elseif(GCC_VERSION VERSION_GREATER 4.3 OR GCC_VERSION VERSION_EQUAL 4.3)
          add_definitions("-std=gnu++0x")
        else ()
          message(FATAL_ERROR "Enabling ENABLE_THREAD_LOCK_DEBUG requires C++11 support. This compiler lacks such support.")
        endif ()
      elseif (${MSVC_VERSION} LESS 1600 )
        message(FATAL_ERROR "Enabling ENABLE_THREAD_LOCK_DEBUG requires C++11 support. This compiler lacks such support.")
      endif ()
    ENDIF( list_of_defines_length )
  ENDIF( EXISTS ${H3DUTIL_INCLUDE_DIR_TMP}/H3DUtil/H3DUtil.h )
endforeach( H3DUTIL_INCLUDE_DIR_TMP )


# make the name of debug libraries end in _d.
SET_TARGET_PROPERTIES( UI PROPERTIES DEBUG_POSTFIX "_d" )

# set the version of the library
SET_TARGET_PROPERTIES( UI PROPERTIES VERSION ${UI_FULL_VERSION} )

SET( UI_LINK_FLAGS_DEBUG "" )

IF(UNIX) 
  SET_TARGET_PROPERTIES( UI PROPERTIES OUTPUT_NAME h3dui )
ENDIF(UNIX)

IF( MSVC )
  SET( H3D_MSVC_VERSION 6 )
  SET( TEMP_MSVC_VERSION 1299 )
  WHILE( ${MSVC_VERSION} GREATER ${TEMP_MSVC_VERSION} )
    MATH( EXPR H3D_MSVC_VERSION "${H3D_MSVC_VERSION} + 1" )
    MATH( EXPR TEMP_MSVC_VERSION "${TEMP_MSVC_VERSION} + 100" )
  ENDWHILE( ${MSVC_VERSION} GREATER ${TEMP_MSVC_VERSION} )

  # change the name depending on compiler to be able to tell them apart
  # since they are not compatible with each other. 
  SET_TARGET_PROPERTIES( UI PROPERTIES OUTPUT_NAME ${PROJECT_NAME}_vc${H3D_MSVC_VERSION} )

  # Treat wchar_t as built in type for all visual studio versions.
  # This is default for every version above 7 ( so far ) but we still set it for all.
  SET( UI_COMPILE_FLAGS "${UI_COMPILE_FLAGS} /Zc:wchar_t")

  IF( ${MSVC_VERSION} GREATER 1399 )
    # Remove compiler warnings about deprecation for visual studio versions 8 and above.
    SET( UI_COMPILE_FLAGS "${UI_COMPILE_FLAGS} -D_CRT_SECURE_NO_DEPRECATE" )
  ENDIF( ${MSVC_VERSION} GREATER 1399 )

  IF( ${MSVC_VERSION} GREATER 1499 )
    # Build using several threads for visual studio versions 9 and above.
    SET( UI_COMPILE_FLAGS "${UI_COMPILE_FLAGS} /MP" )
  ENDIF( ${MSVC_VERSION} GREATER 1499 )
  
  # Seems like UI needs to have incremental linking shut off for vc8. Since this is
  # not the most important feature it is shut off for all visual studio versions.
  SET_TARGET_PROPERTIES( UI PROPERTIES LINK_FLAGS_DEBUG "${UI_LINK_FLAGS_DEBUG} /INCREMENTAL:NO" )
ENDIF( MSVC )

SET_TARGET_PROPERTIES( UI PROPERTIES COMPILE_FLAGS "${UI_COMPILE_FLAGS}" )

# autogenerate UI.h depending on the libraries available.
IF( EXISTS ${UI_SOURCE_DIR}/../include/H3D/UI/UI.h )
  FILE( REMOVE ${UI_SOURCE_DIR}/../include/H3D/UI/UI.h )
ENDIF( EXISTS ${UI_SOURCE_DIR}/../include/H3D/UI/UI.h )
CONFIGURE_FILE( ${UI_SOURCE_DIR}/../include/H3D/UI/UI.cmake ${CMAKE_CURRENT_BINARY_DIR}/include/H3D/UI/UI.h )

IF( NOT GENERATE_CPACK_PROJECT )
  # Install header files on non-windows system (e.g. Unix).
  INSTALL( FILES ${CMAKE_CURRENT_BINARY_DIR}/include/H3D/UI/UI.h
           DESTINATION ${UI_SOURCE_DIR}/../include/H3D/UI )
ENDIF( NOT GENERATE_CPACK_PROJECT )

SET( DEFAULT_BIN_INSTALL "bin" )
SET( DEFAULT_LIB_INSTALL "lib" )

IF( WIN32 )
  SET( DEFAULT_BIN_INSTALL "bin32" )
  SET( DEFAULT_LIB_INSTALL "lib32" )
  IF( CMAKE_SIZEOF_VOID_P EQUAL 8 )
    SET( DEFAULT_BIN_INSTALL "bin64" )
    SET( DEFAULT_LIB_INSTALL "lib64" )
  ENDIF( CMAKE_SIZEOF_VOID_P EQUAL 8 )
ENDIF( WIN32 )

INSTALL( TARGETS UI
         LIBRARY DESTINATION ${DEFAULT_LIB_INSTALL} COMPONENT UI_cpack_runtime
         RUNTIME DESTINATION ${DEFAULT_BIN_INSTALL} COMPONENT UI_cpack_runtime
         ARCHIVE DESTINATION ${DEFAULT_LIB_INSTALL} COMPONENT UI_cpack_libraries)

IF( NOT ( WIN32 OR GENERATE_CPACK_PROJECT ) )
	# install header files on non-windows system
  INSTALL( FILES ${UI_HEADERS}
           DESTINATION include/H3D/UI )
ENDIF( NOT ( WIN32 OR GENERATE_CPACK_PROJECT ) )

IF( H3D_USE_DEPENDENCIES_ONLY )
  SET( INSTALL_RUNTIME_AND_LIBRARIES_ONLY_DEPENDENCIES ${INSTALL_RUNTIME_AND_LIBRARIES_ONLY_DEPENDENCIES} PARENT_SCOPE )
ELSE( H3D_USE_DEPENDENCIES_ONLY )
	INCLUDE (${UI_SOURCE_DIR}/UICPack.cmake)
ENDIF( H3D_USE_DEPENDENCIES_ONLY )

