CMakeLists.txt

cmake_minimum_required(VERSION 3.15)

project(oshot VERSION 0.4.3 LANGUAGES C CXX)
set(PROJECT_FULL_VERSION "${PROJECT_VERSION}${PROJECT_VERSION_SUFFIX}")

if(APPLE)
    enable_language(OBJC OBJCXX)
endif()

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3")

set(CMAKE_CXX_VISIBILITY_PRESET hidden)
set(CMAKE_VISIBILITY_INLINES_HIDDEN ON)

# LTO helper
function(enable_lto target)
    if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
        target_compile_options(
            ${target}
            PRIVATE $<$<CONFIG:Release>:-flto=auto;-ffat-lto-objects>
        )
        target_link_options(${target} PRIVATE $<$<CONFIG:Release>:-flto=auto>)
    elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
        target_compile_options(
            ${target}
            PRIVATE $<$<CONFIG:Release>:-flto=thin>
        )
        target_link_options(${target} PRIVATE $<$<CONFIG:Release>:-flto=thin>)
    endif()
endfunction()

# https://github.com/libcpr/cpr/blob/5f475522597b8f3721e2440daddeced7a969f24c/CMakeLists.txt#L39
macro(add_option OPTION_NAME OPTION_TEXT OPTION_DEFAULT DEFINE_OPTION)
    option(${OPTION_NAME} ${OPTION_TEXT} ${OPTION_DEFAULT})
    if(DEFINED ENV{${OPTION_NAME}})
        # Allow overriding the option through an environment variable
        set(${OPTION_NAME} $ENV{${OPTION_NAME}})
    endif()
    if(${OPTION_NAME} AND DEFINE_OPTION)
        add_definitions(-D${OPTION_NAME}=1)
    endif()
    message(STATUS "  ${OPTION_NAME}: ${${OPTION_NAME}}")
endmacro()

# Options
add_option(WINDOWS_CMD "Enable terminal support on Windows" OFF OFF)

# -----------------------------
# Dependencies
# -----------------------------

find_package(PkgConfig REQUIRED)
find_package(Threads REQUIRED)
find_package(glfw3 REQUIRED)

if(TARGET glfw::glfw)
    set(GLFW_TARGET glfw::glfw)
elseif(TARGET glfw)
    set(GLFW_TARGET glfw)
elseif(TARGET glfw3)
    set(GLFW_TARGET glfw3)
else()
    message(FATAL_ERROR "GLFW found but no usable CMake target was exported")
endif()

find_package(OpenGL REQUIRED)
pkg_check_modules(TESSERACT REQUIRED tesseract)
pkg_check_modules(LEPTONICA REQUIRED lept)
pkg_check_modules(ZBAR REQUIRED zbar)

if(UNIX AND NOT APPLE)
    find_package(X11 REQUIRED)
    pkg_check_modules(APPINDICATOR REQUIRED appindicator3-0.1)
    pkg_check_modules(GIO REQUIRED gio-2.0)
    pkg_check_modules(XRANDR REQUIRED xrandr)
endif()

# -----------------------------
# Main executable
# -----------------------------

file(
    GLOB SRC
    src/*.cpp
    src/libs/toml++/toml.cpp
    src/libs/getopt_port/getopt.c
    src/libs/tinyfiledialogs/tinyfiledialogs.c
)

add_executable(${PROJECT_NAME} ${SRC})
enable_lto(${PROJECT_NAME})

execute_process(
    COMMAND ./scripts/generateVersion.sh
    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
)

target_compile_definitions(${PROJECT_NAME} PRIVATE $<$<CONFIG:Debug>:DEBUG=1>)
target_compile_options(
    ${PROJECT_NAME}
    PRIVATE
        $<$<CONFIG:Debug>:-ggdb3;-fno-omit-frame-pointer;-Wall;-Wextra;-pedantic;-Wno-unused-parameter>
)

target_compile_definitions(${PROJECT_NAME} PRIVATE VERSION="${PROJECT_VERSION}")

target_include_directories(
    ${PROJECT_NAME}
    PRIVATE
        include/
        include/libs
        ${TESSERACT_INCLUDE_DIRS}
        ${LEPTONICA_INCLUDE_DIRS}
        ${ZBAR_INCLUDE_DIRS}
)

if(UNIX AND NOT APPLE)
    target_include_directories(
        ${PROJECT_NAME}
        PRIVATE ${APPINDICATOR_INCLUDE_DIRS}
    )
endif()

target_compile_options(
    ${PROJECT_NAME}
    PRIVATE
        ${TESSERACT_CFLAGS_OTHER}
        ${LEPTONICA_CFLAGS_OTHER}
        ${ZBAR_CFLAGS_OTHER}
)

target_link_directories(
    ${PROJECT_NAME}
    PRIVATE
        ${TESSERACT_LIBRARY_DIRS}
        ${LEPTONICA_LIBRARY_DIRS}
        ${ZBAR_LIBRARY_DIRS}
)

target_link_libraries(
    ${PROJECT_NAME}
    PRIVATE
        OpenGL::GL
        ${GLFW_TARGET}
        ${TESSERACT_LIBRARIES}
        ${LEPTONICA_LIBRARIES}
        ${ZBAR_LIBRARIES}
)

if(WIN32)
    target_link_libraries(${PROJECT_NAME} PRIVATE ws2_32 shcore d3d11 dxgi)

    if(NOT WINDOWS_CMD)
        set_target_properties(${PROJECT_NAME} PROPERTIES WIN32_EXECUTABLE TRUE)
    endif()
elseif(APPLE)
    target_compile_options(${PROJECT_NAME} PRIVATE -fobjc-arc $<$<CXX_COMPILER_ID:AppleClang>:-stdlib=libc++>)

    # Add Metal render loop source
    target_sources(${PROJECT_NAME} PRIVATE src/main_tool_metal.mm)

    target_link_options(${PROJECT_NAME} PRIVATE $<$<CXX_COMPILER_ID:AppleClang>:-stdlib=libc++>)
    target_link_libraries(
        ${PROJECT_NAME}
        PRIVATE
            "-framework Metal"
            "-framework QuartzCore"
            "-framework CoreGraphics"
            "-framework Cocoa"
            "-framework IOKit"
            "-framework OpenGL"
    )
elseif(UNIX)
    target_link_libraries(${PROJECT_NAME} PRIVATE X11::X11)
    target_include_directories(
        ${PROJECT_NAME}
        PRIVATE
        SYSTEM
        ${GIO_INCLUDE_DIRS}
        ${XRANDR_INCLUDE_DIRS}
    )
    target_link_libraries(${PROJECT_NAME} PRIVATE ${GIO_LIBRARIES} ${XRANDR_LIBRARIES})
    target_compile_options(${PROJECT_NAME} PRIVATE ${GIO_CFLAGS_OTHER} ${XRANDR_CFLAGS_OTHER})
endif()

# -----------------------------
# fmt library
# -----------------------------

add_library(fmt STATIC src/libs/fmt/os.cc src/libs/fmt/format.cc)

enable_lto(fmt)

target_include_directories(fmt PUBLIC include/libs)
target_compile_features(fmt PUBLIC cxx_std_20)
target_compile_definitions(fmt PUBLIC FMT_HEADER_ONLY=0)

target_link_libraries(${PROJECT_NAME} PRIVATE fmt)

# -----------------------------
# imgui library
# -----------------------------

file(GLOB IMGUI_SOURCES src/libs/imgui/*.cpp)
if(APPLE)
    list(APPEND IMGUI_SOURCES src/libs/imgui/imgui_impl_metal.mm)
endif()

add_library(imgui STATIC ${IMGUI_SOURCES})

enable_lto(imgui)

target_include_directories(imgui PUBLIC include/libs/imgui)
target_compile_definitions(imgui PUBLIC IMGUI_IMPL_OPENGL_LOADER_GLAD)
target_link_libraries(imgui PUBLIC ${GLFW_TARGET})

target_link_libraries(${PROJECT_NAME} PRIVATE imgui)

# -----------------------------
# Tray library (integrated from its own CMakeLists.txt)
# -----------------------------

if(WIN32)
    list(APPEND TRAY_SOURCES src/libs/tray/tray_windows.cpp)
else()
    if(UNIX)
        if(APPLE)
            find_library(COCOA Cocoa REQUIRED)
            list(APPEND TRAY_SOURCES src/libs/tray/tray_darwin.mm)
        else()
            pkg_check_modules(GTK REQUIRED gtk+-3.0)
            list(APPEND TRAY_SOURCES src/libs/tray/tray_linux.cpp)
        endif()
    endif()
endif()

add_library(tray STATIC ${TRAY_SOURCES})

if(WIN32)
    target_compile_definitions(
        tray
        PRIVATE TRAY_WINAPI=1 WIN32_LEAN_AND_MEAN NOMINMAX
    )
    #target_compile_options(tray PRIVATE "/MT$<$<CONFIG:Debug>:d>")
else()
    if(UNIX)
        if(APPLE)
            target_compile_definitions(tray PRIVATE TRAY_APPKIT=1)
            target_link_libraries(tray PRIVATE ${COCOA})
        else()
            target_compile_options(tray PRIVATE ${GTK_CFLAGS})
            target_link_directories(tray PRIVATE ${GTK_LIBRARY_DIRS})
            target_link_libraries(tray PRIVATE ${GTK_LIBRARIES})

            target_compile_options(tray PRIVATE ${APPINDICATOR_CFLAGS})
            target_link_directories(tray PRIVATE ${APPINDICATOR_LIBRARY_DIRS})
            target_compile_definitions(tray PRIVATE TRAY_APPINDICATOR=1)
            target_link_libraries(tray PRIVATE ${APPINDICATOR_LIBRARIES})
        endif()
    endif()
endif()

target_include_directories(tray PUBLIC include/libs)
target_compile_features(tray PRIVATE cxx_std_20)
set_target_properties(
    tray
    PROPERTIES
        CXX_STANDARD 20
        CXX_EXTENSIONS OFF
        CXX_STANDARD_REQUIRED ON
)

target_link_libraries(${PROJECT_NAME} PRIVATE tray)

# -----------------------------
# clip library (integrated from its own CMakeLists.txt)
# -----------------------------

add_library(clip STATIC src/libs/clip/clip.cpp src/libs/clip/image.cpp)

if(WIN32)
    target_sources(
        clip
        PRIVATE
            src/libs/clip/clip_win.cpp
            src/libs/clip/clip_win_bmp.cpp
            src/libs/clip/clip_win_wic.cpp
    )
elseif(APPLE)
    target_sources(clip PRIVATE src/libs/clip/clip_osx.mm)
elseif(UNIX)
    target_sources(clip PRIVATE src/libs/clip/clip_x11.cpp)
endif()

if(MSVC)
    target_compile_definitions(clip PRIVATE _CRT_SECURE_NO_WARNINGS)
    # MinGW requires the windowscodecs just because CLSIDs are defined
    # in the windowscodecs.a file instead of the wincodec.h file (?!)
elseif(MINGW)
    target_link_libraries(clip PUBLIC shlwapi windowscodecs)
endif()

if(UNIX AND NOT APPLE)
    pkg_check_modules(XCB REQUIRED IMPORTED_TARGET xcb)
    pkg_check_modules(LIBPNG REQUIRED IMPORTED_TARGET libpng)
    target_link_libraries(
        clip
        PRIVATE PkgConfig::XCB Threads::Threads PkgConfig::LIBPNG
    )
endif()

target_include_directories(clip PUBLIC include/libs/clip)
target_compile_features(clip PRIVATE cxx_std_20)
target_compile_definitions(clip PUBLIC CLIP_ENABLE_IMAGE=1 CLIP_X11_WITH_PNG=1 HAVE_PNG_H=1)
set_target_properties(
    clip
    PROPERTIES
        CXX_STANDARD 20
        CXX_EXTENSIONS OFF
        CXX_STANDARD_REQUIRED ON
)

target_link_libraries(${PROJECT_NAME} PRIVATE clip)

# -----------------------------
# tiny-process-library (integrated from its own CMakeLists.txt)
# -----------------------------

add_library(
    tiny-process-library
    STATIC
    "src/libs/tiny-process-library/process.cpp"
)
add_library(
    tiny-process-library::tiny-process-library
    ALIAS tiny-process-library
)

if(MSVC)
    target_compile_definitions(
        tiny-process-library
        PRIVATE _CRT_SECURE_NO_WARNINGS
    )
else()
    target_compile_options(tiny-process-library PRIVATE -Wall -Wextra)
    target_compile_features(tiny-process-library PRIVATE cxx_std_20)
endif()

if(WIN32)
    set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
    target_sources(
        tiny-process-library
        PRIVATE "src/libs/tiny-process-library/process_win.cpp"
    )
    # If compiled using MSYS2, use sh to run commands
    if(MSYS)
        target_compile_definitions(
            tiny-process-library
            PUBLIC MSYS_PROCESS_USE_SH
        )
    endif()
else()
    target_sources(
        tiny-process-library
        PRIVATE "src/libs/tiny-process-library/process_unix.cpp"
    )
endif()

target_link_libraries(tiny-process-library Threads::Threads)
target_include_directories(
    tiny-process-library
    PUBLIC include/libs/tiny-process-library
)
enable_lto(tiny-process-library)
target_link_libraries(${PROJECT_NAME} PRIVATE tiny-process-library)

# -----------------------------
# Install
# -----------------------------

install(TARGETS ${PROJECT_NAME}
    RUNTIME DESTINATION bin
    COMPONENT runtime
)

install(
    PROGRAMS launcher/${PROJECT_NAME}_launcher.py
    DESTINATION bin
    RENAME ${PROJECT_NAME}-launcher
)

install(
    FILES LICENSE
    DESTINATION share/licenses/${PROJECT_NAME}
    COMPONENT documentation
)