def __AddApplications(self,
_holderProject,
_applicationDependenciesList,
_modules,
_modulesFolder,
_pch="",
_holderName=None,
_properties=[]):
"""
Creates application projects and adds them to _holderProject (using _holderProject.AddProject). The holder
project does not depend on these application projects.
It is assumed that _modules is a list containing subfolders of _modulesFolder.
Each subfolder in _modules should contain source files (.cpp, .cxx or .cc), where each source file corresponds to a single application.
Hence, each source file is used to create a new application project. For example, assuming that the _modulesFolder
is called 'Applications', the file 'Applications/Small/Tiny.cpp' will be used to build the 'Tiny' application.
_applicationDependenciesList - List of projects that each new application project is dependent on.
_modulesFolder - Folder containing subfolders with applications.
_modules = List of subfolders of _modulesFolder that should be processed.
_pch - If not "", this is the C++ include file which is used for building a precompiled header file for each application.
"""
for module in _modules:
moduleFolder = "%s/%s" % (_modulesFolder, module)
sourceFiles = []
headerFiles = []
for extension in csnUtility.GetSourceFileExtensions():
sourceFiles.extend(
_holderProject.Glob("%s/*.%s" % (moduleFolder, extension)))
for extension in csnUtility.GetIncludeFileExtensions():
headerFiles.extend(
_holderProject.Glob("%s/*.%s" % (moduleFolder, extension)))
for sourceFile in sourceFiles:
if os.path.isdir(sourceFile):
continue
name = os.path.splitext(os.path.basename(sourceFile))[0]
name = name.replace(' ', '_')
if _holderName is None:
_holderName = _holderProject.name
app = csnBuild.Project(
"%s_%s" % (_holderName, name),
"executable",
_sourceRootFolder=_holderProject.GetSourceRootFolder())
app.AddIncludeFolders([moduleFolder])
app.AddProjects(_applicationDependenciesList)
app.AddSources([sourceFile])
app.AddProperties(_properties)
# add header files so that they appear in visual studio
app.AddSources(headerFiles)
if (_pch != ""):
app.SetPrecompiledHeader(_pch)
_holderProject.AddProjects([app])
def CommandLinePlugin(_name, _holderProject=None):
""" Create a command line plugin project. """
_sourceRootFolder = csnUtility.NormalizePath(
os.path.dirname(csnProject.FindFilename(1)))
# command line lib
projectLibName = "%sLib" % _name
projectLib = csnProject.Project(projectLibName, "dll", _sourceRootFolder)
#project = CilabModuleProject(projectName, "dll", _sourceRootFolder)
projectLib.AddDefinitions(["-Dmain=ModuleEntryPoint"], _private=1)
projectLib.installSubFolder = "commandLinePlugins"
projectLib.CMakeInsertBeforeTarget = new.instancemethod(
CreateCMakeCLPPre, projectLib)
projectLib.CMakeInsertAfterTarget = new.instancemethod(
CreateCMakeCLPPost, projectLib)
# command line executable
projectAppName = _name
projectApp = csnBuild.Project(projectAppName, "executable",
_sourceRootFolder)
projectApp.AddProjects([projectLib])
projectApp.installSubFolder = "commandLinePlugins"
# wrapper for shared libraries
wrapperSourceFile = None
for thirdParty in csnProject.globalCurrentContext.GetThirdPartyFolders():
currentWrapperSourceFile = u'%s/SLICER/Slicer3/Applications/CLI/Templates/CommandLineSharedLibraryWrapper.cxx' % thirdParty
if os.path.isfile(currentWrapperSourceFile):
wrapperSourceFile = currentWrapperSourceFile
if wrapperSourceFile is None:
raise Exception(
"Could not find Slicer template in your thirdParty folders.")
projectApp.AddSources([wrapperSourceFile])
# force the creation of the application project
projectLib.AddProjects([projectApp], _dependency=0)
if not (_holderProject is None):
_holderProject.AddProjects([projectLib])
return projectLib
def AddApplications(self,
_modules,
_pch="",
_applicationDependenciesList=None,
_holderName=None,
_properties=[]):
"""
Creates extra CSnake projects, each project building one application in the 'Applications' subfolder of the current project.
_modules - List of the subfolders within the 'Applications' subfolder that must be scanned for applications.
_pch - If not "", this is the include file used to generate a precompiled header for each application.
"""
dependencies = [self]
if not _applicationDependenciesList is None:
dependencies.extend(_applicationDependenciesList)
if _holderName is None:
_holderName = "%sApplications" % self.name
csnProject.globalCurrentContext.SetSuperSubCategory(
"Applications", _holderName)
if self.applicationsProject is None:
self.applicationsProject = csnBuild.Project(
self.name + "Applications",
"container",
_sourceRootFolder=self.GetSourceRootFolder(),
_categories=[_holderName])
#self.applicationsProject.AddSources([csnUtility.GetDummyCppFilename()], _sourceGroup = "CSnakeGeneratedFiles")
self.applicationsProject.AddProjects([self])
self.AddProjects([self.applicationsProject], _dependency=0)
# look for an 'applications' or 'Applications' folder
_modulesFolder = "%s/applications" % self.GetSourceRootFolder()
if not os.path.exists(_modulesFolder):
_modulesFolder = "%s/Applications" % self.GetSourceRootFolder()
self.__AddApplications(self.applicationsProject, dependencies,
_modules, _modulesFolder, _pch, _holderName,
_properties)
# Used to configure gmCoreLight
import csnBuild
from csnGIMIASDef import *
import os.path
gmCoreLight = csnBuild.Project("gmCoreLight", "library")
gmCoreLight.AddProjects([
gmCommonObjects, gmDataHandling, gmKernel, gmWidgets, gmProcessors,
gmFrontEndPlugin
])
#gmCoreLight.SetPrecompiledHeader("gmCoreLightPCH.h")
gmCoreLight.compileManager.generateWin32Header = False
gmCoreLight.AddLibraries(["util"], _NOT_WIN32=1)
gmCoreLight.AddFilesToInstall(gmCoreLight.Glob("Copyrights/*.txt"),
"Copyrights")
gmCoreLight.AddFilesToInstall(gmCoreLight.Glob("resource"), "resource")
gmCoreLight.AddFilesToInstall(gmCoreLight.Glob("Core/*.xml"), "")
gmCoreLight.AddFilesToInstall(gmCoreLight.Glob("Core/*.xsl"), "")
#gmCoreLight.AddTests(["Tests/*.*"], cxxTest)
#gmCoreLight.testProject.SetPrecompiledHeader("gmCoreLightPCH.h")
# Used to configure coreIO
import csnBuild
from csnGIMIASDef import *
import os.path
import csnProject
gmCommonObjects = csnBuild.Project("gmCommonObjects", "dll")
gmCommonObjects.AddProjects([itk, boost])
gmCommonObjects.SetPrecompiledHeader("gmCommonObjectsPCH.h")
baseFolders = ["src"]
for baseFolder in baseFolders:
gmCommonObjects.AddSources(["%s/*.cxx" % baseFolder], _checkExists=0)
gmCommonObjects.AddSources(["%s/*.txx" % baseFolder], _checkExists=0)
gmCommonObjects.AddSources(["%s/*.h" % baseFolder], _checkExists=0)
gmCommonObjects.AddIncludeFolders([baseFolder])
# Used to configure lcore
import csnBuild
from csnGIMIASDef import *
import os.path
import csnProject
#used to access sys,platform. Delete when remove the fura window. Martin 27/03/2009
import sys
gmDataHandling = csnBuild.Project("gmDataHandling", "dll")
gmDataHandling.AddProjects([
cilabMacros,
itk,
vtk,
baseLibVTK,
baseLibSignal,
baseLibNumericData,
boost,
dcmAPI,
gmCommonObjects
])
gmDataHandling.SetPrecompiledHeader("gmDataHandlingPCH.h")
baseFolders = [
"src"
]
for baseFolder in baseFolders:
gmDataHandling.AddSources(["%s/*.cxx" % baseFolder], _checkExists = 0)
gmDataHandling.AddSources(["%s/*.txx" % baseFolder], _checkExists = 0)
# Used to configure coreIO
import csnBuild
from csnGIMIASDef import *
import os.path
import csnProject
gmKernel = csnBuild.Project("gmKernel", "dll")
gmKernel.AddProjects([
cilabMacros, itk, baseLibVTK, boost, gmCommonObjects, gmDataHandling, gmIO,
gmFrontEndPlugin, dynLib, wxWidgets
])
gmKernel.SetPrecompiledHeader("gmKernelPCH.h")
baseFolders = ["src"]
for baseFolder in baseFolders:
gmKernel.AddSources(["%s/*.cxx" % baseFolder], _checkExists=0)
gmKernel.AddSources(["%s/*.txx" % baseFolder], _checkExists=0)
gmKernel.AddSources(["%s/*.h" % baseFolder], _checkExists=0)
gmKernel.AddIncludeFolders([baseFolder])
gmKernel.AddFilesToInstall(gmKernel.Glob("resource"), "resource")
# Used to configure coreIO
import csnBuild
from csnGIMIASDef import *
import os.path
import csnProject
gmItkDataEntityIO = csnBuild.Project("gmItkDataEntityIO", "dll")
gmItkDataEntityIO.AddProjects([itk, gmDataHandling])
gmItkDataEntityIO.AddSources(["src/itkDataEntityIO/*.cxx"], _checkExists=0)
gmItkDataEntityIO.AddSources(["src/itkDataEntityIO/*.txx"], _checkExists=0)
gmItkDataEntityIO.AddSources(["src/itkDataEntityIO/*.h"], _checkExists=0)
gmItkDataEntityIO.SetPrecompiledHeader("gmitkDataEntityIOPCH.h")
gmItkDataEntityIO.AddIncludeFolders(["src/itkDataEntityIO"])
gmIO = csnBuild.Project("gmIO", "dll")
gmIO.AddProjects([
cilabMacros, xerces, itk, baseLibVTK, boost, dcmAPI, gmCommonObjects,
gmDataHandling, cgns, hdf5, gmItkDataEntityIO
])
gmIO.SetPrecompiledHeader("gmIOPCH.h")
gmIO.AddSources(["src/*.cxx"], _checkExists=0)
gmIO.AddSources(["src/*.txx"], _checkExists=0)
gmIO.AddSources(["src/*.h"], _checkExists=0)
gmIO.AddIncludeFolders(["src"])
IOFolders = gmIO.Glob("src/DataFormatObjects/*")
for IOFolder in IOFolders:
if os.path.isdir(IOFolder):
gmIO.AddSources(["%s/*.cxx" % IOFolder], _checkExists=0)
# Project variable definitions
import csnCilab
import csnBuild
def dummyLib():
import DummyLib.csnDummyLib
return DummyLib.csnDummyLib.dummyLib
def cxxTest():
return csnCilab.LoadThirdPartyModule('CxxTest', 'csnCxxTest').cxxTest
def two():
return csnCilab.LoadThirdPartyModule('Two', 'csnTwo').two
def three():
return csnCilab.LoadThirdPartyModule('Three', 'csnThree').three
def four():
return csnCilab.LoadThirdPartyModule('Four', 'csnFour').four
# Toolkit header -------------------------------------------------------------------------
toolkit = csnBuild.Project("TestToolkit", "library")
toolkit.AddCustomCommand(csnCilab.CreateToolkitHeader)
import csnBuild
from guiBridgeLib import csnGuiBridgeLib
from csnGIMIASDef import *
guiBridgeLibWxWidgets = csnBuild.Project("GuiBridgeLibWxWidgets", "library")
guiBridgeLibWxWidgets.AddIncludeFolders(["src"])
guiBridgeLibWxWidgets.AddSources(["src/gblBridgeWxWidgets.cpp", "src/gblBridgeWxWidgets.h"])
guiBridgeLibWxWidgets.AddSources(["src/gblWxTextCtrlValueProxy.cpp"])
guiBridgeLibWxWidgets.AddSources(["src/gblWxTextCtrlValueProxy.h"])
guiBridgeLibWxWidgets.AddProjects([csnGuiBridgeLib.guiBridgeLib, wxWidgets] )
f.write("// Automatically generated file, do not edit.\n")
f.write("\n")
if hasattr(toolkit, "context"):
f.write("#define CISTIB_TOOLKIT_FOLDER \"%s/..\"\n" %
toolkit.GetSourceRootFolder())
# check is build folder is public or private
buildFolder = None
if hasattr(toolkit.context, "buildFolder"):
buildFolder = toolkit.context.buildFolder
else:
buildFolder = toolkit.context.GetBuildFolder()
f.write("#define CISTIB_TOOLKIT_BUILD_FOLDER \"%s\"\n" % buildFolder)
else:
f.write("#define CISTIB_TOOLKIT_FOLDER \"%s/..\"\n" %
toolkit.sourceRootFolder)
f.write("#define CISTIB_TOOLKIT_BUILD_FOLDER \"%s\"\n" %
toolkit.compiler.GetBuildFolder())
f.write("\n")
f.write("#endif // CISTIBTOOLKIT_H\n")
f.close()
requiredVersion = 2.15
if not hasattr(csnBuild, "version") or csnBuild.version < requiredVersion:
assert False, "\n\nCSnake version must be at least %d. Please update CSnake\n" % requiredVersion
toolkit = csnBuild.Project("CISTIBToolkit", "library")
toolkit.AddCustomCommand(CreateToolkitHeader)
# Used to configure gmCore
import csnBuild
import csnCilab
from csnGIMIASDef import *
import os.path
# Use gmCore and MITK dependency for compatibility
gmCore = csnBuild.Project("gmCore", "library")
gmCore.AddProjects([gmCoreLight, mitkPlugin])
import csnBuild
from csnGIMIASDef import *
gblWxWidgetsTestGUI = csnBuild.Project("gblWxWidgetsTestGUI", "library")
gblWxWidgetsTestGUI.AddIncludeFolders(["src"])
gblWxWidgetsTestGUI.AddSources(
["src/gblWxWidgetsTestGUI.cpp", "src/gblWxWidgetsTestGUI.h"])
gblWxWidgetsTestGUI.AddProjects([guiBridgeLibWxWidgets])
gblWxWidgetsTestGUI.AddProjects([cxxTest])
guiBridgeLibWxWidgetsTest = csnBuild.Project("GuiBridgeLibWxWidgetsTest",
"executable")
guiBridgeLibWxWidgetsTest.AddIncludeFolders(["src"])
guiBridgeLibWxWidgetsTest.AddSources(
["src/BridgeLibWxWidgetsTest.cpp", "src/BridgeLibWxWidgetsTest.h"])
guiBridgeLibWxWidgetsTest.AddProjects([gblWxWidgetsTestGUI])
# Csnake project configuration
import csnBuild
import csnCilab
two = csnBuild.Project("Two", "third party")
two.pathsManager.useFilePath = "%s/Two/UseTwo.cmake" % two.GetBuildFolder()
two.pathsManager.configFilePath = "%s/Two/TwoConfig.cmake" % two.GetBuildFolder(
)
two.AddFilesToInstall(["bin\Debug\TwoLib.dll"], _debugOnly=1, _WIN32=1)
two.AddFilesToInstall(["bin\Release\TwoLib.dll"], _releaseOnly=1, _WIN32=1)
# Used to configure coreIO
import csnBuild
from csnGIMIASDef import *
import os.path
import csnProject
#used to access sys,platform. Delete when remove the fura window. Martin 27/03/2009
import sys
gmWidgets = csnBuild.Project("gmWidgets", "dll")
gmWidgets.AddProjects([
gmProcessors,
gmFrontEndPlugin,
guiBridgeLibWxWidgets,
dynWxAGUILib
])
# GRID
#if (sys.platform == "win32"):
# gmWidgets.AddDefinitions(["-DUSE_GRID_API"] )
# gmWidgets.AddProjects([gridAPI])
gmWidgets.SetPrecompiledHeader("gmWidgetsPCH.h")
widgetFolders = gmWidgets.Glob("src/*")
for widgetFolder in widgetFolders:
if os.path.isdir(widgetFolder):
gmWidgets.AddSources(["%s/*.cpp" % widgetFolder], _checkExists = 0)
gmWidgets.AddSources(["%s/*.cxx" % widgetFolder], _checkExists = 0)
gmWidgets.AddSources(["%s/*.txx" % widgetFolder], _checkExists = 0)
gmWidgets.AddSources(["%s/*.h" % widgetFolder], _checkExists = 0)
gmWidgets.AddIncludeFolders([widgetFolder])
# Used to configure coreIO
import csnBuild
import csnCilab
from csnGIMIASDef import *
import os.path
import csnProject
gmProcessors = csnBuild.Project("gmProcessors", "dll")
gmProcessors.AddProjects([gmDataHandling, gmKernel])
gmProcessors.SetPrecompiledHeader("gmProcessorsPCH.h")
baseFolders = ["src"]
for baseFolder in baseFolders:
gmProcessors.AddSources(["%s/*.cxx" % baseFolder], _checkExists=0)
gmProcessors.AddSources(["%s/*.txx" % baseFolder], _checkExists=0)
gmProcessors.AddSources(["%s/*.h" % baseFolder], _checkExists=0)
gmProcessors.AddIncludeFolders([baseFolder])
# Used to configure coreIO
import csnBuild
from csnGIMIASDef import *
import os.path
import csnProject
gmFrontEndPlugin = csnBuild.Project("gmFrontEndPlugin", "dll")
gmFrontEndPlugin.AddProjects([gmCommonObjects, baseLib, baseLibNumericData])
gmFrontEndPlugin.SetPrecompiledHeader("gmFrontEndPluginPCH.h")
baseFolders = ["src"]
for baseFolder in baseFolders:
gmFrontEndPlugin.AddSources(["%s/*.cxx" % baseFolder], _checkExists=0)
gmFrontEndPlugin.AddSources(["%s/*.txx" % baseFolder], _checkExists=0)
gmFrontEndPlugin.AddSources(["%s/*.h" % baseFolder], _checkExists=0)
gmFrontEndPlugin.AddIncludeFolders([baseFolder])
import csnBuild
import csnCilab
from csnGIMIASDef import *
guiBridgeLibTest = csnBuild.Project("GuiBridgeLibTest", "executable")
guiBridgeLibTest.AddIncludeFolders(["src"])
guiBridgeLibTest.AddSources(["src/BridgeLibTest.cpp", "src/BridgeLibTest.h"])
guiBridgeLibTest.AddProjects([guiBridgeLib, boost, cxxTest])
import csnBuild
from csnGIMIASDef import *
guiBridgeLib = csnBuild.Project("GuiBridgeLib", "library")
guiBridgeLib.AddIncludeFolders(["src"])
guiBridgeLib.AddSources(["src/gblBridge.cpp", "src/gblBridge.h"])
guiBridgeLib.AddSources(
["src/gblValueConverter.cpp", "src/gblValueConverter.h"])
guiBridgeLib.AddSources(
["src/gblMockController.cpp", "src/gblMockController.h"])
guiBridgeLib.AddSources(["src/gblException.h"])
guiBridgeLib.AddProject(boost)
# Used to configure CxxTest
import csnBuild
cxxTest = csnBuild.Project("CxxTest", "library")
# Csnake project configuration
import csnBuild
import csnCilab
three = csnBuild.Project("Three", "third party")
three.pathsManager.useFilePath = "%s/Three/UseThree.cmake" % three.GetBuildFolder(
)
three.pathsManager.configFilePath = "%s/Three/ThreeConfig.cmake" % three.GetBuildFolder(
)
import csnBuild
from csnGIMIASDef import *
guiBridgeLibWxWidgetsTestApp = csnBuild.Project("GuiBridgeLibWxWidgetsTest",
"executable")
guiBridgeLibWxWidgetsTestApp.AddIncludeFolders(["src"])
guiBridgeLibWxWidgetsTestApp.AddSources(["src/*.cpp", "src/*.h"])
guiBridgeLibWxWidgetsTestApp.AddProjects([guiBridgeLibWxWidgets])
