~lubuntu-dev/juffed/trunk

# juffed CMakeLists.txt
# 
# To build juffed, you will need cmake 2.8.11.
# To build the application run this commands:
# 
# mkdir build
# cd build
# cmake .. -DCMAKE_INSTALL_PREFIX=/usr (or whatever prefix you'd like)
# make
# make install
#
# mac os x notes:
# juffed.app is build by default. There are some additions to steps above. 
# "make install" is required to get plugins working
# "make bundle" an optional make target to build bundle with all dependencies inside
#


project (juffed)
cmake_minimum_required (VERSION 2.8.11)

# build options
option(USE_QT5 "Use Qt5. Defaults to Qt4" $ENV{USE_QT5})
option(USE_SYSTEM_QTSINGLEAPPLICATION "Try to find system-wide QtSingleApplication library" $ENV{USE_SYSTEM_SINGLETON})
option(USE_ENCA "Try to find Enca library for file encoding check" $ENV{USE_ENCA})


if (COMMAND cmake_policy)
    CMAKE_POLICY (SET CMP0003 NEW)
endif (COMMAND cmake_policy)

set ( CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake ${CMAKE_MODULE_PATH} )
set ( PREFIX ${CMAKE_INSTALL_PREFIX} )

# switch verbose mode ON or OFF
set ( CMAKE_VERBOSE_MAKEFILE $ENV{VERBOSE_MAKEFILE} )

####################
# Names and Version
####################

set ( JUFFED  "juffed" CACHE STRING "Name of the executeable" )
set ( JUFFLIB "juff"   CACHE STRING "Name of the library" )
set ( QSCI_ENGINE "juffed-engine-qsci" CACHE STRING "" )
file   ( READ "${CMAKE_SOURCE_DIR}/version"      JUFFED_VERSION )
file   ( READ "${CMAKE_SOURCE_DIR}/base_version" BASE_VERSION )
string ( STRIP "${JUFFED_VERSION}" JUFFED_VERSION )
string ( STRIP "${BASE_VERSION}"   BASE_VERSION )

# flag indicating that this is a development version
set ( DEV 0 )

if ( DEV )
    # SVN revision
#    find_package(Subversion)
#    if(Subversion_FOUND)
#        Subversion_WC_INFO(${PROJECT_SOURCE_DIR} SVN)
#    endif(Subversion_FOUND)
#    set ( REV ${SVN_WC_REVISION} )
#    set ( JUFFED_VERSION "${BASE_VERSION}.${REV}" )
endif ( DEV )

message ( STATUS "" )
message ( STATUS "${JUFFED} version: ${JUFFED_VERSION}" )


####################
# Directories
####################

include ( cmake/LibSuffix.cmake )

set (BIN_INSTALL_DIR
    "${PREFIX}/bin"
    CACHE PATH "Install path for executables"
)

set (LIB_INSTALL_DIR
    "${PREFIX}/lib${LIB_SUFFIX}"
    CACHE PATH "Install path for libraries"
)

set (DATA_INSTALL_DIR
    "${PREFIX}/share/${CMAKE_PROJECT_NAME}"
    CACHE PATH "Install path for shared data"
)

message ( STATUS "Install path for executables: ${BIN_INSTALL_DIR}" )
message ( STATUS "Install path for libraries: ${LIB_INSTALL_DIR}" )
message ( STATUS "" )
#set (CMAKE_INSTALL_RPATH "${LIB_INSTALL_DIR}")

set (CMAKE_AUTOMOC ON)

if (USE_QT5)
    find_package ( Qt5 COMPONENTS Widgets Xml Network PrintSupport LinguistTools CONFIG REQUIRED )
    set (JUFF_QT_IMPORTED_TARGETS Qt5::Widgets Qt5::Xml Qt5::Network Qt5::PrintSupport)

    macro(qt_wrap_ui)
      qt5_wrap_ui(${ARGN})
    endmacro()

    macro(qt_add_resources)
      qt5_add_resources(${ARGN})
    endmacro()

    macro(qt_add_translation)
      qt5_add_translation(${ARGN})
    endmacro()
else (USE_QT5)
    find_package ( Qt4 COMPONENTS QtCore QtGui QtXml QtNetwork REQUIRED )
    set (JUFF_QT_IMPORTED_TARGETS Qt4::QtCore Qt4::QtGui Qt4::QtXml Qt4::QtNetwork)

    macro(qt_wrap_ui)
      qt4_wrap_ui(${ARGN})
    endmacro()

    macro(qt_add_resources)
      qt4_add_resources(${ARGN})
    endmacro()

    macro(qt_add_translation)
      qt4_add_translation(${ARGN})
    endmacro()
endif (USE_QT5)

# this is mandatory for Apple builds to load plugin correctly
add_definitions(-DQT_NO_DEBUG)

find_package ( QScintilla2 REQUIRED)


include ( cmake/FileSets.cmake )
include ( cmake/SomeLexers.cmake )

if(USE_SYSTEM_QTSINGLEAPPLICATION)
    find_package ( QtSingleApplication REQUIRED)
else(USE_SYSTEM_QTSINGLEAPPLICATION)
    set(QTSINGLEAPPLICATION_INCLUDE_DIR src/3rd_party/qtsingleapplication)
    SET ( juffed_app_SRCS
        ${juffed_app_SRCS}
        src/3rd_party/qtsingleapplication/qtsinglecoreapplication.cpp
        src/3rd_party/qtsingleapplication/qtsingleapplication.cpp
        src/3rd_party/qtsingleapplication/qtlockedfile.cpp
        src/3rd_party/qtsingleapplication/qtlocalpeer.cpp
    )
    IF ( WIN32 )
        SET ( juffed_app_SRCS
            ${juffed_app_SRCS}
            src/3rd_party/qtsingleapplication/qtlockedfile_win.cpp
        )
    ENDIF ( WIN32 )

    IF ( UNIX )
        SET ( juffed_app_SRCS
            ${juffed_app_SRCS}
            src/3rd_party/qtsingleapplication/qtlockedfile_unix.cpp
        )
    ENDIF ( UNIX )
endif(USE_SYSTEM_QTSINGLEAPPLICATION)


QT_ADD_RESOURCES ( juffed_app_RESOURCES ${juffed_app_RESOURCES} )
QT_ADD_RESOURCES ( juffed_lib_RESOURCES ${juffed_lib_RESOURCES} )
QT_WRAP_UI ( juffed_qsci_UIS_H ${juffed_qsci_UIS} )
QT_WRAP_UI ( juffed_app_UIS_H ${juffed_app_UIS} )
QT_ADD_TRANSLATION ( juffed_QM ${juffed_TS} )


include(FindPkgConfig)
if (USE_ENCA)
# try to find libenca - optional
pkg_check_modules(ENCA enca)
if (ENCA_FOUND)
    add_definitions(-DHAVE_ENCA)
    include_directories(${ENCA_INCLUDE_DIRS})
    link_directories(${ENCA_LIBRARY_DIRS})
    message(STATUS "Enca includes: ${ENCA_INCLUDE_DIRS}")
    message(STATUS "Enca library dir: ${ENCA_LIBRARY_DIRS}")
    message(STATUS "Enca library: ${ENCA_LIBRARIES}")
else (ENCA_FOUND)
    message(WARNING "No enca library found. Building without auto-language-detection")
endif (ENCA_FOUND)
endif (USE_ENCA)


# include directories
include_directories(
    ${CMAKE_BINARY_DIR}
    ${QSCINTILLA_INCLUDE_DIR}
    ${QSCINTILLA_INCLUDE_DIR}/Qsci
    ${QTSINGLEAPPLICATION_INCLUDE_DIR}
    src/app/ui
    src/app/qsci
    ./include
)

configure_file ("${CMAKE_SOURCE_DIR}/cmake/AppInfo.nix.h.cmake" "${CMAKE_BINARY_DIR}/AppInfo.nix.h" @ONLY)
configure_file ("${CMAKE_SOURCE_DIR}/cmake/AppInfo.win.h.cmake" "${CMAKE_BINARY_DIR}/AppInfo.win.h" @ONLY)
configure_file ("${CMAKE_SOURCE_DIR}/cmake/AppInfo.apple.h.cmake" "${CMAKE_BINARY_DIR}/AppInfo.apple.h" @ONLY)


####################
# Targets
####################

# library
add_library ( ${JUFFLIB} SHARED
    ${juffed_lib_SRCS}
    ${juffed_lib_MOC_HEADERS}
    ${juffed_lib_RESOURCES}
)
target_link_libraries ( ${JUFFLIB}
    ${JUFF_QT_IMPORTED_TARGETS}
)
if (ENCA_FOUND)
    target_link_libraries( ${JUFFLIB} ${ENCA_LIBRARIES} )
endif (ENCA_FOUND)

add_library ( ${QSCI_ENGINE} SHARED
    ${juffed_qsci_SRCS}
    ${juffed_qsci_UIS_H}
)
target_link_libraries ( ${QSCI_ENGINE}
    ${JUFFLIB}
    ${JUFF_QT_IMPORTED_TARGETS}
    ${QSCINTILLA_LIBRARY} 
    ${QTSINGLEAPPLICATION_LIBRARY} 
)

if (APPLE)
    message ( STATUS "Building as an apple bundle" )
    set ( APPLE_PREFIX "${CMAKE_INSTALL_PREFIX}/${JUFFED}.app/Contents" )
    
    add_definitions(-DAPPLEBUNDLE)
    set(GUI_TYPE MACOSX_BUNDLE)
    # create Info.plist file
    set(MACOSX_BUNDLE_ICON_FILE juffed.icns)
    set(MACOSX_BUNDLE_INFO_STRING "juffed ${JUFFED_VERSION}")
    set(MACOSX_BUNDLE_GUI_IDENTIFIER "com.juffed")
    set(MACOSX_BUNDLE_LONG_VERSION_STRING "${JUFFED_VERSION}")
    set(MACOSX_BUNDLE_BUNDLE_NAME "${JUFFED}")
    set(MACOSX_BUNDLE_SHORT_VERSION_STRING "${JUFFED_VERSION}")
    set(MACOSX_BUNDLE_BUNDLE_VERSION "${JUFFED_VERSION}")
    set(MACOSX_BUNDLE_COPYRIGHT "(c) juffed.com")
    set_source_files_properties(${CMAKE_SOURCE_DIR}/macosx/juffed.icns PROPERTIES MACOSX_PACKAGE_LOCATION Resources)
    # use icon for app bundle to be visible in finder
    set(APPLE_BUNDLE_SOURCES ${CMAKE_SOURCE_DIR}/macosx/juffed.icns)
    # this is a must to load the lib correctly
    set_target_properties( ${JUFFLIB} PROPERTIES INSTALL_NAME_DIR "@executable_path/../MacOS" )
    set_target_properties( ${QSCI_ENGINE} PROPERTIES INSTALL_NAME_DIR "@executable_path/../MacOS" )
else (APPLE)
    set(GUI_TYPE "")
    set(APPLE_BUNDLE_SOURCES "")
    # now we want to use soversion etc.
    if (NOT APPLE)
        # this causes a build fail on mac (unix-like build)
        set_target_properties ( ${JUFFLIB} PROPERTIES VERSION ${BASE_VERSION} SOVERSION ${BASE_VERSION} )
        set_target_properties ( ${QSCI_ENGINE} PROPERTIES VERSION ${BASE_VERSION} SOVERSION ${BASE_VERSION} )
    else (NOT APPLE)
        # apple requires this one to keep sane dyn-linking
        set_target_properties( ${JUFFLIB} PROPERTIES INSTALL_NAME_DIR ${LIB_INSTALL_DIR} )
        set_target_properties( ${QSCI_ENGINE} PROPERTIES INSTALL_NAME_DIR ${LIB_INSTALL_DIR} )
    endif (NOT APPLE)
endif (APPLE)

if ( MINGW )
    add_definitions(
        -DQSCINTILLA_DLL
    )

    add_definitions( -D__SPECIAL_WINDOWS_DEFINE__ )

    # resource compilation for MinGW
    add_custom_command ( OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/src/app/juffed_ico.o
        COMMAND $ENV{WINDRES} -I${CMAKE_CURRENT_SOURCE_DIR}/src/app -i${CMAKE_CURRENT_SOURCE_DIR}/src/app/juffed.rc 
            -o ${CMAKE_CURRENT_BINARY_DIR}/src/app/juffed_ico.o )
    set ( juffed_app_SRCS ${juffed_app_SRCS} ${CMAKE_CURRENT_BINARY_DIR}/src/app/juffed_ico.o)
endif ( MINGW )


# executable
add_executable ( ${JUFFED}
    ${GUI_TYPE}
    ${juffed_app_SRCS} 
    ${juffed_UIS} 
    ${juffed_app_UIS_H}
    ${juffed_app_RESOURCES} 
    ${juffed_QM} 
    ${APPLE_BUNDLE_SOURCES}
)

if ( MINGW )
    set_target_properties( ${JUFFED} PROPERTIES LINK_FLAGS "-mwindows" )
endif ( MINGW )

target_link_libraries ( ${JUFFED}
    ${JUFFLIB}
    ${QSCI_ENGINE}
    ${JUFF_QT_IMPORTED_TARGETS}
)

if ( UNIX )
    set(CMAKE_CXX_FLAGS "-Wall -Wextra")
endif ( UNIX )

