HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r0:5cbbc595e8f3

Initialisation de l'archi cmake

perrinel -

r0:5cbbc595e8f3

parent child

Context file:

r0:5cbbc595e8f3

.gitignore created 644 +2 0

@@ -0,0 +1,2
	1	build/
	2	CMakeLists.txt.user No newline at end of file

CMakeLists.txt created 644 +11 0

@@ -0,0 +1,11
	1
	2
	3	## Main CMakeLists for SCIQLOP
	4	CMAKE_MINIMUM_REQUIRED (VERSION 2.8.12)
	5
	6	PROJECT(SCIQLOP)
	7
	8	#
	9	# build the project
	10	#
	11	INCLUDE("cmake/sciqlop.cmake") No newline at end of file

LICENSE created 644 +1 0

	@@ -0,0 +1,1
				1	TODO

README.md created 644 +1 0

	@@ -0,0 +1,1
				1	TODO No newline at end of file

cmake/compiler/compiler.cmake created 644 +11 0

@@ -0,0 +1,11
	1	#
	2	# compiler.cmake : configure the compilation flags
	3	#
	4
	5	IF(${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU")
	6	INCLUDE("cmake/compiler/compiler_gnu.cmake")
	7	ELSEIF(${CMAKE_CXX_COMPILER_ID} STREQUAL "MSVC")
	8	INCLUDE("cmake/compiler/compiler_msvc.cmake")
	9	ELSE()
	10	MESSAGE(FATAL_ERROR "Compiler not supported")
	11	ENDIF()

cmake/compiler/compiler_gnu.cmake created 644 +18 0

@@ -0,0 +1,18
	1	#
	2	# compiler_gnu.cmake : specific configuration for GNU compilers
	3	#
	4
	5	# Set the flag -Wall to activate all warnings
	6	IF (${CMAKE_BUILD_TYPE} STREQUAL Debug)
	7	SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wall -std=c++14")
	8	SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wall")
	9
	10	SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_DEBUG}")
	11	SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${CMAKE_C_FLAGS_DEBUG}")
	12	ELSE()
	13	SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -Wall -O2 -std=c++14")
	14	SET(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -Wall -O2")
	15
	16	SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_RELEASE}")
	17	SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${CMAKE_C_FLAGS_RELEASE}")
	18	ENDIF()

cmake/compiler/compiler_msvc.cmake created 644 +7 0

@@ -0,0 +1,7
	1	#
	2	# compiler_msvc.cmake : specific configuration for MSVC compilers
	3	#
	4
	5	ADD_DEFINITIONS( /D _USE_MATH_DEFINES)
	6	ADD_DEFINITIONS( /D _VARIADIC_MAX=10 )
	7	ADD_DEFINITIONS( /D _CRT_SECURE_NO_WARNINGS)

cmake/find_libs.cmake created 644 +30 0

@@ -0,0 +1,30
	1	#
	2	# findslibs.cmake
	3	#
	4
	5	#
	6	# Qt
	7	#
	8	# Find Qt here so that a message is displayed in the console when executing
	9	# cmake, but each application must call SCIQLOP_FIND_QT() to load the Qt modules that
	10	# it needs.
	11	FIND_PACKAGE(Qt5Core REQUIRED)
	12	FIND_PACKAGE(Qt5Test REQUIRED)
	13	FIND_PACKAGE(Qt5Gui REQUIRED)
	14
	15	#
	16	# doxygen tools
	17	#
	18	FIND_PACKAGE(Doxygen)
	19
	20	#
	21	# Cppcheck tool
	22	#
	23	FIND_PACKAGE(cppcheck)
	24
	25	#
	26	# Formatting tools
	27	#
	28	LIST( APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/formatting/cmake")
	29	FIND_PACKAGE(vera++)
	30	FIND_PACKAGE(ClangFormat)

cmake/sciqlop.cmake created 644 +39 0

@@ -0,0 +1,39
	1	#
	2	# sciqlop.cmake
	3	#
	4
	5	#
	6	# Update the CMAKE_MODULE_PATH to use custom FindXXX files
	7	#
	8	LIST( APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/CMakeModules/")
	9
	10	# Include the sciqlop version file
	11	INCLUDE("cmake/sciqlop_version.cmake")
	12
	13	# Include the sciqlop cmake macros
	14	INCLUDE("cmake/sciqlop_macros.cmake")
	15
	16	#
	17	# Define the project parameters
	18	#
	19	INCLUDE("cmake/sciqlop_params.cmake")
	20
	21	#
	22	# Configure the compiler
	23	#
	24	INCLUDE("cmake/compiler/compiler.cmake")
	25
	26	#
	27	# Find all necessary dependencies
	28	#
	29	INCLUDE("cmake/find_libs.cmake")
	30
	31	#
	32	# Compile all applications
	33	#
	34	INCLUDE("cmake/sciqlop_applications.cmake")
	35
	36	#
	37	# Package creation using CPack
	38	#
	39	INCLUDE("cmake/sciqlop_package.cmake")

cmake/sciqlop_applications.cmake created 644 +38 0

@@ -0,0 +1,38
	1	#
	2	# Sciqlop_modules.cmake
	3	#
	4	# Set ouptut directories
	5	#
	6	SET (EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR}/dist/${CMAKE_BUILD_TYPE})
	7	SET (LIBRARY_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR}/dist/${CMAKE_BUILD_TYPE})
	8
	9
	10	#
	11	# Compile the core
	12	#
	13	ADD_SUBDIRECTORY("${CMAKE_SOURCE_DIR}/sqpcore")
	14
	15	#
	16	# Compile the gui
	17	#
	18	ADD_SUBDIRECTORY("${CMAKE_SOURCE_DIR}/sqpgui")
	19
	20	#
	21	# Compile the app
	22	#
	23	ADD_SUBDIRECTORY("${CMAKE_SOURCE_DIR}/sqpapp")
	24
	25	#
	26	# Code formatting
	27	#
	28	INCLUDE ("cmake/sciqlop_formatting.cmake")
	29
	30	#
	31	# Documentation generation
	32	#
	33	INCLUDE ("cmake/sciqlop_doxygen.cmake")
	34
	35	#
	36	# Source code analysis
	37	#
	38	INCLUDE ("cmake/sciqlop_code_analysis.cmake")

cmake/sciqlop_code_analysis.cmake created 644 +52 0

@@ -0,0 +1,52
	1	#
	2	# sciqlop_code_analysis.cmake
	3
	4	# Launch code source analysis with cppcheck. Can be activated with the
	5	# ANALYZE_CODE option.
	6	#
	7	# The following CACHE variables are available:
	8	# * CPPCHECK_EXTRA_ARGS: extra arguments for cppcheck;
	9	# * CPPCHECK_OUTPUT: path to the xml report of cppcheck.
	10	#
	11	# The following variables are used (must be set by the cmake file calling this
	12	# one):
	13	# * ANALYSIS_INPUT_DIRS: directories to analyze;
	14	# * ANALYSIS_EXCLUDE_DIRS: directories to exclude from the analysis.
	15	#
	16
	17	#
	18	# Analyze the source code with cppcheck
	19	#
	20	OPTION (ANALYZE_CODE "Analyze the source code with cppcheck" ON)
	21	IF (ANALYZE_CODE)
	22
	23	# Make sure cppcheck has been found, otherwise the source code can't be
	24	# analyzed
	25	IF (CPPCHECK_FOUND)
	26	SET (CPPCHECK_EXTRA_ARGS --inline-suppr --xml --enable=style --force -v
	27	CACHE STRING "Extra arguments for cppcheck")
	28	MARK_AS_ADVANCED (CPPCHECK_EXTRA_ARGS)
	29
	30	SET (CPPCHECK_OUTPUT "${CMAKE_BINARY_DIR}/cppcheck-report.xml"
	31	CACHE STRING "Output file for the cppcheck report")
	32	MARK_AS_ADVANCED (CPPCHECK_OUTPUT)
	33
	34	SET (CPPCHECK_EXCLUDE_DIRS)
	35	FOREACH (dir ${ANALYSIS_EXCLUDE_DIRS})
	36	LIST (APPEND CPPCHECK_EXCLUDE_DIRS "-i${dir}")
	37	ENDFOREACH ()
	38
	39	# Add the analyze target to launch cppcheck
	40	ADD_CUSTOM_TARGET (analyze
	41	COMMAND
	42	${CPPCHECK_EXECUTABLE}
	43	${CPPCHECK_EXTRA_ARGS}
	44	${ANALYSIS_INPUT_DIRS}
	45	${CPPCHECK_EXCLUDE_DIRS}
	46	2> ${CPPCHECK_OUTPUT}
	47	)
	48
	49	ELSE (CPPCHECK_FOUND)
	50	MESSAGE (STATUS "The source code won't be analyzed - Cppcheck not found")
	51	ENDIF (CPPCHECK_FOUND)
	52	ENDIF (ANALYZE_CODE)

cmake/sciqlop_doxygen.cmake created 644 +110 0

@@ -0,0 +1,110
	1	#
	2	# sciqlop_doxygen.cmake
	3	#
	4	# Launch doxygen generation. Can be activated with the BUILD_DOCUMENTATION
	5	# option.
	6	#
	7	# The following CACHE variables are available:
	8	# * DOXYGEN_LANGUAGE: Documentation language;
	9	#
	10	# The following variables are used (must be set by the cmake file calling this
	11	# one):
	12	# * DOXYGEN_INPUT_DIRS: directories to document;
	13	# * DOXYGEN_EXCLUDE_PATTERNS: directories to exclude from the documentation
	14	# generation.
	15	#
	16
	17	#
	18	# Compile the doxygen documentation
	19	#
	20	OPTION (BUILD_DOCUMENTATION "Build the doxygen-based documentation" ON)
	21	IF (BUILD_DOCUMENTATION)
	22
	23	# Make sure Doxygen is on the system, if not then the documentation can't be built
	24	IF (DOXYGEN_FOUND)
	25
	26	# Append the global docs directory to the list of input directories
	27	LIST (APPEND DOXYGEN_INPUT_DIRS "${CMAKE_SOURCE_DIR}/docs")
	28	LIST (APPEND DOXYGEN_INPUT_DIRS "${CMAKE_BINARY_DIR}/gendocs")
	29
	30	# Exclude the "*_private.h" files by default
	31	list(APPEND DOXYGEN_EXCLUDE_PATTERNS "*_private.h")
	32	# Exclude cpp files
	33	list(APPEND DOXYGEN_EXCLUDE_PATTERNS "*.cpp")
	34
	35	# Set the variables used by the Doxyfile template
	36	SET (PROJECT_NAME "${CMAKE_PROJECT_NAME}")
	37	SET (INPUT_DIRECTORIES)
	38	FOREACH (dir ${DOXYGEN_INPUT_DIRS})
	39	SET (INPUT_DIRECTORIES "${INPUT_DIRECTORIES}\\ \n \"${dir}\" ")
	40	ENDFOREACH ()
	41	SET (EXCLUDE_PATTERNS)
	42	FOREACH (pattern ${DOXYGEN_EXCLUDE_PATTERNS})
	43	SET (EXCLUDE_PATTERNS "${EXCLUDE_PATTERNS}\\ \n \"${pattern}\" ")
	44	ENDFOREACH ()
	45
	46	SET (INDEX_LIST_MODULES "<ul>\n")
	47	FOREACH(module ${ENABLED_MODULE_LIST})
	48	SET (INDEX_LIST_MODULES "${INDEX_LIST_MODULES}<li>[${module}](@ref ${module})</li>\n")
	49	ENDFOREACH()
	50	SET (INDEX_LIST_MODULES "${INDEX_LIST_MODULES}</ul>\n")
	51
	52	# This is the doxyfile that will be used to generate the documentation
	53	# You can use programs like doxywizard to edit the settings
	54	SET (doxygenConfigFileIn "${CMAKE_SOURCE_DIR}/docs/Doxyfile.dox.in")
	55	SET (doxygenConfigFile "${CMAKE_BINARY_DIR}/Doxyfile.dox")
	56
	57	SET (DOXYGEN_LANGUAGE "English" CACHE STRING "Documentation language")
	58	MARK_AS_ADVANCED (DOXYGEN_LANGUAGE)
	59
	60	SET (doxygenIndexFileIn "${CMAKE_SOURCE_DIR}/docs/index.md.in")
	61	SET (doxygenIndexFile "${CMAKE_BINARY_DIR}/gendocs/index.md")
	62
	63	# Using a .in file means we can use CMake to insert project settings
	64	# into the doxyfile. For example, CMake will replace @PROJECT_NAME@ in
	65	# a configured file with the CMake PROJECT_NAME variable's value.
	66
	67
	68	CONFIGURE_FILE (${doxygenConfigFileIn} ${doxygenConfigFile} @ONLY)
	69	CONFIGURE_FILE (${doxygenIndexFileIn} ${doxygenIndexFile} @ONLY)
	70
	71	# Add the documentation target. This lets you run "make docs" from the
	72	# generated CMake makefiles
	73	ADD_CUSTOM_TARGET (docs
	74	${DOXYGEN_EXECUTABLE} ${doxygenConfigFile}
	75	DEPENDS ${doxygenConfigFile}
	76	WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
	77	VERBATIM)
	78
	79	# You can add an "install" directive to install the resulting documentation
	80	# if desired.
	81	INSTALL(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/documentation/html DESTINATION ${INSTALL_DOCUMENTATION_DIR} OPTIONAL COMPONENT binaries)
	82
	83	# Add a custom command to archive the current HTML documentation generated
	84	# by doxygen
	85	set(ARCHIVED_HTML_OUTPUT_FILE_NAME "${PROJECT_NAME}-${SCIQLOP_VERSION}-documentation-html.tar.bz2")
	86	add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/documentation/${ARCHIVED_HTML_OUTPUT_FILE_NAME}
	87	COMMAND sh -c "tar --bzip2 -cf ${ARCHIVED_HTML_OUTPUT_FILE_NAME} html"
	88	DEPENDS docs
	89	WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/documentation)
	90	# Add a custom target to execute the above command
	91	add_custom_target(htmldocs DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/documentation/${ARCHIVED_HTML_OUTPUT_FILE_NAME})
	92
	93	# Add a custom command to execute pdflatex on the latex documentation
	94	# generated by doxygen
	95	set(LATEX_OUTPUT_FILE_NAME "${PROJECT_NAME}-${SCIQLOP_VERSION}-documentation.pdf")
	96	add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/documentation/${LATEX_OUTPUT_FILE_NAME}
	97	COMMAND make
	98	COMMAND cp refman.pdf ../${LATEX_OUTPUT_FILE_NAME}
	99	DEPENDS docs
	100	WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/documentation/latex)
	101	# Add a custom target to execute the above command
	102	add_custom_target(latexdocs DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/documentation/${LATEX_OUTPUT_FILE_NAME})
	103
	104	# Add a custom target to execute all the docs commands
	105	add_custom_target(alldocs DEPENDS htmldocs latexdocs)
	106
	107	ELSE (DOXYGEN_FOUND)
	108	MESSAGE (STATUS "Documentation will not be built - Doxygen not found")
	109	ENDIF (DOXYGEN_FOUND)
	110	ENDIF (BUILD_DOCUMENTATION)

