315 lines
8.4 KiB
CMake
315 lines
8.4 KiB
CMake
# -*- mode: cmake -*-
|
|
#Cmakelists.txt
|
|
# Minimum version of CMake
|
|
cmake_minimum_required(VERSION 2.6)
|
|
if(COMMAND cmake_policy)
|
|
cmake_policy(VERSION 2.6)
|
|
endif()
|
|
|
|
CONFIGURE_FILE(
|
|
"${CMAKE_CURRENT_SOURCE_DIR}/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")
|
|
|
|
# Source dir
|
|
set(SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
|
|
set(BUILD_DIR ${CMAKE_CURRENT_BINARY_DIR})
|
|
|
|
#set(CMAKE_BUILD_TYPE RELEASE)
|
|
option(WITH_LOGOS "install wmfs logos")
|
|
option(GENERATE_MANPAGES "generate manpages" ON)
|
|
|
|
# Project name - wmfs
|
|
set(PROJECT_NAME wmfs)
|
|
set(PROJECT_NAME_SHELL wmfs-shell)
|
|
project(${PROJECT_NAME} C)
|
|
|
|
# Definition of the wmfs source
|
|
set(wmfs_src
|
|
src/barwin.c
|
|
src/client.c
|
|
src/config.c
|
|
src/draw.c
|
|
src/event.c
|
|
src/ewmh.c
|
|
src/frame.c
|
|
src/infobar.c
|
|
src/init.c
|
|
src/launcher.c
|
|
src/layout.c
|
|
src/menu.c
|
|
src/mouse.c
|
|
src/screen.c
|
|
src/tag.c
|
|
src/util.c
|
|
src/wmfs.c)
|
|
set(wmfs-shell_src
|
|
shell/wmfs-shell.c)
|
|
|
|
# Set the executable from the wmfs_src
|
|
add_executable(wmfs ${wmfs_src})
|
|
add_executable(wmfs-shell ${wmfs-shell_src})
|
|
|
|
# Set the version - NOT USED AT THE MOMENT
|
|
set(VERSION "0.1rc4 (On The Run)")
|
|
|
|
# FLAGS
|
|
set(CFLAGS "-g -Wall")
|
|
set(CMAKE_C_FLAGS ${CFLAGS})
|
|
set(LDFLAGS "-L /usr/local/lib")
|
|
set_target_properties(wmfs PROPERTIES LINK_FLAGS ${LDFLAGS})
|
|
# Includes dir for libs in build_dir
|
|
include_directories(
|
|
${BUILD_DIR}/src
|
|
)
|
|
|
|
# Package find
|
|
find_package(Freetype)
|
|
if(FREETYPE_FOUND)
|
|
include_directories(${FREETYPE_INCLUDE_DIRS})
|
|
else (FREETYPE_FOUND)
|
|
message(FATAL_ERROR "Could not find Freetype")
|
|
endif (FREETYPE_FOUND)
|
|
|
|
find_package(X11)
|
|
if(X11_FOUND)
|
|
include_directories(${X11_INCLUDE_DIR})
|
|
else (X11_FOUND)
|
|
message(FATAL_ERROR "Could not find X11")
|
|
endif (X11_FOUND)
|
|
|
|
# Link Libraries
|
|
set(LIBRARIES_TO_LINK
|
|
${FREETYPE_LIBRARIES}
|
|
${X11_LIBRARIES}
|
|
confuse
|
|
Xft
|
|
Xinerama)
|
|
set(SHELL_LINK_LIBS
|
|
${X11_LIBRARIES})
|
|
|
|
target_link_libraries(wmfs ${LIBRARIES_TO_LINK})
|
|
target_link_libraries(wmfs-shell ${SHELL_LINK_LIBS})
|
|
|
|
# Messages
|
|
message("Project version: ${VERSION}")
|
|
message("Using these CFLAGS: ${CFLAGS}")
|
|
message("Using these LDFLAGS: ${LDFLAGS}")
|
|
message("Linking with theses libraries : ${LIBRARIES_TO_LINK}")
|
|
|
|
# Includes
|
|
include(FindDoxygen)
|
|
include(FindPkgConfig)
|
|
|
|
# Use pkgconfig to get required libraries
|
|
pkg_check_modules(wmfs_required
|
|
x11
|
|
libconfuse
|
|
freetype2
|
|
xinerama
|
|
xft)
|
|
|
|
# Find exterbal programs
|
|
macro(a_find_program var prg req)
|
|
set(required ${req})
|
|
find_program(${var} ${prg})
|
|
if(NOT ${var})
|
|
message(STATUS "${prg} not found.")
|
|
if(required)
|
|
message(FATAL_ERROR "${prg} is required to build wmfs")
|
|
endif()
|
|
else()
|
|
message(STATUS "${prg} -> ${${var}}")
|
|
endif()
|
|
endmacro()
|
|
find_program(GIT_EXECUTABLE git)
|
|
|
|
# programs needed for man pages
|
|
a_find_program(ASCIIDOC_EXECUTABLE asciidoc FALSE)
|
|
a_find_program(XMLTO_EXECUTABLE xmlto FALSE)
|
|
a_find_program(GZIP_EXECUTABLE gzip FALSE)
|
|
a_find_program(CAT_EXECUTABLE cat TRUE)
|
|
|
|
# Generating CHANGELOG
|
|
|
|
if(EXISTS ${SOURCE_DIR}/.git/HEAD AND GIT_EXECUTABLE)
|
|
|
|
# generate
|
|
message("Git dir -- Generating changelog...")
|
|
execute_process(
|
|
COMMAND ${GIT_EXECUTABLE} log
|
|
WORKING_DIRECTORY ${SOURCE_DIR}
|
|
OUTPUT_VARIABLE WMFS_CHANGELOG
|
|
)
|
|
set(CHANGELOG_FILE ${SOURCE_DIR}/CHANGELOG)
|
|
file(WRITE ${CHANGELOG_FILE} ${WMFS_CHANGELOG})
|
|
|
|
else()
|
|
|
|
message("Non-Git dir -- Generating fake changelog")
|
|
execute_process(
|
|
COMMAND touch ${SOURCE_DIR}/CHANGELOG
|
|
)
|
|
|
|
endif()
|
|
|
|
# {{{ Check if documentation can be build
|
|
if(GENERATE_MANPAGES)
|
|
if(NOT ASCIIDOC_EXECUTABLE OR NOT XMLTO_EXECUTABLE OR NOT GZIP_EXECUTABLE)
|
|
if(NOT ASCIIDOC_EXECUTABLE)
|
|
SET(missing "asciidoc")
|
|
endif()
|
|
if(NOT XMLTO_EXECUTABLE)
|
|
SET(missing ${missing} " xmlto")
|
|
endif()
|
|
if(NOT GZIP_EXECUTABLE)
|
|
SET(missing ${missing} " gzip")
|
|
endif()
|
|
|
|
message(STATUS "Not generating manpages. Missing: " ${missing})
|
|
set(GENERATE_MANPAGES OFF)
|
|
endif()
|
|
endif()
|
|
|
|
# sets
|
|
# {{{ Install path and configuration variables
|
|
if(DEFINED PREFIX)
|
|
set(PREFIX ${PREFIX} CACHE PATH "install prefix")
|
|
set(CMAKE_INSTALL_PREFIX ${PREFIX})
|
|
else()
|
|
set(PREFIX ${CMAKE_INSTALL_PREFIX} CACHE PATH "install prefix")
|
|
endif()
|
|
|
|
#If a sysconfdir is specified, use it instead
|
|
#of the default configuration dir.
|
|
if(DEFINED SYSCONFDIR)
|
|
set(SYSCONFDIR ${SYSCONFDIR} CACHE PATH "config directory")
|
|
else()
|
|
set(SYSCONFDIR /etc CACHE PATH "config directory")
|
|
endif()
|
|
|
|
#If an XDG Config Dir is specificed, use it instead
|
|
#of the default XDG configuration dir.
|
|
if(DEFINED XDG_CONFIG_DIR)
|
|
set(XDG_CONFIG_DIR ${XDG_CONFIG_SYS} CACHE PATH "xdg config directory")
|
|
else()
|
|
set(XDG_CONFIG_DIR ${SYSCONFDIR}/xdg CACHE PATH "xdg config directory")
|
|
endif()
|
|
|
|
# setting WMFS_XSESSION_PATH
|
|
if(DEFINED WMFS_XSESSION_PATH)
|
|
set(WMFS_XSESSION_PATH ${WMFS_XSESSION_PATH} CACHE PATH "wmfs xsessions directory")
|
|
else()
|
|
set(WMFS_XSESSION_PATH ${PREFIX}/share/xsessions CACHE PATH "wmfs xsessions directory")
|
|
endif()
|
|
|
|
# set man path
|
|
set(WMFS_MAN_SRCS
|
|
${SOURCE_DIR}/wmfs.1.txt)
|
|
|
|
if(DEFINED WMFS_MAN_PATH)
|
|
set(WMFS_MAN_PATH ${WMFS_MAN_PATH} CACHE PATH "wmfs manpage directory")
|
|
else()
|
|
set(WMFS_MAN_PATH ${PREFIX}/share/man CACHE PATH "wmfs manpage directory")
|
|
endif()
|
|
|
|
# {{{ Manpages
|
|
if(GENERATE_MANPAGES)
|
|
foreach(txtfile ${WMFS_MAN_SRCS})
|
|
string(REGEX REPLACE ".txt\$" ".xml" xmlfile ${txtfile})
|
|
string(REPLACE ${SOURCE_DIR}
|
|
${BUILD_DIR} xmlfile ${xmlfile})
|
|
string(REGEX REPLACE ".xml\$" ".gz" gzfile ${xmlfile})
|
|
string(REGEX REPLACE ".gz\$" "" manfile ${gzfile})
|
|
|
|
add_custom_command(
|
|
COMMAND ${CAT_EXECUTABLE} ${txtfile}
|
|
| ${ASCIIDOC_EXECUTABLE} -d manpage -b docbook -o ${xmlfile} -
|
|
WORKING_DIRECTORY ${BUILD_DIR}
|
|
OUTPUT ${xmlfile}
|
|
DEPENDS ${txtfile}
|
|
VERBATIM)
|
|
add_custom_command(
|
|
COMMAND ${XMLTO_EXECUTABLE} man ${xmlfile}
|
|
OUTPUT ${manfile}
|
|
DEPENDS ${xmlfile})
|
|
add_custom_command(
|
|
COMMAND ${CAT_EXECUTABLE} ${manfile}
|
|
| ${GZIP_EXECUTABLE}
|
|
> ${gzfile}
|
|
OUTPUT ${gzfile}
|
|
DEPENDS ${manfile}
|
|
VERBATIM)
|
|
|
|
set(MAN_FILES ${MAN_FILES} ${gzfile})
|
|
|
|
# figure out in what section to install to from filename
|
|
string(REGEX REPLACE "^.*\\.([0-9])\\.gz\$" "\\1" section ${gzfile})
|
|
set(WMFS_MAN${section}_FILES ${WMFS_MAN${section}_FILES} ${gzfile})
|
|
endforeach()
|
|
|
|
add_custom_target(man ALL DEPENDS ${MAN_FILES})
|
|
endif()
|
|
# }}}
|
|
|
|
# {{ Doxygen
|
|
if(DOXYGEN_EXECUTABLE)
|
|
add_custom_target(doc
|
|
COMMAND ${DOXYGEN_EXECUTABLE} ${SOURCE_DIR}/wmfs.doxygen
|
|
WORKING_DIRECTORY ${BUILD_DIR})
|
|
endif()
|
|
# }}
|
|
|
|
# Remplace strings in configs
|
|
set(WMFS_VERSION ${VERSION})
|
|
set(WMFS_COMPILE_MACHINE ${CMAKE_SYSTEM_PROCESSOR})
|
|
set(WMFS_COMPILE_BY $ENV{USER})
|
|
set(WMFS_COMPILE_FLAGS ${CFLAGS})
|
|
set(WMFS_LINKED_LIBS ${LIBRARIES_TO_LINK})
|
|
set(WMFS_SYSCONFDIR ${XDG_CONFIG_DIR}/${PROJECT_NAME})
|
|
set(WMFS_SOURCE_DIR ${SOURCE_DIR})
|
|
|
|
# Configure files
|
|
set(wmfs_configure_files
|
|
src/config.h.in
|
|
wmfs.1.txt.in
|
|
wmfs.doxygen.in)
|
|
|
|
macro(a_configure_file file)
|
|
string(REGEX REPLACE ".in\$" "" outfile ${file})
|
|
message(STATUS "Configuring ${outfile}")
|
|
configure_file(${SOURCE_DIR}/${file}
|
|
${SOURCE_DIR}/${outfile}
|
|
ESCAPE_QUOTE
|
|
@ONLY)
|
|
endmacro()
|
|
|
|
foreach(file ${wmfs_configure_files})
|
|
a_configure_file(${file})
|
|
endforeach()
|
|
|
|
set(PROJECT_DATA_PATH share/${PROJECT_NAME})
|
|
set(PROJECT_TODO ${SOURCE_DIR}/TODO)
|
|
set(PROJECT_README ${SOURCE_DIR}/README)
|
|
set(PROJECT_CHANGELOG ${SOURCE_DIR}/CHANGELOG)
|
|
set(PROJECT_DEFAULT_CONF ${SOURCE_DIR}/wmfsrc)
|
|
|
|
# installs
|
|
install(TARGETS ${PROJECT_NAME} ${PROJECT_NAME_SHELL} RUNTIME DESTINATION bin)
|
|
if(WITH_LOGOS)
|
|
set(PROJECT_LOGOS ${PROJECT_DATA_PATH}/logos)
|
|
set(PROJECT_LOGOS_DIR ${SOURCE_DIR}/logos)
|
|
install(DIRECTORY ${PROJECT_LOGOS_DIR} DESTINATION ${PROJECT_DATA_PATH})
|
|
message("Install With logos")
|
|
endif()
|
|
if(GENERATE_MANPAGES)
|
|
install(FILES ${WMFS_MAN1_FILES} DESTINATION ${WMFS_MAN_PATH}/man1)
|
|
endif()
|
|
install(FILES ${PROJECT_TODO} ${PROJECT_README} ${PROJECT_CHANGELOG}
|
|
${PROJECT_DEFAULT_CONF} DESTINATION ${PROJECT_DATA_PATH})
|
|
install(FILES ${PROJECT_DEFAULT_CONF} DESTINATION ${WMFS_SYSCONFDIR})
|
|
install(FILES "wmfs.desktop" DESTINATION ${WMFS_XSESSION_PATH})
|