#
# plugins
message(STATUS "Plugins: all externally linked cmake-ready plugs will be built")
set(JUFFED_CMAKE_PLUGINS 1)
if (UNIX)
    set(JUFFED_PLUGINS_DIR ${LIB_INSTALL_DIR}/juffed/plugins)
endif (UNIX)
if (APPLE)
    set(JUFFED_PLUGINS_DIR ${APPLE_PREFIX}/plugins)
endif (APPLE)
if (WIN32)
    set(JUFFED_PLUGINS_DIR ${CMAKE_INSTALL_PREFIX}/plugins)
endif(WIN32)
set(JUFFED_INCLUDE_DIR ${CMAKE_SOURCE_DIR}/include)
set(JUFFED_LIBRARY ${JUFFLIB})
add_subdirectory(plugins)

#configure_file ("${CMAKE_SOURCE_DIR}/cmake/version.cmake" "${CMAKE_BINARY_DIR}/version.real" @ONLY)




####################
# Installs
####################
if (NOT APPLE)

    install ( TARGETS ${JUFFED} DESTINATION ${BIN_INSTALL_DIR} )
    install ( TARGETS ${JUFFLIB} DESTINATION ${LIB_INSTALL_DIR} )
    install ( TARGETS ${QSCI_ENGINE} DESTINATION ${LIB_INSTALL_DIR} )
    install ( FILES ${juffed_QM} DESTINATION ${DATA_INSTALL_DIR}/l10n )
    install ( DIRECTORY hlschemes DESTINATION ${DATA_INSTALL_DIR} PATTERN ".svn" EXCLUDE PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ )
    install ( DIRECTORY apis DESTINATION ${DATA_INSTALL_DIR} PATTERN "*.svn" EXCLUDE PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ )
    install ( FILES juffed.png DESTINATION ${CMAKE_INSTALL_PREFIX}/share/pixmaps )
    install ( FILES juffed.desktop DESTINATION ${CMAKE_INSTALL_PREFIX}/share/applications )
    install ( FILES ${juffed_DEV_HEADERS} DESTINATION ${CMAKE_INSTALL_PREFIX}/include/${CMAKE_PROJECT_NAME} )

    ## uninstall 
    configure_file ( "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake" IMMEDIATE @ONLY )
    add_custom_target ( uninstall "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake")

else (NOT APPLE)

    install(CODE "message(STATUS \"Cleaning previously installed bundle (rm -r)\")")
    install(CODE "execute_process(COMMAND rm -r ${CMAKE_INSTALL_PREFIX}/${JUFFED}.app)")

    install( TARGETS ${JUFFED} DESTINATION "${CMAKE_INSTALL_PREFIX}" )
    # lib is linked directly into binary in bundles to prevent Info.plist hacking
    install( TARGETS ${JUFFLIB} DESTINATION "${APPLE_PREFIX}/MacOS" )
    install( TARGETS ${QSCI_ENGINE} DESTINATION "${APPLE_PREFIX}/MacOS" )
    install ( FILES ${juffed_QM} DESTINATION "${APPLE_PREFIX}/Resources/l10n" )

    install ( DIRECTORY hlschemes DESTINATION "${APPLE_PREFIX}/Resources" PATTERN ".svn" EXCLUDE PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ )
    install ( DIRECTORY apis DESTINATION "${APPLE_PREFIX}/Resources" PATTERN "*.svn" EXCLUDE PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ )

    # helper stuff to create real apple bundle.
    # Black magic is summoned here...
        # create a "transportable" bundle - all libs into the bundle: "make bundle" after make install
        configure_file(macosx/bundle.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/bundle.cmake @ONLY)
        add_custom_target(bundle ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/bundle.cmake)

endif (NOT APPLE)


# make dist custom target
SET(CPACK_PACKAGE_NAME ${JUFFED})
SET(CPACK_PACKAGE_VERSION ${JUFFED_VERSION})
SET(CPACK_SOURCE_GENERATOR "TGZ;TBZ2;ZIP;")
SET(CPACK_SOURCE_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}")
SET(CPACK_IGNORE_FILES "/CVS/;/\\\\.svn/;/\\\\.git/;\\\\.swp$;\\\\.#;/#;\\\\.tar.gz$;\\\\~$;/CMakeFiles/;CMakeCache.txt;\\\\.qm$;/win32/;/build/;")
SET(CPACK_SOURCE_IGNORE_FILES ${CPACK_IGNORE_FILES})
INCLUDE(CPack)
# simulate autotools' "make dist"
add_custom_target(dist COMMAND ${CMAKE_MAKE_PROGRAM} package_source)