cmake/sciqlop_formatting.cmake created 644 +53 0

@@ -0,0 +1,53
	1	#
	2	# sciqlop_formatting.cmake
	3	#
	4	# Launch code formatting tools. Can be activated with ENABLE_FORMATTING and
	5	# ENABLE_CHECKSTYLE options.
	6	#
	7	# The following variables are used (must be set by the cmake file calling this
	8	# one):
	9	# * FORMATTING_INPUT_FILES: list of files to format;
	10	# * CHECKSTYLE_INPUT_FILES: list of files to check for style;
	11	# * CHECKSTYLE_EXCLUSION_FILES: list of vera++ exclusion files.
	12	#
	13
	14	OPTION (ENABLE_FORMATTING "Format the source code while compiling" ON)
	15	OPTION (ENABLE_CHECKSTYLE "Analyse the style of the code while compiling" ON)
	16
	17	IF (ENABLE_FORMATTING)
	18	IF (CLANGFORMAT_FOUND)
	19	INCLUDE(${CLANGFORMAT_USE_FILE})
	20
	21	ADD_CLANGFORMAT_TARGETS(${FORMATTING_INPUT_FILES}
	22	ADD_TO_ALL)
	23	ELSE()
	24	MESSAGE (STATUS "Source code will not be formatted - clang-format not found")
	25	ENDIF()
	26	ENDIF()
	27
	28	IF (ENABLE_CHECKSTYLE)
	29	IF (VERA++_FOUND)
	30	INCLUDE(${VERA++_USE_FILE})
	31
	32	SET(EXCLUSIONS)
	33	FOREACH (e ${CHECKSTYLE_EXCLUSION_FILES})
	34	LIST(APPEND EXCLUSIONS EXCLUSION ${e})
	35	ENDFOREACH()
	36
	37	ADD_VERA_TARGETS(${CHECKSTYLE_INPUT_FILES}
	38	ADD_TO_ALL
	39	PROFILE "sciqlop"
	40	ROOT "${CMAKE_SOURCE_DIR}/formatting/vera-root"
	41	PARAMETER "project-name=${PROJECT_NAME}"
	42	${EXCLUSIONS})
	43
	44	ADD_VERA_CHECKSTYLE_TARGET(${CHECKSTYLE_INPUT_FILES}
	45	PROFILE "sciqlop"
	46	ROOT "${CMAKE_SOURCE_DIR}/formatting/vera-root"
	47	PARAMETER "project-name=${PROJECT_NAME}"
	48	${EXCLUSIONS})
	49
	50	ELSE()
	51	MESSAGE (STATUS "Source code will not be checkstyled - vera++ not found")
	52	ENDIF()
	53	ENDIF()

