Page MenuHomePhabricator
Files F5693847

No OneTemporary
Actions

View Options

This document is not UTF8. It was detected as ISO-8859-1 (Latin 1) and converted to UTF8 for display.
diff --git a/Applications/CMakeLists.txt b/Applications/CMakeLists.txt
index 0a913738b9..9968d8a59b 100644
--- a/Applications/CMakeLists.txt
+++ b/Applications/CMakeLists.txt
@@ -1,17 +1,21 @@
SET(MITK_CPACK_PACKAGE_EXECUTABLES "" CACHE INTERNAL "Collecting windows shortcuts to executables" FORCE)
IF(MITK_USE_QT AND QT4_FOUND)
+
+ IF(MITK_USE_CTK)
+ ADD_SUBDIRECTORY(PluginGenerator)
+ ENDIF()
IF(MITK_USE_BLUEBERRY)
IF(MITK_BUILD_org.mitk.gui.qt.application OR MITK_BUILD_ALL_PLUGINS)
ADD_SUBDIRECTORY(CoreApp)
ENDIF()
IF(MITK_BUILD_org.mitk.gui.qt.extapplication OR MITK_BUILD_ALL_PLUGINS)
ADD_SUBDIRECTORY(ExtApp)
ENDIF()
ENDIF()
IF(MITK_BUILD_TUTORIAL)
ADD_SUBDIRECTORY(Tutorial)
ENDIF()
ENDIF()
diff --git a/Applications/PluginGenerator/CMakeLists.txt b/Applications/PluginGenerator/CMakeLists.txt
new file mode 100644
index 0000000000..0106f4fdcb
--- /dev/null
+++ b/Applications/PluginGenerator/CMakeLists.txt
@@ -0,0 +1,70 @@
+cmake_minimum_required(VERSION 2.8.4)
+
+project(MITKPluginGenerator)
+
+set(VERSION_MAJOR 1)
+set(VERSION_MINOR 0)
+set(VERSION_PATCH 0)
+
+if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME)
+ set(standalone_build 1)
+else()
+ set(standalone_build 0)
+endif()
+
+#-----------------------------------------------------------------------------
+# Prerequesites
+#-----------------------------------------------------------------------------
+
+set(QT_DONT_USE_QTGUI 1)
+find_package(Qt 4.6.2 REQUIRED)
+
+include(${QT_USE_FILE})
+
+#-----------------------------------------------------------------------------
+# Executable
+#-----------------------------------------------------------------------------
+
+set(src_files
+ PluginGenerator.cpp
+ ctkCommandLineParser.cpp
+)
+
+qt4_wrap_cpp(src_files ctkCommandLineParser.h)
+qt4_add_resources(src_files plugin_template.qrc project_template.qrc)
+
+set(exec_target ${PROJECT_NAME})
+add_executable(${exec_target} ${src_files})
+target_link_libraries(${exec_target} ${QT_LIBRARIES})
+
+if(NOT standalone_build)
+ # subproject support
+ add_dependencies(MITK-CoreUI ${exec_target})
+endif()
+
+#-----------------------------------------------------------------------------
+# Win32 Convenience
+#-----------------------------------------------------------------------------
+
+if(WIN32 AND NOT standalone_build)
+ file(TO_NATIVE_PATH "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${CMAKE_CFG_INTDIR}" native_runtime_dir)
+ add_custom_target(NewPlugin start "MITK PluginGenerator" /D "${native_runtime_dir}" cmd /K ${exec_target}.exe -h
+ DEPENDS ${exec_target})
+endif()
+
+#-----------------------------------------------------------------------------
+# Testing
+#-----------------------------------------------------------------------------
+
+if(NOT standalone_build)
+ # Test the plugin generator
+ include(mitkTestPluginGenerator)
+endif()
+
+#-----------------------------------------------------------------------------
+# Packaging support
+#-----------------------------------------------------------------------------
+
+if(standalone_build)
+ include(SetupPackaging.cmake)
+endif()
diff --git a/Applications/PluginGenerator/MITKCopyright.txt b/Applications/PluginGenerator/MITKCopyright.txt
new file mode 100644
index 0000000000..70a3ffbe02
--- /dev/null
+++ b/Applications/PluginGenerator/MITKCopyright.txt
@@ -0,0 +1,35 @@
+/*=========================================================================
+
+Copyright (c) 2003-2010 German Cancer Research Center, Division of Medical
+and Biological Informatics
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ * The name of the German Cancer Research Center, nor the names of any
+ contributors, may be used to endorse or promote products derived from this
+ software without specific prior written permission.
+
+ * Modified source versions must be plainly marked as such, and must not be
+ misrepresented as being the original software.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS''
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=========================================================================*/
diff --git a/Applications/PluginGenerator/MITKLicense.txt b/Applications/PluginGenerator/MITKLicense.txt
new file mode 100644
index 0000000000..36c7283585
--- /dev/null
+++ b/Applications/PluginGenerator/MITKLicense.txt
@@ -0,0 +1,16 @@
+/*=========================================================================
+
+Program: Medical Imaging & Interaction Toolkit
+Language: C++
+Date: $Date$
+Version: $Revision$
+
+Copyright (c) German Cancer Research Center, Division of Medical and
+Biological Informatics. All rights reserved.
+See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
+
+This software is distributed WITHOUT ANY WARRANTY; without even
+the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+PURPOSE. See the above copyright notices for more information.
+
+=========================================================================*/
diff --git a/Applications/PluginGenerator/PluginGenerator.cpp b/Applications/PluginGenerator/PluginGenerator.cpp
new file mode 100644
index 0000000000..7663f9b7d1
--- /dev/null
+++ b/Applications/PluginGenerator/PluginGenerator.cpp
@@ -0,0 +1,402 @@
+/*=========================================================================
+
+Program: Medical Imaging & Interaction Toolkit
+Language: C++
+Date: $Date$
+Version: $Revision$
+
+Copyright (c) German Cancer Research Center, Division of Medical and
+Biological Informatics. All rights reserved.
+See MITKCopyright.txt or http://www.mitk.org/ for details.
+
+This software is distributed WITHOUT ANY WARRANTY; without even
+the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+PURPOSE. See the above copyright notices for more information.
+
+=========================================================================*/
+
+#include "ctkCommandLineParser.h"
+
+#include <QCoreApplication>
+#include <QTextStream>
+#include <QDebug>
+#include <QFile>
+#include <QDir>
+
+#include <cstdlib>
+#include <iostream>
+#include <limits>
+#include <cctype>
+
+bool readAnswer(char defaultAnswer)
+{
+ std::string line;
+ std::cin >> std::noskipws >> line;
+
+ // consume the new line character
+ std::cin.clear();
+ std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+
+ char answer = defaultAnswer;
+ if (!line.empty() && line[0] != '\n')
+ {
+ answer = std::tolower(line[0]);
+ }
+
+ if (answer == 'y') return true;
+ if (answer == 'n') return false;
+ if (defaultAnswer == 'y') return true;
+ return false;
+}
+
+void createFilePathMapping(const QString& templateName, const QString& baseInDir, const QString& baseOutDir, QHash<QString, QString>& fileNameMapping)
+{
+ QFileInfo info(templateName);
+ if (info.isDir())
+ {
+ QStringList subEntries = QDir(templateName).entryList();
+ foreach(QString subEntry, subEntries)
+ {
+ createFilePathMapping(templateName + "/" + subEntry, baseInDir, baseOutDir, fileNameMapping);
+ }
+ return;
+ }
+
+ fileNameMapping[templateName] = QString(templateName).replace(baseInDir, baseOutDir);
+}
+
+QHash<QString,QString> createTemplateFileMapping(const QString& qrcBase, const QString& baseOutDir, const QHash<QString, QString>& fileNameMapping)
+{
+ QHash<QString,QString> filePathMapping;
+ createFilePathMapping(qrcBase, qrcBase, baseOutDir, filePathMapping);
+
+ QMutableHashIterator<QString,QString> i(filePathMapping);
+ while(i.hasNext())
+ {
+ i.next();
+ QHashIterator<QString,QString> j(fileNameMapping);
+ while(j.hasNext())
+ {
+ j.next();
+ i.setValue(i.value().replace(j.key(), j.value()));
+ }
+ }
+
+ return filePathMapping;
+}
+
+bool generateFiles(const QHash<QString, QString>& parameters,
+ const QHash<QString, QString>& filePathMapping)
+{
+ QHashIterator<QString,QString> paths(filePathMapping);
+ while(paths.hasNext())
+ {
+ paths.next();
+ QFile templ(paths.key());
+ templ.open(QIODevice::ReadOnly);
+ QByteArray templContent = templ.readAll();
+
+ QHashIterator<QString,QString> i(parameters);
+ while (i.hasNext())
+ {
+ i.next();
+ templContent.replace(i.key(), QByteArray(i.value().toLatin1()));
+ }
+
+ QFile outTempl(paths.value());
+ QDir dir(QFileInfo(outTempl).dir());
+ if (!dir.exists())
+ {
+ if (!dir.mkpath(dir.absolutePath()))
+ {
+ qCritical() << "Could not create directory" << dir.absolutePath();
+ return EXIT_FAILURE;
+ }
+ }
+
+ if (!outTempl.open(QIODevice::WriteOnly))
+ {
+ qCritical() << outTempl.errorString();
+ return false;
+ }
+ outTempl.write(templContent);
+ }
+
+ return true;
+}
+
+int main(int argc, char** argv)
+{
+ QCoreApplication app(argc, argv);
+ app.setApplicationName("PluginGenerator");
+ app.setOrganizationName("DKFZ");
+
+ ctkCommandLineParser parser;
+ // Use Unix-style argument names
+ parser.setArgumentPrefix("--", "-");
+ parser.setStrictModeEnabled(true);
+
+ // Add command line argument names
+ parser.addArgument("help", "h", QVariant::Bool, "Show this help text");
+ parser.addArgument("out-dir", "o", QVariant::String, "Output directory", QDir::tempPath());
+ parser.addArgument("license", "l", QVariant::String, "Path to a file containing license information", ":/MITKLicense.txt");
+ parser.addArgument("vendor", "v", QVariant::String, "The vendor of the generated code", "DKFZ, Medical and Biological Informatics");
+ parser.addArgument("quiet", "q", QVariant::Bool, "Do not print additional information");
+ parser.addArgument("confirm-all", "y", QVariant::Bool, "Answer all questions with 'yes'");
+
+ parser.beginGroup("Plug-in options");
+ parser.addArgument("plugin-symbolic-name", "ps", QVariant::String, "The plugin's symbolic name");
+ parser.setExactMatchRegularExpression("-ps", "^[a-zA-Z]+\\.[a-zA-Z0-9._]+[^\\.]$", "Symbolic name invalid");
+ parser.addArgument("plugin-name", "pn", QVariant::String, "The plug-in's human readable name");
+
+ parser.beginGroup("Plug-in View options");
+ parser.addArgument("view-class", "vc", QVariant::String, "The View's' class name");
+ parser.addArgument("view-name", "vn", QVariant::String, "The View's human readable name");
+
+ parser.beginGroup("Project options");
+ parser.addArgument("project-copyright", "", QVariant::String, "Path to a file containing copyright information", ":/MITKCopyright.txt");
+ parser.addArgument("project-name", "", QVariant::String, "The project name");
+ parser.setExactMatchRegularExpression("--project-name", "^[a-zA-Z_\\-]+$", "Project name invalid");
+ parser.addArgument("project-app-name", "", QVariant::String, "The application name");
+ parser.setExactMatchRegularExpression("--project-app-name", "^[a-zA-Z_\\-]+$", "Project application name invalid");
+ parser.endGroup();
+
+
+ // Parse the command line arguments
+ bool ok = false;
+ QHash<QString, QVariant> parsedArgs = parser.parseArguments(QCoreApplication::arguments(), &ok);
+ if (!ok)
+ {
+ QTextStream(stderr, QIODevice::WriteOnly) << "Error parsing arguments: "
+ << parser.errorString() << "\n";
+ return EXIT_FAILURE;
+ }
+
+ QTextStream out(stdout, QIODevice::WriteOnly);
+
+ // Show a help message
+ if (parsedArgs.contains("help"))
+ {
+ out << "A CTK plug-in generator for MITK\n\n"
+ << parser.helpText();
+ return EXIT_SUCCESS;
+ }
+
+ // Check arguments
+
+ // Project options
+ QString projectName = parsedArgs["project-name"].toString();
+ QString projectAppName = parsedArgs["project-app-name"].toString();
+ QString copyrightPath = QDir::fromNativeSeparators(parsedArgs["project-copyright"].toString());
+
+ bool createProject = !projectName.isEmpty();
+ if (createProject && projectAppName.isEmpty())
+ {
+ projectAppName = projectName;
+ }
+
+ QString pluginSymbolicName = parsedArgs["plugin-symbolic-name"].toString();
+ if (pluginSymbolicName.isEmpty())
+ {
+ qCritical() << "Required argument 'plugin-symbolic-name' missing.";
+ return EXIT_FAILURE;
+ }
+
+ QString pluginTarget(pluginSymbolicName);
+ pluginTarget.replace('.', '_');
+
+ QString outDir = QDir::fromNativeSeparators(parsedArgs["out-dir"].toString());
+ QString licensePath = QDir::fromNativeSeparators(parsedArgs["license"].toString());
+ QString pluginExportDirective = pluginSymbolicName.split('.').last().toUpper() + "_EXPORT";
+
+ QString pluginName = parsedArgs["plugin-name"].toString();
+ if (pluginName.isEmpty())
+ {
+ QStringList toks = pluginSymbolicName.split('.');
+ pluginName = toks.last();
+ pluginName[0] = pluginName[0].toUpper();
+ }
+
+ QString vendor = parsedArgs["vendor"].toString();
+
+ QString viewName = parsedArgs["view-name"].toString();
+ if (viewName.isEmpty())
+ {
+ qCritical() << "Required argument 'view-name' missing.";
+ return EXIT_FAILURE;
+ }
+
+ QStringList toks = viewName.split(QRegExp("\\s"), QString::SkipEmptyParts);
+ QString viewClass = parsedArgs["view-class"].toString();
+ if (viewClass.isEmpty())
+ {
+ foreach(QString tok, toks)
+ {
+ QString tmp = tok;
+ tmp[0] = tmp[0].toUpper();
+ viewClass += tmp;
+ }
+ }
+
+ QString viewId;
+ if (viewId.isEmpty())
+ {
+ viewId = "org.mitk.views.";
+ foreach(QString tok, toks)
+ {
+ viewId += tok.toLower();
+ }
+ }
+
+ bool quiet = parsedArgs.contains("quiet");
+ bool autoConfirm = parsedArgs.contains("confirm-all");
+
+ if (!outDir.endsWith('/'))
+ outDir += '/';
+ if (createProject)
+ outDir += projectName;
+ else
+ outDir += pluginSymbolicName;
+
+ // Print the collected information
+ if(!quiet)
+ {
+ if (createProject)
+ {
+ out << "Using the following information to create a project:\n\n"
+ << " Project Name: " << projectName << '\n'
+ << " Application Name: " << projectAppName << '\n'
+ << " Copyright File: " << QDir::toNativeSeparators(copyrightPath) << '\n';
+ }
+ else
+ {
+ out << "Using the following information to create a plug-in:\n\n";
+ }
+
+ out << " License File: " << QDir::toNativeSeparators(licensePath) << '\n'
+ << " Plugin-SymbolicName: " << pluginSymbolicName << '\n'
+ << " Plugin-Name: " << pluginName << '\n'
+ << " Plugin-Vendor: " << vendor << '\n'
+ << " View Name: " << viewName << '\n'
+ << " View Id: " << viewId << '\n'
+ << " View Class: " << viewClass << '\n' << '\n'
+ << "Create in: " << outDir << '\n' << '\n';
+
+ if (!autoConfirm)
+ out << "Continue [Y/n]? ";
+
+ out.flush();
+
+ if(!autoConfirm && !readAnswer('y'))
+ {
+ out << "Aborting.\n";
+ return EXIT_SUCCESS;
+ }
+ }
+
+ // Check the output directory
+ if (!QDir(outDir).exists())
+ {
+ if (!autoConfirm)
+ {
+ out << "Directory '" << outDir << "' does not exist. Create it [Y/n]? ";
+ out.flush();
+ }
+
+ if (autoConfirm || readAnswer('y'))
+ {
+ if (!QDir().mkpath(outDir))
+ {
+ qCritical() << "Could not create directory:" << outDir;
+ return EXIT_FAILURE;
+ }
+ }
+ else
+ {
+ out << "Aborting.\n";
+ return EXIT_SUCCESS;
+ }
+
+ }
+
+ if (!QDir(outDir).entryList(QDir::AllEntries | QDir::NoDotAndDotDot).isEmpty())
+ {
+ if (!autoConfirm)
+ {
+ out << "Directory '" << outDir << "' is not empty. Continue [y/N]? ";
+ out.flush();
+ }
+
+ if (!autoConfirm && !readAnswer('n'))
+ {
+ out << "Aborting.\n";
+ return EXIT_SUCCESS;
+ }
+ }
+
+ // Extract the license text
+ QFile licenseFile(licensePath);
+ if (!licenseFile.open(QIODevice::ReadOnly))
+ {
+ qCritical() << "Cannot open file" << licenseFile.fileName();
+ return EXIT_FAILURE;
+ }
+ QString licenseText = licenseFile.readAll();
+ licenseFile.close();
+
+ QHash<QString,QString> parameters;
+ if (createProject)
+ {
+ // Extract the copyright
+ QFile copyrightFile(copyrightPath);
+ if (!copyrightFile.open(QIODevice::ReadOnly))
+ {
+ qCritical() << "Cannot open file" << copyrightFile.fileName();
+ return EXIT_FAILURE;
+ }
+ QString copyrighText = copyrightFile.readAll();
+ copyrightFile.close();
+
+ parameters["$(copyright)"] = copyrighText;
+ parameters["$(project-name)"] = projectName;
+ parameters["$(project-app-name)"] = projectAppName;
+ parameters["$(project-plugins)"] = QString("Plugins/") + pluginSymbolicName + ":ON";
+
+ QStringList toks = pluginTarget.split("_");
+ QString projectPluginBase = toks[0] + "_" + toks[1];
+ parameters["$(project-plugin-base)"] = projectPluginBase;
+ }
+ parameters["$(license)"] = licenseText;
+ parameters["$(plugin-name)"] = pluginName;
+ parameters["$(plugin-symbolic-name)"] = pluginSymbolicName;
+ parameters["$(vendor)"] = vendor;
+ parameters["$(plugin-target)"] = pluginTarget;
+ parameters["$(plugin-export-directive)"] = pluginExportDirective;
+ parameters["$(view-id)"] = viewId;
+ parameters["$(view-name)"] = viewName;
+ parameters["$(view-file-name)"] = viewClass;
+ parameters["$(view-class-name)"] = viewClass;
+
+ if (createProject)
+ {
+ QHash<QString,QString> projectFileNameMapping;
+ projectFileNameMapping["TemplateApp"] = projectAppName;
+
+ QHash<QString,QString> filePathMapping = createTemplateFileMapping(":/ProjectTemplate", outDir, projectFileNameMapping);
+ generateFiles(parameters, filePathMapping);
+ }
+
+ QHash<QString,QString> pluginFileNameMapping;
+ pluginFileNameMapping["QmitkTemplateView"] = viewClass;
+
+ if (createProject)
+ {
+ if (!outDir.endsWith('/'))
+ outDir += '/';
+ outDir += "Plugins/" + pluginSymbolicName;
+ }
+ QHash<QString,QString> filePathMapping = createTemplateFileMapping(":/PluginTemplate", outDir, pluginFileNameMapping);
+ generateFiles(parameters, filePathMapping);
+
+ return EXIT_SUCCESS;
+}
diff --git a/Applications/PluginGenerator/PluginTemplate/CMakeLists.txt b/Applications/PluginGenerator/PluginTemplate/CMakeLists.txt
new file mode 100644
index 0000000000..abb155621c
--- /dev/null
+++ b/Applications/PluginGenerator/PluginTemplate/CMakeLists.txt
@@ -0,0 +1,7 @@
+project($(plugin-target))
+
+MACRO_CREATE_MITK_CTK_PLUGIN(
+ EXPORT_DIRECTIVE $(plugin-export-directive)
+ EXPORTED_INCLUDE_SUFFIXES src
+ MODULE_DEPENDENCIES QmitkExt
+)
diff --git a/Applications/PluginGenerator/PluginTemplate/documentation/Manual/Manual.dox b/Applications/PluginGenerator/PluginTemplate/documentation/Manual/Manual.dox
new file mode 100755
index 0000000000..84b8b5dd98
--- /dev/null
+++ b/Applications/PluginGenerator/PluginTemplate/documentation/Manual/Manual.dox
@@ -0,0 +1,19 @@
+/**
+\bundlemainpage{$(plugin-symbolic-name)} $(plugin-name)
+
+\image html icon.png "Icon of $(plugin-name)"
+
+Available sections:
+ - \ref $(plugin-symbolic-name)Overview
+
+\section $(plugin-symbolic-name)Overview
+Describe the features of your awesome plugin here
+<ul>
+<li>Increases productivity
+<li>Creates beautiful images
+<li>Generates PhD thesis
+<li>Brings world peace
+</ul>
+
+*/
+
diff --git a/Applications/PluginGenerator/PluginTemplate/documentation/Manual/icon.png b/Applications/PluginGenerator/PluginTemplate/documentation/Manual/icon.png
new file mode 100644
index 0000000000..7a51d8cb11
--- /dev/null
+++ b/Applications/PluginGenerator/PluginTemplate/documentation/Manual/icon.png
@@ -0,0 +1,26 @@
+‰PNG
+
+
+•|€©$¦Š@IQIaSR•TRPyUÀ/­dKÁ6ے‘eëe=VÒJûÞyõtߓÝ=ÓÓ;+Ù Nü©ÚšÙîž{ï9÷œÿ9çîÀ¯_¿~½ª_?ûÙÏ^ÑñåW=`î¾jŸèlºæ}~n‹ 7ˆÊZT‡Œh7*í¨"h‘9QpÐs®Øþvç‘gß=:bÓc<òÈ#ìÙ³çÕ©
+#EuÎ}ºà؇þzû±oýöö”Óó=úè£Üy睯8÷ ïíˆqßÂzU>%»DµSQƒÅ€Ò×fXÓe*ݞЩ€Zh™¯*WŠ–ñù™Rˆ0‚5¨¨v:á¿oé]øÒ÷>rý"¯ 0”°/DÜ¿àd-èçP½GròºeБ[‡\npèkT›'‰>‹D˜ó•ç.×xê‚ϱ‰šVj*µPUzrÁC¯˜¿o÷ÐÜS¿ÿŽ'æE>
+À°Ö222òÊ+@î/¢ñŽËýÅë>Šê'èõ`]·£;V¸²}¹KޅPÁ*¨*o_]p
+H®׀çÀ‚¯<9îóø™ªž› d¦’Â5…êßÝÚWü篼ó±'éýêÈ4
+ÀÁƒÙ½{÷¯Puዮ ßWÕ7·­ÏéÎ.9â]‹?4 ±H-¬ÁÈb|hVŽb¢i¨–GN”õ[O/ˆç ËÛkÿõ‘›ÆÿüÎóß²óîé—6¯­€/”àc¸¿ÔŽðª[;r»7zzû #ª &<R£‘MÖÔS×ëÂk›¬ ~¶I=}Oyþ²¯_98+Õ@Y‘¯=óñ­g?½¦à?1::rñ¥*aiÜWÇF¡؉ʏQÝÙ㉾ïOnpðÃxAdv±•Ég>g­d‘ÅÈÕ¬DG„““>ÿòجN­\W¨>óÉÛÎ~fu§ÿؔßvá7ïÚÍ¡C‡ð}Éa–ð±ðV
+¨|«;{Û ¼±M^ÛïPKÚ¬F›¡=õk!Öltßs Ëƒ¾ `¨
+®2¯E°
+A¨¼yk+{s\*¹«÷÷¼eÁw¶#˓qüñ«(à åÄ÷W¢úρmCŽôy±ð*XR“Ó
+—‹p©“e¨…K[G¢„î6xMoMl‹h£¤7CXћ“mëòz¹d:žœè¸£šMª¬IÆ=tèP£”oü€w:;–åÄ5B`#ݦwÅjŒâqҒ$/6YMJ¨¹*œœ†‹ ʗjÑsm `ÛJXÑÙ#’`M7¼0©¦’¥d-iÌ9ÂÖµž;_áç—:¶ýÖºéC+:üÓcccGFFæwíÚÕÂóùT½åyÑë» ~H“é7™=)ßO]³qî^®ÁÃ'áëÏFïO^€gàJ ¦Ë‘<;ß==»F‰BèÕ,®áŠUX՗“ Ë<­ïà…®×;ÂZ`ÅÒ ø±<<P*
+üD6£8×w;ØHOÆ÷ÓæGc‡Zùi+ì°
+¾…U]°®§u¨L¬æâ|sHm…͘¥H«Úpå…éüÏè Â`†ÀÞ½{›¢ÀZ”•
+С‚'´9ˆÆhºÈücM‡×ÐÌÎ.Š ™1Bj„·lŒB\@fRã§'¢ÈÑï3•Í l¬¸Á#hhŜšm[™3Ú£ªûöíË&B:€Ò×ëI¼pi65myuPÊ,¨é+"+ïÂ;n„›VÑJø‰"ì;í~2V¨-\¡Ed
+-t\Œˆ Êø‚7àºE¤ÓÄ5rʤlwG.šÉ&¦¤©Ê+ÅèÔÍ?6E£ÍæŸv‹º+ÅBåspÏXۓ2ÛLÁ$ >|õp#é²)’5Ô¨@ۘ7Læ«_¾Pð 3>2Su»Œh§ªv¨ªl]F5oi3 $šý8Ê&B¦h­0QBê;Mø'H>>»ë%J_6
+¥MìRj\kã I¯%‹Ñ¼‚µÐî(ÕL»@ȋH³¨ª àˆÔ‰ˆ¹4ÃÓ©¶XP, \å¾kà]7GyýRi/DdÈwŽE™¢#`M›ÚEŠÐFyî:Q8,9 '"^B¸ÉEUµ ÐÒDG3¶0ñ¥îÇ߯†ð–õ°y¨µðɵssðÍ£è¹&Us¤ mme¶Nž¦Ö'l¢`¢àSUטh‹
+@k
+|õHôϓ ¥æëJ¯ÛµÀ"(í®EµÎꈪ¦]@Š A%P×jJ“×P6’8}ßƶ—°8¡Â꘻ôíc0UŽwÞ6*Á¦¹¤a‹Ö•YK̅r5ª¹»<Zƒ‘ªŠHCFìŒ*³Åš„4£kS‹K»¶¦Ò÷“d*´ÐíET×RLÕ(Þ{i³×Œk%}„Ôçì¼MkA¨øà×,F` _óCÈꄷI¹
+Ûü¼M‘"M|‚f®i‹’ܶ(Ém\#¤X©Ë3UJå@E`Ûʅ™š•i`(íÝ»w1+<ñG}.”“3AœnjƒŠ¶
+<!$ìb¢$¹–°H* ÚîD­±v'ª Úݨ0rœÆXš¢¿Cm¦Ä[­ES
+ “Ï—&+,”C¹eYÙvæìe«2)"SªZJºÇn—?XûÆLÍÝzz®&7ôåÄÄH¥éŒ, F™L0 F‚'ð¡­ù‘
+°gϞ†8p
+³ Jƒ`lÂKž<“殏f‘VN¶3”¥àj5ˉ³s„Ê]¯™«xŽž΋ÈxŒWï þñ¦S_l3vz¶jå̜¯ ªÚĈÕÅDH؂H¹V3ޑ¥Q½•5´ŠV£¨uîb‘K“U¹y°Â¦þÊ%#zô,p~dd¤’îšìqT€ßÛ|bü֞…ÏZ gg}™)‡1Òj=üeim›ª¼Òi¢®Ñtd1Ël[)¶`„R½ÁJ%àȱiÍç`çêbiyGí pxQU/%ó%=Â&ìÙ³‡ýû÷#ëï±÷¬ºðÍe^õÀ‚rjºŠ¨*B˜tˆS´vØ"¤i)›Ê—T€ÓºšØfоѓˆ6&´Ê“G®Z+¯*Û«.Xå¸*'EäÔèèhñšíñä áGo¸xñ ˦>ßéÚKç檜­Öµ¬hK0²KðtFççáôÌâ¿ssQhiAr.Jp·Â”ˆù9z|š©™
+C…·n˜™î̅Ï[•€"r> öK7GcW›÷„OúñÁ3Åö/ý|ºûS'&+y× k{ÛŪÔOfd‰p‰b©\ƒ|:s™SI-`R¬oúûM,šj(¼X…3gç8{~^syû¦éò¦ÊñrÍ=&"ÏWðƒÔÁþª
+HŽ–m½ã'³Ÿ®æþõ“G6^ÿËùÂRkaÝ@;֦θ]ƒ(‘¸U5]Y|f0Ý6©Z>!ZÉtMº ×hî³ãsœ|qF«È‡·N¿±jád%# ¿‘_ŠÈ€žžž—qJ ùKní?÷W·{ð†ŽÒ÷ §§Êzâr9&&‘·•©fk„ô¹ô)¥D–¥úiWh
diff --git a/Applications/PluginGenerator/PluginTemplate/documentation/doxygen/modules.dox b/Applications/PluginGenerator/PluginTemplate/documentation/doxygen/modules.dox
new file mode 100644
index 0000000000..d29e765f4d
--- /dev/null
+++ b/Applications/PluginGenerator/PluginTemplate/documentation/doxygen/modules.dox
@@ -0,0 +1,16 @@
+/**
+ \defgroup $(plugin-target) $(plugin-symbolic-name) Plugin
+ \ingroup MITKPlugins
+
+ \brief Describe your plugin here.
+
+*/
+
+/**
+ \defgroup $(plugin-target)_internal Internal
+ \ingroup $(plugin-target)
+
+ \brief This subcategory includes the internal classes of the $(plugin-symbolic-name) plugin. Other
+ plugins must not rely on these classes. They contain implementation details and their interface
+ may change at any time. We mean it.
+*/
diff --git a/Applications/PluginGenerator/PluginTemplate/files.cmake b/Applications/PluginGenerator/PluginTemplate/files.cmake
new file mode 100644
index 0000000000..b95ed676d3
--- /dev/null
+++ b/Applications/PluginGenerator/PluginTemplate/files.cmake
@@ -0,0 +1,43 @@
+set(SRC_CPP_FILES
+
+)
+
+set(INTERNAL_CPP_FILES
+ mitkPluginActivator.cpp
+ $(view-file-name).cpp
+)
+
+set(UI_FILES
+ src/internal/$(view-file-name)Controls.ui
+)
+
+set(MOC_H_FILES
+ src/internal/mitkPluginActivator.h
+ src/internal/$(view-file-name).h
+)
+
+# list of resource files which can be used by the plug-in
+# system without loading the plug-ins shared library,
+# for example the icon used in the menu and tabs for the
+# plug-in views in the workbench
+set(CACHED_RESOURCE_FILES
+ resources/icon.xpm
+ plugin.xml
+)
+
+# list of Qt .qrc files which contain additional resources
+# specific to this plugin
+set(QRC_FILES
+
+)
+
+set(CPP_FILES )
+
+foreach(file ${SRC_CPP_FILES})
+ set(CPP_FILES ${CPP_FILES} src/${file})
+endforeach(file ${SRC_CPP_FILES})
+
+foreach(file ${INTERNAL_CPP_FILES})
+ set(CPP_FILES ${CPP_FILES} src/internal/${file})
+endforeach(file ${INTERNAL_CPP_FILES})
+
diff --git a/Applications/PluginGenerator/PluginTemplate/manifest_headers.cmake b/Applications/PluginGenerator/PluginTemplate/manifest_headers.cmake
new file mode 100644
index 0000000000..cc383dba7b
--- /dev/null
+++ b/Applications/PluginGenerator/PluginTemplate/manifest_headers.cmake
@@ -0,0 +1,5 @@
+set(Plugin-Name "$(plugin-name)")
+set(Plugin-Version "0.1")
+set(Plugin-Vendor "$(vendor)")
+set(Plugin-ContactAddress "")
+set(Require-Plugin org.mitk.gui.qt.common)
diff --git a/Applications/PluginGenerator/PluginTemplate/plugin.xml b/Applications/PluginGenerator/PluginTemplate/plugin.xml
new file mode 100644
index 0000000000..51215b975c
--- /dev/null
+++ b/Applications/PluginGenerator/PluginTemplate/plugin.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<plugin>
+
+ <extension point="org.blueberry.ui.views">
+ <view id="$(view-id)"
+ name="$(view-name)"
+ class="$(view-class-name)"
+ icon="resources/icon.xpm" />
+ </extension>
+
+</plugin>
diff --git a/Applications/PluginGenerator/PluginTemplate/resources/icon.xpm b/Applications/PluginGenerator/PluginTemplate/resources/icon.xpm
new file mode 100644
index 0000000000..9057c20bc6
--- /dev/null
+++ b/Applications/PluginGenerator/PluginTemplate/resources/icon.xpm
@@ -0,0 +1,21 @@
+/* XPM */
+static const char * icon_xpm[] = {
+"16 16 2 1",
+" c #FF0000",
+". c #000000",
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" ",
+" "};
diff --git a/Applications/PluginGenerator/PluginTemplate/src/internal/QmitkTemplateView.cpp b/Applications/PluginGenerator/PluginTemplate/src/internal/QmitkTemplateView.cpp
new file mode 100644
index 0000000000..4354ab0dc0
--- /dev/null
+++ b/Applications/PluginGenerator/PluginTemplate/src/internal/QmitkTemplateView.cpp
@@ -0,0 +1,94 @@
+$(license)
+
+// Blueberry
+#include <berryISelectionService.h>
+#include <berryIWorkbenchWindow.h>
+
+// Qmitk
+#include "$(view-file-name).h"
+#include "QmitkStdMultiWidget.h"
+
+// Qt
+#include <QMessageBox>
+
+
+const std::string $(view-class-name)::VIEW_ID = "$(view-id)";
+
+$(view-class-name)::$(view-class-name)()
+: QmitkFunctionality()
+{
+}
+
+$(view-class-name)::~$(view-class-name)()
+{
+}
+
+void $(view-class-name)::CreateQtPartControl( QWidget *parent )
+{
+ // create GUI widgets from the Qt Designer's .ui file
+ m_Controls.setupUi( parent );
+ connect( m_Controls.buttonPerformImageProcessing, SIGNAL(clicked()), this, SLOT(DoImageProcessing()) );
+}
+
+void $(view-class-name)::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
+{
+ // iterate all selected objects, adjust warning visibility
+ for( std::vector<mitk::DataNode*>::iterator it = nodes.begin();
+ it != nodes.end();
+ ++it )
+ {
+ mitk::DataNode::Pointer node = *it;
+
+ if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
+ {
+ m_Controls.labelWarning->setVisible( false );
+ m_Controls.buttonPerformImageProcessing->setEnabled( true );
+ return;
+ }
+ }
+
+ m_Controls.labelWarning->setVisible( true );
+ m_Controls.buttonPerformImageProcessing->setEnabled( false );
+}
+
+
+void $(view-class-name)::DoImageProcessing()
+{
+ std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
+ if (nodes.empty()) return;
+
+ mitk::DataNode* node = nodes.front();
+
+ if (!node)
+ {
+ // Nothing selected. Inform the user and return
+ QMessageBox::information( NULL, "Template", "Please load and select an image before starting image processing.");
+ return;
+ }
+
+ // here we have a valid mitk::DataNode
+
+ // a node itself is not very useful, we need its data item (the image)
+ mitk::BaseData* data = node->GetData();
+ if (data)
+ {
+ // test if this data item is an image or not (could also be a surface or something totally different)
+ mitk::Image* image = dynamic_cast<mitk::Image*>( data );
+ if (image)
+ {
+ std::stringstream message;
+ std::string name;
+ message << "Performing image processing for image ";
+ if (node->GetName(name))
+ {
+ // a property called "name" was found for this DataNode
+ message << "'" << name << "'";
+ }
+ message << ".";
+ MITK_INFO << message.str();
+
+ // actually do something here...
+
+ }
+ }
+}
diff --git a/Applications/PluginGenerator/PluginTemplate/src/internal/QmitkTemplateView.h b/Applications/PluginGenerator/PluginTemplate/src/internal/QmitkTemplateView.h
new file mode 100644
index 0000000000..570f90d6d7
--- /dev/null
+++ b/Applications/PluginGenerator/PluginTemplate/src/internal/QmitkTemplateView.h
@@ -0,0 +1,51 @@
+$(license)
+
+#ifndef $(view-file-name)_h
+#define $(view-file-name)_h
+
+#include <berryISelectionListener.h>
+
+#include <QmitkFunctionality.h>
+
+#include "ui_$(view-file-name)Controls.h"
+
+
+/*!
+ \brief $(view-class-name)
+
+ \warning This class is not yet documented. Use "git blame" and ask the author to provide basic documentation.
+
+ \sa QmitkFunctionality
+ \ingroup ${plugin_target}_internal
+*/
+class $(view-class-name) : public QmitkFunctionality
+{
+ // this is needed for all Qt objects that should have a Qt meta-object
+ // (everything that derives from QObject and wants to have signal/slots)
+ Q_OBJECT
+
+ public:
+
+ static const std::string VIEW_ID;
+
+ $(view-class-name)();
+ virtual ~$(view-class-name)();
+
+ virtual void CreateQtPartControl(QWidget *parent);
+
+ protected slots:
+
+ /// \brief Called when the user clicks the GUI button
+ void DoImageProcessing();
+
+ protected:
+
+ /// \brief called by QmitkFunctionality when DataManager's selection has changed
+ virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes );
+
+ Ui::$(view-file-name)Controls m_Controls;
+
+};
+
+#endif // $(view-file-name)_h
+
diff --git a/Applications/PluginGenerator/PluginTemplate/src/internal/QmitkTemplateViewControls.ui b/Applications/PluginGenerator/PluginTemplate/src/internal/QmitkTemplateViewControls.ui
new file mode 100644
index 0000000000..0f3aa65b82
--- /dev/null
+++ b/Applications/PluginGenerator/PluginTemplate/src/internal/QmitkTemplateViewControls.ui
@@ -0,0 +1,64 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>$(view-file-name)Controls</class>
+ <widget class="QWidget" name="$(view-file-name)Controls">
+ <property name="geometry">
+ <rect>
+ <x>0</x>
+ <y>0</y>
+ <width>222</width>
+ <height>161</height>
+ </rect>
+ </property>
+ <property name="minimumSize">
+ <size>
+ <width>0</width>
+ <height>0</height>
+ </size>
+ </property>
+ <property name="windowTitle">
+ <string>QmitkTemplate</string>
+ </property>
+ <layout class="QVBoxLayout" name="verticalLayout">
+ <item>
+ <widget class="QLabel" name="labelWarning">
+ <property name="styleSheet">
+ <string notr="true">QLabel { color: rgb(255, 0, 0) }</string>
+ </property>
+ <property name="text">
+ <string>Please select an image!</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QPushButton" name="buttonPerformImageProcessing">
+ <property name="toolTip">
+ <string>Do image processing</string>
+ </property>
+ <property name="text">
+ <string>Do Something</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <spacer name="spacer1">
+ <property name="orientation">
+ <enum>Qt::Vertical</enum>
+ </property>
+ <property name="sizeType">
+ <enum>QSizePolicy::Expanding</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>20</width>
+ <height>220</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ </layout>
+ </widget>
+ <layoutdefault spacing="6" margin="11"/>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/Applications/PluginGenerator/PluginTemplate/src/internal/mitkPluginActivator.cpp b/Applications/PluginGenerator/PluginTemplate/src/internal/mitkPluginActivator.cpp
new file mode 100644
index 0000000000..0d45eaca62
--- /dev/null
+++ b/Applications/PluginGenerator/PluginTemplate/src/internal/mitkPluginActivator.cpp
@@ -0,0 +1,23 @@
+$(license)
+
+#include "mitkPluginActivator.h"
+
+#include <QtPlugin>
+
+#include "$(view-file-name).h"
+
+namespace mitk {
+
+void PluginActivator::start(ctkPluginContext* context)
+{
+ BERRY_REGISTER_EXTENSION_CLASS($(view-class-name), context)
+}
+
+void PluginActivator::stop(ctkPluginContext* context)
+{
+ Q_UNUSED(context)
+}
+
+}
+
+Q_EXPORT_PLUGIN2($(plugin-target), mitk::PluginActivator)
diff --git a/Applications/PluginGenerator/PluginTemplate/src/internal/mitkPluginActivator.h b/Applications/PluginGenerator/PluginTemplate/src/internal/mitkPluginActivator.h
new file mode 100644
index 0000000000..d739a85347
--- /dev/null
+++ b/Applications/PluginGenerator/PluginTemplate/src/internal/mitkPluginActivator.h
@@ -0,0 +1,25 @@
+$(license)
+
+#ifndef MITKPLUGINACTIVATOR_H
+#define MITKPLUGINACTIVATOR_H
+
+#include <ctkPluginActivator.h>
+
+namespace mitk {
+
+class PluginActivator :
+ public QObject, public ctkPluginActivator
+{
+ Q_OBJECT
+ Q_INTERFACES(ctkPluginActivator)
+
+public:
+
+ void start(ctkPluginContext* context);
+ void stop(ctkPluginContext* context);
+
+}; // PluginActivator
+
+}
+
+#endif // MITKPLUGINACTIVATOR_H
diff --git a/Applications/PluginGenerator/ProjectTemplate/Apps/TemplateApp/CMakeLists.txt b/Applications/PluginGenerator/ProjectTemplate/Apps/TemplateApp/CMakeLists.txt
new file mode 100644
index 0000000000..5fd74fb0e3
--- /dev/null
+++ b/Applications/PluginGenerator/ProjectTemplate/Apps/TemplateApp/CMakeLists.txt
@@ -0,0 +1,86 @@
+#-----------------------------------------------------------------------------
+# Prerequesites
+#-----------------------------------------------------------------------------
+
+find_package(Qt REQUIRED)
+
+#-----------------------------------------------------------------------------
+# Include and linker directories
+#-----------------------------------------------------------------------------
+
+include(${QT_USE_FILE})
+
+include_directories(
+ ${org_blueberry_osgi_INCLUDE_DIRS}
+ ${Poco_INCLUDE_DIRS}
+ ${mbilog_INCLUDE_DIRS}
+ ${ALL_INCLUDE_DIRECTORIES}
+)
+
+#-----------------------------------------------------------------------------
+# Executable
+#-----------------------------------------------------------------------------
+
+if(${MY_PROJECT_NAME}_SHOW_CONSOLE_WINDOW)
+ add_executable(${MY_APP_NAME} MACOSX_BUNDLE ${MY_APP_NAME}.cpp)
+else()
+ add_executable(${MY_APP_NAME} MACOSX_BUNDLE WIN32 ${MY_APP_NAME}.cpp)
+endif()
+
+target_link_libraries(${MY_APP_NAME} org_blueberry_osgi ${ALL_LIBRARIES})
+if(WIN32)
+ target_link_libraries(${MY_APP_NAME} ${QT_QTCORE_LIBRARY} ${QT_QTMAIN_LIBRARY})
+endif()
+
+# Make sure all enabled plug-ins are up to date when building the application
+ctkFunctionExtractPluginTargets("${PROJECT_PLUGINS}" ON PROJECT_ENABLED_PLUGINS)
+if(PROJECT_ENABLED_PLUGINS)
+ add_dependencies(${MY_APP_NAME} ${PROJECT_ENABLED_PLUGINS})
+endif()
+
+#-----------------------------------------------------------------------------
+# Additional files needed for the executable
+#-----------------------------------------------------------------------------
+
+# Create a provisioning file, listing all enabled plug-ins
+set(PROJECT_PROVISIONING_FILE "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${MY_APP_NAME}.provisioning")
+FunctionCreateProvisioningFile(
+ FILE ${PROJECT_PROVISIONING_FILE}
+ INCLUDE "${MITK_PLUGIN_PROVISIONING_FILE}"
+ PLUGIN_DIR "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/plugins"
+ PLUGINS ${PROJECT_PLUGINS}
+ )
+
+# Create a .ini file for initial parameters
+configure_file(${MY_APP_NAME}.ini
+ ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${MY_APP_NAME}.ini)
+
+# Create batch files for Windows platforms
+if(WIN32)
+ foreach(BUILD_TYPE debug release)
+ mitkFunctionCreateWindowsBatchScript(start${MY_APP_NAME}.bat.in
+ ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/start${MY_APP_NAME}_${BUILD_TYPE}.bat
+ ${BUILD_TYPE})
+ endforeach()
+endif()
+
+#-----------------------------------------------------------------------------
+# Install support
+#-----------------------------------------------------------------------------
+
+# This installs all enabled CTK plug-ins
+FunctionInstallThirdPartyCTKPlugins(${CTK_PLUGIN_LIBRARIES})
+
+# Install the executable and its provisioning file
+MITK_INSTALL_TARGETS(EXECUTABLES ${MY_APP_NAME} GLOB_PLUGINS)
+mitkFunctionInstallProvisioningFiles(${MITK_PROVISIONING_FILES}
+ ${PROJECT_PROVISIONING_FILE})
+
+# On Linux, create a shell script to start a relocatable application
+if(UNIX AND NOT APPLE)
+ install(PROGRAMS "${MITK_SOURCE_DIR}/CMake/RunInstalledApp.sh" DESTINATION "." RENAME ${MY_APP_NAME}.sh)
+endif()
+
+# Tell cpack the executables that you want in the start menu as links
+set(MITK_CPACK_PACKAGE_EXECUTABLES "${MITK_CPACK_PACKAGE_EXECUTABLES}" "${MY_APP_NAME};MITK - ${MY_APP_NAME} Application" CACHE INTERNAL "Collecting windows shortcuts to executables")
+
diff --git a/Applications/PluginGenerator/ProjectTemplate/Apps/TemplateApp/TemplateApp.cpp b/Applications/PluginGenerator/ProjectTemplate/Apps/TemplateApp/TemplateApp.cpp
new file mode 100644
index 0000000000..58366de985
--- /dev/null
+++ b/Applications/PluginGenerator/ProjectTemplate/Apps/TemplateApp/TemplateApp.cpp
@@ -0,0 +1,28 @@
+$(license)
+
+#include <berryStarter.h>
+#include <Poco/Util/MapConfiguration.h>
+
+#include <QApplication>
+
+int main(int argc, char** argv)
+{
+ // Create a QApplication instance first
+ QApplication myApp(argc, argv);
+ myApp.setApplicationName("$(project-app-name)");
+ myApp.setOrganizationName("$(vendor)");
+
+ // These paths replace the .ini file and are tailored for installation
+ // packages created with CPack. If a .ini file is presented, it will
+ // overwrite the settings in MapConfiguration
+ Poco::Path basePath(argv[0]);
+ basePath.setFileName("");
+
+ Poco::Path provFile(basePath);
+ provFile.setFileName("$(project-app-name).provisioning");
+
+ Poco::Util::MapConfiguration* sbConfig(new Poco::Util::MapConfiguration());
+ sbConfig->setString(berry::Platform::ARG_PROVISIONING, provFile.toString());
+ sbConfig->setString(berry::Platform::ARG_APPLICATION, "org.mitk.qt.extapplication");
+ return berry::Starter::Run(argc, argv, sbConfig);
+}
diff --git a/Applications/PluginGenerator/ProjectTemplate/Apps/TemplateApp/TemplateApp.ini b/Applications/PluginGenerator/ProjectTemplate/Apps/TemplateApp/TemplateApp.ini
new file mode 100644
index 0000000000..b0adfb0dbc
--- /dev/null
+++ b/Applications/PluginGenerator/ProjectTemplate/Apps/TemplateApp/TemplateApp.ini
@@ -0,0 +1,2 @@
+BlueBerry.home=@BLUEBERRY_BINARY_DIR@
+BlueBerry.provisioning=@PROJECT_PROVISIONING_FILE@
diff --git a/Applications/PluginGenerator/ProjectTemplate/Apps/TemplateApp/startTemplateApp.bat.in b/Applications/PluginGenerator/ProjectTemplate/Apps/TemplateApp/startTemplateApp.bat.in
new file mode 100644
index 0000000000..1f31392d44
--- /dev/null
+++ b/Applications/PluginGenerator/ProjectTemplate/Apps/TemplateApp/startTemplateApp.bat.in
@@ -0,0 +1,2 @@
+PATH=@MITK_RUNTIME_PATH@;@CMAKE_RUNTIME_OUTPUT_DIRECTORY@\@VS_BUILD_TYPE@;@CMAKE_RUNTIME_OUTPUT_DIRECTORY@\plugins\@VS_BUILD_TYPE@;%PATH%
+@VS_BUILD_TYPE@\@MY_APP_NAME@.exe
diff --git a/Applications/PluginGenerator/ProjectTemplate/CMake/CPackSetup.cmake b/Applications/PluginGenerator/ProjectTemplate/CMake/CPackSetup.cmake
new file mode 100644
index 0000000000..bfe678051b
--- /dev/null
+++ b/Applications/PluginGenerator/ProjectTemplate/CMake/CPackSetup.cmake
@@ -0,0 +1,24 @@
+set(CPACK_PACKAGE_NAME ${PROJECT_NAME})
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "This is an awesome app")
+set(CPACK_PACKAGE_VENDOR "$(vendor)")
+set(CPACK_CREATE_DESKTOP_LINKS "${MY_APP_NAME}")
+set(CPACK_PACKAGE_DESCRIPTION_FILE "${PROJECT_SOURCE_DIR}/Copyright.txt")
+set(CPACK_RESOURCE_FILE_LICENSE "${PROJECT_SOURCE_DIR}/Copyright.txt")
+set(CPACK_PACKAGE_VERSION_MAJOR "${${PROJECT_NAME}_VERSION_MAJOR}")
+set(CPACK_PACKAGE_VERSION_MINOR "${${PROJECT_NAME}_VERSION_MINOR}")
+
+# append revision number if available
+if(${PROJECT_NAME}_REVISION_ID)
+ if(${PROJECT_NAME}_WC_TYPE STREQUAL "git")
+ set(git_hash ${${PROJECT_NAME}_REVISION_ID})
+ string(LENGTH "${git_hash}" hash_length)
+ if(hash_length GREATER 6)
+ string(SUBSTRING ${git_hash} 0 6 git_hash)
+ endif()
+ set(CPACK_PACKAGE_VERSION_PATCH "${${PROJECT_NAME}_VERSION_PATCH}_r${git_hash}")
+ else()
+ set(CPACK_PACKAGE_VERSION_PATCH "${${PROJECT_NAME}_VERSION_PATCH}_r${${PROJECT_NAME}_REVISION_ID}")
+ endif()
+else()
+ set(CPACK_PACKAGE_VERSION_PATCH "${${PROJECT_NAME}_VERSION_PATCH}")
+endif()
diff --git a/Applications/PluginGenerator/ProjectTemplate/CMake/CTestCustom.cmake.in b/Applications/PluginGenerator/ProjectTemplate/CMake/CTestCustom.cmake.in
new file mode 100644
index 0000000000..fb9b4d60f6
--- /dev/null
+++ b/Applications/PluginGenerator/ProjectTemplate/CMake/CTestCustom.cmake.in
@@ -0,0 +1,80 @@
+set(CTEST_CUSTOM_COVERAGE_EXCLUDE
+ ${CTEST_CUSTOM_COVERAGE_EXCLUDE}
+
+ # Exclude try_compile sources from coverage results:
+ "/CMakeFiles/CMakeTmp/"
+
+ # Exclude files generated by the moc pre-compiler
+ ".*/moc_.*"
+
+ # Exclude files generated by the uic pre-compiler
+ ".*/ui_.*"
+
+ # Exclude files from the Testing directories
+ ".*/Testing/.*"
+
+ ".*/CMakeExternals/.*"
+
+ )
+
+# The following tests should not be run under valgrind
+set(CTEST_CUSTOM_MEMCHECK_IGNORE
+
+ )
+
+set(CTEST_CUSTOM_ERROR_MATCH
+ ${CTEST_CUSTOM_ERROR_MATCH}
+ "CMake Error[ :]"
+ )
+
+set(CTEST_CUSTOM_WARNING_MATCH
+ ${CTEST_CUSTOM_WARNING_MATCH}
+ "CMake Warning[ :]"
+ )
+
+set(CTEST_CUSTOM_WARNING_EXCEPTION
+ ${CTEST_CUSTOM_WARNING_EXCEPTION}
+
+ # kwstyle suppressions
+ "[Kk][Ww][Ss]tyle.*kws.*cxx"
+ "[Kk][Ww][Ss]tyle.*kws.*h"
+ "[Kk][Ww][Ss]tyle.*metaCommand.*cxx"
+
+ # vtk suppressions
+ "vtkfreetype"
+ "Utilities.vtktiff"
+ "VTK.*IO.vtkMySQLQuery.cxx"
+ "VTK.*Utilities.vtkexodus2"
+ "VTK.*Utilities.vtklibproj"
+ "VTK.*Utilities.vtksqlite"
+ "VTK.*Utilities.vtkmetaio"
+ "VTK.*warn_unused_result"
+ "VTK.*Filtering.*cxx"
+ "VTK.*IO.*cxx"
+ "VTK.*Infovis.*cxx"
+
+ # qt suppressions from vtk...
+ # Some VTK dashboards include building bits of Qt which produce lots of
+ # the following warnings when built with the MS compilers. Qt guys should
+ # fix their code. Until they do, keep the Qt chatter off the VTK dashboard
+ # results:
+ "include.[Qq]t([Cc]ore|[Gg]ui).*warning C4127: conditional expression is constant"
+ "[Qq]t.*h.*warning.*declaration of .* shadows a member of .this"
+ "[Qq]t.*h.*warning.*(copy constructor|assignment operator) could not be generated"
+
+ # Suppress warning caused when QT 'foreach' loops are combined
+ ".*warning: declaration of '_container_' shadows a previous local"
+
+ # PythonQt suppressions
+ "PythonQt.*src.*PythonQt.*(cpp|h)"
+ "include.PythonQt.PythonQt.*h"
+
+ # Suppressing warnings about duplicate libraries in Darwin
+ # At some point this may be addressed by CMake feature request:
+ # http://public.kitware.com/Bug/view.php?id=10179
+ "ld: warning: duplicate dylib.*"
+
+ # Visual studio spurious warnings...
+ "The following environment variables were not found"
+
+ )
diff --git a/Applications/PluginGenerator/ProjectTemplate/CMake/MacroEmptyExternalProject.cmake b/Applications/PluginGenerator/ProjectTemplate/CMake/MacroEmptyExternalProject.cmake
new file mode 100644
index 0000000000..fa19380a82
--- /dev/null
+++ b/Applications/PluginGenerator/ProjectTemplate/CMake/MacroEmptyExternalProject.cmake
@@ -0,0 +1,18 @@
+
+#
+# Convenient macro allowing to define a "empty" project in case an external one is provided
+# using for example <proj>_DIR.
+# Doing so allows to keep the external project dependency system happy.
+#
+macro(MacroEmptyExternalProject proj dependencies)
+
+ ExternalProject_Add(${proj}
+ DOWNLOAD_COMMAND ""
+ CONFIGURE_COMMAND ""
+ BUILD_COMMAND ""
+ INSTALL_COMMAND ""
+ DEPENDS
+ ${dependencies}
+ )
+
+endmacro()
diff --git a/Applications/PluginGenerator/ProjectTemplate/CMake/StartVS.bat.in b/Applications/PluginGenerator/ProjectTemplate/CMake/StartVS.bat.in
new file mode 100644
index 0000000000..0b70b447cb
--- /dev/null
+++ b/Applications/PluginGenerator/ProjectTemplate/CMake/StartVS.bat.in
@@ -0,0 +1,6 @@
+@set CL=/D_CRT_SECURE_NO_DEPRECATE /D_CRT_NONSTDC_NO_DEPRECATE
+@set LINK=/LARGEADDRESSAWARE
+
+PATH=@MITK_RUNTIME_PATH@;@CMAKE_RUNTIME_OUTPUT_DIRECTORY@/@VS_BUILD_TYPE@;@CMAKE_RUNTIME_OUTPUT_DIRECTORY@/plugins/@VS_BUILD_TYPE@;%PATH%
+"@VS_SOLUTION_FILE@"
+
diff --git a/Applications/PluginGenerator/ProjectTemplate/CMakeExternals/MITK.cmake b/Applications/PluginGenerator/ProjectTemplate/CMakeExternals/MITK.cmake
new file mode 100644
index 0000000000..695a930245
--- /dev/null
+++ b/Applications/PluginGenerator/ProjectTemplate/CMakeExternals/MITK.cmake
@@ -0,0 +1,115 @@
+#-----------------------------------------------------------------------------
+# MITK
+#-----------------------------------------------------------------------------
+
+set(MITK_DEPENDS)
+set(proj_DEPENDENCIES)
+set(proj MITK)
+
+if(NOT MITK_DIR)
+
+ #-----------------------------------------------------------------------------
+ # Generate cmake variable names for BlueBerry bundles
+ #-----------------------------------------------------------------------------
+
+ option(MITK_USE_SUPERBUILD "Use superbuild for MITK" ON)
+ option(MITK_USE_BLUEBERRY "Build the BlueBerry platform in MITK" ON)
+ option(MITK_BUILD_TUTORIAL "Build the MITK tutorial" OFF)
+ option(MITK_BUILD_ALL_PLUGINS "Build all MITK plugins" OFF)
+ option(MITK_USE_CTK "Use CTK in MITK" ${MITK_USE_BLUEBERRY})
+ option(MITK_USE_GDCMIO "Use the GDCMIO class instead of ImageIO2 for DICOM" ON)
+ option(MITK_USE_DCMTK "Use DCMTK in MITK" ON)
+ option(MITK_USE_QT "Use Trolltech's Qt library in MITK" ON)
+ option(MITK_USE_Boost "Use the Boost library in MITK" OFF)
+ option(MITK_USE_OpenCV "Use Intel's OpenCV library" OFF)
+
+
+ mark_as_advanced(MITK_USE_SUPERBUILD
+ MITK_BUILD_ALL_PLUGINS
+ )
+
+ set(mitk_cmake_boolean_args
+ MITK_USE_SUPERBUILD
+ MITK_USE_BLUEBERRY
+ MITK_BUILD_TUTORIAL
+ MITK_BUILD_ALL_PLUGINS
+ MITK_USE_CTK
+ MITK_USE_GDCMIO
+ MITK_USE_DCMTK
+ MITK_USE_QT
+ MITK_USE_Boost
+ MITK_USE_OpenCV
+ )
+
+ #-----------------------------------------------------------------------------
+ # Create the final variable containing superbuild boolean args
+ #-----------------------------------------------------------------------------
+
+ set(mitk_boolean_args)
+ foreach(mitk_cmake_arg ${mitk_cmake_boolean_args})
+ list(APPEND mitk_boolean_args -D${mitk_cmake_arg}:BOOL=${${mitk_cmake_arg}})
+ endforeach()
+
+ #-----------------------------------------------------------------------------
+ # Additional MITK CMake variables
+ #-----------------------------------------------------------------------------
+
+ set(additional_mitk_cmakevars )
+ foreach(proj CTK DCMTK VTK ITK OpenCV)
+ if(${proj}_DIR)
+ list(APPEND additional_mitk_cmakevars "-D${proj}_DIR:PATH=${${proj}_DIR}")
+ endif()
+ endforeach()
+
+ if(MITK_USE_QT AND QT_QMAKE_EXECUTABLE)
+ list(APPEND additional_mitk_cmakevars "-DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}")
+ endif()
+
+ if(BOOST_ROOT)
+ list(APPEND additional_mitk_cmakevars "-DBOOST_ROOT:INTERNAL=${BOOST_ROOT}")
+ endif()
+
+ if(MITK_INITIAL_CACHE_FILE)
+ list(APPEND additional_mitk_cmakevars "-DMITK_INITIAL_CACHE_FILE:INTERNAL=${MITK_INITIAL_CACHE_FILE}")
+ endif()
+
+ if(MITK_USE_SUPERBUILD)
+ set(MITK_BINARY_DIR ${proj}-superbuild)
+ else()
+ set(MITK_BINARY_DIR ${proj}-build)
+ endif()
+
+ set(proj_DEPENDENCIES)
+ set(MITK_DEPENDS ${proj})
+
+ ExternalProject_Add(${proj}
+ SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}
+ BINARY_DIR ${MITK_BINARY_DIR}
+ PREFIX ${proj}${ep_suffix}
+ GIT_REPOSITORY "${git_protocol}://git.mitk.org/MITK.git"
+ GIT_TAG "origin/master"
+ INSTALL_COMMAND ""
+ CMAKE_GENERATOR ${gen}
+ CMAKE_ARGS
+ ${ep_common_args}
+ ${mitk_boolean_args}
+ ${additional_mitk_cmakevars}
+ -DBUILD_SHARED_LIBS:BOOL=ON
+ DEPENDS
+ ${proj_DEPENDENCIES}
+ )
+
+ if(MITK_USE_SUPERBUILD)
+ set(MITK_DIR "${CMAKE_CURRENT_BINARY_DIR}/${MITK_BINARY_DIR}/MITK-build")
+ else()
+ set(MITK_DIR "${CMAKE_CURRENT_BINARY_DIR}/${MITK_BINARY_DIR}")
+ endif()
+
+else()
+
+ # The project is provided using MITK_DIR, nevertheless since other
+ # projects may depend on MITK, let's add an 'empty' one
+ MacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
+
+endif()
+
diff --git a/Applications/PluginGenerator/ProjectTemplate/CMakeLists.txt b/Applications/PluginGenerator/ProjectTemplate/CMakeLists.txt
new file mode 100644
index 0000000000..1177f382ad
--- /dev/null
+++ b/Applications/PluginGenerator/ProjectTemplate/CMakeLists.txt
@@ -0,0 +1,364 @@
+cmake_minimum_required(VERSION 2.8.4)
+
+# Change project and application name to your own
+set(MY_PROJECT_NAME $(project-name))
+set(MY_APP_NAME $(project-app-name))
+
+#-----------------------------------------------------------------------------
+# Set a default build type if none was specified
+#-----------------------------------------------------------------------------
+
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+ message(STATUS "Setting build type to 'Debug' as none was specified.")
+ set(CMAKE_BUILD_TYPE Debug CACHE STRING "Choose the type of build." FORCE)
+
+ # Set the possible values of build type for cmake-gui
+ set_property(CACHE CMAKE_BUILD_TYPE PROPERTY
+ STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
+endif()
+
+#-----------------------------------------------------------------------------
+# Superbuild Option - Enabled by default
+#-----------------------------------------------------------------------------
+
+option(${MY_PROJECT_NAME}_USE_SUPERBUILD "Build ${MY_PROJECT_NAME} and the projects it depends on via SuperBuild.cmake." ON)
+
+if(${MY_PROJECT_NAME}_USE_SUPERBUILD)
+ project(${MY_PROJECT_NAME}-superbuild)
+ set(${MY_PROJECT_NAME}_SOURCE_DIR ${PROJECT_SOURCE_DIR})
+ set(${MY_PROJECT_NAME}_BINARY_DIR ${PROJECT_BINARY_DIR})
+else()
+ project(${MY_PROJECT_NAME})
+endif()
+
+#-----------------------------------------------------------------------------
+# See http://cmake.org/cmake/help/cmake-2-8-docs.html#section_Policies for details
+#-----------------------------------------------------------------------------
+
+set(project_policies
+ CMP0001 # NEW: CMAKE_BACKWARDS_COMPATIBILITY should no longer be used.
+ CMP0002 # NEW: Logical target names must be globally unique.
+ CMP0003 # NEW: Libraries linked via full path no longer produce linker search paths.
+ CMP0004 # NEW: Libraries linked may NOT have leading or trailing whitespace.
+ CMP0005 # NEW: Preprocessor definition values are now escaped automatically.
+ CMP0006 # NEW: Installing MACOSX_BUNDLE targets requires a BUNDLE DESTINATION.
+ CMP0007 # NEW: List command no longer ignores empty elements.
+ CMP0008 # NEW: Libraries linked by full-path must have a valid library file name.
+ CMP0009 # NEW: FILE GLOB_RECURSE calls should not follow symlinks by default.
+ CMP0010 # NEW: Bad variable reference syntax is an error.
+ CMP0011 # NEW: Included scripts do automatic cmake_policy PUSH and POP.
+ CMP0012 # NEW: if() recognizes numbers and boolean constants.
+ CMP0013 # NEW: Duplicate binary directories are not allowed.
+ CMP0014 # NEW: Input directories must have CMakeLists.txt
+ )
+foreach(policy ${project_policies})
+ if(POLICY ${policy})
+ cmake_policy(SET ${policy} NEW)
+ endif()
+endforeach()
+
+#-----------------------------------------------------------------------------
+# Update CMake module path
+#------------------------------------------------------------------------------
+
+set(CMAKE_MODULE_PATH
+ ${${MY_PROJECT_NAME}_SOURCE_DIR}/CMake
+ ${CMAKE_MODULE_PATH}
+ )
+
+#-----------------------------------------------------------------------------
+# CMake Function(s) and Macro(s)
+#-----------------------------------------------------------------------------
+
+include(MacroEmptyExternalProject)
+
+#-----------------------------------------------------------------------------
+# Output directories.
+#-----------------------------------------------------------------------------
+
+foreach(type LIBRARY RUNTIME ARCHIVE)
+ set(output_dir ${${MY_PROJECT_NAME}_BINARY_DIR}/bin)
+ set(CMAKE_${type}_OUTPUT_DIRECTORY ${output_dir} CACHE INTERNAL "Single output directory for building all libraries.")
+ mark_as_advanced(CMAKE_${type}_OUTPUT_DIRECTORY)
+endforeach()
+
+#-----------------------------------------------------------------------------
+# Additional Options (also shown during superbuild)
+#-----------------------------------------------------------------------------
+
+option(BUILD_SHARED_LIBS "Build ${MY_PROJECT_NAME} with shared libraries" ON)
+option(WITH_COVERAGE "Enable/Disable coverage" OFF)
+option(BUILD_TESTING "Test the project" ON)
+
+option(${MY_PROJECT_NAME}_BUILD_ALL_PLUGINS "Build all ${MY_PROJECT_NAME} plugins" OFF)
+
+mark_as_advanced(${MY_PROJECT_NAME}_INSTALL_RPATH_RELATIVE
+ ${MY_PROJECT_NAME}_BUILD_ALL_PLUGINS
+ )
+
+#-----------------------------------------------------------------------------
+# Additional CXX/C Flags
+#-----------------------------------------------------------------------------
+
+set(ADDITIONAL_C_FLAGS "" CACHE STRING "Additional C Flags")
+mark_as_advanced(ADDITIONAL_C_FLAGS)
+set(ADDITIONAL_CXX_FLAGS "" CACHE STRING "Additional CXX Flags")
+mark_as_advanced(ADDITIONAL_CXX_FLAGS)
+
+#-----------------------------------------------------------------------------
+# Superbuild script
+#-----------------------------------------------------------------------------
+
+if(${MY_PROJECT_NAME}_USE_SUPERBUILD)
+ include("${CMAKE_CURRENT_SOURCE_DIR}/SuperBuild.cmake")
+ return()
+endif()
+
+#*****************************************************************************
+#**************************** END OF SUPERBUILD ****************************
+#*****************************************************************************
+
+#-----------------------------------------------------------------------------
+# Prerequesites
+#-----------------------------------------------------------------------------
+
+find_package(MITK REQUIRED)
+link_directories(${MITK_LINK_DIRECTORIES})
+
+#-----------------------------------------------------------------------------
+# CMake Function(s) and Macro(s)
+#-----------------------------------------------------------------------------
+
+set(CMAKE_MODULE_PATH
+ ${MITK_SOURCE_DIR}/CMake
+ ${CMAKE_MODULE_PATH}
+ )
+
+include(mitkFunctionCheckCompilerFlags)
+include(mitkFunctionGetGccVersion)
+include(mitkFunctionGetVersion)
+
+#-----------------------------------------------------------------------------
+# Set project specific options and variables (NOT available during superbuild)
+#-----------------------------------------------------------------------------
+
+set(${PROJECT_NAME}_VERSION_MAJOR "0")
+set(${PROJECT_NAME}_VERSION_MINOR "1")
+set(${PROJECT_NAME}_VERSION_PATCH "1")
+set(${PROJECT_NAME}_VERSION_STRING "${${PROJECT_NAME}_VERSION_MAJOR}.${${PROJECT_NAME}_VERSION_MINOR}.${${PROJECT_NAME}_VERSION_PATCH}")
+
+# Ask the user if a console window should be shown with the applications
+option(${PROJECT_NAME}_SHOW_CONSOLE_WINDOW "Use this to enable or disable the console window when starting GUI Applications" ON)
+mark_as_advanced(${PROJECT_NAME}_SHOW_CONSOLE_WINDOW)
+
+if(NOT UNIX AND NOT MINGW)
+ set(MITK_WIN32_FORCE_STATIC "STATIC")
+endif()
+
+set(${PROJECT_NAME}_MODULES_PACKAGE_DEPENDS_DIR "${PROJECT_SOURCE_DIR}/CMake/PackageDepends")
+list(APPEND MODULES_PACKAGE_DEPENDS_DIRS ${${PROJECT_NAME}_MODULES_PACKAGE_DEPENDS_DIR})
+
+#-----------------------------------------------------------------------------
+# Get project version info
+#-----------------------------------------------------------------------------
+
+mitkFunctionGetVersion(${PROJECT_SOURCE_DIR} ${PROJECT_NAME})
+
+#-----------------------------------------------------------------------------
+# Installation preparation
+#
+# These should be set before any MITK install macros are used
+#-----------------------------------------------------------------------------
+
+# on Mac OSX all CTK plugins get copied into every
+# application bundle (.app directory) specified here
+set(MACOSX_BUNDLE_NAMES)
+if(APPLE)
+ list(APPEND MACOSX_BUNDLE_NAMES ${MY_APP_NAME})
+endif(APPLE)
+
+#-----------------------------------------------------------------------------
+# Set symbol visibility Flags
+#-----------------------------------------------------------------------------
+
+# MinGW does not export all symbols automatically, so no need to set flags
+if(CMAKE_COMPILER_IS_GNUCXX AND NOT MINGW)
+ # The MITK module build system does not yet support default hidden visibility
+ set(VISIBILITY_CXX_FLAGS ) # "-fvisibility=hidden -fvisibility-inlines-hidden")
+endif()
+
+#-----------------------------------------------------------------------------
+# Set coverage Flags
+#-----------------------------------------------------------------------------
+
+if(WITH_COVERAGE)
+ if(CMAKE_COMPILER_IS_GNUCXX)
+ set(coverage_flags "-g -fprofile-arcs -ftest-coverage -O0 -DNDEBUG")
+ set(COVERAGE_CXX_FLAGS ${coverage_flags})
+ set(COVERAGE_C_FLAGS ${coverage_flags})
+ endif()
+endif()
+
+#-----------------------------------------------------------------------------
+# Project C/CXX Flags
+#-----------------------------------------------------------------------------
+
+set(${PROJECT_NAME}_C_FLAGS "${COVERAGE_C_FLAGS} ${ADDITIONAL_C_FLAGS}")
+set(${PROJECT_NAME}_CXX_FLAGS "${VISIBILITY_CXX_FLAGS} ${COVERAGE_CXX_FLAGS} ${ADDITIONAL_CXX_FLAGS}")
+
+if(CMAKE_COMPILER_IS_GNUCXX)
+ set(cflags "-Wall -Wextra -Wpointer-arith -Winvalid-pch -Wcast-align -Wwrite-strings -D_FORTIFY_SOURCE=2")
+
+ mitkFunctionCheckCompilerFlags("-fdiagnostics-show-option" cflags)
+ mitkFunctionCheckCompilerFlags("-Wl,--no-undefined" cflags)
+
+ mitkFunctionGetGccVersion(${CMAKE_CXX_COMPILER} GCC_VERSION)
+ # With older version of gcc supporting the flag -fstack-protector-all, an extra dependency to libssp.so
+ # is introduced. If gcc is smaller than 4.4.0 and the build type is Release let's not include the flag.
+ # Doing so should allow to build package made for distribution using older linux distro.
+ if(${GCC_VERSION} VERSION_GREATER "4.4.0" OR (CMAKE_BUILD_TYPE STREQUAL "Debug" AND ${GCC_VERSION} VERSION_LESS "4.4.0"))
+ mitkFunctionCheckCompilerFlags("-fstack-protector-all" cflags)
+ endif()
+ if(MINGW)
+ # suppress warnings about auto imported symbols
+ set(${PROJECT_NAME}_CXX_FLAGS "-Wl,--enable-auto-import ${${PROJECT_NAME}_CXX_FLAGS}")
+ # we need to define a Windows version
+ set(${PROJECT_NAME}_CXX_FLAGS "-D_WIN32_WINNT=0x0500 ${${PROJECT_NAME}_CXX_FLAGS}")
+ endif()
+
+ set(${PROJECT_NAME}_C_FLAGS "${cflags} ${${PROJECT_NAME}_C_FLAGS}")
+ set(${PROJECT_NAME}_CXX_FLAGS "${cflags} -Woverloaded-virtual -Wstrict-null-sentinel -Wsign-promo ${${PROJECT_NAME}_CXX_FLAGS}")
+ # The following line produces a lot of warnings in MITK header files...
+ #set(${PROJECT_NAME}_CXX_FLAGS "${cflags} -Woverloaded-virtual -Wold-style-cast -Wstrict-null-sentinel -Wsign-promo ${${PROJECT_NAME}_CXX_FLAGS}")
+endif()
+
+#-----------------------------------------------------------------------------
+# Set C/CXX Flags
+#-----------------------------------------------------------------------------
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${${PROJECT_NAME}_CXX_FLAGS}")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${${PROJECT_NAME}_C_FLAGS}")
+
+#-----------------------------------------------------------------------------
+# Testing
+#-----------------------------------------------------------------------------
+
+if(BUILD_TESTING)
+ enable_testing()
+ include(CTest)
+ mark_as_advanced(TCL_TCLSH DART_ROOT)
+
+ # Setup file for setting custom ctest vars
+ configure_file(
+ CMake/CTestCustom.cmake.in
+ ${CMAKE_CURRENT_BINARY_DIR}/CTestCustom.cmake
+ @ONLY
+ )
+
+ # Configuration for the CMake-generated test driver
+ set(CMAKE_TESTDRIVER_EXTRA_INCLUDES "#include <stdexcept>")
+ set(CMAKE_TESTDRIVER_BEFORE_TESTMAIN "
+ try
+ {")
+ set(CMAKE_TESTDRIVER_AFTER_TESTMAIN " }
+ catch( std::exception & excp )
+ {
+ fprintf(stderr,\"%s\\n\",excp.what());
+ return EXIT_FAILURE;
+ }
+ catch( ... )
+ {
+ printf(\"Exception caught in the test driver\\n\");
+ return EXIT_FAILURE;
+ }
+ ")
+endif()
+
+#-----------------------------------------------------------------------------
+# ${MY_PROJECT_NAME}_SUPERBUILD_BINARY_DIR
+#-----------------------------------------------------------------------------
+
+# If ${MY_PROJECT_NAME}_SUPERBUILD_BINARY_DIR isn't defined, it means this project is
+# *NOT* build using Superbuild. In that specific case, ${MY_PROJECT_NAME}_SUPERBUILD_BINARY_DIR
+# should default to PROJECT_BINARY_DIR
+if(NOT DEFINED ${PROJECT_NAME}_SUPERBUILD_BINARY_DIR)
+ set(${PROJECT_NAME}_SUPERBUILD_BINARY_DIR ${PROJECT_BINARY_DIR})
+endif()
+
+#-----------------------------------------------------------------------------
+# Qt support
+#-----------------------------------------------------------------------------
+
+if(MITK_USE_QT)
+ set(QT_QMAKE_EXECUTABLE ${MITK_QMAKE_EXECUTABLE})
+ add_definitions(-DQWT_DLL)
+endif()
+
+#-----------------------------------------------------------------------------
+# MITK modules
+#-----------------------------------------------------------------------------
+
+#add_subdirectory(Modules)
+
+#-----------------------------------------------------------------------------
+# CTK plugins
+#-----------------------------------------------------------------------------
+
+# The CMake code in this section *must* be in the top-level CMakeLists.txt file
+
+macro(GetMyTargetLibraries all_target_libraries varname)
+ set(re_ctkplugin "^$(project-plugin-base)_[a-zA-Z0-9_]+$")
+ set(_tmp_list)
+ list(APPEND _tmp_list ${all_target_libraries})
+ ctkMacroListFilter(_tmp_list re_ctkplugin OUTPUT_VARIABLE ${varname})
+endmacro()
+
+include(${CMAKE_CURRENT_SOURCE_DIR}/Plugins/Plugins.cmake)
+ctkMacroSetupExternalPlugins(${PROJECT_PLUGINS}
+ BUILD_OPTION_PREFIX ${MY_PROJECT_NAME}_
+ BUILD_ALL ${${MY_PROJECT_NAME}_BUILD_ALL_PLUGINS})
+
+#-----------------------------------------------------------------------------
+# Add subdirectories
+#-----------------------------------------------------------------------------
+
+add_subdirectory(Apps/$(project-app-name))
+
+#-----------------------------------------------------------------------------
+# Installation
+#-----------------------------------------------------------------------------
+
+# set MITK cpack variables
+include(mitkSetupCPack)
+
+# Customize CPack variables for this project
+include(CPackSetup)
+
+list(APPEND CPACK_CREATE_DESKTOP_LINKS "${MY_APP_NAME}")
+
+configure_file(${MITK_SOURCE_DIR}/MITKCPackOptions.cmake.in
+ ${PROJECT_BINARY_DIR}/${PROJECT_NAME}CPackOptions.cmake @ONLY)
+set(CPACK_PROJECT_CONFIG_FILE "${PROJECT_BINARY_DIR}/${PROJECT_NAME}CPackOptions.cmake")
+
+# include CPack model once all variables are set
+include(CPack)
+
+# Additional installation rules
+include(mitkInstallRules)
+
+#-----------------------------------------------------------------------------
+# Last configuration steps
+#-----------------------------------------------------------------------------
+
+# If we are under Windows, create two batch files which correctly
+# set up the environment for the application and for Visual Studio
+if(WIN32)
+ include(mitkFunctionCreateWindowsBatchScript)
+
+ set(VS_SOLUTION_FILE "${PROJECT_BINARY_DIR}/${PROJECT_NAME}.sln")
+ foreach(VS_BUILD_TYPE debug release)
+ mitkFunctionCreateWindowsBatchScript("${PROJECT_SOURCE_DIR}/CMake/StartVS.bat.in"
+ ${PROJECT_BINARY_DIR}/StartVS_${VS_BUILD_TYPE}.bat
+ ${VS_BUILD_TYPE})
+ endforeach()
+endif(WIN32)
diff --git a/Applications/PluginGenerator/ProjectTemplate/Copyright.txt b/Applications/PluginGenerator/ProjectTemplate/Copyright.txt
new file mode 100644
index 0000000000..adf2b2d3e7
--- /dev/null
+++ b/Applications/PluginGenerator/ProjectTemplate/Copyright.txt
@@ -0,0 +1 @@
+$(copyright)
diff --git a/Applications/PluginGenerator/ProjectTemplate/Plugins/Plugins.cmake b/Applications/PluginGenerator/ProjectTemplate/Plugins/Plugins.cmake
new file mode 100644
index 0000000000..b5b5fc1943
--- /dev/null
+++ b/Applications/PluginGenerator/ProjectTemplate/Plugins/Plugins.cmake
@@ -0,0 +1,3 @@
+set(PROJECT_PLUGINS
+ $(project-plugins)
+)
diff --git a/Applications/PluginGenerator/ProjectTemplate/SuperBuild.cmake b/Applications/PluginGenerator/ProjectTemplate/SuperBuild.cmake
new file mode 100644
index 0000000000..68d0b6869f
--- /dev/null
+++ b/Applications/PluginGenerator/ProjectTemplate/SuperBuild.cmake
@@ -0,0 +1,198 @@
+
+#-------------------------- ITK/VTK -------------------------
+# Provide an option to supply pre-built versions of ITK and VTK.
+# If not found, MITK will build them itself during superbuild
+set(VTK_DIR "" CACHE PATH "Use the supplied VTK installation/binary dir instead of superbuilding it")
+set(ITK_DIR "" CACHE PATH "Use the supplied ITK installation/binary dir instead of superbuilding it")
+mark_as_advanced(VTK_DIR ITK_DIR)
+
+#---------------------------- MITK --------------------------
+
+if(MITK_DIR)
+
+ # sanity checks in the case of a pre-built MITK
+ set(my_itk_dir ${ITK_DIR})
+ set(my_vtk_dir ${VTK_DIR})
+ set(my_qmake_executable ${QT_QMAKE_EXECUTABLE})
+
+ find_package(MITK REQUIRED)
+
+ if(my_itk_dir AND NOT my_itk_dir STREQUAL ${ITK_DIR})
+ message(FATAL_ERROR "ITK packages do not match:\n ${MY_PROJECT_NAME}: ${my_itk_dir}\n MITK: ${ITK_DIR}")
+ endif()
+
+ if(my_vtk_dir AND NOT my_vtk_dir STREQUAL ${VTK_DIR})
+ message(FATAL_ERROR "VTK packages do not match:\n ${MY_PROJECT_NAME}: ${my_vtk_dir}\n MITK: ${VTK_DIR}")
+ endif()
+
+ if(my_qmake_executable AND NOT my_qmake_executable STREQUAL ${MITK_QMAKE_EXECUTABLE})
+ message(FATAL_ERROR "Qt qmake does not match:\n ${MY_PROJECT_NAME}: ${my_qmake_executable}\n MITK: ${MITK_QMAKE_EXECUTABLE}")
+ endif()
+
+endif()
+
+
+#-----------------------------------------------------------------------------
+# External project settings
+#-----------------------------------------------------------------------------
+
+include(ExternalProject)
+
+set(ep_base "${CMAKE_BINARY_DIR}/CMakeExternals")
+set_property(DIRECTORY PROPERTY EP_BASE ${ep_base})
+
+set(ep_install_dir "${CMAKE_BINARY_DIR}/CMakeExternals/Install")
+set(ep_suffix "-cmake")
+set(ep_build_shared_libs ON)
+set(ep_build_testing OFF)
+
+# Compute -G arg for configuring external projects with the same CMake generator:
+if(CMAKE_EXTRA_GENERATOR)
+ set(gen "${CMAKE_EXTRA_GENERATOR} - ${CMAKE_GENERATOR}")
+else()
+ set(gen "${CMAKE_GENERATOR}")
+endif()
+
+# Use this value where semi-colons are needed in ep_add args:
+set(sep "^^")
+
+##
+
+if(MSVC90 OR MSVC10)
+ set(ep_common_C_FLAGS "${CMAKE_C_FLAGS} /bigobj /MP")
+ set(ep_common_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj /MP")
+else()
+ set(ep_common_C_FLAGS "${CMAKE_C_FLAGS} -DLINUX_EXTRA")
+ set(ep_common_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DLINUX_EXTRA")
+endif()
+
+set(ep_common_args
+ -DBUILD_TESTING:BOOL=${ep_build_testing}
+ -DCMAKE_INSTALL_PREFIX:PATH=${ep_install_dir}
+ -DBUILD_SHARED_LIBS:BOOL=${ep_build_shared_libs}
+ -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
+ -DCMAKE_C_COMPILER:FILEPATH=${CMAKE_C_COMPILER}
+ -DCMAKE_CXX_COMPILER:FILEPATH=${CMAKE_CXX_COMPILER}
+ "-DCMAKE_C_FLAGS:STRING=${ep_common_C_FLAGS}"
+ "-DCMAKE_CXX_FLAGS:STRING=${ep_common_CXX_FLAGS}"
+)
+
+#-----------------------------------------------------------------------------
+# Git protocol option
+#-----------------------------------------------------------------------------
+
+option(${MY_PROJECT_NAME}_USE_GIT_PROTOCOL "If behind a firewall turn this OFF to use http instead." OFF)
+mark_as_advanced(${MY_PROJECT_NAME}_USE_GIT_PROTOCOL)
+
+set(git_protocol "git")
+if(NOT ${MY_PROJECT_NAME}_USE_GIT_PROTOCOL)
+ set(git_protocol "http")
+endif()
+
+#-----------------------------------------------------------------------------
+# ExternalProjects
+#-----------------------------------------------------------------------------
+
+set(external_projects
+ MITK
+ )
+
+# Include external projects
+foreach(p ${external_projects})
+ include(CMakeExternals/${p}.cmake)
+endforeach()
+
+#-----------------------------------------------------------------------------
+# Set superbuild boolean args
+#-----------------------------------------------------------------------------
+
+set(my_cmake_boolean_args
+ WITH_COVERAGE
+ BUILD_TESTING
+ ${MY_PROJECT_NAME}_BUILD_ALL_PLUGINS
+ )
+
+#-----------------------------------------------------------------------------
+# Create the final variable containing superbuild boolean args
+#-----------------------------------------------------------------------------
+
+set(my_superbuild_boolean_args)
+foreach(my_cmake_arg ${my_cmake_boolean_args})
+ list(APPEND my_superbuild_boolean_args -D${my_cmake_arg}:BOOL=${${my_cmake_arg}})
+endforeach()
+
+#-----------------------------------------------------------------------------
+# Project Utilities
+#-----------------------------------------------------------------------------
+
+set(proj ${MY_PROJECT_NAME}-Utilities)
+ExternalProject_Add(${proj}
+ DOWNLOAD_COMMAND ""
+ CONFIGURE_COMMAND ""
+ BUILD_COMMAND ""
+ INSTALL_COMMAND ""
+ DEPENDS
+ # Mandatory dependencies
+ ${MITK_DEPENDS}
+ # Optional dependencies
+)
+
+#-----------------------------------------------------------------------------
+# Project Configure
+#-----------------------------------------------------------------------------
+
+set(proj ${MY_PROJECT_NAME}-Configure)
+
+ExternalProject_Add(${proj}
+ DOWNLOAD_COMMAND ""
+ CMAKE_GENERATOR ${gen}
+ CMAKE_ARGS
+ ${ep_common_args}
+ ${my_superbuild_boolean_args}
+ -D${MY_PROJECT_NAME}_USE_SUPERBUILD:BOOL=OFF
+ -D${MY_PROJECT_NAME}_CONFIGURED_VIA_SUPERBUILD:BOOL=ON
+ -DCTEST_USE_LAUNCHERS:BOOL=${CTEST_USE_LAUNCHERS}
+ -D${MY_PROJECT_NAME}_SUPERBUILD_BINARY_DIR:PATH=${PROJECT_BINARY_DIR}
+ -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
+ -DMITK_DIR:PATH=${MITK_DIR}
+ -DITK_DIR:PATH=${ITK_DIR}
+ -DVTK_DIR:PATH=${VTK_DIR}
+
+ SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}
+ BINARY_DIR ${CMAKE_BINARY_DIR}/${MY_PROJECT_NAME}-build
+ BUILD_COMMAND ""
+ INSTALL_COMMAND ""
+ DEPENDS
+ ${MY_PROJECT_NAME}-Utilities
+ )
+
+
+#-----------------------------------------------------------------------------
+# Project
+#-----------------------------------------------------------------------------
+
+# The variable SUPERBUILD_EXCLUDE_${MY_PROJECT_NAME}BUILD_TARGET should be set when submitting to a dashboard
+if(NOT DEFINED SUPERBUILD_EXCLUDE_${MY_PROJECT_NAME}BUILD_TARGET OR NOT SUPERBUILD_EXCLUDE_${MY_PROJECT_NAME}BUILD_TARGET)
+ set(proj ${MY_PROJECT_NAME}-build)
+ ExternalProject_Add(${proj}
+ DOWNLOAD_COMMAND ""
+ CONFIGURE_COMMAND ""
+ CMAKE_GENERATOR ${gen}
+ BUILD_COMMAND ${CMAKE_COMMAND} --build ${CMAKE_CURRENT_BINARY_DIR}/${MY_PROJECT_NAME}-build --config ${CMAKE_CFG_INTDIR}
+ SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}
+ BINARY_DIR ${MY_PROJECT_NAME}-build
+ INSTALL_COMMAND ""
+ DEPENDS
+ "${MY_PROJECT_NAME}-Configure"
+ )
+endif()
+
+#-----------------------------------------------------------------------------
+# Custom target allowing to drive the build of the project itself
+#-----------------------------------------------------------------------------
+
+add_custom_target(${MY_PROJECT_NAME}
+ COMMAND ${CMAKE_COMMAND} --build ${CMAKE_CURRENT_BINARY_DIR}/${MY_PROJECT_NAME}-build --config ${CMAKE_CFG_INTDIR}
+ WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${MY_PROJECT_NAME}-build
+)
+
diff --git a/Applications/PluginGenerator/SetupPackaging.cmake b/Applications/PluginGenerator/SetupPackaging.cmake
new file mode 100644
index 0000000000..48cbf89818
--- /dev/null
+++ b/Applications/PluginGenerator/SetupPackaging.cmake
@@ -0,0 +1,50 @@
+#-----------------------------------------------------------------------------
+# Installation
+#-----------------------------------------------------------------------------
+
+install(TARGETS ${exec_target} DESTINATION .)
+
+install(CODE "
+ set(DIRS
+ ${QT_LIBRARY_DIR}
+ ${QT_LIBRARY_DIR}/../bin
+ ${CTK_LIBRARY_DIRS}
+ )
+
+ include(BundleUtilities)
+
+ fixup_bundle(\"\${CMAKE_INSTALL_PREFIX}/${exec_target}${CMAKE_EXECUTABLE_SUFFIX}\" \"\" \"\${DIRS}\")
+")
+
+#-----------------------------------------------------------------------------
+# Packaging
+#-----------------------------------------------------------------------------
+
+#
+# First, set the generator variable
+#
+if(WIN32)
+ set(CPACK_GENERATOR ZIP)
+elseif(APPLE)
+ set(CPACK_GENERATOR DragNDrop)
+else()
+ set(CPACK_GENERATOR TGZ)
+endif()
+
+# include required mfc libraries
+include(InstallRequiredSystemLibraries)
+
+set(CPACK_PACKAGE_NAME "MITKPluginGenerator")
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "MITK PluginGenerator bootstraps MITK-based projects")
+set(CPACK_PACKAGE_VENDOR "German Cancer Research Center (DKFZ)")
+set(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/MITKCopyright.txt")
+set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/MITKCopyright.txt")
+set(CPACK_PACKAGE_VERSION_MAJOR "${VERSION_MAJOR}")
+set(CPACK_PACKAGE_VERSION_MINOR "${VERSION_MINOR}")
+set(CPACK_PACKAGE_VERSION_PATCH "${VERSION_PATCH}")
+
+# tell cpack to strip all debug symbols from all files
+set(CPACK_STRIP_FILES ON)
+
+include(CPack)
+
diff --git a/Applications/PluginGenerator/ctkCommandLineParser.cpp b/Applications/PluginGenerator/ctkCommandLineParser.cpp
new file mode 100644
index 0000000000..39586d8812
--- /dev/null
+++ b/Applications/PluginGenerator/ctkCommandLineParser.cpp
@@ -0,0 +1,832 @@
+/*=========================================================================
+
+ Library: CTK
+
+ Copyright (c) Kitware Inc.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0.txt
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+=========================================================================*/
+
+// STL includes
+#include <stdexcept>
+
+// Qt includes
+#include <QHash>
+#include <QStringList>
+#include <QTextStream>
+#include <QDebug>
+#include <QSettings>
+#include <QPointer>
+
+// CTK includes
+#include "ctkCommandLineParser.h"
+
+namespace
+{
+// --------------------------------------------------------------------------
+class CommandLineParserArgumentDescription
+{
+public:
+ CommandLineParserArgumentDescription(
+ const QString& longArg, const QString& longArgPrefix,
+ const QString& shortArg, const QString& shortArgPrefix,
+ QVariant::Type type, const QString& argHelp,
+ const QVariant& defaultValue, bool ignoreRest,
+ bool deprecated)
+ : LongArg(longArg), LongArgPrefix(longArgPrefix),
+ ShortArg(shortArg), ShortArgPrefix(shortArgPrefix),
+ ArgHelp(argHelp), IgnoreRest(ignoreRest), NumberOfParametersToProcess(0),
+ Deprecated(deprecated), DefaultValue(defaultValue), Value(type), ValueType(type)
+ {
+ if (defaultValue.isValid())
+ {
+ Value = defaultValue;
+ }
+
+ switch (type)
+ {
+ case QVariant::String:
+ {
+ NumberOfParametersToProcess = 1;
+ RegularExpression = ".*";
+ }
+ break;
+ case QVariant::Bool:
+ {
+ NumberOfParametersToProcess = 0;
+ RegularExpression = "";
+ }
+ break;
+ case QVariant::StringList:
+ {
+ NumberOfParametersToProcess = -1;
+ RegularExpression = ".*";
+ }
+ break;
+ case QVariant::Int:
+ {
+ NumberOfParametersToProcess = 1;
+ RegularExpression = "-?[0-9]+";
+ ExactMatchFailedMessage = "A negative or positive integer is expected.";
+ }
+ break;
+ default:
+ ExactMatchFailedMessage = QString("Type %1 not supported.").arg(static_cast<int>(type));
+ }
+
+ }
+
+ ~CommandLineParserArgumentDescription(){}
+
+ bool addParameter(const QString& value);
+
+ QString helpText(int fieldWidth, const char charPad, const QString& settingsValue = "");
+
+ QString LongArg;
+ QString LongArgPrefix;
+ QString ShortArg;
+ QString ShortArgPrefix;
+ QString ArgHelp;
+ bool IgnoreRest;
+ int NumberOfParametersToProcess;
+ QString RegularExpression;
+ QString ExactMatchFailedMessage;
+ bool Deprecated;
+
+ QVariant DefaultValue;
+ QVariant Value;
+ QVariant::Type ValueType;
+};
+
+// --------------------------------------------------------------------------
+bool CommandLineParserArgumentDescription::addParameter(const QString& value)
+{
+ if (!RegularExpression.isEmpty())
+ {
+ // Validate value
+ QRegExp regexp(this->RegularExpression);
+ if (!regexp.exactMatch(value))
+ {
+ return false;
+ }
+ }
+
+ switch (Value.type())
+ {
+ case QVariant::String:
+ {
+ Value.setValue(value);
+ }
+ break;
+ case QVariant::Bool:
+ {
+ Value.setValue(!QString::compare(value, "true", Qt::CaseInsensitive));
+ }
+ break;
+ case QVariant::StringList:
+ {
+ if (Value.isNull())
+ {
+ QStringList list;
+ list << value;
+ Value.setValue(list);
+ }
+ else
+ {
+ QStringList list = Value.toStringList();
+ list << value;
+ Value.setValue(list);
+ }
+ }
+ break;
+ case QVariant::Int:
+ {
+ Value.setValue(value.toInt());
+ }
+ break;
+ default:
+ return false;
+ }
+
+ return true;
+}
+
+// --------------------------------------------------------------------------
+QString CommandLineParserArgumentDescription::helpText(int fieldWidth, const char charPad,
+ const QString& settingsValue)
+{
+ QString text;
+ QTextStream stream(&text);
+ stream.setFieldAlignment(QTextStream::AlignLeft);
+ stream.setPadChar(charPad);
+
+ QString shortAndLongArg;
+ if (!this->ShortArg.isEmpty())
+ {
+ shortAndLongArg += QString(" %1%2").arg(this->ShortArgPrefix).arg(this->ShortArg);
+ }
+
+ if (!this->LongArg.isEmpty())
+ {
+ if (this->ShortArg.isEmpty())
+ {
+ shortAndLongArg.append(" ");
+ }
+ else
+ {
+ shortAndLongArg.append(", ");
+ }
+
+ shortAndLongArg += QString("%1%2").arg(this->LongArgPrefix).arg(this->LongArg);
+ }
+
+ if(!this->ArgHelp.isEmpty())
+ {
+ stream.setFieldWidth(fieldWidth);
+ }
+
+ stream << shortAndLongArg;
+ stream.setFieldWidth(0);
+ stream << this->ArgHelp;
+ if (!settingsValue.isNull())
+ {
+ stream << " (default: " << settingsValue << ")";
+ }
+ else if (!this->DefaultValue.isNull())
+ {
+ stream << " (default: " << this->DefaultValue.toString() << ")";
+ }
+ stream << "\n";
+ return text;
+}
+
+}
+
+// --------------------------------------------------------------------------
+// ctkCommandLineParser::ctkInternal class
+
+// --------------------------------------------------------------------------
+class ctkCommandLineParser::ctkInternal
+{
+public:
+ ctkInternal(QSettings* settings)
+ : Debug(false), FieldWidth(0), UseQSettings(false),
+ Settings(settings), MergeSettings(true), StrictMode(false)
+ {}
+
+ ~ctkInternal() { qDeleteAll(ArgumentDescriptionList); }
+
+ CommandLineParserArgumentDescription* argumentDescription(const QString& argument);
+
+ QList<CommandLineParserArgumentDescription*> ArgumentDescriptionList;
+ QHash<QString, CommandLineParserArgumentDescription*> ArgNameToArgumentDescriptionMap;
+ QMap<QString, QList<CommandLineParserArgumentDescription*> > GroupToArgumentDescriptionListMap;
+
+ QStringList UnparsedArguments;
+ QStringList ProcessedArguments;
+ QString ErrorString;
+ bool Debug;
+ int FieldWidth;
+ QString LongPrefix;
+ QString ShortPrefix;
+ QString CurrentGroup;
+ bool UseQSettings;
+ QPointer<QSettings> Settings;
+ QString DisableQSettingsLongArg;
+ QString DisableQSettingsShortArg;
+ bool MergeSettings;
+ bool StrictMode;
+};
+
+// --------------------------------------------------------------------------
+// ctkCommandLineParser::ctkInternal methods
+
+// --------------------------------------------------------------------------
+CommandLineParserArgumentDescription*
+ ctkCommandLineParser::ctkInternal::argumentDescription(const QString& argument)
+{
+ QString unprefixedArg = argument;
+ if (!LongPrefix.isEmpty() && argument.startsWith(LongPrefix))
+ {
+ // Case when (ShortPrefix + UnPrefixedArgument) matches LongPrefix
+ if (argument == LongPrefix && !ShortPrefix.isEmpty() && argument.startsWith(ShortPrefix))
+ {
+ unprefixedArg = argument.mid(ShortPrefix.length());
+ }
+ else
+ {
+ unprefixedArg = argument.mid(LongPrefix.length());
+ }
+ }
+ else if (!ShortPrefix.isEmpty() && argument.startsWith(ShortPrefix))
+ {
+ unprefixedArg = argument.mid(ShortPrefix.length());
+ }
+ else if (!LongPrefix.isEmpty() && !ShortPrefix.isEmpty())
+ {
+ return 0;
+ }
+
+ if (this->ArgNameToArgumentDescriptionMap.contains(unprefixedArg))
+ {
+ return this->ArgNameToArgumentDescriptionMap[unprefixedArg];
+ }
+ return 0;
+}
+
+// --------------------------------------------------------------------------
+// ctkCommandLineParser methods
+
+// --------------------------------------------------------------------------
+ctkCommandLineParser::ctkCommandLineParser(QObject* newParent) : Superclass(newParent)
+{
+ this->Internal = new ctkInternal(0);
+}
+
+// --------------------------------------------------------------------------
+ctkCommandLineParser::ctkCommandLineParser(QSettings* settings, QObject* newParent) :
+ Superclass(newParent)
+{
+ this->Internal = new ctkInternal(settings);
+}
+
+// --------------------------------------------------------------------------
+ctkCommandLineParser::~ctkCommandLineParser()
+{
+ delete this->Internal;
+}
+
+// --------------------------------------------------------------------------
+QHash<QString, QVariant> ctkCommandLineParser::parseArguments(const QStringList& arguments,
+ bool* ok)
+{
+ // Reset
+ this->Internal->UnparsedArguments.clear();
+ this->Internal->ProcessedArguments.clear();
+ this->Internal->ErrorString.clear();
+ foreach (CommandLineParserArgumentDescription* desc,
+ this->Internal->ArgumentDescriptionList)
+ {
+ desc->Value = QVariant(desc->ValueType);
+ if (desc->DefaultValue.isValid())
+ {
+ desc->Value = desc->DefaultValue;
+ }
+ }
+
+ bool error = false;
+ bool ignoreRest = false;
+ bool useSettings = this->Internal->UseQSettings;
+ CommandLineParserArgumentDescription * currentArgDesc = 0;
+ QList<CommandLineParserArgumentDescription*> parsedArgDescriptions;
+ for(int i = 1; i < arguments.size(); ++i)
+ {
+ QString argument = arguments.at(i);
+ if (this->Internal->Debug) { qDebug() << "Processing" << argument; }
+
+ // should argument be ignored ?
+ if (ignoreRest)
+ {
+ if (this->Internal->Debug)
+ {
+ qDebug() << " Skipping: IgnoreRest flag was been set";
+ }
+ this->Internal->UnparsedArguments << argument;
+ continue;
+ }
+
+ // Skip if the argument does not start with the defined prefix
+ if (!(argument.startsWith(this->Internal->LongPrefix)
+ || argument.startsWith(this->Internal->ShortPrefix)))
+ {
+ if (this->Internal->StrictMode)
+ {
+ this->Internal->ErrorString = QString("Unknown argument %1").arg(argument);
+ error = true;
+ break;
+ }
+ if (this->Internal->Debug)
+ {
+ qDebug() << " Skipping: It does not start with the defined prefix";
+ }
+ this->Internal->UnparsedArguments << argument;
+ continue;
+ }
+
+ // Skip if argument has already been parsed ...
+ if (this->Internal->ProcessedArguments.contains(argument))
+ {
+ if (this->Internal->StrictMode)
+ {
+ this->Internal->ErrorString = QString("Argument %1 already processed !").arg(argument);
+ error = true;
+ break;
+ }
+ if (this->Internal->Debug)
+ {
+ qDebug() << " Skipping: Already processed !";
+ }
+ continue;
+ }
+
+ // Retrieve corresponding argument description
+ currentArgDesc = this->Internal->argumentDescription(argument);
+
+ // Is there a corresponding argument description ?
+ if (currentArgDesc)
+ {
+ // If the argument is deprecated, print the help text but continue processing
+ if (currentArgDesc->Deprecated)
+ {
+ qWarning().nospace() << "Deprecated argument " << argument << ": " << currentArgDesc->ArgHelp;
+ }
+ else
+ {
+ parsedArgDescriptions.push_back(currentArgDesc);
+ }
+
+ // Is the argument the special "disable QSettings" argument?
+ if ((!currentArgDesc->LongArg.isEmpty() && currentArgDesc->LongArg == this->Internal->DisableQSettingsLongArg)
+ || (!currentArgDesc->ShortArg.isEmpty() && currentArgDesc->ShortArg == this->Internal->DisableQSettingsShortArg))
+ {
+ useSettings = false;
+ }
+
+ this->Internal->ProcessedArguments << currentArgDesc->ShortArg << currentArgDesc->LongArg;
+ int numberOfParametersToProcess = currentArgDesc->NumberOfParametersToProcess;
+ ignoreRest = currentArgDesc->IgnoreRest;
+ if (this->Internal->Debug && ignoreRest)
+ {
+ qDebug() << " IgnoreRest flag is True";
+ }
+
+ // Is the number of parameters associated with the argument being processed known ?
+ if (numberOfParametersToProcess == 0)
+ {
+ currentArgDesc->addParameter("true");
+ }
+ else if (numberOfParametersToProcess > 0)
+ {
+ QString missingParameterError =
+ "Argument %1 has %2 value(s) associated whereas exacly %3 are expected.";
+ for(int j=1; j <= numberOfParametersToProcess; ++j)
+ {
+ if (i + j >= arguments.size())
+ {
+ this->Internal->ErrorString =
+ missingParameterError.arg(argument).arg(j-1).arg(numberOfParametersToProcess);
+ if (this->Internal->Debug) { qDebug() << this->Internal->ErrorString; }
+ if (ok) { *ok = false; }
+ return QHash<QString, QVariant>();
+ }
+ QString parameter = arguments.at(i + j);
+ if (this->Internal->Debug)
+ {
+ qDebug() << " Processing parameter" << j << ", value:" << parameter;
+ }
+ if (this->argumentAdded(parameter))
+ {
+ this->Internal->ErrorString =
+ missingParameterError.arg(argument).arg(j-1).arg(numberOfParametersToProcess);
+ if (this->Internal->Debug) { qDebug() << this->Internal->ErrorString; }
+ if (ok) { *ok = false; }
+ return QHash<QString, QVariant>();
+ }
+ if (!currentArgDesc->addParameter(parameter))
+ {
+ this->Internal->ErrorString = QString(
+ "Value(s) associated with argument %1 are incorrect. %2").
+ arg(argument).arg(currentArgDesc->ExactMatchFailedMessage);
+
+ if (this->Internal->Debug) { qDebug() << this->Internal->ErrorString; }
+ if (ok) { *ok = false; }
+ return QHash<QString, QVariant>();
+ }
+ }
+ // Update main loop increment
+ i = i + numberOfParametersToProcess;
+ }
+ else if (numberOfParametersToProcess == -1)
+ {
+ if (this->Internal->Debug)
+ {
+ qDebug() << " Proccessing StringList ...";
+ }
+ int j = 1;
+ while(j + i < arguments.size())
+ {
+ if (this->argumentAdded(arguments.at(j + i)))
+ {
+ if (this->Internal->Debug)
+ {
+ qDebug() << " No more parameter for" << argument;
+ }
+ break;
+ }
+ QString parameter = arguments.at(j + i);
+ if (this->Internal->Debug)
+ {
+ qDebug() << " Processing parameter" << j << ", value:" << parameter;
+ }
+ if (!currentArgDesc->addParameter(parameter))
+ {
+ this->Internal->ErrorString = QString(
+ "Value(s) associated with argument %1 are incorrect. %2").
+ arg(argument).arg(currentArgDesc->ExactMatchFailedMessage);
+
+ if (this->Internal->Debug) { qDebug() << this->Internal->ErrorString; }
+ if (ok) { *ok = false; }
+ return QHash<QString, QVariant>();
+ }
+ j++;
+ }
+ // Update main loop increment
+ i = i + j;
+ }
+ }
+ else
+ {
+ if (this->Internal->StrictMode)
+ {
+ this->Internal->ErrorString = QString("Unknown argument %1").arg(argument);
+ error = true;
+ break;
+ }
+ if (this->Internal->Debug)
+ {
+ qDebug() << " Skipping: Unknown argument";
+ }
+ this->Internal->UnparsedArguments << argument;
+ }
+ }
+
+ if (ok)
+ {
+ *ok = !error;
+ }
+
+ QSettings* settings = 0;
+ if (this->Internal->UseQSettings && useSettings)
+ {
+ if (this->Internal->Settings)
+ {
+ settings = this->Internal->Settings;
+ }
+ else
+ {
+ // Use a default constructed QSettings instance
+ settings = new QSettings();
+ }
+ }
+
+ QHash<QString, QVariant> parsedArguments;
+ QListIterator<CommandLineParserArgumentDescription*> it(this->Internal->ArgumentDescriptionList);
+ while (it.hasNext())
+ {
+ QString key;
+ CommandLineParserArgumentDescription* desc = it.next();
+ if (!desc->LongArg.isEmpty())
+ {
+ key = desc->LongArg;
+ }
+ else
+ {
+ key = desc->ShortArg;
+ }
+
+ if (parsedArgDescriptions.contains(desc))
+ {
+ // The argument was supplied on the command line, so use the given value
+
+ if (this->Internal->MergeSettings && settings)
+ {
+ // Merge with QSettings
+ QVariant settingsVal = settings->value(key);
+
+ if (desc->ValueType == QVariant::StringList &&
+ settingsVal.canConvert(QVariant::StringList))
+ {
+ QStringList stringList = desc->Value.toStringList();
+ stringList.append(settingsVal.toStringList());
+ parsedArguments.insert(key, stringList);
+ }
+ else
+ {
+ // do a normal insert
+ parsedArguments.insert(key, desc->Value);
+ }
+ }
+ else
+ {
+ // No merging, just insert all user values
+ parsedArguments.insert(key, desc->Value);
+ }
+ }
+ else
+ {
+ if (settings)
+ {
+ // If there is a valid QSettings entry for the argument, use the value
+ QVariant settingsVal = settings->value(key, desc->Value);
+ if (!settingsVal.isNull())
+ {
+ parsedArguments.insert(key, settingsVal);
+ }
+ }
+ else
+ {
+ // Just insert the arguments with valid default values
+ if (!desc->Value.isNull())
+ {
+ parsedArguments.insert(key, desc->Value);
+ }
+ }
+ }
+ }
+
+ // If we created a default QSettings instance, delete it
+ if (settings && !this->Internal->Settings)
+ {
+ delete settings;
+ }
+
+ return parsedArguments;
+}
+
+// -------------------------------------------------------------------------
+QHash<QString, QVariant> ctkCommandLineParser::parseArguments(int argc, char** argv, bool* ok)
+{
+ QStringList arguments;
+
+ // Create a QStringList of arguments
+ for(int i = 0; i < argc; ++i)
+ {
+ arguments << argv[i];
+ }
+
+ return this->parseArguments(arguments, ok);
+}
+
+// -------------------------------------------------------------------------
+QString ctkCommandLineParser::errorString() const
+{
+ return this->Internal->ErrorString;
+}
+
+// -------------------------------------------------------------------------
+const QStringList& ctkCommandLineParser::unparsedArguments() const
+{
+ return this->Internal->UnparsedArguments;
+}
+
+// --------------------------------------------------------------------------
+void ctkCommandLineParser::addArgument(const QString& longarg, const QString& shortarg,
+ QVariant::Type type, const QString& argHelp,
+ const QVariant& defaultValue, bool ignoreRest,
+ bool deprecated)
+{
+ Q_ASSERT_X(!(longarg.isEmpty() && shortarg.isEmpty()), "addArgument",
+ "both long and short argument names are empty");
+ if (longarg.isEmpty() && shortarg.isEmpty()) { return; }
+
+ Q_ASSERT_X(!defaultValue.isValid() || defaultValue.type() == type, "addArgument",
+ "defaultValue type does not match");
+ if (defaultValue.isValid() && defaultValue.type() != type)
+ throw std::logic_error("The QVariant type of defaultValue does not match the specified type");
+
+ /* Make sure it's not already added */
+ bool added = this->Internal->ArgNameToArgumentDescriptionMap.contains(longarg);
+ Q_ASSERT_X(!added, "addArgument", "long argument already added");
+ if (added) { return; }
+
+ added = this->Internal->ArgNameToArgumentDescriptionMap.contains(shortarg);
+ Q_ASSERT_X(!added, "addArgument", "short argument already added");
+ if (added) { return; }
+
+ CommandLineParserArgumentDescription* argDesc =
+ new CommandLineParserArgumentDescription(longarg, this->Internal->LongPrefix,
+ shortarg, this->Internal->ShortPrefix, type,
+ argHelp, defaultValue, ignoreRest, deprecated);
+
+ int argWidth = 0;
+ if (!longarg.isEmpty())
+ {
+ this->Internal->ArgNameToArgumentDescriptionMap[longarg] = argDesc;
+ argWidth += longarg.length() + this->Internal->LongPrefix.length();
+ }
+ if (!shortarg.isEmpty())
+ {
+ this->Internal->ArgNameToArgumentDescriptionMap[shortarg] = argDesc;
+ argWidth += shortarg.length() + this->Internal->ShortPrefix.length() + 2;
+ }
+ argWidth += 5;
+
+ // Set the field width for the arguments
+ if (argWidth > this->Internal->FieldWidth)
+ {
+ this->Internal->FieldWidth = argWidth;
+ }
+
+ this->Internal->ArgumentDescriptionList << argDesc;
+ this->Internal->GroupToArgumentDescriptionListMap[this->Internal->CurrentGroup] << argDesc;
+}
+
+// --------------------------------------------------------------------------
+void ctkCommandLineParser::addDeprecatedArgument(
+ const QString& longarg, const QString& shortarg, const QString& argHelp)
+{
+ addArgument(longarg, shortarg, QVariant::StringList, argHelp, QVariant(), false, true);
+}
+
+// --------------------------------------------------------------------------
+bool ctkCommandLineParser::setExactMatchRegularExpression(
+ const QString& argument, const QString& expression, const QString& exactMatchFailedMessage)
+{
+ CommandLineParserArgumentDescription * argDesc =
+ this->Internal->argumentDescription(argument);
+ if (!argDesc)
+ {
+ return false;
+ }
+
+ if (argDesc->Value.type() == QVariant::Bool)
+ {
+ return false;
+ }
+ argDesc->RegularExpression = expression;
+ argDesc->ExactMatchFailedMessage = exactMatchFailedMessage;
+ return true;
+}
+
+// --------------------------------------------------------------------------
+int ctkCommandLineParser::fieldWidth() const
+{
+ return this->Internal->FieldWidth;
+}
+
+// --------------------------------------------------------------------------
+void ctkCommandLineParser::beginGroup(const QString& description)
+{
+ this->Internal->CurrentGroup = description;
+}
+
+// --------------------------------------------------------------------------
+void ctkCommandLineParser::endGroup()
+{
+ this->Internal->CurrentGroup.clear();
+}
+
+// --------------------------------------------------------------------------
+void ctkCommandLineParser::enableSettings(const QString& disableLongArg, const QString& disableShortArg)
+{
+ this->Internal->UseQSettings = true;
+ this->Internal->DisableQSettingsLongArg = disableLongArg;
+ this->Internal->DisableQSettingsShortArg = disableShortArg;
+}
+
+// --------------------------------------------------------------------------
+void ctkCommandLineParser::mergeSettings(bool merge)
+{
+ this->Internal->MergeSettings = merge;
+}
+
+// --------------------------------------------------------------------------
+bool ctkCommandLineParser::settingsEnabled() const
+{
+ return this->Internal->UseQSettings;
+}
+
+// --------------------------------------------------------------------------
+QString ctkCommandLineParser::helpText(const char charPad) const
+{
+ QString text;
+ QTextStream stream(&text);
+
+ QList<CommandLineParserArgumentDescription*> deprecatedArgs;
+
+ // Loop over grouped argument descriptions
+ QMapIterator<QString, QList<CommandLineParserArgumentDescription*> > it(
+ this->Internal->GroupToArgumentDescriptionListMap);
+ while(it.hasNext())
+ {
+ it.next();
+ if (!it.key().isEmpty())
+ {
+ stream << "\n" << it.key() << "\n";
+ }
+ foreach(CommandLineParserArgumentDescription* argDesc, it.value())
+ {
+ if (argDesc->Deprecated)
+ {
+ deprecatedArgs << argDesc;
+ }
+ else
+ {
+ // Extract associated value from settings if any
+ QString settingsValue;
+ if (this->Internal->Settings)
+ {
+ QString key;
+ if (!argDesc->LongArg.isEmpty())
+ {
+ key = argDesc->LongArg;
+ }
+ else
+ {
+ key = argDesc->ShortArg;
+ }
+ settingsValue = this->Internal->Settings->value(key).toString();
+ }
+ stream << argDesc->helpText(this->Internal->FieldWidth, charPad, settingsValue);
+ }
+ }
+ }
+
+ if (!deprecatedArgs.empty())
+ {
+ stream << "\nDeprecated arguments:\n";
+ foreach(CommandLineParserArgumentDescription* argDesc, deprecatedArgs)
+ {
+ stream << argDesc->helpText(this->Internal->FieldWidth, charPad);
+ }
+ }
+
+ return text;
+}
+
+// --------------------------------------------------------------------------
+bool ctkCommandLineParser::argumentAdded(const QString& argument) const
+{
+ return this->Internal->ArgNameToArgumentDescriptionMap.contains(argument);
+}
+
+// --------------------------------------------------------------------------
+bool ctkCommandLineParser::argumentParsed(const QString& argument) const
+{
+ return this->Internal->ProcessedArguments.contains(argument);
+}
+
+// --------------------------------------------------------------------------
+void ctkCommandLineParser::setArgumentPrefix(const QString& longPrefix, const QString& shortPrefix)
+{
+ this->Internal->LongPrefix = longPrefix;
+ this->Internal->ShortPrefix = shortPrefix;
+}
+
+// --------------------------------------------------------------------------
+void ctkCommandLineParser::setStrictModeEnabled(bool strictMode)
+{
+ this->Internal->StrictMode = strictMode;
+}
+
diff --git a/Applications/PluginGenerator/ctkCommandLineParser.h b/Applications/PluginGenerator/ctkCommandLineParser.h
new file mode 100644
index 0000000000..edc7616eec
--- /dev/null
+++ b/Applications/PluginGenerator/ctkCommandLineParser.h
@@ -0,0 +1,419 @@
+/*=========================================================================
+
+ Library: CTK
+
+ Copyright (c) Kitware Inc.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0.txt
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+=========================================================================*/
+
+#ifndef __ctkCommandLineParser_h
+#define __ctkCommandLineParser_h
+
+// Qt includes
+#include <QString>
+#include <QStringList>
+#include <QVariant>
+
+class QSettings;
+
+
+/**
+ * \ingroup Core
+ *
+ * The CTK command line parser.
+ *
+ * Use this class to add information about the command line arguments
+ * your program understands and to easily parse them from a given list
+ * of strings.
+ *
+ * This parser provides the following features:
+ *
+ * <ul>
+ * <li>Add arguments by supplying a long name and/or a short name.
+ * Arguments are validated using a regular expression. They can have
+ * a default value and a help string.</li>
+ * <li>Deprecated arguments.</li>
+ * <li>Custom regular expressions for argument validation.</li>
+ * <li>Set different argument name prefixes for native platform look and feel.</li>
+ * <li>QSettings support. Default values for arguments can be read from
+ * a QSettings object.</li>
+ * <li>Create a help text for the command line arguments with support for
+ * grouping arguments.</li>
+ * </ul>
+ *
+ * Here is an example how to use this class inside a main function:
+ *
+ * \code
+ * #include <ctkCommandLineParser.h>
+ * #include <QCoreApplication>
+ * #include <QTextStream>
+ *
+ * int main(int argc, char** argv)
+ * {
+ * QCoreApplication app(argc, argv);
+ * // This is used by QSettings
+ * QCoreApplication::setOrganizationName("MyOrg");
+ * QCoreApplication::setApplicationName("MyApp");
+ *
+ * ctkCommandLineParser parser;
+ * // Use Unix-style argument names
+ * parser.setArgumentPrefix("--", "-");
+ * // Enable QSettings support
+ * parser.enableSettings("disable-settings");
+ *
+ * // Add command line argument names
+ * parser.addArgument("disable-settings", "", QVariant::Bool, "Do not use QSettings");
+ * parser.addArgument("help", "h", QVariant::Bool, "Show this help text");
+ * parser.addArgument("search-paths", "s", QVariant::StringList, "A list of paths to search");
+ *
+ * // Parse the command line arguments
+ * bool ok = false;
+ * QHash<QString, QVariant> parsedArgs = parser.parseArguments(QCoreApplication::arguments(), &ok);
+ * if (!ok)
+ * {
+ * QTextStream(stderr, QIODevice::WriteOnly) << "Error parsing arguments: "
+ * << parser.errorString() << "\n";
+ * return EXIT_FAILURE;
+ * }
+ *
+ * // Show a help message
+ * if (parsedArgs.contains("help") || parsedArgs.contains("h"))
+ * {
+ * QTextStream(stdout, QIODevice::WriteOnly) << parser.helpText();
+ * return EXIT_SUCCESS;
+ * }
+ *
+ * // Do something
+ *
+ * return EXIT_SUCCESS;
+ * }
+ * \endcode
+ */
+class ctkCommandLineParser : public QObject
+{
+ Q_OBJECT
+ Q_PROPERTY(QString errorString READ errorString)
+ Q_PROPERTY(QStringList unparsedArguments READ unparsedArguments)
+ Q_PROPERTY(bool settingsEnabled READ settingsEnabled)
+
+public:
+
+ typedef QObject Superclass;
+
+ /**
+ * Constructs a parser instance.
+ *
+ * If QSettings support is enabled by a call to <code>enableSettings()</code>
+ * a default constructed QSettings instance will be used when parsing
+ * the command line arguments. Make sure to call <code>QCoreApplication::setOrganizationName()</code>
+ * and <code>QCoreApplication::setApplicationName()</code> before using default
+ * constructed QSettings objects.
+ *
+ * @param newParent The QObject parent.
+ */
+ ctkCommandLineParser(QObject* newParent = 0);
+
+ /**
+ * Constructs a parser instance.
+ *
+ * If QSettings support is enabled by a call to <code>enableSettings()</code>
+ * the provided QSettings instance will be used. If the QSettings instance is
+ * zero, a default constructed QSettings instance will be used when parsing
+ * the command line arguments. Using a default constructed instance is usually
+ * what you want, if you have called <code>QCoreApplication::setOrganizationName()</code>
+ * and <code>QCoreApplication::setApplicationName()</code>.
+ *
+ * @param settings A QSettings instance which should be used.
+ * @param newParent The QObject parent.
+ *
+ *
+ */
+ ctkCommandLineParser(QSettings* settings, QObject* newParent = 0);
+
+ ~ctkCommandLineParser();
+
+ /**
+ * Parse a given list of command line arguments.
+ *
+ * This method parses a list of QString elements considering the known arguments
+ * added by calls to <code>addArgument()</code>. If any one of the argument
+ * values does not match the corresponding regular expression,
+ * <code>ok</code> is set to false and an empty QHash object is returned.
+ *
+ * The keys in the returned QHash object correspond to the long argument string,
+ * if it is not empty. Otherwise, the short argument string is used as key. The
+ * QVariant values can safely be converted to the type specified in the
+ * <code>addArgument()</code> method call.
+ *
+ * @param arguments A QStringList containing command line arguments. Usually
+ * given by <code>QCoreApplication::arguments()</code>.
+ * @param ok A pointer to a boolean variable. Will be set to <code>true</code>
+ * if all regular expressions matched, <code>false</code> otherwise.
+ * @return A QHash object mapping the long argument (if empty, the short one)
+ * to a QVariant containing the value.
+ */
+ QHash<QString, QVariant> parseArguments(const QStringList &arguments, bool* ok = 0);
+
+ /**
+ * Convenient method allowing to parse a given list of command line arguments.
+ * @see parseArguments(const QStringList &, bool*)
+ */
+ QHash<QString, QVariant> parseArguments(int argc, char** argv, bool* ok = 0);
+
+ /**
+ * Returns a detailed error description if a call to <code>parseArguments()</code>
+ * failed.
+ *
+ * @return The error description, empty if no error occured.
+ * @see parseArguments(const QStringList&, bool*)
+ */
+ QString errorString() const;
+
+ /**
+ * This method returns all unparsed arguments, i.e. all arguments
+ * for which no long or short name has been registered via a call
+ * to <code>addArgument()</code>.
+ *
+ * @see addArgument()
+ *
+ * @return A list containing unparsed arguments.
+ */
+ const QStringList& unparsedArguments() const;
+
+ /**
+ * Checks if the given argument has been added via a call
+ * to <code>addArgument()</code>.
+ *
+ * @see addArgument()
+ *
+ * @param argument The argument to be checked.
+ * @return <code>true</code> if the argument was added, <code>false</code>
+ * otherwise.
+ */
+ Q_INVOKABLE bool argumentAdded(const QString& argument) const;
+
+ /**
+ * Checks if the given argument has been parsed successfully by a previous
+ * call to <code>parseArguments()</code>.
+ *
+ * @param argument The argument to be checked.
+ * @return <code>true</code> if the argument was parsed, <code>false</code>
+ * otherwise.
+ */
+ Q_INVOKABLE bool argumentParsed(const QString& argument) const;
+
+ /**
+ * Adds a command line argument. An argument can have a long name
+ * (like --long-argument-name), a short name (like -l), or both. The type
+ * of the argument can be specified by using the <code>type</code> parameter.
+ * The following types are supported:
+ *
+ * <table>
+ * <tr><td><b>Type</b></td><td><b># of parameters</b></td><td><b>Default regular expr</b></td>
+ * <td><b>Example</b></td></tr>
+ * <tr><td>QVariant::String</td><td>1</td><td>.*</td><td>--test-string StringParameter</td></tr>
+ * <tr><td>QVariant::Bool</td><td>0</td><td>does not apply</td><td>--enable-something</td></tr>
+ * <tr><td>QVariant::StringList</td><td>-1</td><td>.*</td><td>--test-list string1 string2</td></tr>
+ * <tr><td>QVariant::Int</td><td>1</td><td>-?[0-9]+</td><td>--test-int -5</td></tr>
+ * </table>
+ *
+ * The regular expressions are used to validate the parameters of command line
+ * arguments. You can restrict the valid set of parameters by calling
+ * <code>setExactMatchRegularExpression()</code> for your argument.
+ *
+ * Optionally, a help string and a default value can be provided for the argument. If
+ * the QVariant type of the default value does not match <code>type</code>, an
+ * exception is thrown. Arguments with default values are always returned by
+ * <code>parseArguments()</code>.
+ *
+ * You can also declare an argument deprecated, by setting <code>deprecated</code>
+ * to <code>true</code>. Alternatively you can add a deprecated argument by calling
+ * <code>addDeprecatedArgument()</code>.
+ *
+ * If the long or short argument has already been added, or if both are empty strings,
+ * the method call has no effect.
+ *
+ * @param longarg The long argument name.
+ * @param shortarg The short argument name.
+ * @param type The argument type (see the list above for supported types).
+ * @param argHelp A help string describing the argument.
+ * @param defaultValue A default value for the argument.
+ * @param ignoreRest All arguments after the current one will be ignored.
+ * @param deprecated Declares the argument deprecated.
+ *
+ * @see setExactMatchRegularExpression()
+ * @see addDeprecatedArgument()
+ * @throws std::logic_error If the QVariant type of <code>defaultValue</code>
+ * does not match <code>type</code>, a <code>std::logic_error</code> is thrown.
+ */
+ void addArgument(const QString& longarg, const QString& shortarg,
+ QVariant::Type type, const QString& argHelp = QString(),
+ const QVariant& defaultValue = QVariant(),
+ bool ignoreRest = false, bool deprecated = false);
+
+ /**
+ * Adds a deprecated command line argument. If a deprecated argument is provided
+ * on the command line, <code>argHelp</code> is displayed in the console and
+ * processing continues with the next argument.
+ *
+ * Deprecated arguments are grouped separately at the end of the help text
+ * returned by <code>helpText()</code>.
+ *
+ * @param longarg The long argument name.
+ * @param shortarg The short argument name.
+ * @param argHelp A help string describing alternatives to the deprecated argument.
+ */
+ void addDeprecatedArgument(const QString& longarg, const QString& shortarg,
+ const QString& argHelp);
+
+ /**
+ * Sets a custom regular expression for validating argument parameters. The method
+ * <code>errorString()</code> can be used the get the last error description.
+ *
+ * @param argument The previously added long or short argument name.
+ * @param expression A regular expression which the arugment parameters must match.
+ * @param exactMatchFailedMessage An error message explaining why the parameter did
+ * not match.
+ *
+ * @return <code>true</code> if the argument was found and the regular expression was set,
+ * <code>false</code> otherwise.
+ *
+ * @see errorString()
+ */
+ bool setExactMatchRegularExpression(const QString& argument, const QString& expression,
+ const QString& exactMatchFailedMessage);
+
+ /**
+ * The field width for the argument names without the help text.
+ *
+ * @return The argument names field width in the help text.
+ */
+ int fieldWidth() const;
+
+ /**
+ * Creates a help text containing properly formatted argument names and help strings
+ * provided by calls to <code>addArgument()</code>. The arguments can be grouped by
+ * using <code>beginGroup()</code> and <code>endGroup()</code>.
+ *
+ * @param charPad The padding character.
+ * @return The formatted help text.
+ */
+ QString helpText(const char charPad = ' ') const;
+
+ /**
+ * Sets the argument prefix for long and short argument names. This can be used
+ * to create native command line arguments without changing the calls to
+ * <code>addArgument()</code>. For example on Unix-based systems, long argument
+ * names start with "--" and short names with "-", while on Windows argument names
+ * always start with "/".
+ *
+ * Note that all methods in ctkCommandLineParser which take an argument name
+ * expect the name as it was supplied to <code>addArgument</code>.
+ *
+ * Example usage:
+ *
+ * \code
+ * ctkCommandLineParser parser;
+ * parser.setArgumentPrefix("--", "-");
+ * parser.addArgument("long-argument", "l", QVariant::String);
+ * QStringList args;
+ * args << "program name" << "--long-argument Hi";
+ * parser.parseArguments(args);
+ * \endcode
+ *
+ * @param longPrefix The prefix for long argument names.
+ * @param shortPrefix The prefix for short argument names.
+ */
+ void setArgumentPrefix(const QString& longPrefix, const QString& shortPrefix);
+
+ /**
+ * Begins a new group for documenting arguments. All newly added arguments via
+ * <code>addArgument()</code> will be put in the new group. You can close the
+ * current group by calling <code>endGroup()</code> or be opening a new group.
+ *
+ * Note that groups cannot be nested and all arguments which do not belong to
+ * a group will be listed at the top of the text created by <code>helpText()</code>.
+ *
+ * @param description The description of the group
+ */
+ void beginGroup(const QString& description);
+
+ /**
+ * Ends the current group.
+ *
+ * @see beginGroup(const QString&)
+ */
+ void endGroup();
+
+ /**
+ * Enables QSettings support in ctkCommandLineParser. If an argument name is found
+ * in the QSettings instance with a valid QVariant, the value is considered as
+ * a default value and overwrites default values registered with
+ * <code>addArgument()</code>. User supplied values on the command line overwrite
+ * values in the QSettings instance, except for arguments with multiple parameters
+ * which are merged with QSettings values. Call <code>mergeSettings(false)</code>
+ * to disable merging.
+ *
+ * See <code>ctkCommandLineParser(QSettings*)</code> for information about how to
+ * supply a QSettings instance.
+ *
+ * Additionally, a long and short argument name can be specified which will disable
+ * QSettings support if supplied on the command line. The argument name must be
+ * registered as a regular argument via <code>addArgument()</code>.
+ *
+ * @param disableLongArg Long argument name.
+ * @param disableShortArg Short argument name.
+ *
+ * @see ctkCommandLineParser(QSettings*)
+ */
+ void enableSettings(const QString& disableLongArg = "",
+ const QString& disableShortArg = "");
+
+ /**
+ * Controlls the merging behavior of user values and QSettings values.
+ *
+ * If merging is on (the default), user supplied values for an argument
+ * which can take more than one parameter are merged with values stored
+ * in the QSettings instance. If merging is off, the user values overwrite
+ * the QSettings values.
+ *
+ * @param merge <code>true</code> enables QSettings merging, <code>false</code>
+ * disables it.
+ */
+ void mergeSettings(bool merge);
+
+ /**
+ * Can be used to check if QSettings support has been enabled by a call to
+ * <code>enableSettings()</code>.
+ *
+ * @return <code>true</code> if QSettings support is enabled, <code>false</code>
+ * otherwise.
+ */
+ bool settingsEnabled() const;
+
+
+ /**
+ * Can be used to teach the parser to stop parsing the arguments and return False when
+ * an unknown argument is encountered. By default <code>StrictMode</code> is disabled.
+ *
+ * @see parseArguments(const QStringList &, bool*)
+ */
+ void setStrictModeEnabled(bool strictMode);
+
+private:
+ class ctkInternal;
+ ctkInternal * Internal;
+};
+#endif
diff --git a/Applications/PluginGenerator/plugin_template.qrc b/Applications/PluginGenerator/plugin_template.qrc
new file mode 100644
index 0000000000..6a59da691f
--- /dev/null
+++ b/Applications/PluginGenerator/plugin_template.qrc
@@ -0,0 +1,18 @@
+<RCC>
+ <qresource prefix="/">
+ <file>PluginTemplate/CMakeLists.txt</file>
+ <file>PluginTemplate/files.cmake</file>
+ <file>PluginTemplate/manifest_headers.cmake</file>
+ <file>PluginTemplate/plugin.xml</file>
+ <file>PluginTemplate/documentation/doxygen/modules.dox</file>
+ <file>PluginTemplate/documentation/Manual/icon.png</file>
+ <file>PluginTemplate/documentation/Manual/Manual.dox</file>
+ <file>PluginTemplate/resources/icon.xpm</file>
+ <file>PluginTemplate/src/internal/mitkPluginActivator.cpp</file>
+ <file>PluginTemplate/src/internal/mitkPluginActivator.h</file>
+ <file>PluginTemplate/src/internal/QmitkTemplateView.cpp</file>
+ <file>PluginTemplate/src/internal/QmitkTemplateView.h</file>
+ <file>PluginTemplate/src/internal/QmitkTemplateViewControls.ui</file>
+ <file>MITKLicense.txt</file>
+ </qresource>
+</RCC>
diff --git a/Applications/PluginGenerator/project_template.qrc b/Applications/PluginGenerator/project_template.qrc
new file mode 100644
index 0000000000..20a2c11b5a
--- /dev/null
+++ b/Applications/PluginGenerator/project_template.qrc
@@ -0,0 +1,18 @@
+<RCC>
+ <qresource prefix="/">
+ <file>ProjectTemplate/CMakeLists.txt</file>
+ <file>ProjectTemplate/Copyright.txt</file>
+ <file>ProjectTemplate/SuperBuild.cmake</file>
+ <file>ProjectTemplate/Apps/TemplateApp/CMakeLists.txt</file>
+ <file>ProjectTemplate/Apps/TemplateApp/startTemplateApp.bat.in</file>
+ <file>ProjectTemplate/Apps/TemplateApp/TemplateApp.cpp</file>
+ <file>ProjectTemplate/Apps/TemplateApp/TemplateApp.ini</file>
+ <file>ProjectTemplate/CMake/CPackSetup.cmake</file>
+ <file>ProjectTemplate/CMake/CTestCustom.cmake.in</file>
+ <file>ProjectTemplate/CMake/MacroEmptyExternalProject.cmake</file>
+ <file>ProjectTemplate/CMake/StartVS.bat.in</file>
+ <file>ProjectTemplate/CMakeExternals/MITK.cmake</file>
+ <file>ProjectTemplate/Plugins/Plugins.cmake</file>
+ <file>MITKCopyright.txt</file>
+ </qresource>
+</RCC>
diff --git a/CMake/mitkTestPluginGenerator.cmake b/CMake/mitkTestPluginGenerator.cmake
new file mode 100644
index 0000000000..8f040e4782
--- /dev/null
+++ b/CMake/mitkTestPluginGenerator.cmake
@@ -0,0 +1,83 @@
+if(BUILD_TESTING)
+
+ set(proj GeneratedTestProject)
+ set(test_project_out_dir "${MITK_BINARY_DIR}")
+ set(test_project_source_dir "${MITK_BINARY_DIR}/${proj}")
+ set(test_project_binary_dir "${MITK_BINARY_DIR}/${proj}-bin")
+
+ if(NOT EXISTS "${test_project_binary_dir}")
+ file(MAKE_DIRECTORY "${test_project_binary_dir}")
+ endif()
+
+ add_test(NAME mitkPluginGeneratorCreateTest
+ COMMAND PluginGenerator --project-name "${proj}" --project-app-name "TestApp"
+ -ps org.test.plugin -pn "Test Plugin" -vn "Test View"
+ -o ${test_project_out_dir} -y
+ )
+ set_tests_properties(mitkPluginGeneratorCreateTest PROPERTIES
+ LABELS "MITK;BlueBerry")
+
+ if(CMAKE_CONFIGURATION_TYPES)
+ foreach(config ${CMAKE_CONFIGURATION_TYPES})
+ add_test(NAME mitkPluginGeneratorConfigureTest-${config} CONFIGURATIONS ${config}
+ WORKING_DIRECTORY "${test_project_binary_dir}"
+ COMMAND ${CMAKE_COMMAND} -D MITK_DIR:PATH=${MITK_BINARY_DIR}
+ -G ${CMAKE_GENERATOR}
+ "${test_project_source_dir}")
+ set_tests_properties(mitkPluginGeneratorConfigureTest-${config} PROPERTIES
+ DEPENDS mitkPluginGeneratorCreateTest
+ LABELS "MITK;BlueBerry")
+
+ add_test(NAME mitkPluginGeneratorBuildTest-${config} CONFIGURATIONS ${config}
+ COMMAND ${CMAKE_COMMAND} --build ${test_project_binary_dir} --config ${config})
+ set_tests_properties(mitkPluginGeneratorBuildTest-${config} PROPERTIES
+ DEPENDS mitkPluginGeneratorConfigureTest-${config}
+ LABELS "MITK;BlueBerry")
+ endforeach()
+ else()
+ add_test(NAME mitkPluginGeneratorConfigureTest-${CMAKE_BUILD_TYPE}
+ WORKING_DIRECTORY "${test_project_binary_dir}"
+ COMMAND ${CMAKE_COMMAND} -D MITK_DIR:PATH=${MITK_BINARY_DIR}
+ -D CMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
+ -G ${CMAKE_GENERATOR}
+ "${test_project_source_dir}")
+ set_tests_properties(mitkPluginGeneratorConfigureTest-${CMAKE_BUILD_TYPE} PROPERTIES
+ DEPENDS mitkPluginGeneratorCreateTest
+ LABELS "MITK;BlueBerry")
+
+ add_test(mitkPluginGeneratorBuildTest-${CMAKE_BUILD_TYPE}
+ ${CMAKE_COMMAND} --build ${test_project_binary_dir})
+ set_tests_properties(mitkPluginGeneratorBuildTest-${CMAKE_BUILD_TYPE} PROPERTIES
+ DEPENDS mitkPluginGeneratorConfigureTest-${CMAKE_BUILD_TYPE}
+ LABELS "MITK;BlueBerry")
+ endif()
+
+ set(package_test_configurations)
+ if(WIN32)
+ # Only test packaging if build type is "Release" on Windows
+ set(package_test_configurations CONFIGURATIONS Release)
+ endif()
+
+ if(NOT MITK_FAST_TESTING)
+
+ if(WIN32)
+ # Only test packaging if build type is "Release" on Windows
+ add_test(NAME mitkPluginGeneratorPackageTest CONFIGURATIONS Release
+ COMMAND ${CMAKE_COMMAND} --build ${test_project_binary_dir}/${proj}-build --config Release --target package)
+ set_tests_properties(mitkPluginGeneratorPackageTest PROPERTIES
+ DEPENDS mitkPluginGeneratorBuildTest-Release
+ TIMEOUT 1200
+ LABELS "MITK;BlueBerry")
+ elseif(CMAKE_BUILD_TYPE)
+ add_test(mitkPluginGeneratorPackageTest
+ ${CMAKE_COMMAND} --build ${test_project_binary_dir}/${proj}-build --config ${CMAKE_BUILD_TYPE} --target package)
+ set_tests_properties(mitkPluginGeneratorPackageTest PROPERTIES
+ DEPENDS mitkPluginGeneratorBuildTest-${CMAKE_BUILD_TYPE}
+ TIMEOUT 1200
+ LABELS "MITK;BlueBerry")
+ endif()
+
+ endif()
+
+endif()
+
diff --git a/Documentation/Doxygen/BuildInstructions.dox b/Documentation/Doxygen/BuildInstructions.dox
index 3d113873b0..b99e71efbd 100644
--- a/Documentation/Doxygen/BuildInstructions.dox
+++ b/Documentation/Doxygen/BuildInstructions.dox
@@ -1,160 +1,163 @@
/**
\page BuildInstructionsPage Build Instructions
\section BIZero Introduction
The MITK build system (which is based on CMake) supports a "superbuild" process, meaning that it will download, configure, and build
all required third-party libraries (except Qt) automatically. These instructions will show you how to use the MITK superbuild.
+\note This page explains explicitly how to build MITK itself. If you want to create your own project based on MITK, the process
+described below is completely automated. Please see http://www.mitk.org/wiki/SetupAMitkBasedProject
+
For more advanced users, the last sections explain how to inject custom build libraries into the supebuild process.
\section BIOne Prerequisites
You need:
-# Git from http://git-scm.com (there are also numerous third-party graphical clients available)
-# <a href="http://www.cmake.org">CMake</a> (version 2.8.4 or higher)
-# <a href="http://qt.nokia.com">Qt</a> 4.x if you plan to develop Qt-based applications
(version 4.5 or above is recommended, we cannot guarantee compatibility with lower versions)
\section BITwo Get a source tree
Since MITK is under active development we recommend to use git to get
the most recent version. To make sure you get a stable tree, check the
<a href="http://cdash.mitk.org/index.php?project=MITK">MITK dashboard</a>
before checking out. If the build tree is not clean, you can specify an
older revision for the checkout or get a stable tar ball from
<a href="http://www.mitk.org">www.mitk.org</a>
To clone MITK's current git repository do:
\code
git clone http://git.mitk.org/MITK.git
\endcode
\section BIThree Build MITK with CMake
Create a new directory for the superbuild binary tree, change to it and call CMake:
In the shell (assuming you current directory is the same as the one where you
issued the git clone command):
\code
mkdir MITK-superbuild
cd MITK-superbuild
ccmake ../MITK
\endcode
If you use <B>Windows</B>, then you just start the CMake GUI and enter the location of the source and of the binary tree,
choose a suitable generator and configure the project.
CMake will present you a couple of options, these are the most important ones:
- <tt><b>MITK_USE_Boost</b></tt> Build MITK code which depends on Boost (this will download Boost 1.45.0)
- <tt><b>MITK_USE_OpenCV</b></tt> Build MITK code which depends on OpenCV (this will download and build OpenCV 2.2)
- <tt><b>MITK_USE_QT</b></tt> Build MITK code which depends on Qt
- <tt><b>QT_QMAKE_EXECUTABLE</b></tt> The path to the qmake executable of your Qt installation
If you are satisfied with the configuration of your MITK superbuild, generate the project files with
CMake by pressing "Generate".
<b>Linux</b> users usually just enter "make" (optionally supplying the number threads to be used for
a parallel build):
\code
make -j4
\endcode
<b>Windows</b> users using Visual Studio can open the generated <tt>MITK-superbuild.sln</tt> solution file
in the <tt>MITK-superbuild</tt> directory and start the build by building the <tt>BUILD_ALL</tt> project.
\section BIFour Customize your MITK superbuild
The MITK superbuild configured MITK with all needed external libraries. The build directories of these libraries,
and of MITK itself are located inside the <tt>MITK-superbuild</tt> directory. For example, the directory layout may
look like:
\code
MITK-superbuild
|- ITK-build
|- VTK-build
|- MITK-build
\endcode
To change the configuration of the MITK build, choose the MITK-build directory as the binary directory in the
CMake GUI. After generating the project files, build the MITK project by either issuing "make" in the MITK-build
directory (Linux), or by opening MITK-build/MITK.sln and building the project with Visual Studio.
You may also change the configuration of any project configured via the superbuild process. Make sure to also build
the changed project and also the projects which depend on it.
\section BIFive Running Applications
On Linux, just execute the application you want to run. MITK executables are located in
<tt>MITK-superbuild/MITK-build/bin</tt>
On Windows, the <tt>PATH</tt> environment variable must contain the directories containging third-party libraries.
The MITK build system generated Windows Batch files in the <tt>MITK-build</tt> directory which set up a correct
environment and opens the appropriate Visual Studio solution file. Use (and maybe modify/enhance) these Batch files
to be able to start and debug MITK applications from inside Visual Studio.
\section BISix Documentation
If you have the <a href="http://www.doxygen.org">Doxygen</a> documentation tool installed, you get a new project
(Visual Studio) or "make" target named "doc". You can build this to generate the HTML documentation of MITK in
the Documentation/Doxygen directory of your MITK-build binary tree or in the <tt>MITK_DOXYGEN_OUTPUT_DIR</tt> CMake variable
(if specified).
\section BISeven Extend MITK on your own (using the application framework BlueBerry)
\ref NewPluginPage
\section BIEight Use MITK in your own project (as a toolkit)
In the MITK-build binary tree the MITKConfig.cmake file is generated. You can include it in your own project with
FIND_PACKAGE(MITK)
On Windows you also need
FIND_PACKAGE(ITK)
FIND_PACKAGE(VTK)
to get the library dependencies right.
After that you can set your include path with
INCLUDE_DIRECTORIES(${QMITK_INCLUDE_DIRS})
and create an application:
LINK_DIRECTORIES(${MITK_LINK_DIRECTORIES})
ADD_EXECUTABLE(MyApp MyApp.cpp)
TARGET_LINK_LIBRARIES(Step1 ${QMITK_LIBRARIES})
\note IMPORTANT: do not include the ITK_USE_FILE in your project when using MITK. There's a conflict in the ITK
and MITK tree classes which will be resolved soon.
\section BINine Superbuild Customization
You can inject pre-build third-party libraries into the MITK superbuild by setting certain CMake variables before
the first configure step. MITK will then use these third-party libraries instead of downloading and building them
itself. Note you must take care to configure those libraries with all options MITK requires.
The following variables are supported:
- <tt><b>BOOST_ROOT</b></tt> Set this variable to your custom Boost installation
- <tt><b>CTK_DIR</b></tt> Set this variable to your CTK binary tree (the directory containing the CTKConfig.cmake file)
- <tt><b>DCMTK_DIR</b></tt> Set this variable to your DCMTK binary tree (the directory containing the DCMTKConfig.cmake file)
- <tt><b>GDCM_DIR</b></tt> Set this variable to your GDCM binary tree (the directory containing the GDCMConfig.cmake file)
- <tt><b>ITK_DIR</b></tt> Set this variable to your ITK binary tree (the directory containing the ITKConfig.cmake file)
- <tt><b>OpenCV_DIR</b></tt> Set this variable to your OpenCV binary tree (the directory containing the OpenCVConfig.cmake file)
- <tt><b>VTK_DIR</b></tt> Set this variable to your VTK binary tree (the directory containing the VTKConfig.cmake file)
To set CMake options before the first configure step is invoked, either supply them on the command line, i.e.
\code
ccmake -DITK_DIR:PATH=/opt/ITK-release ../MITK
\endcode
or add them in the CMake GUI by pressing "Add Entry" (before pressing "Configure" the first time).
See the following link for more information about how to configure third-party libraries:
\ref BuildToolkits "How to build ITK, VTK and QT"
*/
diff --git a/Documentation/Doxygen/BundleGenerator1.png b/Documentation/Doxygen/BundleGenerator1.png
deleted file mode 100755
index 6491502c52..0000000000
Binary files a/Documentation/Doxygen/BundleGenerator1.png and /dev/null differ
diff --git a/Documentation/Doxygen/BundleGenerator2.png b/Documentation/Doxygen/BundleGenerator2.png
deleted file mode 100755
index 33a05b2d51..0000000000
Binary files a/Documentation/Doxygen/BundleGenerator2.png and /dev/null differ
diff --git a/Documentation/Doxygen/BundleGenerator3.png b/Documentation/Doxygen/BundleGenerator3.png
deleted file mode 100755
index 6e259bc6d4..0000000000
Binary files a/Documentation/Doxygen/BundleGenerator3.png and /dev/null differ
diff --git a/Documentation/Doxygen/NewPlugin.dox b/Documentation/Doxygen/NewPlugin.dox
index 8ccb986694..29cb922719 100755
--- a/Documentation/Doxygen/NewPlugin.dox
+++ b/Documentation/Doxygen/NewPlugin.dox
@@ -1,107 +1,95 @@
/**
\page NewPluginPage How to create a new MITK Plug-in
-\attention The procedure described here will generate legacy BlueBerry bundles. MITK switched to using the
-CTK plugin framework and hence it is recommended to create CTK plug-ins instead of BlueBerry bundles. Until
-there is similar generator for CTK-based MITK projects available, please read
-<a href="http://www.mitk.org/wiki/SetupAMitkBasedProject">Set-up a MITK-based Project</a>.
-
-\section CmakePluginGen CMake-based plug-in generator
-The BundleGenerator is a tool to simplify the process of creating your own MITK project (optional) and plug-ins.
-
-\par Introduction
-This how-to will show you how to create a new MITK project together with a new plug-in. You will not need to touch
-either the MITK source tree or any MITK binary tree. MITK will be used in the sense of a Software Development Kit (SDK),
-providing only header files and binaries (shared objects).
-
-\par Limitations
-The CMake based generator will generate only very few classes for you. It can generate an Activator class and a View class for GUI contributions.
-Nevertheless, you are advised to use it because it generates the correct plug-in directory structure. In the future, there will be a more
-sophisticated generator available.
-
-\par Prerequisites
-We will use MITK as a SDK, which we have to set up first. Since there is no SDK package available
-yet which you could download and install, we have to follow the steps in
- <a href="http://www.mitk.org/wiki/SetupMitkQt4BlueBerry">SetupMitkQt4BlueBerry</a>.
-This will set up a binary MITK tree which we can be used later on to link our plug-ins to.
+The MITK Plugin Generator is a command line tool to simplify the process of creating your own MITK project
+(optional) and plug-ins. It can either be downloaded <a href="http://www.mitk.org/wiki/Download">here</a>
+or used from an existing MITK build.
-\par
-After you have build MITK, you have to think about a name and an id for your new plug-in and/or
-your new project. The generator uses the CMake GUI for configuration.
-
-\par Windows
-\li Start the CMake GUI
-\li Choose \c \<MITK-SRC-DIR\>/Build/Tools/BundleGenerator as source directory
-\li Choose a directory for the source code of your project and/or plug-in (create it if it doesn't exist)
-\li Press "Configure" and don't care about the generator
-\li Follow the steps for "All"
-
-\par Linux
-\li Create a directory for the source code of your project and/or plug-in and cd into it.
-\li Start <tt>ccmake</tt> with <tt>\<MITK-SRC-DIR\>/Build/Tools/BundleGenerator</tt> as source directory
-\li Press "Configure"
-
-\par All
-
-\image html BundleGenerator1.png
-\n
-\li CUSTOM_PROJECT_NAME (optional): The name of your new project. If empty, only the source code for your plug-in is generated.
- MBI members should not supply a value.
-\li GUI_SUPPORT: you usually want to contribute to the UI, so leave this ON
-\li PLUGIN_ID: Enter an id for the new plug-in. It must be a unique identifier, so the following form is recommended: \c my.domain.identifier.
- MBI members should use an id similar to \c org.mitk.gui.qt.isosurface.
-\li PLUGIN_NAME: The name of your plug-in in human-readable form. For example: MITK IsoSurface Plug-in
-\li PLUGIN_TEMPLATE: Leave this as it is, unless you really know what you are doing.
-\li Press "Configure" again and you will get the following screen:
-\n
-\n
-\image html BundleGenerator2.png
-\n
-\li ACTIVATOR_CLASS (optional): The name of a class (without namespaces) which can be used to react to lifecycle events of your plug-in. See berry::IBundleActivator .
-\li CUSTOM_PROJECT_EXECUTABLE (optional/required): If you supplied a CUSTOM_PROJECT_NAME, this variable will hold the name of your executable which will start an BlueBerry Workbench.
-\li PLUGIN_VENDOR: The person or institution from which this plug-in comes from. Change to your needs.
-\li PLUGIN_VERSION: The version number of your plug-in. This will be used by the platform for managing plug-in dependencies.
-\li REQUIRED_PLUGINS: The ids of plug-ins your plug-in directly depends on. Usually you won't need to change something.
-\li VIEW_BASE_CLASS: The class from which your new view inherits from. Usually not changed.
-\li VIEW_BASE_CLASS_H: The header file for the base class of your new view. Usually not changed.
-\li VIEW_CLASS: The name of your new view (i.e. functionality) class.
-\li VIEW_ID: A unique id for your new view. Again, it is recommended to use something like my.domain.views.id.
- MBI members should use an id similar to \c org.mitk.views.isosurface
-\li VIEW_NAME: The name of your view in human-readable form. This name will be shown in the UI of your application.
-\li Press "Configure" again, which will give the following screen:
-\n
-\n
-\image html BundleGenerator3.png
-\n
-If everything looks okay, press "Generate" and CMake will create a directory named Generated/\<CUSTOM_PROJECT_NAME\> (if you set a value for it) or
-a directory named Generated/\<PLUGIN_ID\>. You can move or rename the \<CUSTOM_PROJECT_NAME\> directory (or the \<PLUGIN_ID\> directory if you did not create a project)
-somewhere else if you want to get rid of the parent directories.
-
-\par Integrating your new plug-in
-If you supplied a CUSTOM_PROJECT_NAME value, create a new directory outside of the \<CUSTOM_PROJECT_NAME\> directory for your project's
-binary tree. Start CMake again and use \<CUSTOM_PROJECT_NAME\> as source directory and your newly created directory as binary directory.
-Go through the configuration and generation process again (you will have to set the variable MITK_DIR to your MITK binary directory)
- and you will get project files for your chosen environment. On Windows, use
-the supplied \b startVS2008.bat file in your binary tree to start Visual Studio (this will correctly set your path environment variable).
+The Plugin Generator takes the following command line arguments:
+
+\verbatim
+./MITKPluginGenerator -h
+A CTK plug-in generator for MITK
+
+ -h, --help Show this help text
+ -o, --out-dir Output directory (default: /tmp)
+ -l, --license Path to a file containing license information (default: :/MITKLicense.txt)
+ -v, --vendor The vendor of the generated code (default: DKFZ, Medical and Biological Informatics)
+ -q, --quiet Do not print additional information
+ -y, --confirm-all Answer all questions with 'yes'
+
+Plug-in View options
+ -vc, --view-class The View's' class name
+ -vn, --view-name The View's human readable name
+
+Plug-in options
+ -ps, --plugin-symbolic-name The plugin's symbolic name
+ -pn, --plugin-name The plug-in's human readable name
+
+Project options
+ --project-copyright Path to a file containing copyright information (default: :/MITKCopyright.txt)
+ --project-name The project name
+ --project-app-name The application name
+\endverbatim
+
+If a project name is provided via the <tt>--project-name</tt> argument, the new plug-in will be generated
+as part of a new project.
+
+\section NewPluginOnly Creating a new MITK plug-in
+
+Here is an example call to the Plugin Generator, creating one plug-in with the symbolic name
+<tt>com.mycompany.myplugin</tt> and a View named <tt>My View</tt>:
+
+\verbatim
+./MITKPluginGenerator --plugin-symbolic-name org.mycompany.myplugin --view-name "My View"
+\endverbatim
+
+If you did not already specify the final location of the plug-in via the <tt>--out-dir</tt> argument, move the
+directory (in our example <tt>/tmp/org.mycompany.myplugin</tt>) to your existing project. Do not forget to add the
+plug-in in your project's build system (usually in the file <tt>&lt;your-project&gt;/Plugins/Plugins.cmake</tt>).
+
+\section NewPluginWithProject Creating a new MITK project
+
+\subsection NewPluginProjectPrerequisites Prerequisites
+
+You need:
+ -# Git from http://git-scm.com (there are also numerous third-party graphical clients available)
+ -# <a href="http://www.cmake.org">CMake</a> (version 2.8.4 or higher)
+ -# <a href="http://qt.nokia.com">Qt</a> 4.x if you plan to develop Qt-based applications
+ (version 4.5 or above is recommended, we cannot guarantee compatibility with lower versions)
+
+Here is an example call to the Plugin Generator, creating the same plug-in as above but integrated in a new project:
+
+\verbatim
+./MITKPluginGenerator --plugin-symbolic-name org.mycompany.myplugin --view-name "My View" --project-name "MyProject" --project-app-name "MyApp"
+\endverbatim
+
+The generated project is completely self-contained and can be configured via CMake immediately. When building the
+generated project, it will first download all required dependencies (like MITK itself). For an explanation of the
+project's build directory layout, see <a href="http://www.mitk.org/wiki/SetupAMitkBasedProject">SetupAMITKBasedProject</a>.
+
+
+\section Limitations
+
+The Plugin Generator supports only a very limited set of possible configuration options. For more customizations of your
+project or plug-in, you must familiarize yourself with CMake and the generated build system.
+
+Further, the generator is not able to modify existing projects, it can only create new ones.
-\par
-If you did not want to create a new project (because you already have one), copy your new plug-in from the temporary directory
-in your project's source tree. (Hint for MBI members: put it in \c \<MITK-SRC-DIR\>/Modules/Bundles or \c \<MITK-MBI-SRC-DIR\>/mbi-sb/Bundles !)
-Switch back to the CMake configuration of your custom project (MBI: MITK). On Windows you can just switch the "Where to build the binaries" combobox back
-to your projects (MBI: MITKs) binary directory. After pressing "Configure" a new build option for your plug-in should appear.
\section BuildSystem Build system for plug-ins
Just put new files in your plug-in's \c src or \c src/internal directory and edit the \c files.cmake file there.
If you have any fancy stuff like external libraries and include directories you should have a look at the CMake manual and general MITK build system documentation.
+
\section Troubleshooting Troubleshooting
\par I get "Could not find library" messages and similar stuff when I try to start my project's executable.
This is mostly due to wrong environment settings. On Windows, make sure that you use the supplied batch files to start
Visual Studio or your project's executable. If you still get errors, double check the value of the PATH variable in
your batch files (it must contain MITK's binary directory and paths to the ITK, VTK and Qt libraries.
\par
On Linux, set your LD_LIBRARY_PATH variable accordingly.
*/
diff --git a/Documentation/doxygen.conf.in b/Documentation/doxygen.conf.in
index f71d59beaa..b2b3685920 100644
--- a/Documentation/doxygen.conf.in
+++ b/Documentation/doxygen.conf.in
@@ -1,1764 +1,1765 @@
# Doxyfile 1.7.3
# This file describes the settings to be used by the documentation system
# doxygen (www.doxygen.org) for a project.
#
# All text after a hash (#) is considered a comment and will be ignored.
# The format is:
# TAG = value [value, ...]
# For lists items can also be appended using:
# TAG += value [value, ...]
# Values that contain spaces should be placed between quotes (" ").
#---------------------------------------------------------------------------
# Project related configuration options
#---------------------------------------------------------------------------
# This tag specifies the encoding used for all characters in the config file
# that follow. The default is UTF-8 which is also the encoding used for all
# text before the first occurrence of this tag. Doxygen uses libiconv (or the
# iconv built into libc) for the transcoding. See
# http://www.gnu.org/software/libiconv for the list of possible encodings.
DOXYFILE_ENCODING = UTF-8
# The PROJECT_NAME tag is a single word (or a sequence of words surrounded
# by quotes) that should identify the project.
PROJECT_NAME = MITK
# The PROJECT_NUMBER tag can be used to enter a project or revision number.
# This could be handy for archiving the generated documentation or
# if some version control system is used.
PROJECT_NUMBER = @MITK_VERSION_STRING@
# Using the PROJECT_BRIEF tag one can provide an optional one line description
# for a project that appears at the top of each page and should give viewer a
# quick idea about the purpose of the project. Keep the description short.
PROJECT_BRIEF = "Medical Imaging Interaction Toolkit"
# With the PROJECT_LOGO tag one can specify an logo or icon that is
# included in the documentation. The maximum height of the logo should not
# exceed 55 pixels and the maximum width should not exceed 200 pixels.
# Doxygen will copy the logo to the output directory.
PROJECT_LOGO =
# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
# base path where the generated documentation will be put.
# If a relative path is entered, it will be relative to the location
# where doxygen was started. If left blank the current directory will be used.
OUTPUT_DIRECTORY = @MITK_DOXYGEN_OUTPUT_DIR@
# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create
# 4096 sub-directories (in 2 levels) under the output directory of each output
# format and will distribute the generated files over these directories.
# Enabling this option can be useful when feeding doxygen a huge amount of
# source files, where putting all generated files in the same directory would
# otherwise cause performance problems for the file system.
CREATE_SUBDIRS = NO
# The OUTPUT_LANGUAGE tag is used to specify the language in which all
# documentation generated by doxygen is written. Doxygen will use this
# information to generate all constant output in the proper language.
# The default language is English, other supported languages are:
# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional,
# Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German,
# Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English
# messages), Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian,
# Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrillic, Slovak,
# Slovene, Spanish, Swedish, Ukrainian, and Vietnamese.
OUTPUT_LANGUAGE = English
# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will
# include brief member descriptions after the members that are listed in
# the file and class documentation (similar to JavaDoc).
# Set to NO to disable this.
BRIEF_MEMBER_DESC = YES
# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend
# the brief description of a member or function before the detailed description.
# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
# brief descriptions will be completely suppressed.
REPEAT_BRIEF = YES
# This tag implements a quasi-intelligent brief description abbreviator
# that is used to form the text in various listings. Each string
# in this list, if found as the leading text of the brief description, will be
# stripped from the text and the result after processing the whole list, is
# used as the annotated text. Otherwise, the brief description is used as-is.
# If left blank, the following values are used ("$name" is automatically
# replaced with the name of the entity): "The $name class" "The $name widget"
# "The $name file" "is" "provides" "specifies" "contains"
# "represents" "a" "an" "the"
ABBREVIATE_BRIEF =
# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
# Doxygen will generate a detailed section even if there is only a brief
# description.
ALWAYS_DETAILED_SEC = NO
# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
# inherited members of a class in the documentation of that class as if those
# members were ordinary class members. Constructors, destructors and assignment
# operators of the base classes will not be shown.
INLINE_INHERITED_MEMB = NO
# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full
# path before files name in the file list and in the header files. If set
# to NO the shortest path that makes the file name unique will be used.
FULL_PATH_NAMES = NO
# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag
# can be used to strip a user-defined part of the path. Stripping is
# only done if one of the specified strings matches the left-hand part of
# the path. The tag can be used to show relative paths in the file list.
# If left blank the directory from which doxygen is run is used as the
# path to strip.
STRIP_FROM_PATH =
# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of
# the path mentioned in the documentation of a class, which tells
# the reader which header file to include in order to use a class.
# If left blank only the name of the header file containing the class
# definition is used. Otherwise one should specify the include paths that
# are normally passed to the compiler using the -I flag.
STRIP_FROM_INC_PATH =
# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter
# (but less readable) file names. This can be useful if your file system
# doesn't support long names like on DOS, Mac, or CD-ROM.
SHORT_NAMES = NO
# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen
# will interpret the first line (until the first dot) of a JavaDoc-style
# comment as the brief description. If set to NO, the JavaDoc
# comments will behave just like regular Qt-style comments
# (thus requiring an explicit @brief command for a brief description.)
JAVADOC_AUTOBRIEF = NO
# If the QT_AUTOBRIEF tag is set to YES then Doxygen will
# interpret the first line (until the first dot) of a Qt-style
# comment as the brief description. If set to NO, the comments
# will behave just like regular Qt-style comments (thus requiring
# an explicit \brief command for a brief description.)
QT_AUTOBRIEF = NO
# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen
# treat a multi-line C++ special comment block (i.e. a block of //! or ///
# comments) as a brief description. This used to be the default behaviour.
# The new default is to treat a multi-line C++ comment block as a detailed
# description. Set this tag to YES if you prefer the old behaviour instead.
MULTILINE_CPP_IS_BRIEF = NO
# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented
# member inherits the documentation from any documented member that it
# re-implements.
INHERIT_DOCS = YES
# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce
# a new page for each member. If set to NO, the documentation of a member will
# be part of the file/class/namespace that contains it.
SEPARATE_MEMBER_PAGES = NO
# The TAB_SIZE tag can be used to set the number of spaces in a tab.
# Doxygen uses this value to replace tabs by spaces in code fragments.
TAB_SIZE = 8
# This tag can be used to specify a number of aliases that acts
# as commands in the documentation. An alias has the form "name=value".
# For example adding "sideeffect=\par Side Effects:\n" will allow you to
# put the command \sideeffect (or @sideeffect) in the documentation, which
# will result in a user-defined paragraph with heading "Side Effects:".
# You can put \n's in the value part of an alias to insert newlines.
ALIASES = "FIXME=\par Fix Me's:\n" \
"BlueBerry=\if BLUEBERRY" \
"endBlueBerry=\endif" \
"bundlemainpage{1}=\page \1"
# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C
# sources only. Doxygen will then generate output that is more tailored for C.
# For instance, some of the names that are used will be different. The list
# of all members will be omitted, etc.
OPTIMIZE_OUTPUT_FOR_C = NO
# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java
# sources only. Doxygen will then generate output that is more tailored for
# Java. For instance, namespaces will be presented as packages, qualified
# scopes will look different, etc.
OPTIMIZE_OUTPUT_JAVA = NO
# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
# sources only. Doxygen will then generate output that is more tailored for
# Fortran.
OPTIMIZE_FOR_FORTRAN = NO
# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
# sources. Doxygen will then generate output that is tailored for
# VHDL.
OPTIMIZE_OUTPUT_VHDL = NO
# Doxygen selects the parser to use depending on the extension of the files it
# parses. With this tag you can assign which parser to use for a given extension.
# Doxygen has a built-in mapping, but you can override or extend it using this
# tag. The format is ext=language, where ext is a file extension, and language
# is one of the parsers supported by doxygen: IDL, Java, Javascript, CSharp, C,
# C++, D, PHP, Objective-C, Python, Fortran, VHDL, C, C++. For instance to make
# doxygen treat .inc files as Fortran files (default is PHP), and .f files as C
# (default is Fortran), use: inc=Fortran f=C. Note that for custom extensions
# you also need to set FILE_PATTERNS otherwise the files are not read by doxygen.
EXTENSION_MAPPING =
# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
# to include (a tag file for) the STL sources as input, then you should
# set this tag to YES in order to let doxygen match functions declarations and
# definitions whose arguments contain STL classes (e.g. func(std::string); v.s.
# func(std::string) {}). This also makes the inheritance and collaboration
# diagrams that involve STL classes more complete and accurate.
BUILTIN_STL_SUPPORT = YES
# If you use Microsoft's C++/CLI language, you should set this option to YES to
# enable parsing support.
CPP_CLI_SUPPORT = NO
# Set the SIP_SUPPORT tag to YES if your project consists of sip sources only.
# Doxygen will parse them like normal C++ but will assume all classes use public
# instead of private inheritance when no explicit protection keyword is present.
SIP_SUPPORT = NO
# For Microsoft's IDL there are propget and propput attributes to indicate getter
# and setter methods for a property. Setting this option to YES (the default)
# will make doxygen replace the get and set methods by a property in the
# documentation. This will only work if the methods are indeed getting or
# setting a simple type. If this is not the case, or you want to show the
# methods anyway, you should set this option to NO.
IDL_PROPERTY_SUPPORT = YES
# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
# tag is set to YES, then doxygen will reuse the documentation of the first
# member in the group (if any) for the other members of the group. By default
# all members of a group must be documented explicitly.
DISTRIBUTE_GROUP_DOC = NO
# Set the SUBGROUPING tag to YES (the default) to allow class member groups of
# the same type (for instance a group of public functions) to be put as a
# subgroup of that type (e.g. under the Public Functions section). Set it to
# NO to prevent subgrouping. Alternatively, this can be done per class using
# the \nosubgrouping command.
SUBGROUPING = YES
# When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum
# is documented as struct, union, or enum with the name of the typedef. So
# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
# with name TypeT. When disabled the typedef will appear as a member of a file,
# namespace, or class. And the struct will be named TypeS. This can typically
# be useful for C code in case the coding convention dictates that all compound
# types are typedef'ed and only the typedef is referenced, never the tag name.
TYPEDEF_HIDES_STRUCT = NO
# The SYMBOL_CACHE_SIZE determines the size of the internal cache use to
# determine which symbols to keep in memory and which to flush to disk.
# When the cache is full, less often used symbols will be written to disk.
# For small to medium size projects (<1000 input files) the default value is
# probably good enough. For larger projects a too small cache size can cause
# doxygen to be busy swapping symbols to and from disk most of the time
# causing a significant performance penalty.
# If the system has enough physical memory increasing the cache will improve the
# performance by keeping more symbols in memory. Note that the value works on
# a logarithmic scale so increasing the size by one will roughly double the
# memory usage. The cache size is given by this formula:
# 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0,
# corresponding to a cache size of 2^16 = 65536 symbols
SYMBOL_CACHE_SIZE = 0
#---------------------------------------------------------------------------
# Build related configuration options
#---------------------------------------------------------------------------
# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
# documentation are documented, even if no documentation was available.
# Private class members and static file members will be hidden unless
# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
EXTRACT_ALL = YES
# If the EXTRACT_PRIVATE tag is set to YES all private members of a class
# will be included in the documentation.
EXTRACT_PRIVATE = NO
# If the EXTRACT_STATIC tag is set to YES all static members of a file
# will be included in the documentation.
EXTRACT_STATIC = YES
# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs)
# defined locally in source files will be included in the documentation.
# If set to NO only classes defined in header files are included.
EXTRACT_LOCAL_CLASSES = NO
# This flag is only useful for Objective-C code. When set to YES local
# methods, which are defined in the implementation section but not in
# the interface are included in the documentation.
# If set to NO (the default) only methods in the interface are included.
EXTRACT_LOCAL_METHODS = NO
# If this flag is set to YES, the members of anonymous namespaces will be
# extracted and appear in the documentation as a namespace called
# 'anonymous_namespace{file}', where file will be replaced with the base
# name of the file that contains the anonymous namespace. By default
# anonymous namespaces are hidden.
EXTRACT_ANON_NSPACES = NO
# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all
# undocumented members of documented classes, files or namespaces.
# If set to NO (the default) these members will be included in the
# various overviews, but no documentation section is generated.
# This option has no effect if EXTRACT_ALL is enabled.
HIDE_UNDOC_MEMBERS = NO
# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all
# undocumented classes that are normally visible in the class hierarchy.
# If set to NO (the default) these classes will be included in the various
# overviews. This option has no effect if EXTRACT_ALL is enabled.
HIDE_UNDOC_CLASSES = NO
# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all
# friend (class|struct|union) declarations.
# If set to NO (the default) these declarations will be included in the
# documentation.
HIDE_FRIEND_COMPOUNDS = NO
# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any
# documentation blocks found inside the body of a function.
# If set to NO (the default) these blocks will be appended to the
# function's detailed documentation block.
HIDE_IN_BODY_DOCS = NO
# The INTERNAL_DOCS tag determines if documentation
# that is typed after a \internal command is included. If the tag is set
# to NO (the default) then the documentation will be excluded.
# Set it to YES to include the internal documentation.
INTERNAL_DOCS = NO
# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate
# file names in lower-case letters. If set to YES upper-case letters are also
# allowed. This is useful if you have classes or files whose names only differ
# in case and if your file system supports case sensitive file names. Windows
# and Mac users are advised to set this option to NO.
CASE_SENSE_NAMES = YES
# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen
# will show members with their full class and namespace scopes in the
# documentation. If set to YES the scope will be hidden.
HIDE_SCOPE_NAMES = NO
# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen
# will put a list of the files that are included by a file in the documentation
# of that file.
SHOW_INCLUDE_FILES = YES
# If the FORCE_LOCAL_INCLUDES tag is set to YES then Doxygen
# will list include files with double quotes in the documentation
# rather than with sharp brackets.
FORCE_LOCAL_INCLUDES = NO
# If the INLINE_INFO tag is set to YES (the default) then a tag [inline]
# is inserted in the documentation for inline members.
INLINE_INFO = YES
# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen
# will sort the (detailed) documentation of file and class members
# alphabetically by member name. If set to NO the members will appear in
# declaration order.
SORT_MEMBER_DOCS = YES
# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the
# brief documentation of file, namespace and class members alphabetically
# by member name. If set to NO (the default) the members will appear in
# declaration order.
SORT_BRIEF_DOCS = NO
# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen
# will sort the (brief and detailed) documentation of class members so that
# constructors and destructors are listed first. If set to NO (the default)
# the constructors will appear in the respective orders defined by
# SORT_MEMBER_DOCS and SORT_BRIEF_DOCS.
# This tag will be ignored for brief docs if SORT_BRIEF_DOCS is set to NO
# and ignored for detailed docs if SORT_MEMBER_DOCS is set to NO.
SORT_MEMBERS_CTORS_1ST = NO
# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the
# hierarchy of group names into alphabetical order. If set to NO (the default)
# the group names will appear in their defined order.
SORT_GROUP_NAMES = NO
# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be
# sorted by fully-qualified names, including namespaces. If set to
# NO (the default), the class list will be sorted only by class name,
# not including the namespace part.
# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
# Note: This option applies only to the class list, not to the
# alphabetical list.
SORT_BY_SCOPE_NAME = YES
# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper type resolution of all parameters of a function it will reject a
# match between the prototype and the implementation of a member function even if there is only one candidate or it is obvious which candidate to choose by doing a simple string match. By disabling STRICT_PROTO_MATCHING doxygen
# will still accept a match between prototype and implementation in such cases.
STRICT_PROTO_MATCHING = NO
# The GENERATE_TODOLIST tag can be used to enable (YES) or
# disable (NO) the todo list. This list is created by putting \todo
# commands in the documentation.
GENERATE_TODOLIST = @MITK_DOXYGEN_GENERATE_TODOLIST@
# The GENERATE_TESTLIST tag can be used to enable (YES) or
# disable (NO) the test list. This list is created by putting \test
# commands in the documentation.
GENERATE_TESTLIST = YES
# The GENERATE_BUGLIST tag can be used to enable (YES) or
# disable (NO) the bug list. This list is created by putting \bug
# commands in the documentation.
GENERATE_BUGLIST = @MITK_DOXYGEN_GENERATE_BUGLIST@
# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or
# disable (NO) the deprecated list. This list is created by putting
# \deprecated commands in the documentation.
GENERATE_DEPRECATEDLIST= @MITK_DOXYGEN_GENERATE_DEPRECATEDLIST@
# The ENABLED_SECTIONS tag can be used to enable conditional
# documentation sections, marked by \if sectionname ... \endif.
ENABLED_SECTIONS = @MITK_DOXYGEN_ENABLED_SECTIONS@
# The MAX_INITIALIZER_LINES tag determines the maximum number of lines
# the initial value of a variable or macro consists of for it to appear in
# the documentation. If the initializer consists of more lines than specified
# here it will be hidden. Use a value of 0 to hide initializers completely.
# The appearance of the initializer of individual variables and macros in the
# documentation can be controlled using \showinitializer or \hideinitializer
# command in the documentation regardless of this setting.
MAX_INITIALIZER_LINES = 0
# Set the SHOW_USED_FILES tag to NO to disable the list of files generated
# at the bottom of the documentation of classes and structs. If set to YES the
# list will mention the files that were used to generate the documentation.
SHOW_USED_FILES = YES
# If the sources in your project are distributed over multiple directories
# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy
# in the documentation. The default is NO.
SHOW_DIRECTORIES = NO
# Set the SHOW_FILES tag to NO to disable the generation of the Files page.
# This will remove the Files entry from the Quick Index and from the
# Folder Tree View (if specified). The default is YES.
SHOW_FILES = YES
# Set the SHOW_NAMESPACES tag to NO to disable the generation of the
# Namespaces page.
# This will remove the Namespaces entry from the Quick Index
# and from the Folder Tree View (if specified). The default is YES.
SHOW_NAMESPACES = YES
# The FILE_VERSION_FILTER tag can be used to specify a program or script that
# doxygen should invoke to get the current version for each file (typically from
# the version control system). Doxygen will invoke the program by executing (via
# popen()) the command <command> <input-file>, where <command> is the value of
# the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file
# provided by doxygen. Whatever the program writes to standard output
# is used as the file version. See the manual for examples.
FILE_VERSION_FILTER =
# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
# by doxygen. The layout file controls the global structure of the generated
# output files in an output format independent way. The create the layout file
# that represents doxygen's defaults, run doxygen with the -l option.
# You can optionally specify a file name after the option, if omitted
# DoxygenLayout.xml will be used as the name of the layout file.
LAYOUT_FILE =
#---------------------------------------------------------------------------
# configuration options related to warning and progress messages
#---------------------------------------------------------------------------
# The QUIET tag can be used to turn on/off the messages that are generated
# by doxygen. Possible values are YES and NO. If left blank NO is used.
QUIET = NO
# The WARNINGS tag can be used to turn on/off the warning messages that are
# generated by doxygen. Possible values are YES and NO. If left blank
# NO is used.
WARNINGS = YES
# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings
# for undocumented members. If EXTRACT_ALL is set to YES then this flag will
# automatically be disabled.
WARN_IF_UNDOCUMENTED = YES
# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for
# potential errors in the documentation, such as not documenting some
# parameters in a documented function, or documenting parameters that
# don't exist or using markup commands wrongly.
WARN_IF_DOC_ERROR = YES
# The WARN_NO_PARAMDOC option can be enabled to get warnings for
# functions that are documented, but have no documentation for their parameters
# or return value. If set to NO (the default) doxygen will only warn about
# wrong or incomplete parameter documentation, but not about the absence of
# documentation.
WARN_NO_PARAMDOC = NO
# The WARN_FORMAT tag determines the format of the warning messages that
# doxygen can produce. The string should contain the $file, $line, and $text
# tags, which will be replaced by the file and line number from which the
# warning originated and the warning text. Optionally the format may contain
# $version, which will be replaced by the version of the file (if it could
# be obtained via FILE_VERSION_FILTER)
WARN_FORMAT = "$file:$line: $text"
# The WARN_LOGFILE tag can be used to specify a file to which warning
# and error messages should be written. If left blank the output is written
# to stderr.
WARN_LOGFILE =
#---------------------------------------------------------------------------
# configuration options related to the input files
#---------------------------------------------------------------------------
# The INPUT tag can be used to specify the files and/or directories that contain
# documented source files. You may enter file names like "myfile.cpp" or
# directories like "/usr/src/myproject". Separate the files or directories
# with spaces.
INPUT = ./ \
@MITK_SOURCE_DIR@ \
@MITK_BINARY_DIR@ \
@MITK_DOXYGEN_ADDITIONAL_INPUT_DIRS@
# This tag can be used to specify the character encoding of the source files
# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
# also the default input encoding. Doxygen uses libiconv (or the iconv built
# into libc) for the transcoding. See http://www.gnu.org/software/libiconv for
# the list of possible encodings.
INPUT_ENCODING = UTF-8
# If the value of the INPUT tag contains directories, you can use the
# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
# and *.h) to filter out the source-files in the directories. If left
# blank the following patterns are tested:
# *.c *.cc *.cxx *.cpp *.c++ *.d *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh
# *.hxx *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.dox *.py
# *.f90 *.f *.for *.vhd *.vhdl
FILE_PATTERNS = *.h \
*.cpp \
*.dox \
*.txx \
*.cxx \
*.cmake
# The RECURSIVE tag can be used to turn specify whether or not subdirectories
# should be searched for input files as well. Possible values are YES and NO.
# If left blank NO is used.
RECURSIVE = YES
# The EXCLUDE tag can be used to specify files and/or directories that should
# excluded from the INPUT source files. This way you can easily exclude a
# subdirectory from a directory tree whose root is specified with the INPUT tag.
EXCLUDE = @MITK_SOURCE_DIR@/Utilities/vecmath/ \
@MITK_SOURCE_DIR@/Utilities/ann/ \
@MITK_SOURCE_DIR@/Utilities/glew/ \
@MITK_SOURCE_DIR@/Utilities/KWStyle/ \
@MITK_SOURCE_DIR@/Utilities/qwt/ \
@MITK_SOURCE_DIR@/Utilities/qxt/ \
@MITK_SOURCE_DIR@/Utilities/tinyxml/ \
@MITK_SOURCE_DIR@/Utilities/Poco/ \
+ @MITK_SOURCE_DIR@/Applications/PluginGenerator/ \
@MITK_SOURCE_DIR@/BlueBerry/ \
@MITK_SOURCE_DIR@/Deprecated/ \
@MITK_SOURCE_DIR@/Build/ \
@MITK_SOURCE_DIR@/Core/Testing/ \
@MITK_SOURCE_DIR@/CMake/PackageDepends \
@MITK_SOURCE_DIR@/CMake/QBundleTemplate \
@MITK_SOURCE_DIR@/CMakeExternals \
@MITK_SOURCE_DIR@/Modules/QmitkExt/vtkQtChartHeaders/ \
@MITK_DOXYGEN_ADDITIONAL_EXCLUDE_DIRS@
# The EXCLUDE_SYMLINKS tag can be used select whether or not files or
# directories that are symbolic links (a Unix file system feature) are excluded
# from the input.
EXCLUDE_SYMLINKS = NO
# If the value of the INPUT tag contains directories, you can use the
# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
# certain files from those directories. Note that the wildcards are matched
# against the file with absolute path, so to exclude all test directories
# for example use the pattern */test/*
EXCLUDE_PATTERNS = moc_* \
Register* \
*/files.cmake \
@MITK_BINARY_DIR@/*.cmake
# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
# (namespaces, classes, functions, etc.) that should be excluded from the
# output. The symbol name can be a fully qualified name, a word, or if the
# wildcard * is used, a substring. Examples: ANamespace, AClass,
# AClass::ANamespace, ANamespace::*Test
EXCLUDE_SYMBOLS =
# The EXAMPLE_PATH tag can be used to specify one or more files or
# directories that contain example code fragments that are included (see
# the \include command).
EXAMPLE_PATH = @MITK_SOURCE_DIR@/Applications/Tutorial/ \
@MITK_SOURCE_DIR@/Core/Code/ \
@MITK_SOURCE_DIR@/Applications/Tests/QtFreeRender/
# If the value of the EXAMPLE_PATH tag contains directories, you can use the
# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
# and *.h) to filter out the source-files in the directories. If left
# blank all files are included.
EXAMPLE_PATTERNS =
# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
# searched for input files to be used with the \include or \dontinclude
# commands irrespective of the value of the RECURSIVE tag.
# Possible values are YES and NO. If left blank NO is used.
EXAMPLE_RECURSIVE = YES
# The IMAGE_PATH tag can be used to specify one or more files or
# directories that contain image that are included in the documentation (see
# the \image command).
IMAGE_PATH = @MITK_SOURCE_DIR@/Documentation/Doxygen/ \
@MITK_SOURCE_DIR@/Documentation/Doxygen/Modules/ \
@MITK_SOURCE_DIR@/Documentation/Doxygen/Tutorial/ \
@MITK_SOURCE_DIR@/Core/DataStructures/ \
@MITK_SOURCE_DIR@
# The INPUT_FILTER tag can be used to specify a program that doxygen should
# invoke to filter for each input file. Doxygen will invoke the filter program
# by executing (via popen()) the command <filter> <input-file>, where <filter>
# is the value of the INPUT_FILTER tag, and <input-file> is the name of an
# input file. Doxygen will then use the output that the filter program writes
# to standard output.
# If FILTER_PATTERNS is specified, this tag will be
# ignored.
INPUT_FILTER =
# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
# basis.
# Doxygen will compare the file name with each pattern and apply the
# filter if there is a match.
# The filters are a list of the form:
# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further
# info on how filters are used. If FILTER_PATTERNS is empty or if
# non of the patterns match the file name, INPUT_FILTER is applied.
FILTER_PATTERNS = *.cmake=@CMakeDoxygenFilter_EXECUTABLE@
# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
# INPUT_FILTER) will be used to filter the input files when producing source
# files to browse (i.e. when SOURCE_BROWSER is set to YES).
FILTER_SOURCE_FILES = NO
# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
# pattern. A pattern will override the setting for FILTER_PATTERN (if any)
# and it is also possible to disable source filtering for a specific pattern
# using *.ext= (so without naming a filter). This option only has effect when
# FILTER_SOURCE_FILES is enabled.
FILTER_SOURCE_PATTERNS =
#---------------------------------------------------------------------------
# configuration options related to source browsing
#---------------------------------------------------------------------------
# If the SOURCE_BROWSER tag is set to YES then a list of source files will
# be generated. Documented entities will be cross-referenced with these sources.
# Note: To get rid of all source code in the generated output, make sure also
# VERBATIM_HEADERS is set to NO.
SOURCE_BROWSER = YES
# Setting the INLINE_SOURCES tag to YES will include the body
# of functions and classes directly in the documentation.
INLINE_SOURCES = NO
# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct
# doxygen to hide any special comment blocks from generated source code
# fragments. Normal C and C++ comments will always remain visible.
STRIP_CODE_COMMENTS = YES
# If the REFERENCED_BY_RELATION tag is set to YES
# then for each documented function all documented
# functions referencing it will be listed.
REFERENCED_BY_RELATION = YES
# If the REFERENCES_RELATION tag is set to YES
# then for each documented function all documented entities
# called/used by that function will be listed.
REFERENCES_RELATION = YES
# If the REFERENCES_LINK_SOURCE tag is set to YES (the default)
# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from
# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will
# link to the source code.
# Otherwise they will link to the documentation.
REFERENCES_LINK_SOURCE = YES
# If the USE_HTAGS tag is set to YES then the references to source code
# will point to the HTML generated by the htags(1) tool instead of doxygen
# built-in source browser. The htags tool is part of GNU's global source
# tagging system (see http://www.gnu.org/software/global/global.html). You
# will need version 4.8.6 or higher.
USE_HTAGS = NO
# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen
# will generate a verbatim copy of the header file for each class for
# which an include is specified. Set to NO to disable this.
VERBATIM_HEADERS = YES
#---------------------------------------------------------------------------
# configuration options related to the alphabetical class index
#---------------------------------------------------------------------------
# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index
# of all compounds will be generated. Enable this if the project
# contains a lot of classes, structs, unions or interfaces.
ALPHABETICAL_INDEX = YES
# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then
# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns
# in which this list will be split (can be a number in the range [1..20])
COLS_IN_ALPHA_INDEX = 3
# In case all classes in a project start with a common prefix, all
# classes will be put under the same header in the alphabetical index.
# The IGNORE_PREFIX tag can be used to specify one or more prefixes that
# should be ignored while generating the index headers.
IGNORE_PREFIX =
#---------------------------------------------------------------------------
# configuration options related to the HTML output
#---------------------------------------------------------------------------
# If the GENERATE_HTML tag is set to YES (the default) Doxygen will
# generate HTML output.
GENERATE_HTML = YES
# The HTML_OUTPUT tag is used to specify where the HTML docs will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
# put in front of it. If left blank `html' will be used as the default path.
HTML_OUTPUT = html
# The HTML_FILE_EXTENSION tag can be used to specify the file extension for
# each generated HTML page (for example: .htm,.php,.asp). If it is left blank
# doxygen will generate files with .html extension.
HTML_FILE_EXTENSION = .html
# The HTML_HEADER tag can be used to specify a personal HTML header for
# each generated HTML page. If it is left blank doxygen will generate a
# standard header.
HTML_HEADER =
# The HTML_FOOTER tag can be used to specify a personal HTML footer for
# each generated HTML page. If it is left blank doxygen will generate a
# standard footer.
HTML_FOOTER =
# The HTML_STYLESHEET tag can be used to specify a user-defined cascading
# style sheet that is used by each HTML page. It can be used to
# fine-tune the look of the HTML output. If the tag is left blank doxygen
# will generate a default style sheet. Note that doxygen will try to copy
# the style sheet file to the HTML output directory, so don't put your own
# stylesheet in the HTML output directory as well, or it will be erased!
HTML_STYLESHEET =
# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output.
# Doxygen will adjust the colors in the stylesheet and background images
# according to this color. Hue is specified as an angle on a colorwheel,
# see http://en.wikipedia.org/wiki/Hue for more information.
# For instance the value 0 represents red, 60 is yellow, 120 is green,
# 180 is cyan, 240 is blue, 300 purple, and 360 is red again.
# The allowed range is 0 to 359.
HTML_COLORSTYLE_HUE = 220
# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of
# the colors in the HTML output. For a value of 0 the output will use
# grayscales only. A value of 255 will produce the most vivid colors.
HTML_COLORSTYLE_SAT = 100
# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to
# the luminance component of the colors in the HTML output. Values below
# 100 gradually make the output lighter, whereas values above 100 make
# the output darker. The value divided by 100 is the actual gamma applied,
# so 80 represents a gamma of 0.8, The value 220 represents a gamma of 2.2,
# and 100 does not change the gamma.
HTML_COLORSTYLE_GAMMA = 80
# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
# page will contain the date and time when the page was generated. Setting
# this to NO can help when comparing the output of multiple runs.
HTML_TIMESTAMP = YES
# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes,
# files or namespaces will be aligned in HTML using tables. If set to
# NO a bullet list will be used.
HTML_ALIGN_MEMBERS = YES
# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
# documentation will contain sections that can be hidden and shown after the
# page has loaded. For this to work a browser that supports
# JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox
# Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari).
HTML_DYNAMIC_SECTIONS = @MITK_DOXYGEN_HTML_DYNAMIC_SECTIONS@
# If the GENERATE_DOCSET tag is set to YES, additional index files
# will be generated that can be used as input for Apple's Xcode 3
# integrated development environment, introduced with OSX 10.5 (Leopard).
# To create a documentation set, doxygen will generate a Makefile in the
# HTML output directory. Running make will produce the docset in that
# directory and running "make install" will install the docset in
# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find
# it at startup.
# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
# for more information.
GENERATE_DOCSET = NO
# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the
# feed. A documentation feed provides an umbrella under which multiple
# documentation sets from a single provider (such as a company or product suite)
# can be grouped.
DOCSET_FEEDNAME = "Doxygen generated docs"
# When GENERATE_DOCSET tag is set to YES, this tag specifies a string that
# should uniquely identify the documentation set bundle. This should be a
# reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen
# will append .docset to the name.
DOCSET_BUNDLE_ID = org.doxygen.Project
# When GENERATE_PUBLISHER_ID tag specifies a string that should uniquely identify
# the documentation publisher. This should be a reverse domain-name style
# string, e.g. com.mycompany.MyDocSet.documentation.
DOCSET_PUBLISHER_ID = org.doxygen.Publisher
# The GENERATE_PUBLISHER_NAME tag identifies the documentation publisher.
DOCSET_PUBLISHER_NAME = Publisher
# If the GENERATE_HTMLHELP tag is set to YES, additional index files
# will be generated that can be used as input for tools like the
# Microsoft HTML help workshop to generate a compiled HTML help file (.chm)
# of the generated HTML documentation.
GENERATE_HTMLHELP = NO
# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can
# be used to specify the file name of the resulting .chm file. You
# can add a path in front of the file if the result should not be
# written to the html output directory.
CHM_FILE =
# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can
# be used to specify the location (absolute path including file name) of
# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run
# the HTML help compiler on the generated index.hhp.
HHC_LOCATION =
# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag
# controls if a separate .chi index file is generated (YES) or that
# it should be included in the master .chm file (NO).
GENERATE_CHI = NO
# If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING
# is used to encode HtmlHelp index (hhk), content (hhc) and project file
# content.
CHM_INDEX_ENCODING =
# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag
# controls whether a binary table of contents is generated (YES) or a
# normal table of contents (NO) in the .chm file.
BINARY_TOC = NO
# The TOC_EXPAND flag can be set to YES to add extra items for group members
# to the contents of the HTML help documentation and to the tree view.
TOC_EXPAND = NO
# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated
# that can be used as input for Qt's qhelpgenerator to generate a
# Qt Compressed Help (.qch) of the generated HTML documentation.
GENERATE_QHP = @MITK_DOXYGEN_GENERATE_QHP@
# If the QHG_LOCATION tag is specified, the QCH_FILE tag can
# be used to specify the file name of the resulting .qch file.
# The path specified is relative to the HTML output folder.
QCH_FILE = @MITK_DOXYGEN_QCH_FILE@
# The QHP_NAMESPACE tag specifies the namespace to use when generating
# Qt Help Project output. For more information please see
# http://doc.trolltech.com/qthelpproject.html#namespace
QHP_NAMESPACE = "org.mitk"
# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating
# Qt Help Project output. For more information please see
# http://doc.trolltech.com/qthelpproject.html#virtual-folders
QHP_VIRTUAL_FOLDER = MITK
# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to
# add. For more information please see
# http://doc.trolltech.com/qthelpproject.html#custom-filters
QHP_CUST_FILTER_NAME =
# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the
# custom filter to add. For more information please see
# <a href="http://doc.trolltech.com/qthelpproject.html#custom-filters">
# Qt Help Project / Custom Filters</a>.
QHP_CUST_FILTER_ATTRS =
# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
# project's
# filter section matches.
# <a href="http://doc.trolltech.com/qthelpproject.html#filter-attributes">
# Qt Help Project / Filter Attributes</a>.
QHP_SECT_FILTER_ATTRS =
# If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can
# be used to specify the location of Qt's qhelpgenerator.
# If non-empty doxygen will try to run qhelpgenerator on the generated
# .qhp file.
QHG_LOCATION = @QT_HELPGENERATOR_EXECUTABLE@
# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files
# will be generated, which together with the HTML files, form an Eclipse help
# plugin. To install this plugin and make it available under the help contents
# menu in Eclipse, the contents of the directory containing the HTML and XML
# files needs to be copied into the plugins directory of eclipse. The name of
# the directory within the plugins directory should be the same as
# the ECLIPSE_DOC_ID value. After copying Eclipse needs to be restarted before
# the help appears.
GENERATE_ECLIPSEHELP = NO
# A unique identifier for the eclipse help plugin. When installing the plugin
# the directory name containing the HTML and XML files should also have
# this name.
ECLIPSE_DOC_ID = org.doxygen.Project
# The DISABLE_INDEX tag can be used to turn on/off the condensed index at
# top of each HTML page. The value NO (the default) enables the index and
# the value YES disables it.
DISABLE_INDEX = NO
# This tag can be used to set the number of enum values (range [0,1..20])
# that doxygen will group on one line in the generated HTML documentation.
# Note that a value of 0 will completely suppress the enum values from appearing in the overview section.
ENUM_VALUES_PER_LINE = 4
# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
# structure should be generated to display hierarchical information.
# If the tag value is set to YES, a side panel will be generated
# containing a tree-like index structure (just like the one that
# is generated for HTML Help). For this to work a browser that supports
# JavaScript, DHTML, CSS and frames is required (i.e. any modern browser).
# Windows users are probably better off using the HTML help feature.
GENERATE_TREEVIEW = YES
# By enabling USE_INLINE_TREES, doxygen will generate the Groups, Directories,
# and Class Hierarchy pages using a tree view instead of an ordered list.
USE_INLINE_TREES = NO
# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be
# used to set the initial width (in pixels) of the frame in which the tree
# is shown.
TREEVIEW_WIDTH = 300
# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open
# links to external symbols imported via tag files in a separate window.
EXT_LINKS_IN_WINDOW = NO
# Use this tag to change the font size of Latex formulas included
# as images in the HTML documentation. The default is 10. Note that
# when you change the font size after a successful doxygen run you need
# to manually remove any form_*.png images from the HTML output directory
# to force them to be regenerated.
FORMULA_FONTSIZE = 10
# Use the FORMULA_TRANPARENT tag to determine whether or not the images
# generated for formulas are transparent PNGs. Transparent PNGs are
# not supported properly for IE 6.0, but are supported on all modern browsers.
# Note that when changing this option you need to delete any form_*.png files
# in the HTML output before the changes have effect.
FORMULA_TRANSPARENT = YES
# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax
# (see http://www.mathjax.org) which uses client side Javascript for the
# rendering instead of using prerendered bitmaps. Use this if you do not
# have LaTeX installed or if you want to formulas look prettier in the HTML
# output. When enabled you also need to install MathJax separately and
# configure the path to it using the MATHJAX_RELPATH option.
USE_MATHJAX = NO
# When MathJax is enabled you need to specify the location relative to the
# HTML output directory using the MATHJAX_RELPATH option. The destination
# directory should contain the MathJax.js script. For instance, if the mathjax
# directory is located at the same level as the HTML output directory, then
# MATHJAX_RELPATH should be ../mathjax. The default value points to the mathjax.org site, so you can quickly see the result without installing
# MathJax, but it is strongly recommended to install a local copy of MathJax
# before deployment.
MATHJAX_RELPATH = http://www.mathjax.org/mathjax
# When the SEARCHENGINE tag is enabled doxygen will generate a search box
# for the HTML output. The underlying search engine uses javascript
# and DHTML and should work on any modern browser. Note that when using
# HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets
# (GENERATE_DOCSET) there is already a search function so this one should
# typically be disabled. For large projects the javascript based search engine
# can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution.
SEARCHENGINE = YES
# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
# implemented using a PHP enabled web server instead of at the web client
# using Javascript. Doxygen will generate the search PHP script and index
# file to put on the web server. The advantage of the server
# based approach is that it scales better to large projects and allows
# full text search. The disadvantages are that it is more difficult to setup
# and does not have live searching capabilities.
SERVER_BASED_SEARCH = NO
#---------------------------------------------------------------------------
# configuration options related to the LaTeX output
#---------------------------------------------------------------------------
# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will
# generate Latex output.
GENERATE_LATEX = NO
# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
# put in front of it. If left blank `latex' will be used as the default path.
LATEX_OUTPUT = latex
# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
# invoked. If left blank `latex' will be used as the default command name.
# Note that when enabling USE_PDFLATEX this option is only used for
# generating bitmaps for formulas in the HTML output, but not in the
# Makefile that is written to the output directory.
LATEX_CMD_NAME = latex
# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to
# generate index for LaTeX. If left blank `makeindex' will be used as the
# default command name.
MAKEINDEX_CMD_NAME = makeindex
# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact
# LaTeX documents. This may be useful for small projects and may help to
# save some trees in general.
COMPACT_LATEX = NO
# The PAPER_TYPE tag can be used to set the paper type that is used
# by the printer. Possible values are: a4, letter, legal and
# executive. If left blank a4wide will be used.
PAPER_TYPE = a4wide
# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX
# packages that should be included in the LaTeX output.
EXTRA_PACKAGES = amssymb
# The LATEX_HEADER tag can be used to specify a personal LaTeX header for
# the generated latex document. The header should contain everything until
# the first chapter. If it is left blank doxygen will generate a
# standard header. Notice: only use this tag if you know what you are doing!
LATEX_HEADER =
# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated
# is prepared for conversion to pdf (using ps2pdf). The pdf file will
# contain links (just like the HTML output) instead of page references
# This makes the output suitable for online browsing using a pdf viewer.
PDF_HYPERLINKS = NO
# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of
# plain latex in the generated Makefile. Set this option to YES to get a
# higher quality PDF documentation.
USE_PDFLATEX = NO
# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode.
# command to the generated LaTeX files. This will instruct LaTeX to keep
# running if errors occur, instead of asking the user for help.
# This option is also used when generating formulas in HTML.
LATEX_BATCHMODE = NO
# If LATEX_HIDE_INDICES is set to YES then doxygen will not
# include the index chapters (such as File Index, Compound Index, etc.)
# in the output.
LATEX_HIDE_INDICES = NO
# If LATEX_SOURCE_CODE is set to YES then doxygen will include
# source code with syntax highlighting in the LaTeX output.
# Note that which sources are shown also depends on other settings
# such as SOURCE_BROWSER.
LATEX_SOURCE_CODE = NO
#---------------------------------------------------------------------------
# configuration options related to the RTF output
#---------------------------------------------------------------------------
# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output
# The RTF output is optimized for Word 97 and may not look very pretty with
# other RTF readers or editors.
GENERATE_RTF = NO
# The RTF_OUTPUT tag is used to specify where the RTF docs will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
# put in front of it. If left blank `rtf' will be used as the default path.
RTF_OUTPUT = rtf
# If the COMPACT_RTF tag is set to YES Doxygen generates more compact
# RTF documents. This may be useful for small projects and may help to
# save some trees in general.
COMPACT_RTF = NO
# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated
# will contain hyperlink fields. The RTF file will
# contain links (just like the HTML output) instead of page references.
# This makes the output suitable for online browsing using WORD or other
# programs which support those fields.
# Note: wordpad (write) and others do not support links.
RTF_HYPERLINKS = NO
# Load stylesheet definitions from file. Syntax is similar to doxygen's
# config file, i.e. a series of assignments. You only have to provide
# replacements, missing definitions are set to their default value.
RTF_STYLESHEET_FILE =
# Set optional variables used in the generation of an rtf document.
# Syntax is similar to doxygen's config file.
RTF_EXTENSIONS_FILE =
#---------------------------------------------------------------------------
# configuration options related to the man page output
#---------------------------------------------------------------------------
# If the GENERATE_MAN tag is set to YES (the default) Doxygen will
# generate man pages
GENERATE_MAN = NO
# The MAN_OUTPUT tag is used to specify where the man pages will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
# put in front of it. If left blank `man' will be used as the default path.
MAN_OUTPUT = man
# The MAN_EXTENSION tag determines the extension that is added to
# the generated man pages (default is the subroutine's section .3)
MAN_EXTENSION = .3
# If the MAN_LINKS tag is set to YES and Doxygen generates man output,
# then it will generate one additional man file for each entity
# documented in the real man page(s). These additional files
# only source the real man page, but without them the man command
# would be unable to find the correct page. The default is NO.
MAN_LINKS = NO
#---------------------------------------------------------------------------
# configuration options related to the XML output
#---------------------------------------------------------------------------
# If the GENERATE_XML tag is set to YES Doxygen will
# generate an XML file that captures the structure of
# the code including all documentation.
GENERATE_XML = NO
# The XML_OUTPUT tag is used to specify where the XML pages will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
# put in front of it. If left blank `xml' will be used as the default path.
XML_OUTPUT = xml
# The XML_SCHEMA tag can be used to specify an XML schema,
# which can be used by a validating XML parser to check the
# syntax of the XML files.
XML_SCHEMA =
# The XML_DTD tag can be used to specify an XML DTD,
# which can be used by a validating XML parser to check the
# syntax of the XML files.
XML_DTD =
# If the XML_PROGRAMLISTING tag is set to YES Doxygen will
# dump the program listings (including syntax highlighting
# and cross-referencing information) to the XML output. Note that
# enabling this will significantly increase the size of the XML output.
XML_PROGRAMLISTING = YES
#---------------------------------------------------------------------------
# configuration options for the AutoGen Definitions output
#---------------------------------------------------------------------------
# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will
# generate an AutoGen Definitions (see autogen.sf.net) file
# that captures the structure of the code including all
# documentation. Note that this feature is still experimental
# and incomplete at the moment.
GENERATE_AUTOGEN_DEF = NO
#---------------------------------------------------------------------------
# configuration options related to the Perl module output
#---------------------------------------------------------------------------
# If the GENERATE_PERLMOD tag is set to YES Doxygen will
# generate a Perl module file that captures the structure of
# the code including all documentation. Note that this
# feature is still experimental and incomplete at the
# moment.
GENERATE_PERLMOD = NO
# If the PERLMOD_LATEX tag is set to YES Doxygen will generate
# the necessary Makefile rules, Perl scripts and LaTeX code to be able
# to generate PDF and DVI output from the Perl module output.
PERLMOD_LATEX = NO
# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be
# nicely formatted so it can be parsed by a human reader.
# This is useful
# if you want to understand what is going on.
# On the other hand, if this
# tag is set to NO the size of the Perl module output will be much smaller
# and Perl will parse it just the same.
PERLMOD_PRETTY = YES
# The names of the make variables in the generated doxyrules.make file
# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX.
# This is useful so different doxyrules.make files included by the same
# Makefile don't overwrite each other's variables.
PERLMOD_MAKEVAR_PREFIX =
#---------------------------------------------------------------------------
# Configuration options related to the preprocessor
#---------------------------------------------------------------------------
# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will
# evaluate all C-preprocessor directives found in the sources and include
# files.
ENABLE_PREPROCESSING = YES
# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro
# names in the source code. If set to NO (the default) only conditional
# compilation will be performed. Macro expansion can be done in a controlled
# way by setting EXPAND_ONLY_PREDEF to YES.
MACRO_EXPANSION = YES
# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES
# then the macro expansion is limited to the macros specified with the
# PREDEFINED and EXPAND_AS_DEFINED tags.
EXPAND_ONLY_PREDEF = NO
# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files
# in the INCLUDE_PATH (see below) will be search if a #include is found.
SEARCH_INCLUDES = YES
# The INCLUDE_PATH tag can be used to specify one or more directories that
# contain include files that are not input files but should be processed by
# the preprocessor.
INCLUDE_PATH =
# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
# patterns (like *.h and *.hpp) to filter out the header-files in the
# directories. If left blank, the patterns specified with FILE_PATTERNS will
# be used.
INCLUDE_FILE_PATTERNS =
# The PREDEFINED tag can be used to specify one or more macro names that
# are defined before the preprocessor is started (similar to the -D option of
# gcc). The argument of the tag is a list of macros of the form: name
# or name=definition (no spaces). If the definition and the = are
# omitted =1 is assumed. To prevent a macro definition from being
# undefined via #undef or recursively expanded use the := operator
# instead of the = operator.
PREDEFINED = itkNotUsed(x)= \
"itkSetMacro(name,type)= virtual void Set##name (type _arg);" \
"itkGetMacro(name,type)= virtual type Get##name ();" \
"itkGetConstMacro(name,type)= virtual type Get##name () const;" \
"itkSetStringMacro(name)= virtual void Set##name (const char* _arg);" \
"itkGetStringMacro(name)= virtual const char* Get##name () const;" \
"itkSetClampMacro(name,type,min,max)= virtual void Set##name (type _arg);" \
"itkSetObjectMacro(name,type)= virtual void Set##name (type* _arg);" \
"itkGetObjectMacro(name,type)= virtual type* Get##name ();" \
"itkSetConstObjectMacro(name,type)= virtual void Set##name ( const type* _arg);" \
"itkGetConstObjectMacro(name,type)= virtual const type* Get##name ();" \
"itkGetConstReferenceMacro(name,type)= virtual const type& Get##name ();" \
"itkGetConstReferenceObjectMacro(name,type)= virtual const type::Pointer& Get##name () const;" \
"itkBooleanMacro(name)= virtual void name##On (); virtual void name##Off ();" \
"itkSetVector2Macro(name,type)= virtual void Set##name (type _arg1, type _arg2) virtual void Set##name (type _arg[2]);" \
"itkGetVector2Macro(name,type)= virtual type* Get##name () const; virtual void Get##name (type& _arg1, type& _arg2) const; virtual void Get##name (type _arg[2]) const;" \
"itkSetVector3Macro(name,type)= virtual void Set##name (type _arg1, type _arg2, type _arg3) virtual void Set##name (type _arg[3]);" \
"itkGetVector3Macro(name,type)= virtual type* Get##name () const; virtual void Get##name (type& _arg1, type& _arg2, type& _arg3) const; virtual void Get##name (type _arg[3]) const;" \
"itkSetVector4Macro(name,type)= virtual void Set##name (type _arg1, type _arg2, type _arg3, type _arg4) virtual void Set##name (type _arg[4]);" \
"itkGetVector4Macro(name,type)= virtual type* Get##name () const; virtual void Get##name (type& _arg1, type& _arg2, type& _arg3, type& _arg4) const; virtual void Get##name (type _arg[4]) const;" \
"itkSetVector6Macro(name,type)= virtual void Set##name (type _arg1, type _arg2, type _arg3, type _arg4, type _arg5, type _arg6) virtual void Set##name (type _arg[6]);" \
"itkGetVector6Macro(name,type)= virtual type* Get##name () const; virtual void Get##name (type& _arg1, type& _arg2, type& _arg3, type& _arg4, type& _arg5, type& _arg6) const; virtual void Get##name (type _arg[6]) const;" \
"itkSetVectorMacro(name,type,count)= virtual void Set##name(type data[]);" \
"itkGetVectorMacro(name,type,count)= virtual type* Get##name () const;" \
"itkNewMacro(type)= static Pointer New();" \
"itkTypeMacro(thisClass,superclass)= virtual const char *GetClassName() const;" \
"itkConceptMacro(name,concept)= enum { name = 0 };" \
"ITK_NUMERIC_LIMITS= std::numeric_limits" \
"ITK_TYPENAME= typename" \
"FEM_ABSTRACT_CLASS(thisClass,parentClass)= public: /** Standard Self typedef.*/ typedef thisClass Self; /** Standard Superclass typedef. */ typedef parentClass Superclass; /** Pointer or SmartPointer to an object. */ typedef Self* Pointer; /** Const pointer or SmartPointer to an object. */ typedef const Self* ConstPointer; private:" \
"FEM_CLASS(thisClass,parentClass)= FEM_ABSTRACT_CLASS(thisClass,parentClass) public: /** Create a new object from the existing one */ virtual Baseclass::Pointer Clone() const; /** Class ID for FEM object factory */ static const int CLID; /** Virtual function to access the class ID */ virtual int ClassID() const { return CLID; } /** Object creation in an itk compatible way */ static Self::Pointer New() { return new Self(); } private:" \
FREEVERSION \
ERROR_CHECKING \
HAS_TIFF \
HAS_JPEG \
HAS_NETLIB \
HAS_PNG \
HAS_ZLIB \
HAS_GLUT \
HAS_QT \
VCL_USE_NATIVE_STL=1 \
VCL_USE_NATIVE_COMPLEX=1 \
VCL_HAS_BOOL=1 \
VXL_BIG_ENDIAN=1 \
VXL_LITTLE_ENDIAN=0 \
VNL_DLL_DATA= \
size_t=vcl_size_t \
DOXYGEN_SKIP
# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
# this tag can be used to specify a list of macro names that should be expanded.
# The macro definition that is found in the sources will be used.
# Use the PREDEFINED tag if you want to use a different macro definition that overrules the definition found in the source code.
EXPAND_AS_DEFINED =
# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then
# doxygen's preprocessor will remove all references to function-like macros
# that are alone on a line, have an all uppercase name, and do not end with a
# semicolon, because these will confuse the parser if not removed.
SKIP_FUNCTION_MACROS = YES
#---------------------------------------------------------------------------
# Configuration::additions related to external references
#---------------------------------------------------------------------------
# The TAGFILES option can be used to specify one or more tagfiles.
# Optionally an initial location of the external documentation
# can be added for each tagfile. The format of a tag file without
# this location is as follows:
#
# TAGFILES = file1 file2 ...
# Adding location for the tag files is done as follows:
#
# TAGFILES = file1=loc1 "file2 = loc2" ...
# where "loc1" and "loc2" can be relative or absolute paths or
# URLs. If a location is present for each tag, the installdox tool
# does not have to be run to correct the links.
# Note that each tag file must have a unique name
# (where the name does NOT include the path)
# If a tag file is not located in the directory in which doxygen
# is run, you must also specify the path to the tagfile here.
TAGFILES = @BLUEBERRY_DOXYGEN_TAGFILE@
# When a file name is specified after GENERATE_TAGFILE, doxygen will create
# a tag file that is based on the input files it reads.
GENERATE_TAGFILE = @MITK_DOXYGEN_TAGFILE_NAME@
# If the ALLEXTERNALS tag is set to YES all external classes will be listed
# in the class index. If set to NO only the inherited external classes
# will be listed.
ALLEXTERNALS = NO
# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed
# in the modules index. If set to NO, only the current project's groups will
# be listed.
EXTERNAL_GROUPS = NO
# The PERL_PATH should be the absolute path and name of the perl script
# interpreter (i.e. the result of `which perl').
PERL_PATH = /usr/bin/perl
#---------------------------------------------------------------------------
# Configuration options related to the dot tool
#---------------------------------------------------------------------------
# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will
# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base
# or super classes. Setting the tag to NO turns the diagrams off. Note that
# this option also works with HAVE_DOT disabled, but it is recommended to
# install and use dot, since it yields more powerful graphs.
CLASS_DIAGRAMS = YES
# You can define message sequence charts within doxygen comments using the \msc
# command. Doxygen will then run the mscgen tool (see
# http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the
# documentation. The MSCGEN_PATH tag allows you to specify the directory where
# the mscgen tool resides. If left empty the tool is assumed to be found in the
# default search path.
MSCGEN_PATH =
# If set to YES, the inheritance and collaboration graphs will hide
# inheritance and usage relations if the target is undocumented
# or is not a class.
HIDE_UNDOC_RELATIONS = YES
# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
# available from the path. This tool is part of Graphviz, a graph visualization
# toolkit from AT&T and Lucent Bell Labs. The other options in this section
# have no effect if this option is set to NO (the default)
HAVE_DOT = @HAVE_DOT@
# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is
# allowed to run in parallel. When set to 0 (the default) doxygen will
# base this on the number of processors available in the system. You can set it
# explicitly to a value larger than 0 to get control over the balance
# between CPU load and processing speed.
DOT_NUM_THREADS = @MITK_DOXYGEN_DOT_NUM_THREADS@
# By default doxygen will write a font called Helvetica to the output
# directory and reference it in all dot files that doxygen generates.
# When you want a differently looking font you can specify the font name
# using DOT_FONTNAME. You need to make sure dot is able to find the font,
# which can be done by putting it in a standard location or by setting the
# DOTFONTPATH environment variable or by setting DOT_FONTPATH to the directory
# containing the font.
DOT_FONTNAME = FreeSans.ttf
# The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs.
# The default size is 10pt.
DOT_FONTSIZE = 10
# By default doxygen will tell dot to use the output directory to look for the
# FreeSans.ttf font (which doxygen will put there itself). If you specify a
# different font using DOT_FONTNAME you can set the path where dot
# can find it using this tag.
DOT_FONTPATH =
# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen
# will generate a graph for each documented class showing the direct and
# indirect inheritance relations. Setting this tag to YES will force the
# the CLASS_DIAGRAMS tag to NO.
CLASS_GRAPH = YES
# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen
# will generate a graph for each documented class showing the direct and
# indirect implementation dependencies (inheritance, containment, and
# class references variables) of the class with other documented classes.
COLLABORATION_GRAPH = YES
# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen
# will generate a graph for groups, showing the direct groups dependencies
GROUP_GRAPHS = YES
# If the UML_LOOK tag is set to YES doxygen will generate inheritance and
# collaboration diagrams in a style similar to the OMG's Unified Modeling
# Language.
UML_LOOK = @MITK_DOXYGEN_UML_LOOK@
# If set to YES, the inheritance and collaboration graphs will show the
# relations between templates and their instances.
TEMPLATE_RELATIONS = YES
# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT
# tags are set to YES then doxygen will generate a graph for each documented
# file showing the direct and indirect include dependencies of the file with
# other documented files.
INCLUDE_GRAPH = NO
# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and
# HAVE_DOT tags are set to YES then doxygen will generate a graph for each
# documented header file showing the documented files that directly or
# indirectly include this file.
INCLUDED_BY_GRAPH = NO
# If the CALL_GRAPH and HAVE_DOT options are set to YES then
# doxygen will generate a call dependency graph for every global function
# or class method. Note that enabling this option will significantly increase
# the time of a run. So in most cases it will be better to enable call graphs
# for selected functions only using the \callgraph command.
CALL_GRAPH = NO
# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then
# doxygen will generate a caller dependency graph for every global function
# or class method. Note that enabling this option will significantly increase
# the time of a run. So in most cases it will be better to enable caller
# graphs for selected functions only using the \callergraph command.
CALLER_GRAPH = NO
# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen
# will generate a graphical hierarchy of all classes instead of a textual one.
GRAPHICAL_HIERARCHY = NO
# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES
# then doxygen will show the dependencies a directory has on other directories
# in a graphical way. The dependency relations are determined by the #include
# relations between the files in the directories.
DIRECTORY_GRAPH = YES
# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
# generated by dot. Possible values are png, svg, gif or svg.
# If left blank png will be used.
DOT_IMAGE_FORMAT = png
# The tag DOT_PATH can be used to specify the path where the dot tool can be
# found. If left blank, it is assumed the dot tool can be found in the path.
DOT_PATH = @DOXYGEN_DOT_PATH@
# The DOTFILE_DIRS tag can be used to specify one or more directories that
# contain dot files that are included in the documentation (see the
# \dotfile command).
DOTFILE_DIRS =
# The MSCFILE_DIRS tag can be used to specify one or more directories that
# contain msc files that are included in the documentation (see the
# \mscfile command).
MSCFILE_DIRS =
# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of
# nodes that will be shown in the graph. If the number of nodes in a graph
# becomes larger than this value, doxygen will truncate the graph, which is
# visualized by representing a node as a red box. Note that doxygen if the
# number of direct children of the root node in a graph is already larger than
# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note
# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
DOT_GRAPH_MAX_NODES = 50
# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the
# graphs generated by dot. A depth value of 3 means that only nodes reachable
# from the root by following a path via at most 3 edges will be shown. Nodes
# that lay further from the root node will be omitted. Note that setting this
# option to 1 or 2 may greatly reduce the computation time needed for large
# code bases. Also note that the size of a graph can be further restricted by
# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
MAX_DOT_GRAPH_DEPTH = 0
# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
# background. This is disabled by default, because dot on Windows does not
# seem to support this out of the box. Warning: Depending on the platform used,
# enabling this option may lead to badly anti-aliased labels on the edges of
# a graph (i.e. they become hard to read).
DOT_TRANSPARENT = NO
# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
# files in one run (i.e. multiple -o and -T options on the command line). This
# makes dot run faster, but since only newer versions of dot (>1.8.10)
# support this, this feature is disabled by default.
DOT_MULTI_TARGETS = NO
# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will
# generate a legend page explaining the meaning of the various boxes and
# arrows in the dot generated graphs.
GENERATE_LEGEND = YES
# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will
# remove the intermediate dot files that are used to generate
# the various graphs.
DOT_CLEANUP = YES

File Metadata

Mime Type
application/octet-stream
Expires
Wed, Oct 30, 11:54 PM (20 h, 6 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
2343491
Default Alt Text
(222 KB)

Event Timeline

MITK · MIC · IMSY · DKFZ