lamino-filters/src/CMakeLists.txt

cmake_minimum_required(VERSION 2.6)

# --- Set sources -------------------------------------------------------------
set(ufofilter_SRCS 
    ufo-scale-task.c
    ufo-padding-2d-task.c
    ufo-lamino-bp-task.c
    #    ufo-filter-lamino-bp-generic.c
    #ufo-filter-3d-edf-writer.c
    #ufo-filter-padding-2d.c
    #ufo-filter-lamino-ramp.c
    #ufo-filter-lamino-ft-conv.c
    )

set(ufofilter_KERNELS
    scale.cl
    lamino_bp_generic.cl
    padding_2d.cl
    lamino_ramp.cl
    lamino_ft_conv.cl
    )

set(ufofilter_LIBS
    ${UFO_LIBRARIES}
    ${GLIB2_LIBRARIES}
    ${GOBJECT2_LIBRARIES}
    )

set(ufofilter_HEADERS
   lamino-filter-def.h
)

link_directories(${UFO_LIBRARY_DIRS})


# --- Target ------------------------------------------------------------------
include_directories(${CMAKE_CURRENT_BINARY_DIR})

get_property(LIB64 GLOBAL PROPERTY FIND_LIBRARY_USE_LIB64_PATHS)

set(LIB_INSTALL_DIR "lib${LIB_SUFFIX}/ufo")
set(shared_objects "")
set(documented_types "")
set(all_targets)

foreach(_src ${ufofilter_SRCS})
    # find plugin suffix
    string(REGEX REPLACE "ufo-([^ \\.]+)-task.*" "\\1" task "${_src}")

    # build string to get miscalleanous sources
    string(REPLACE "-" "_" _misc ${task})
    string(TOUPPER ${_misc} _misc_upper)

    # create an option name and add this to disable filters
    set(target_option "ENABLE_${_misc_upper}")
    option(${target_option} "Build filter ${task}" ON)

    if (${target_option})
        set(documented_types "${documented_types}\nufo_${_misc}_task_get_type")
        set(_misc "${_misc}_misc_SRCS")

        string(REPLACE "-" "" _targetname ${task})
        set(target "ufofilter${_targetname}")
        set(shared_objects "${shared_objects} -l${target}")

        # build single shared library per filter
        if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
            add_library(${target} MODULE ${_src} ${${_misc}})
        else()
            add_library(${target} SHARED ${_src} ${${_misc}})
        endif()

        target_link_libraries(${target} ${ufofilter_LIBS})
        list(APPEND all_targets ${target})
        
        install(TARGETS ${target}
            ARCHIVE DESTINATION ${LIB_INSTALL_DIR}
            LIBRARY DESTINATION ${LIB_INSTALL_DIR})
    endif()
endforeach()

# copy kernels into $LIB_INSTALL_DIR
foreach(_kernel ${ufofilter_KERNELS})
    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/${_kernel}
        ${CMAKE_CURRENT_BINARY_DIR}/${_kernel})

    install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/${_kernel}
        DESTINATION ${LIB_INSTALL_DIR})
endforeach()

#copy aux headers into $LIB_INSTALL_DIR
foreach(_header ${ufofilter_HEADERS})
    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/${_header}
            ${CMAKE_CURRENT_BINARY_DIR}/${_header})
		        
    install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/${_header}
        DESTINATION ${LIB_INSTALL_DIR})
endforeach()


# --- Build filter reference ---------------------------------------------------
pkg_check_modules(GTK_DOC gtk-doc)
if(GTK_DOC_FOUND)
    option(WITH_GTK_DOC "Build filter documentation" ON)
    if (WITH_GTK_DOC)
        get_directory_property(_current_include_dirs INCLUDE_DIRECTORIES)

        set(GTK_DOC_CFLAGS)
        foreach(_incl ${_current_include_dirs})
            set(GTK_DOC_CFLAGS "-I${_incl} ${GTK_DOC_CFLAGS}")
        endforeach()

        set(GTK_DOC_LDFLAGS)
        foreach(_lib ${ufofilter_LIBS})
            # check if we have an absolute library path
            if (NOT ${_lib} MATCHES "^[/]")
                set(GTK_DOC_LDFLAGS "-l${_lib} ${GTK_DOC_LDFLAGS}")
            endif()
        endforeach()

        find_program(GTK_DOC_SCAN gtkdoc-scan REQUIRED)
        find_program(GTK_DOC_SCANGOBJ gtkdoc-scangobj REQUIRED)
        find_program(GTK_DOC_MKDB gtkdoc-mkdb REQUIRED)
        find_program(GTK_DOC_MKHTML gtkdoc-mkhtml REQUIRED)

        set(doc_base "${CMAKE_CURRENT_BINARY_DIR}/../docs")
        set(doc_out "${doc_base}/reference")

        set(_xml_doc_input)

        foreach (_src ${ufofilter_SRCS})
            string(REPLACE ".c" ".xml" _xml_doc ${_src})
            list(APPEND _xml_doc_input "<xi:include href=\"xml/${_xml_doc}\"/>")
        endforeach()

        string(REPLACE ";" "\n" _xml_doc_input ${_xml_doc_input})
        configure_file("${CMAKE_CURRENT_SOURCE_DIR}/UfoFilters-docs.xml.in" "${doc_out}/UfoFilters-docs.xml")
        configure_file("${CMAKE_CURRENT_SOURCE_DIR}/scangobj.sh.in" "${doc_out}/scangobj.sh")
        configure_file("${CMAKE_CURRENT_SOURCE_DIR}/UfoFilters.types.in" "${doc_out}/UfoFilters.types")

        add_custom_command(OUTPUT ${doc_out}/UfoFilters-decl.txt
            COMMAND ${GTK_DOC_SCAN}
                    --module=UfoFilters
                    --source-dir=${CMAKE_CURRENT_SOURCE_DIR}/../src
                    DEPENDS ${ufofilter_SRCS}
            WORKING_DIRECTORY ${doc_out})

        add_custom_command(OUTPUT ${doc_out}/UfoFilters.args
            COMMAND sh scangobj.sh
            DEPENDS ${ufofilter_SRCS} ${doc_out}/UfoFilters-decl.txt ${all_targets}
            WORKING_DIRECTORY ${doc_out})

        add_custom_command(OUTPUT ${doc_out}/sgml.stamp
            COMMAND ${GTK_DOC_MKDB}
                    --module=UfoFilters
                    --source-dir=${CMAKE_CURRENT_SOURCE_DIR}
                    --output-format=xml
            DEPENDS ${ufofilter_SRCS} ${doc_out}/UfoFilters.args
            WORKING_DIRECTORY ${doc_out})

        add_custom_command(OUTPUT ${doc_base}/html.stamp
            COMMAND ${GTK_DOC_MKHTML}
                    UfoFilters
                    ${doc_out}/UfoFilters-docs.xml
            DEPENDS ${doc_out}/sgml.stamp
            WORKING_DIRECTORY ${doc_out})

        add_custom_target(reference ALL DEPENDS ${doc_base}/html.stamp)
    endif()
endif(GTK_DOC_FOUND)