cmake/sciqlop_macros.cmake created 644 +191 0

@@ -0,0 +1,191
	1	#
	2	# sciqlop_macros.cmake
	3	#
	4	# The following functions or macros are defined in this document:
	5	# - SUBDIRLIST
	6	# - SCIQLOP_SET_TO_PARENT_SCOPE
	7	# - SCIQLOP_PROCESS_EXTERN_DEPENDENCIES
	8	# - SCIQLOP_COPY_TO_TARGET
	9	# - SCIQLOP_READ_FILE
	10	# - SCIQLOP_FIND_QT
	11	# - SCIQLOP_ADD_EXTERN_DEPENDENCY
	12
	13	#
	14	# Define a macro to retrieve all subdirectory names of a specific directory
	15	#
	16	MACRO(SUBDIRLIST result curdir)
	17	FILE(GLOB children RELATIVE ${curdir} ${curdir}/*)
	18	SET(dirlist "")
	19	FOREACH(child ${children})
	20	IF(IS_DIRECTORY ${curdir}/${child})
	21	LIST(APPEND dirlist ${child})
	22	ENDIF()
	23	ENDFOREACH()
	24	SET(${result} ${dirlist})
	25	ENDMACRO()
	26
	27	# SCIQLOP_SET_TO_PARENT_SCOPE(variable)
	28	#
	29	# Set the given variable to the parent scope.
	30	#
	31	MACRO (SCIQLOP_SET_TO_PARENT_SCOPE variable)
	32	SET(${variable} ${${variable}} PARENT_SCOPE)
	33	ENDMACRO (SCIQLOP_SET_TO_PARENT_SCOPE)
	34
	35	MACRO(SCIQLOP_FIND_QT)
	36	# Find includes in corresponding build directories
	37	set(CMAKE_INCLUDE_CURRENT_DIR ON)
	38	# Instruct CMake to run moc automatically when needed.
	39	set(CMAKE_AUTOMOC ON)
	40
	41	# Find Qt5 and the modules asked
	42	FOREACH(component ${ARGN})
	43	FIND_PACKAGE(Qt5${component} QUIET REQUIRED)
	44	INCLUDE_DIRECTORIES(${Qt5${component}_INCLUDE_DIRS})
	45	ENDFOREACH(component)
	46	ENDMACRO(SCIQLOP_FIND_QT)
	47
	48	# SCIQLOP_PROCESS_EXTERN_DEPENDENCIES(externFile externLibraries externSharedLibraries)
	49	#
	50	# Process the dependencies file for the modules. Each line of this file must
	51	# contain the parameters to pass to the FIND_PACKAGE function. This function
	52	# will append the libraries of the extern dependency found to the variable
	53	# passed as a second parameter, and add the include directories of the extern
	54	# dependency to the global include directories. Moreover, the extern shared
	55	# libraries are stored in the variable passed as a third parameter. These shared
	56	# libraries can then be copied to a target output path by using the
	57	# SCIQLOP_COPY_TO_TARGET function.
	58	#
	59	# Examples:
	60	#
	61	# SCIQLOP_PROCESS_MODULE_DEPENDENCIES("path/to/extern.dependencies"
	62	# EXTERN_LIBRARIES
	63	# EXTERN_SHARED_LIBRARIES)
	64	#
	65	FUNCTION (SCIQLOP_PROCESS_EXTERN_DEPENDENCIES externFile librariesVar sharedLibrariesVar)
	66
	67	SCIQLOP_READ_FILE(${externFile} externDependencies)
	68	SET (externLibraries)
	69	SET (externSharedLibraries)
	70	FOREACH (externDependency ${externDependencies})
	71	# Check if the line is a comment (begins with #)
	72	STRING(REGEX MATCH "^ #.$" matched "${externDependency}")
	73	IF (NOT matched)
	74	STRING(REGEX REPLACE " +" ";" externDependency "${externDependency}")
	75	SCIQLOP_ADD_EXTERN_DEPENDENCY(externLibraries externSharedLibraries ${externDependency})
	76	ENDIF()
	77	ENDFOREACH()
	78
	79	LIST (APPEND ${librariesVar} ${externLibraries})
	80	SCIQLOP_SET_TO_PARENT_SCOPE(${librariesVar})
	81
	82	LIST (APPEND ${sharedLibrariesVar} ${externSharedLibraries})
	83	SCIQLOP_SET_TO_PARENT_SCOPE(${sharedLibrariesVar})
	84	ENDFUNCTION (SCIQLOP_PROCESS_EXTERN_DEPENDENCIES)
	85
	86	# SCIQLOP_COPY_TO_TARGET copy the given files to the given target output path.
	87	#
	88	# The first parameter must be RUNTIME or LIBRARY, and it indicates the type of
	89	# the target.
	90	#
	91	# The second parameter is the name of the target where the files must be copied.
	92	# The RUNTIME_OUTPUT_DIRECTORY or LIBRARY_OUTPUT_DIRECTORY target properties
	93	# will be used to find the output path of the copy. If these properties are
	94	# empty, then the EXECUTABLE_OUTPUT_PATH or LIBRARY_OUTPUT_PATH variables will
	95	# be used.
	96	#
	97	# The rest of the parameters are the files that must be copied.
	98	FUNCTION (SCIQLOP_COPY_TO_TARGET runtimeOrLibrary targetName)
	99	# Check RUNTIME or LIBRARY argument
	100	IF (${runtimeOrLibrary} STREQUAL "RUNTIME")
	101	SET (targetProperty "RUNTIME_OUTPUT_DIRECTORY")
	102	SET (pathProperty ${EXECUTABLE_OUTPUT_PATH})
	103	ELSEIF (${runtimeOrLibrary} STREQUAL "LIBRARY")
	104	SET (targetProperty "LIBRARY_OUTPUT_DIRECTORY")
	105	SET (pathProperty ${LIBRARY_OUTPUT_PATH})
	106	ELSE ()
	107	MESSAGE (FATAL "The first parameter of COPY_TO_TARGET must be either RUNTIME or LIBRARY, not \"${runtimeOrLibrary}\"")
	108	ENDIF ()
	109
	110	# Select the output directory
	111	GET_TARGET_PROPERTY(OUTPUT_DIR ${targetName} ${targetProperty})
	112	IF (OUTPUT_DIR STREQUAL "OUTPUT_DIR-NOTFOUND")
	113	SET (OUTPUT_DIR ${pathProperty})
	114	ENDIF ()
	115
	116	# Retrieve the list of files to copy by listing the rest of the macro
	117	# arguments
	118	FOREACH (arg ${ARGN})
	119	LIST(APPEND fileList ${arg})
	120	ENDFOREACH()
	121
	122	# Only copy if the list isn't empty
	123	IF (fileList)
	124	FILE(COPY ${fileList} DESTINATION ${OUTPUT_DIR})
	125	ENDIF()
	126	ENDFUNCTION (SCIQLOP_COPY_TO_TARGET)
	127
	128	# SCIQLOP_READ_FILE(file contents)
	129	#
	130	# Read the given file line by line and store the resulting list inside the
	131	# contents variable.
	132	#
	133	# /!\ If the file contains semicolons, the macro will escape them before
	134	# returning the list.
	135	#
	136	# From <http://public.kitware.com/pipermail/cmake/2007-May/014222.html>
	137	FUNCTION (SCIQLOP_READ_FILE file contentsVar)
	138	FILE (READ ${file} contents)
	139
	140	# Convert file contents into a CMake list (where each element in the list
	141	# is one line of the file)
	142	#
	143	STRING(REGEX REPLACE ";" "\\\\;" contents "${contents}")
	144	STRING(REGEX REPLACE "\n" ";" contents "${contents}")
	145
	146	# Return file contents as a list
	147	SET (${contentsVar} "${contents}" PARENT_SCOPE)
	148	ENDFUNCTION (SCIQLOP_READ_FILE)
	149
	150	# SCIQLOP_ADD_EXTERN_DEPENDENCY(externLibrariesVar externSharedLibrariesVar dependencyName [EXTRA FIND_PACKAGE ARGS])
	151	#
	152	# SCIQLOP_ADD_EXTERN_DEPENDENCY can be used to add a dependency residing in the
	153	# extern subdirectory to a module.
	154	#
	155	# The first parameter is the name of the variable where the found libraries will
	156	# be added.
	157	#
	158	# The second parameter is the name of the variable where the found shared
	159	# libraries will be added.
	160	#
	161	# The third parameter is the name of the dependency, and the rest of the
	162	# arguments are the same than the FIND_PACKAGE command. In fact they are passed
	163	# as-is to the command.
	164	#
	165	# If the dependency is found, then INCLUDE_DIRECTORIES is called for the
	166	# dependency include directories, and the libraries are added to the
	167	# externLibrariesVar variable. Moreover, if the dependency is a shared library,
	168	# then the dynamic libraries are added to the externSharedLibrariesVar so that
	169	# they can be copied and installed alongside the module. The libraries in this
	170	# variable are ordered so that the real library is before the symlinks to the
	171	# library, so that the copy and install works as expected.
	172	FUNCTION (SCIQLOP_ADD_EXTERN_DEPENDENCY externLibrariesVar externSharedLibrariesVar dependencyName)
	173	STRING (TOUPPER ${dependencyName} upperDependencyName)
	174
	175	FIND_PACKAGE(${dependencyName} ${ARGN})
	176	IF (${upperDependencyName}_FOUND)
	177	# Add the include directories of the dependency
	178	INCLUDE_DIRECTORIES(${${upperDependencyName}_INCLUDE_DIRS})
	179
	180	# Add the libraries to the externLibrariesVar variable and export it to
	181	# the parent scope
	182	LIST(APPEND ${externLibrariesVar} ${${upperDependencyName}_LIBRARIES})
	183	SCIQLOP_SET_TO_PARENT_SCOPE(${externLibrariesVar})
	184
	185	# Find the shared libraries
	186	LIST(APPEND ${externSharedLibrariesVar} ${${upperDependencyName}_SHARED_LIBRARIES})
	187
	188	# Export the externSharedLibrariesVar variable to the parent scope
	189	SCIQLOP_SET_TO_PARENT_SCOPE(${externSharedLibrariesVar})
	190	ENDIF ()
	191	ENDFUNCTION (SCIQLOP_ADD_EXTERN_DEPENDENCY)

cmake/sciqlop_package.cmake created 644 0 0

NO CONTENT: new file 100644

cmake/sciqlop_params.cmake created 644 +90 0

@@ -0,0 +1,90
	1	#
	2	# sciqlop_params : Define compilation parameters
	3	#
	4	# Debug or release
	5	#
	6	# As the "NMake Makefiles" forces by default the CMAKE_BUILD_TYPE variable to Debug, SCIQLOP_BUILD_TYPE variable is used to be sure that the debug mode is a user choice
	7	SET(SCIQLOP_BUILD_TYPE "Release" CACHE STRING "Choose to compile in Debug or Release mode")
	8
	9	IF(SCIQLOP_BUILD_TYPE MATCHES "Debug")
	10	MESSAGE (STATUS "Build in Debug")
	11	SET (CMAKE_BUILD_TYPE "Debug")
	12	SET (DEBUG_SUFFIX "d")
	13	ELSE()
	14	MESSAGE (STATUS "Build in Release")
	15	SET (CMAKE_BUILD_TYPE "Release")
	16	SET (SCIQLOP_BUILD_TYPE "Release")
	17	SET (DEBUG_SUFFIX "")
	18	ENDIF()
	19
	20	#
	21	# Need to compile tests?
	22	#
	23	OPTION (BUILD_TESTS "Build the tests" OFF)
	24	ENABLE_TESTING(${BUILD_TESTS})
	25
	26	#
	27	# Path to the folder for sciqlop's extern libraries.
	28	#
	29	# When looking for an external library in sciqlop, we look to the following
	30	# folders:
	31	# - The specific folder for the library (generally of the form <LIBRARY>_ROOT_DIR
	32	# - The global Sciqlop extern folder
	33	# - The system folders.
	34	#
	35	# If a dependency is found in the global extern folder or a specific folder for
	36	# the library, then it is installed with the sciqlop libraries. If it is found
	37	# in the system folders, it is not. This behavior can be overriden with the
	38	# <LIBRARY>_COPY_SHARED_LIBRARIES flag.
	39	#
	40	set(SCIQLOP_EXTERN_FOLDER "${CMAKE_CURRENT_SOURCE_DIR}/extern"
	41	CACHE PATH "Path to the folder for sciqlop's extern libraries")
	42	option(SCIQLOP_FORCE_UPDATE_EXT_ROOT_DIR "Force the <LIBRARY>_ROOT_DIR to be updated to the global sciqlop extern folder"
	43	OFF)
	44
	45	if (SCIQLOP_FORCE_UPDATE_EXT_ROOT_DIR)
	46	set(libRootDirForceValue FORCE)
	47	else()
	48	set(libRootDirForceValue)
	49	endif()
	50
	51
	52
	53	#
	54	# Static or shared libraries
	55	#
	56	OPTION (BUILD_SHARED_LIBS "Build the shared libraries" ON)
	57
	58	# Generate position independant code (-fPIC)
	59	SET(CMAKE_POSITION_INDEPENDENT_CODE TRUE)
	60
	61	#
	62	# Configure installation directories
	63	#
	64	IF (UNIX)
	65	SET(defaultBin "bin")
	66	SET(defaultInc "include/sciqlop")
	67
	68	# 32 or 64 bits compiler
	69	IF( CMAKE_SIZEOF_VOID_P EQUAL 8 )
	70	SET(defaultLib "lib64/sciqlop")
	71	ELSE()
	72	SET(defaultLib "lib/sciqlop")
	73	ENDIF()
	74
	75	SET(defaultDoc "share/docs/sciqlop")
	76	ELSE()
	77	SET(defaultBin "bin")
	78	SET(defaultInc "include/sciqlop")
	79	SET(defaultLib "lib/sciqlop")
	80	SET(defaultDoc "docs/sciqlop")
	81	ENDIF()
	82
	83	SET(INSTALL_BINARY_DIR "${defaultBin}" CACHE STRING
	84	"Installation directory for binaries")
	85	SET(INSTALL_LIBRARY_DIR "${defaultLib}" CACHE STRING
	86	"Installation directory for libraries")
	87	SET(INSTALL_INCLUDE_DIR "${defaultInc}" CACHE STRING
	88	"Installation directory for headers")
	89	SET(INSTALL_DOCUMENTATION_DIR "${defaultDoc}" CACHE STRING
	90	"Installation directory for documentations")

cmake/sciqlop_version.cmake created 644 +22 0

@@ -0,0 +1,22
	1	#
	2	# sciqlop_version.cmake
	3	#
	4	# Holds the version of sciqlop.
	5	#
	6	# These variables are used to generate the
	7	# "Version.h" and "Version.cpp" files so that the version number is available
	8	# inside of sciqlop source code.
	9	#
	10	# Moreover, they're used with CPack to display the version number in the setups.
	11	#
	12
	13	# Version number parts. These variables must be updated when the version change.
	14	SET (SCIQLOP_VERSION_MAJOR 0)
	15	SET (SCIQLOP_VERSION_MINOR 1)
	16	SET (SCIQLOP_VERSION_PATCH 0)
	17	SET (SCIQLOP_VERSION_SUFFIX "")
	18
	19	# Version number as a string. This variable is automatically generated from the
	20	# above variables to build a version number of the form: MAJOR.MINOR.PATCH. If
	21	# SCIQLOP_VERSION_SUFFIX isn't empty, it is appended to the version number.
	22	SET (SCIQLOP_VERSION "${SCIQLOP_VERSION_MAJOR}.${SCIQLOP_VERSION_MINOR}.${SCIQLOP_VERSION_PATCH}${SCIQLOP_VERSION_SUFFIX}")

sqpapp/CMakeLists.txt created 644 +141 0

@@ -0,0 +1,141
	1
	2	## sciqlop - CMakeLists.txt
	3	SET(EXECUTABLE_NAME "sciqlop")
	4	SET(SOURCES_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src/)
	5	SET(INCLUDE_FOLDER ${CMAKE_CURRENT_SOURCE_DIR}/include)
	6	SET(UI_FOLDER ${CMAKE_CURRENT_SOURCE_DIR}/src)
	7	SET(RES_FOLDER ${CMAKE_CURRENT_SOURCE_DIR}/resources)
	8
	9	#
	10	# Find Qt modules
	11	#
	12	SCIQLOP_FIND_QT(Core Widgets)
	13
	14	#
	15	# Find dependent libraries
	16	# ========================
	17	SET(LIBRARIES)
	18	SET(EXTERN_LIBRARIES)
	19	SET(EXTERN_SHARED_LIBRARIES)
	20
	21	# Add sqpcore to the list of libraries to use
	22	list(APPEND LIBRARIES ${SQPCORE_LIBRARY_NAME})
	23
	24	# Include sqpcore directory
	25	include_directories("${CMAKE_CURRENT_SOURCE_DIR}/../sqpcore/src")
	26
	27	# Add dependent shared libraries
	28	list(APPEND SHARED_LIBRARIES ${SQPCORE_SHARED_LIBRARIES})
	29
	30	# Retrieve the location of the dynamic library to copy it to the output path
	31	get_property(sqpcoreLocation TARGET ${SQPCORE_LIBRARY_NAME} PROPERTY LOCATION)
	32	list(APPEND SHARED_LIBRARIES_FROM_TARGETS ${sqpcoreLocation})
	33
	34	#
	35	# Compile the application
	36	#
	37	FILE (GLOB_RECURSE APPLICATION_SOURCES
	38	${SOURCES_DIR}/*.c
	39	${SOURCES_DIR}/*.cpp
	40	${SOURCES_DIR}/*.h)
	41
	42	# Headers files (.h)
	43	FILE (GLOB_RECURSE PROJECT_HEADERS ${INCLUDE_FOLDER}/*.h)
	44
	45	# Ui files
	46	FILE (GLOB_RECURSE PROJECT_FORMS ${UI_FOLDER}/*.ui)
	47
	48	# Resources files
	49	FILE (GLOB_RECURSE PROJECT_RESOURCES ${RES_FOLDER}/*.qrc)
	50
	51	# Retrieve resources files
	52	FILE (GLOB_RECURSE APPLICATION_RESOURCES ${RES_FOLDER}/*.qrc)
	53
	54	QT5_ADD_RESOURCES(RCC_HDRS ${APPLICATION_RESOURCES} )
	55
	56	QT5_WRAP_UI(UIS_HDRS
	57	${PROJECT_FORMS}
	58	)
	59
	60
	61	ADD_EXECUTABLE(${EXECUTABLE_NAME} ${APPLICATION_SOURCES} ${RCC_HDRS} ${UIS_HDRS})
	62	target_link_libraries(${EXECUTABLE_NAME}
	63	${LIBRARIES})
	64
	65	# Link with Qt5 modules
	66	qt5_use_modules(${EXECUTABLE_NAME} Core Widgets)
	67
	68
	69	# Add the files to the list of files to be analyzed
	70	LIST(APPEND CHECKSTYLE_INPUT_FILES ${APPLICATION_SOURCES})
	71	SCIQLOP_SET_TO_PARENT_SCOPE(CHECKSTYLE_INPUT_FILES)
	72	# Vera++ exclusion files
	73	#LIST(APPEND CHECKSTYLE_EXCLUSION_FILES ${CMAKE_CURRENT_SOURCE_DIR}/path/to/exclusionFiles.tcl)
	74	SCIQLOP_SET_TO_PARENT_SCOPE(CHECKSTYLE_EXCLUSION_FILES)
	75
	76	#
	77	# Compile the tests
	78	#
	79	IF(BUILD_TESTS)
	80	INCLUDE_DIRECTORIES(${SOURCES_DIR})
	81	FILE (GLOB_RECURSE TESTS_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/Test*.cpp)
	82	FILE (GLOB_RECURSE TESTS_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/Test*.h)
	83	SET( TEST_LIBRARIES ${LIBRARIES} ${EXTERN_LIBRARIES})
	84
	85	FOREACH( testFile ${TESTS_SOURCES} )
	86	GET_FILENAME_COMPONENT( testDirectory ${testFile} DIRECTORY )
	87	GET_FILENAME_COMPONENT( testName ${testFile} NAME_WE )
	88
	89	# Add to the list of sources files all the sources in the same
	90	# directory that aren't another test
	91	FILE (GLOB currentTestSources
	92	${testDirectory}/*.c
	93	${testDirectory}/*.cpp
	94	${testDirectory}/*.h)
	95	LIST (REMOVE_ITEM currentTestSources ${TESTS_SOURCES})
	96	LIST (REMOVE_ITEM currentTestSources ${TESTS_HEADERS})
	97
	98	ADD_EXECUTABLE(${testName} ${testFile} ${currentTestSources})
	99	TARGET_LINK_LIBRARIES( ${testName} ${TEST_LIBRARIES} )
	100	qt5_use_modules(${testName} Test)
	101
	102	ADD_TEST( NAME ${testName} COMMAND ${testName} )
	103
	104	SCIQLOP_COPY_TO_TARGET(RUNTIME ${testName} ${EXTERN_SHARED_LIBRARIES})
	105	ENDFOREACH( testFile )
	106
	107	LIST(APPEND testFilesToFormat ${TESTS_SOURCES})
	108	LIST(APPEND testFilesToFormat ${TESTS_HEADERS})
	109	LIST(APPEND FORMATTING_INPUT_FILES ${testFilesToFormat})
	110	SCIQLOP_SET_TO_PARENT_SCOPE(FORMATTING_INPUT_FILES)
	111	ENDIF(BUILD_TESTS)
	112
	113	#
	114	# Set the files that must be formatted by clang-format.
	115	#
	116	LIST (APPEND FORMATTING_INPUT_FILES ${APPLICATION_SOURCES})
	117	SCIQLOP_SET_TO_PARENT_SCOPE(FORMATTING_INPUT_FILES)
	118
	119	#
	120	# Set the directories that doxygen must browse to generate the
	121	# documentation.
	122	#
	123	# Source directories:
	124	LIST (APPEND DOXYGEN_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/docs")
	125	LIST (APPEND DOXYGEN_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/src")
	126	SCIQLOP_SET_TO_PARENT_SCOPE(DOXYGEN_INPUT_DIRS)
	127	# Source directories to exclude from the documentation generation
	128	#LIST (APPEND DOXYGEN_EXCLUDE_PATTERNS "${CMAKE_CURRENT_SOURCE_DIR}/path/to/subdir/*")
	129	SCIQLOP_SET_TO_PARENT_SCOPE(DOXYGEN_EXCLUDE_PATTERNS)
	130
	131	#
	132	# Set the directories with the sources to analyze and propagate the
	133	# modification to the parent scope
	134	#
	135	# Source directories to analyze:
	136	LIST (APPEND ANALYSIS_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/src")
	137	LIST (APPEND ANALYSIS_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/tests")
	138	SCIQLOP_SET_TO_PARENT_SCOPE(ANALYSIS_INPUT_DIRS)
	139	# Source directories to exclude from the analysis
	140	#LIST (APPEND ANALYSIS_EXCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/path/to/subdir")
	141	SCIQLOP_SET_TO_PARENT_SCOPE(ANALYSIS_EXCLUDE_DIRS)

sqpcore/CMakeLists.txt created 644 +121 0

@@ -0,0 +1,121
	1
	2	## sqpcore - CMakeLists.txt
	3	STRING(TOLOWER ${CMAKE_PROJECT_NAME} LIBRARY_PREFFIX)
	4	SET(SQPCORE_LIBRARY_NAME "${LIBRARY_PREFFIX}_sqpcore${DEBUG_SUFFIX}")
	5	SET(SOURCES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/src/")
	6
	7	# Set a variable to display a warning in the version files.
	8	SET(SCIQLOP_CMAKE_GENERATION_WARNING "DON'T CHANGE THIS FILE. AUTOGENERATED BY CMAKE.")
	9	# Generate the version file from the cmake version variables. The version
	10	# variables are defined in the cmake/sciqlop_version.cmake file.
	11	CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/resources/Version.h.in"
	12	"${SOURCES_DIR}/Version.h")
	13	CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/resources/Version.cpp.in"
	14	"${SOURCES_DIR}/Version.cpp")
	15
	16	#
	17	# Find Qt modules
	18	#
	19	SCIQLOP_FIND_QT(Core)
	20
	21	#
	22	# Compile the library library
	23	#
	24	FILE (GLOB_RECURSE MODULE_SOURCES
	25	${SOURCES_DIR}/*.c
	26	${SOURCES_DIR}/*.cpp
	27	${SOURCES_DIR}/*.h)
	28
	29	ADD_LIBRARY(${SQPCORE_LIBRARY_NAME} ${MODULE_SOURCES})
	30	TARGET_LINK_LIBRARIES(${SQPCORE_LIBRARY_NAME} ${EXTERN_LIBRARIES})
	31	qt5_use_modules(${SQPCORE_LIBRARY_NAME} Core)
	32
	33	# From cmake documentation: http://www.cmake.org/cmake/help/v3.0/manual/cmake-buildsystem.7.html
	34	# Entries in the COMPILE_DEFINITIONS are prefixed with -D or /D and added to the compile line in an unspecified order.
	35	# The DEFINE_SYMBOL target property is also added as a compile definition as a special convenience case for SHARED and MODULE library targets
	36	IF(BUILD_SHARED_LIBS)
	37	SET_TARGET_PROPERTIES(${SQPCORE_LIBRARY_NAME} PROPERTIES COMPILE_DEFINITIONS "SCIQLOP_EXPORT")
	38	ELSE()
	39	TARGET_COMPILE_DEFINITIONS(${SQPCORE_LIBRARY_NAME} PUBLIC "SCIQLOP_STATIC_LIBRARIES")
	40	ENDIF()
	41
	42	# Set the variable to parent scope so that the other projects can copy the
	43	# dependent shared libraries
	44	SCIQLOP_SET_TO_PARENT_SCOPE(SQPCORE_LIBRARY_NAME)
	45
	46	# Copy extern shared libraries to the lib folder
	47	SCIQLOP_COPY_TO_TARGET(LIBRARY ${SQPCORE_LIBRARY_NAME} ${EXTERN_SHARED_LIBRARIES})
	48
	49	# Add the files to the list of files to be analyzed
	50	LIST(APPEND CHECKSTYLE_INPUT_FILES ${MODULE_SOURCES})
	51	SCIQLOP_SET_TO_PARENT_SCOPE(CHECKSTYLE_INPUT_FILES)
	52	# Vera++ exclusion files
	53	#LIST(APPEND CHECKSTYLE_EXCLUSION_FILES ${CMAKE_CURRENT_SOURCE_DIR}/path/to/exclusionFiles.tcl)
	54	SCIQLOP_SET_TO_PARENT_SCOPE(CHECKSTYLE_EXCLUSION_FILES)
	55
	56	#
	57	# Compile the tests
	58	#
	59	IF(BUILD_TESTS)
	60	INCLUDE_DIRECTORIES(${SOURCES_DIR})
	61	FILE (GLOB_RECURSE TESTS_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/Test*.cpp)
	62	FILE (GLOB_RECURSE TESTS_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/Test*.h)
	63	SET( TEST_LIBRARIES ${SQPCORE_LIBRARY_NAME} ${EXTERN_LIBRARIES})
	64
	65	FOREACH( testFile ${TESTS_SOURCES} )
	66	GET_FILENAME_COMPONENT( testDirectory ${testFile} DIRECTORY )
	67	GET_FILENAME_COMPONENT( testName ${testFile} NAME_WE )
	68
	69	# Add to the list of sources files all the sources in the same
	70	# directory that aren't another test
	71	FILE (GLOB currentTestSources
	72	${testDirectory}/*.c
	73	${testDirectory}/*.cpp
	74	${testDirectory}/*.h)
	75	LIST (REMOVE_ITEM currentTestSources ${TESTS_SOURCES})
	76	LIST (REMOVE_ITEM currentTestSources ${TESTS_HEADERS})
	77
	78	ADD_EXECUTABLE(${testName} ${testFile} ${currentTestSources})
	79	TARGET_LINK_LIBRARIES( ${testName} ${TEST_LIBRARIES} )
	80	qt5_use_modules(${testName} Test)
	81
	82	ADD_TEST( NAME ${testName} COMMAND ${testName} )
	83
	84	SCIQLOP_COPY_TO_TARGET(RUNTIME ${testName} ${EXTERN_SHARED_LIBRARIES})
	85	ENDFOREACH( testFile )
	86
	87	LIST(APPEND testFilesToFormat ${TESTS_SOURCES})
	88	LIST(APPEND testFilesToFormat ${TESTS_HEADERS})
	89	LIST(APPEND FORMATTING_INPUT_FILES ${testFilesToFormat})
	90	SCIQLOP_SET_TO_PARENT_SCOPE(FORMATTING_INPUT_FILES)
	91	ENDIF(BUILD_TESTS)
	92
	93	#
	94	# Set the files that must be formatted by clang-format.
	95	#
	96	LIST (APPEND FORMATTING_INPUT_FILES ${MODULE_SOURCES})
	97	SCIQLOP_SET_TO_PARENT_SCOPE(FORMATTING_INPUT_FILES)
	98
	99	#
	100	# Set the directories that doxygen must browse to generate the
	101	# documentation.
	102	#
	103	# Source directories:
	104	LIST (APPEND DOXYGEN_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/docs")
	105	LIST (APPEND DOXYGEN_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/src")
	106	SCIQLOP_SET_TO_PARENT_SCOPE(DOXYGEN_INPUT_DIRS)
	107	# Source directories to exclude from the documentation generation
	108	#LIST (APPEND DOXYGEN_EXCLUDE_PATTERNS "${CMAKE_CURRENT_SOURCE_DIR}/path/to/subdir/*")
	109	SCIQLOP_SET_TO_PARENT_SCOPE(DOXYGEN_EXCLUDE_PATTERNS)
	110
	111	#
	112	# Set the directories with the sources to analyze and propagate the
	113	# modification to the parent scope
	114	#
	115	# Source directories to analyze:
	116	LIST (APPEND ANALYSIS_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/src")
	117	LIST (APPEND ANALYSIS_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/tests")
	118	SCIQLOP_SET_TO_PARENT_SCOPE(ANALYSIS_INPUT_DIRS)
	119	# Source directories to exclude from the analysis
	120	#LIST (APPEND ANALYSIS_EXCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/path/to/subdir")
	121	SCIQLOP_SET_TO_PARENT_SCOPE(ANALYSIS_EXCLUDE_DIRS)

sqpgui/CMakeLists.txt created 644 +138 0

@@ -0,0 +1,138
	1
	2	## sqpgui - CMakeLists.txt
	3	STRING(TOLOWER ${CMAKE_PROJECT_NAME} LIBRARY_PREFFIX)
	4	SET(SQPGUI_LIBRARY_NAME "${LIBRARY_PREFFIX}_sqpgui${DEBUG_SUFFIX}")
	5	SET(SOURCES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/src")
	6	SET(INCLUDE_FOLDER ${CMAKE_CURRENT_SOURCE_DIR}/include)
	7	SET(UI_FOLDER ${CMAKE_CURRENT_SOURCE_DIR}/ui)
	8	SET(RES_FOLDER ${CMAKE_CURRENT_SOURCE_DIR}/resources)
	9
	10	# Set a variable to display a warning in the version files.
	11	SET(SCIQLOP_CMAKE_GENERATION_WARNING "DON'T CHANGE THIS FILE. AUTOGENERATED BY CMAKE.")
	12
	13	#
	14	# Find Qt modules
	15	#
	16	SCIQLOP_FIND_QT(Core Widgets)
	17
	18	#
	19	# Compile the library library
	20	#
	21	FILE (GLOB_RECURSE MODULE_SOURCES
	22	${SOURCES_DIR}/*.c
	23	${SOURCES_DIR}/*.cpp
	24	${SOURCES_DIR}/*.h)
	25
	26	# Headers files (.h)
	27	FILE (GLOB_RECURSE PROJECT_HEADERS ${INCLUDE_FOLDER}/*.h)
	28
	29	# Ui files
	30	FILE (GLOB_RECURSE PROJECT_FORMS ${UI_FOLDER}/*.ui)
	31
	32	# Resources files
	33	FILE (GLOB_RECURSE PROJECT_RESOURCES ${RES_FOLDER}/*.qrc)
	34
	35	QT5_ADD_RESOURCES(RCC_HDRS
	36	${PROJECT_RESOURCES}
	37	)
	38
	39	QT5_WRAP_UI(UIS_HDRS
	40	${PROJECT_FORMS}
	41	)
	42
	43	include_directories("${CMAKE_CURRENT_BINARY_DIR}")
	44	message(CURRENT INCLUDE : ${CMAKE_CURRENT_BINARY_DIR})
	45
	46	ADD_LIBRARY(${SQPGUI_LIBRARY_NAME} ${MODULE_SOURCES} ${UIS_HDRS})
	47	TARGET_LINK_LIBRARIES(${SQPGUI_LIBRARY_NAME} ${EXTERN_LIBRARIES})
	48	qt5_use_modules(${SQPGUI_LIBRARY_NAME} Core Widgets)
	49
	50	# From cmake documentation: http://www.cmake.org/cmake/help/v3.0/manual/cmake-buildsystem.7.html
	51	# Entries in the COMPILE_DEFINITIONS are prefixed with -D or /D and added to the compile line in an unspecified order.
	52	# The DEFINE_SYMBOL target property is also added as a compile definition as a special convenience case for SHARED and MODULE library targets
	53	IF(BUILD_SHARED_LIBS)
	54	SET_TARGET_PROPERTIES(${SQPGUI_LIBRARY_NAME} PROPERTIES COMPILE_DEFINITIONS "SCIQLOP_EXPORT")
	55	ELSE()
	56	TARGET_COMPILE_DEFINITIONS(${SQPGUI_LIBRARY_NAME} PUBLIC "SCIQLOP_STATIC_LIBRARIES")
	57	ENDIF()
	58
	59	# Set the variable to parent scope so that the other projects can copy the
	60	# dependent shared libraries
	61	SCIQLOP_SET_TO_PARENT_SCOPE(SQPGUI_LIBRARY_NAME)
	62
	63	# Copy extern shared libraries to the lib folder
	64	SCIQLOP_COPY_TO_TARGET(LIBRARY ${SQPGUI_LIBRARY_NAME} ${EXTERN_SHARED_LIBRARIES})
	65
	66	# Add the files to the list of files to be analyzed
	67	LIST(APPEND CHECKSTYLE_INPUT_FILES ${MODULE_SOURCES})
	68	SCIQLOP_SET_TO_PARENT_SCOPE(CHECKSTYLE_INPUT_FILES)
	69	# Vera++ exclusion files
	70	#LIST(APPEND CHECKSTYLE_EXCLUSION_FILES ${CMAKE_CURRENT_SOURCE_DIR}/path/to/exclusionFiles.tcl)
	71	SCIQLOP_SET_TO_PARENT_SCOPE(CHECKSTYLE_EXCLUSION_FILES)
	72
	73	#
	74	# Compile the tests
	75	#
	76	IF(BUILD_TESTS)
	77	INCLUDE_DIRECTORIES(${SOURCES_DIR})
	78	FILE (GLOB_RECURSE TESTS_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/Test*.cpp)
	79	FILE (GLOB_RECURSE TESTS_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/Test*.h)
	80	SET( TEST_LIBRARIES ${SQPGUI_LIBRARY_NAME} ${EXTERN_LIBRARIES})
	81
	82	FOREACH( testFile ${TESTS_SOURCES} )
	83	GET_FILENAME_COMPONENT( testDirectory ${testFile} DIRECTORY )
	84	GET_FILENAME_COMPONENT( testName ${testFile} NAME_WE )
	85
	86	# Add to the list of sources files all the sources in the same
	87	# directory that aren't another test
	88	FILE (GLOB currentTestSources
	89	${testDirectory}/*.c
	90	${testDirectory}/*.cpp
	91	${testDirectory}/*.h)
	92	LIST (REMOVE_ITEM currentTestSources ${TESTS_SOURCES})
	93	LIST (REMOVE_ITEM currentTestSources ${TESTS_HEADERS})
	94
	95	ADD_EXECUTABLE(${testName} ${testFile} ${currentTestSources})
	96	TARGET_LINK_LIBRARIES( ${testName} ${TEST_LIBRARIES} )
	97	qt5_use_modules(${testName} Test)
	98
	99	ADD_TEST( NAME ${testName} COMMAND ${testName} )
	100
	101	SCIQLOP_COPY_TO_TARGET(RUNTIME ${testName} ${EXTERN_SHARED_LIBRARIES})
	102	ENDFOREACH( testFile )
	103
	104	LIST(APPEND testFilesToFormat ${TESTS_SOURCES})
	105	LIST(APPEND testFilesToFormat ${TESTS_HEADERS})
	106	LIST(APPEND FORMATTING_INPUT_FILES ${testFilesToFormat})
	107	SCIQLOP_SET_TO_PARENT_SCOPE(FORMATTING_INPUT_FILES)
	108	ENDIF(BUILD_TESTS)
	109
	110	#
	111	# Set the files that must be formatted by clang-format.
	112	#
	113	LIST (APPEND FORMATTING_INPUT_FILES ${MODULE_SOURCES})
	114	SCIQLOP_SET_TO_PARENT_SCOPE(FORMATTING_INPUT_FILES)
	115
	116	#
	117	# Set the directories that doxygen must browse to generate the
	118	# documentation.
	119	#
	120	# Source directories:
	121	LIST (APPEND DOXYGEN_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/docs")
	122	LIST (APPEND DOXYGEN_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/src")
	123	SCIQLOP_SET_TO_PARENT_SCOPE(DOXYGEN_INPUT_DIRS)
	124	# Source directories to exclude from the documentation generation
	125	#LIST (APPEND DOXYGEN_EXCLUDE_PATTERNS "${CMAKE_CURRENT_SOURCE_DIR}/path/to/subdir/*")
	126	SCIQLOP_SET_TO_PARENT_SCOPE(DOXYGEN_EXCLUDE_PATTERNS)
	127
	128	#
	129	# Set the directories with the sources to analyze and propagate the
	130	# modification to the parent scope
	131	#
	132	# Source directories to analyze:
	133	LIST (APPEND ANALYSIS_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/src")
	134	LIST (APPEND ANALYSIS_INPUT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/tests")
	135	SCIQLOP_SET_TO_PARENT_SCOPE(ANALYSIS_INPUT_DIRS)
	136	# Source directories to exclude from the analysis
	137	#LIST (APPEND ANALYSIS_EXCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/path/to/subdir")
	138	SCIQLOP_SET_TO_PARENT_SCOPE(ANALYSIS_EXCLUDE_DIRS)

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

		It's really simple to do that. we have to assume code that we don't want to compile don't have to be in the source....
		...
		I think it's nice to do the differences of the name for debug and release....
		ok...
		The current cmake mimum version is 3.6. Do you want it to downgrade to 3.1 or it's ok for you ?...
		this implies that we will always build all files, I have no problem with that, be sure that you want that.
		this is distribution dependent, we can't hardcode this....
		Changing binary name for debug binaries is usualy a bad choice it leaks everywhere, it might be better to produce debuginfos and use only one name.
		Isn't that function doing what macdeployqt or windeployqt does? If yes the deploy apps resolves dependencies from binary which might be safer.
		Feel free to remove such comments, they basicaly rephrase the code but doesn't add information.
		Please don't, instead raise cmake minimum version to 3.1(Dec 2014) and use either set (CMAKE_CXX_STANDARD 14) or target_compile_features but avoid setting CMAKE_CXX_FLAGS as much as possible....

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages