diff --git a/Documentation/Doxygen/3-DeveloperManual/Starting/FirstSteps/FirstSteps.dox b/Documentation/Doxygen/3-DeveloperManual/Starting/FirstSteps/FirstSteps.dox
index cb3f5cd61f..c85df71692 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Starting/FirstSteps/FirstSteps.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/Starting/FirstSteps/FirstSteps.dox
@@ -1,16 +1,15 @@
/**
\page FirstSteps First steps in Development
This section will show you how to extend MITK for your own project.
<ul>
<li> \subpage NewPluginPage </li>
<li> \subpage NewModulePage </li>
<li> \subpage NewDataTypePage </li>
<li> \subpage NewViewPage</li>
<li> \subpage CMAKE_FAQ </li>
- <li> \subpage StatemachineEditor </li>
<li> \subpage MiniAppCommandLineToolHowToPage </li>
</ul>
*/
diff --git a/Documentation/Doxygen/3-DeveloperManual/Starting/FirstSteps/MiniAppCommandLineTool/MiniAppCommandLineToolHowTo.dox b/Documentation/Doxygen/3-DeveloperManual/Starting/FirstSteps/MiniAppCommandLineTool/MiniAppCommandLineToolHowTo.dox
index bce1c618c2..88a8162957 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Starting/FirstSteps/MiniAppCommandLineTool/MiniAppCommandLineToolHowTo.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/Starting/FirstSteps/MiniAppCommandLineTool/MiniAppCommandLineToolHowTo.dox
@@ -1,140 +1,138 @@
/**
\page MiniAppCommandLineToolHowToPage How to create a MiniApp command line tool
\tableofcontents
This page will give you an overview of creating your own command line tool that can be integrated into a MiniApp.
If you don't know about MiniApps, you can read about their purpose and use at \ref MiniAppExplainPage page.
\section MiniAppCommandLineToolHowToPageDescription What's a MiniApp command line tool?
A MiniApp command line tool allows for configuration of command line arguments and eases the access to these argument values.
Additionally, a command line tool provides a XML representation of the configured arguments. This XML representation can be used for automatic user interface generation.
\section MiniAppCommandLineToolHowToPageSetUp Setting up a command line tool
This section describes the most important code parts of a command line tool using the ExampleToUpperCaseMiniApp.cpp as an example. See \ref NewModulePage for a suggested structure of a new module and its MiniApps.
Each MiniApp contains its own main function.
\snippet ExampleToUpperCaseMiniApp.cpp main
Within the main function the first thing should be to configure the accepted arguments. This can be done using the mitkCommandLineParser.
Our example accepts an input filename an output filename and an optional flag for verbose processing.
\snippet ExampleToUpperCaseMiniApp.cpp create parser
\snippet ExampleToUpperCaseMiniApp.cpp add arguments
Following argument types are available for the addArgument method:
\li String
\li Bool
\li StringList
\li Int
\li Float
\li InputDirectory
\li InputFile
\li InputImage
\li OutputDirectory
\li OutputFile
The distinction between InputFile/OutputFile and InputDirectory/OutputDirectory respectively ensures that the appropriate UI widget is chosen.
The label string passed to the addArgument method is the label for the corresponding UI widget.
After specification of allowed arguments the parser's parseArguments method is called.
\snippet ExampleToUpperCaseMiniApp.cpp parse the arguments
After all arguments have been parsed we can do the actual processing. In this case we read the file, convert the contained text to upper case and
write the new data to the specified output location.
\snippet ExampleToUpperCaseMiniApp.cpp do processing
\subsection MiniAppCommandLineToolHowToPageSetUpExampleHelpOutput Example Help Output
Running the ExampleToUpperCaseMiniApp without an argument or with wrong ones:
\code
./ExampleToUpperCaseMiniApp
\endcode
... will emit the following help text:
\verbatim
Command Line Utility *To Upper Case* in Category *MITK-Examples*
An example MiniApp that converts the contents of a test file to upper case.
German Cancer Research Center (DKFZ)
Use --xml to generate an XML description parsable as a CTK Command Line Module Plugin.
Optional parameters
-v, --verbose, Whether to produce verbose output (optional)
Required I/O parameters
-i, --input, input file (.txt/.example)
-o, --output, where to save the output (.txt/.example)
\endverbatim
\section MiniAppCommandLineToolHowToPageXMLRepresentation Retrieving XML argument description
According to the specified command line arguments, a XML representation of the arguments is generated and emitted on the console if the MiniApp command line tool is executed with argument "--xml".
In order to use the XML representation for automatic user interface generation additional information has to be provided for the parser.
-Please provide category, title, description and contributor as shown in code snippet below for the \ref TensorReconstruction command line tool:
+Please provide category, title, description and contributor as shown in code snippet below:
\snippet ExampleToUpperCaseMiniApp.cpp create parser
Note that in the generated UI the parameter widgets are contained in a group box. There is a default label ("Parameters") and a default description ("Groupbox containing parameters.") specified. The label of such a parameter group and the description can be set via the parser's changeParameterGroup method.
The method must be called before adding the arguments.
-See \ref MiniAppExplainPageWorkbenchIntegration for information how to access your MiniApp from within the application instead of calling it directly from the command line.
-
\subsection MiniAppCommandLineToolHowToPageXMLRepresentationExampleXMLOutput Example XML Output
Running the ExampleToUpperCaseMiniApp with argument "--xml" ...
\code
./ExampleToUpperCaseMiniApp --xml
\endcode
... will emit following XML description:
\verbatim
<executable>
<category>MITK-Examples</category>
<title>To Upper Case</title>
<description>An example MiniApp that converts the contents of a test file to upper case.</description>
<contributor>German Cancer Research Center (DKFZ)</contributor>
<parameters>
<label>Parameters</label>
<description>Parameters</description>
<file>
<name>input</name>
<description>input file (.txt/.example)</description>
<label>Input file</label>
<longflag>input</longflag>
<flag>i</flag>
<channel>input</channel>
</file>
<file>
<name>output</name>
<description>where to save the output (.txt/.example)</description>
<label>Output file</label>
<longflag>output</longflag>
<flag>o</flag>
<channel>output</channel>
</file>
<boolean>
<name>verbose</name>
<description>Whether to produce verbose output</description>
<label>Verbose Output</label>
<longflag>verbose</longflag>
<flag>v</flag>
</boolean>
</parameters>
</executable>
\endverbatim
This XML description is used for automatic user interface generation in MITK Workbench. The generated user interface is depicted in the following screenshot:
\imageMacro{generated_ui_example.png, "Generated UI of example command line tool in MITK Workbench", 10}
*/
diff --git a/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step02.dox b/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step02.dox
index 849f9b41bd..56d7eaa879 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step02.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step02.dox
@@ -1,29 +1,27 @@
/**
\page Step02Page MITK Tutorial - Step 2: Load one or more data sets
- \li \ref Step2.cpp "Step2.cpp" \n
- Contains the code for this example.
- \li Path to files used in this step: \n
-https://www.mitk.org/download/tutorial-data/Pic3D.nrrd (image) \n
+ \li Examples/Tutorial/Step2
+ \li https://www.mitk.org/download/tutorial-data/Pic3D.nrrd (image) \n
https://www.mitk.org/download/tutorial-data/lungs.vtk (surface)
\image html step2_result.png
\dontinclude Step2.cpp
This program shows how to load multiple data sets.
The picture above shows the result of the program when reading both the image file and the surface file.
In order to obtain the result the program has to be executed using the image file Pic3D.nrrd and the surface file lungs.vtk.
The code for this example equals the code of Step 1 except for part II and part III which are changed as follows:
\skipline Part II
\until mitk::IOUtil::Load(argv[i],*storage);
\line }
\ref Step01Page "[Previous step]" \ref Step03Page "[Next step]" \ref TutorialPage "[Main tutorial page]"
*/
diff --git a/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step03.dox b/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step03.dox
index 67ed0d56ad..2ca501aa3c 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step03.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step03.dox
@@ -1,49 +1,47 @@
/**
\page Step03Page MITK Tutorial - Step 3: Create 3D view
- \li \ref Step3.cpp "Step3.cpp" \n
-Contains the code that both creates a 3D view and turns volume rendering on.
- \li Path to files used in this step: \n
-https://www.mitk.org/download/tutorial-data/Pic3D.nrrd (image) \n
+ \li Examples/Tutorial/Step3
+ \li https://www.mitk.org/download/tutorial-data/Pic3D.nrrd (image) \n
https://www.mitk.org/download/tutorial-data/lungs.vtk (surface)
As in the previous step, one or more data sets (many images, surface and other formats) may be loaded. The difference is that they are displayed in a 3D view.
The QmitkRenderWindow is now used for displaying a 3D view, by setting the used mapper-slot to Standard3D.
Since volume-rendering is a (rather) slow procedure, the default is that images are not displayed in the 3D view.
\li Step 3a works for default condition for surface mesh. To run this tutorial with Step 3a, pass the argument as "lungs.vtk" (without quotes).
\li Step 3b works for surface mesh with volume rendering. To run this tutorial with Step 3b, pass the arguments as "Pic3D.nrrd lungs.vtk" (without quotes).
\section Step3aSection Step 3a - Volume rendering turned off
\imageMacro{step3a_result.png,"",6.22}
\dontinclude Step3.cpp
Tell the renderer to create a 3D view:
\skipline // Use it as a 3D view!
\skipline renderWindow.GetRenderer()->SetMapperID
The rest of the code remains unchanged.
The picture above shows the result of the program when reading both the image and the surface file.
As volume rendering is off the image is not visible.
\section Step3bSection Step 3b - Volume rendering turned on
\imageMacro{step3b_result.png,"",6.22}
Volume Rendering is now turned on as shown in the picture above.
\dontinclude Step3.cpp
The property "volumerendering" has to be enabled on the node containing the image.
\skipline Check
\until node->SetProperty
\ref Step02Page "[Previous step]" \ref Step04Page "[Next step]" \ref TutorialPage "[Main tutorial page]"
*/
diff --git a/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step04.dox b/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step04.dox
index 3eec800c47..e399106c64 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step04.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step04.dox
@@ -1,69 +1,67 @@
/**
\page Step04Page MITK Tutorial - Step 4: Use several views to explore data
-\li \ref Step4.cpp "Step4.cpp"\n
-Contains the code of step 4a + b.
-\li Path to files used in this step: \n
-https://www.mitk.org/download/tutorial-data/Pic3D.nrrd (image) \n
+\li Examples/Tutorial/Step4
+\li https://www.mitk.org/download/tutorial-data/Pic3D.nrrd (image) \n
https://www.mitk.org/download/tutorial-data/lungs.vtk (surface)
As in Step 2 and Step 3 one or more data sets may be loaded.
This now creates three views on the data.
The QmitkRenderWindow is used for displaying a 3D view as in Step 3, but without volume-rendering.
Furthermore two 2D views for slicing through the data are created.
The class QmitkSliceWidget is used, which is based on the class QmitkRenderWindow, but additionally provides sliders to slice through the data. We create two instances of
QmitkSliceWidget, one for axial and one for sagittal slicing.
Step 4b enhances the program in that the two slices are also shown at their correct position in 3D as well as intersection-line, each in the other 2D view.
As in the previous steps, to obtain the result the program has to be executed using the image file Pic3D.nrrd and the surface file lungs.vtk.
\section Step4aSection Step 4a - Create axial and sagittal view
\imageMacro{step4a_result.png,"",11.01}
\dontinclude Step4.cpp
Create a Qt horizontal box for the layout:
\skipline QHBox
Then create a renderwindow:
\skipline QmitkRenderWindow
\until SetMapperID
Create a 2D view for slicing axially:
\skipline view2
\until view2.SetData
Then create a 2D view for slicing sagitally.
\skipline view3
\until view3.SetData
The toplevelWidget is now the new main widget:
\skipline qtapplication
\skipline toplevelWidget.show
\section Step4bSection Step 4b - Display slice positions
\imageMacro{step4b_result.png,"",11.01}
We now want to see the position of the slice in 2D and the slice itself in 3D.
Therefore it has to be added to the tree:
\dontinclude Step4.cpp
\skipline ds->Add(view2.GetRenderer()
\skipline ds->Add(view3.GetRenderer()
Slice positions are now displayed as shown in the picture.
\dontinclude Step4.cpp
\ref Step03Page "[Previous step]" \ref Step05Page "[Next step]" \ref TutorialPage "[Main tutorial page]"
*/
diff --git a/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step05.dox b/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step05.dox
index 07b2b344b7..96ff8fc34f 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step05.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step05.dox
@@ -1,40 +1,38 @@
/**
\page Step05Page MITK Tutorial - Step 5: Interactively add points
- \li \ref Step5.cpp "Step5.cpp"\n
- Contains the code for this step.
- \li Path to files used in this step: \n
-https://www.mitk.org/download/tutorial-data/Pic3D.nrrd (image) \n
+ \li Examples/Tutorial/Step5
+ \li https://www.mitk.org/download/tutorial-data/Pic3D.nrrd (image) \n
https://www.mitk.org/download/tutorial-data/lungs.vtk (surface)
In addition to Step 4 where 3 views were created on the data, we now want to interactively add points.
A node containing a PointSet as data is added to the data tree and a PointSetDataInteractor is associated with the node, which handles the interaction.
The @em interaction @em pattern is defined in a state-machine, stored in an external XML file. Thus, we need to load a state-machine.
A state machine describes interaction pattern with different states (states beeing something like "a point is selected") and transitions to these states (e.g. "select a point").
These transitions are associated with actions. In this way it is possible to model complex interaction schemes.
By what these transitions and actions are triggered is described in a configuration file. It maps user events to identifiers that are used in the state machine patterns.
In this way the user interaction can be changed by simply loading a different configuration file for a state machine, and the user may add points now with a right click instead of
left click + SHIFT, as in our case.
Therefore after loading the state machine pattern the PointSetDataInteractor is also given a event configuration file.
More information about interaction in MITK can be found \ref InteractionPage "here".
In order to add a point the shift key has to be pressed while left clicking in a render window.
You can also move points or remove them (left click while pressing ALT).
\image html step5_result.png
\dontinclude Step5.cpp
A PointSet and a node for it have to be created to be able to interactively adding points:
\skipline mitk::PointSet
\until interactor->SetDataNode(pointSetNode)
\ref Step04Page "[Previous step]" \ref Step06Page "[Next step]" \ref TutorialPage "[Main tutorial page]"
*/
diff --git a/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step06.dox b/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step06.dox
index f4aa9a82c9..291199950c 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step06.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step06.dox
@@ -1,117 +1,110 @@
/**
\page Step06Page MITK Tutorial - Step 6: Use an interactive region-grower
The source is now split among several files:
-\li \ref Step6.cpp "Step6.cpp"
-\li \ref Step6.h "Step6.h"
-\li \ref Step6RegionGrowing.txx "Step6RegionGrowing.txx"
-\li \ref Step6RegionGrowing1.cpp "Step6RegionGrowing1.cpp"
-\li \ref Step6RegionGrowing2.cpp "Step6RegionGrowing2.cpp"
-\li \ref Step6main.cpp "Step6main.cpp"
-\li Path to files used in this step: \n
-https://www.mitk.org/download/tutorial-data/Pic3D.nrrd (image)
-
+\li Examples/Tutorial/Step6
+\li https://www.mitk.org/download/tutorial-data/Pic3D.nrrd (image)
In this step the program is enhanced by the possibility to start a region-grower at interactively added points.
We will see how MITK images can be accessed as ITK images.
We now load the image file Pic3D.nrrd only since the surface will be the result of the region-growing.
Add points in the image by pressing SHIFT+left mouse key, then adjust the thresholds and press 'Start region growing'.
\imageMacro{step6_result.png,"",13.55}
The class Step6 inherits from QWidget and provides methods for setting up the widgets.
-Step6RegionGrowing.cpp contains a method for performing the region-growing. Step6main.cpp contains main.
+%Step6RegionGrowing.cpp contains a method for performing the region-growing. %Step6main.cpp contains main.
Like in ITK and VTK class member names start with m_ followed by the proper member name starting with a capital letter (e.g. m_Tree).
Function names start with capital letters. To learn more about style conventions in MITK read \ref StyleGuideAndNotesPage "The MITK Style Guide".
\dontinclude Step6.cpp
The widgets are initialized as in the previous steps but with an additional QVBox for a button to start the segmentation:
\skipline Create controlsParent
\until hlayout->addWidget(m_LineEditThresholdMax)
This creates a button to start the segmentation and its clicked() signal is connected to the method StartRegionGrowing():
\dontinclude Step6.cpp
\skipline QPushButton *startButton
\skipline connect(startButton
\section AccessMTIKImagesAsITKImagesSection Access MITK images as ITK images
ITK images are templated whereas mitk::Images are not. To use ITK filters with MITK images, we have to convert from MITK to ITK. To do so, first
define an access method, which is templated as an ITK image is:
\code
template<TPixel, VImageDimension>
MyAccessMethod(itk::Image<TPixel, VImageDimension>* itkImage)
{
...
}
\endcode
If you don't understand this template syntax, you should read any C++ text book. Understanding template syntax is crucial to successfully using ITK.
To call this templated method with an (untemplated) mitk::Image, you can use the AccessByItk macro from mitkImageAccessByItk.h. This macro checks for
the actual image type of the mitk::Image and does any neccessary conversions. Look into "Modules / Adaptor classes" for more information.
\code
AccessByItk(mitkImage, MyAccessMethod)
\endcode
\dontinclude Step6RegionGrowing.txx
-In this step our access method is called RegionGrowing() (defined in \ref Step6RegionGrowing.txx "Step6RegionGrowing.txx"):
+In this step our access method is called RegionGrowing() (defined in %Step6RegionGrowing.txx ):
\skipline template
\until } //RegionGrowing()
Additionally the access function has to be instantiated for all datatypes and two/three dimensions as some compilers have memory problems without this explicit instantiation, some even need instantiations in separate files for 2D/3D: \n
-For 2D in \ref Step6RegionGrowing1.cpp "Step6RegionGrowing1.cpp" :
+For 2D in %Step6RegionGrowing1.cpp :
\dontinclude Step6RegionGrowing1.cpp
\skipline InstantiateAccessFunctionForFixedDimension
-... and for 3D in \ref Step6RegionGrowing2.cpp "Step6RegionGrowing2.cpp":
+... and for 3D in %Step6RegionGrowing2.cpp :
\dontinclude Step6RegionGrowing2.cpp
\skipline InstantiateAccessFunctionForFixedDimension
\dontinclude Step6.cpp
The method StartRegionGrowing() finally calls our access method RegionGrowing():
\skipline Step6::StartRegionGrowing
\until }
\section ConvertingITKMITKSection Converting ITK images to MITK images and vice versa
In some cases it is useful to simply convert between ITK and MITK images. The direction ITK to MITK is easy, since mitk::Image can handle most data types. The direction MITK to ITK is more critical, since ITK images have to be instantiated with a fixed pixel type and fixed dimension at compile time.
\li \code mitk::Image mitk::ImportItkImage(itk::Image<...>) \endcode
\li \code mitk::CastToItkImage(mitkImage, itk::Image<...>) \endcode
\section ConnectingMITKToVTKSection Connecting MITK images to VTK
Images are not converted or copied: The data array is just accessed via an encapsulating VTK object.
\li \code vtkImageData* mitk::Image::GetVtkImageData(int time = 0) \endcode
\section SurfacesMITKToVTKSection MITK Surfaces to VTK and vice versa
Again: not a conversion, just accessing.
\li \code vtkPolyData* mitk::Surface::GetVtkPolyData(int time = 0) \endcode
\li \code mitk::Surface::SetVtkPolyData(vtkPolyData*, int time = 0) \endcode
\ref Step05Page "[Previous step]" \ref Step07Page "[Next step]" \ref TutorialPage "[Main tutorial page]"
*/
diff --git a/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step07.dox b/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step07.dox
index 318d8faa76..7afcab6109 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step07.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step07.dox
@@ -1,21 +1,18 @@
/**
\page Step07Page MITK Tutorial - Step 7: Convert result of region growing into a surface
- \li \ref Step7.cpp "Step7.cpp"\n
- \li \ref Step7.h "Step7.h"\n
- \li \ref Step7main.cpp "Step7main.cpp"\n
- \li Path to files used in this step: \n
-https://www.mitk.org/download/tutorial-data/Pic3D.nrrd (image)
+ \li Examples/Tutorial/Step7
+ \li https://www.mitk.org/download/tutorial-data/Pic3D.nrrd (image)
In this step the result of the previous step is converted into a surface by means of a VTK filter.
Step7 inherits from Step6. It enhances the method StartRegionGrowing() by processing the result image.
\dontinclude Step7.cpp
\skipline if (m_ResultImage
\until }
\ref Step06Page "[Previous step]" \ref Step08Page "[Next step]" \ref TutorialPage "[Main tutorial page]"
*/
diff --git a/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step08.dox b/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step08.dox
index 565524c888..c066d688e1 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step08.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step08.dox
@@ -1,25 +1,22 @@
/**
\page Step08Page MITK Tutorial - Step 8: Use QmitkStdMultiWidget as widget
- \li \ref Step8.cpp "Step8.cpp"\n
- \li \ref Step8.h "Step8.h"\n
- \li \ref Step8main.cpp "Step8main.cpp"\n
- \li Path to files used in this step: \n
-https://www.mitk.org/download/tutorial-data/Pic3D.nrrd (image)
+ \li Examples/Tutorial/Step8
+ \li https://www.mitk.org/download/tutorial-data/Pic3D.nrrd (image)
In this step a QmitkStdMultiWidget is used. It offers four views of the data.
From top left to bottom left the views are initialized as axial, sagittal and coronar. The bottom right view is initialized as 3D view.
\image html step8_result.png
Step8 inherits from Step6. The method SetupWidgets() is changed: A QmitkStdMultiWidget is used instead of one QmitkRenderWindow and two instances of QmitkSliceWidget.
\dontinclude Step8.cpp
\skipline Part Ia
\until levelWindowWidget->SetDataStorage(m_DataStorage);
\ref Step07Page "[Previous step]" \ref Step09Page "[Next step]"
*/
diff --git a/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step10.dox b/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step10.dox
index e863011a4d..ea9e4d01e8 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step10.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/Starting/GettingToKnow/Tutorial/Step10.dox
@@ -1,499 +1,501 @@
/**
\page Step10Page MITK Tutorial - Step 10: Adding new Interaction
\tableofcontents
\section HowToUseDataInteractor Step 01 - How to use an existing DataInteractor in your Module/Plugin/...
MITK provides finished DataInteractors for a variety of tasks, they can be found in Core/Code/Interactions. They can be used with
state machine patterns and config files located under Core/Code/Resources/Interactions.
A mitk::DataInteractor consists of four parts. The class describing the functionality and two XML files; one describes the state machine pattern, that is the workflow of an interaction and
the second describes the user events which trigger an action. Lastly every mitk::DataInteractor works on a mitk::DataNode in which it stores and manipulates data.
To use a mitk::DataInteractor these parts have to be brought together.
** TODO add code of mitk::PointSetDataInteractor Plugin ..
<b>This code demonstrates the use of an existing mitk::DataInteractor exemplary for the mitk::PointSetDataInteractor:</b>
First we need a mitk::DataNode in which the PointSets is stored. It has to be added to the mitk::DataStorage.
\code
mitk::DataNode::Pointer dataNode = mitk::DataNode::New();
GetDataStorage()->Add(dataNode.GetPointer());
\endcode
Then we create an instance of a mitk::PointSetDataInteractor and load a predefined statemachine pattern as well as a configuration
for it:
\code
m_CurrentInteractor = mitk::PointSetDataInteractor::New();
m_CurrentInteractor->LoadStateMachine("PointSet.xml");
m_CurrentInteractor->SetEventConfig("PointSetConfig.xml");
\endcode
Lastly the mitk::DataNode is added to the mitk::DataInteractor
\code
m_CurrentInteractor->SetDataNode(dataNode);
\endcode
now the mitk::DataInteractor is ready for usage.
\section HowToModifyInteraction Step 02 - How to modify the behaviour of a DataInteractor
The behavior of a mitk::DataInteractor is determined by two aspects. One, the state machine pattern which describes the flow/order of actions
that are performed. Secondly the configuration which determines which user interaction triggers the actions.
\subsection ModifyDisplayInteractorBehavior How to modify the display interactor behavior
Sometimes it may be desirable to change the behaviour of the mitk::DisplayInteractor which controls zooming, panning and scrolling, e.g. when a
Tool is activated that reacts to the same events. Changing the behavior of the DisplayInteractor (or possibly any other EventHandler) can be achieved from anywhere
in the code by requesting the InteractionEventObserver and assigning an alternative configuration to it, as demonstrated in this example:
\code
std::ifstream* configStream = new std::ifstream( #path to alternative configuration file# );
mitk::EventConfig newConfig(configStream);
// Requesting all registered EventObservers
std::list<mitk::ServiceReference> listEventObserver = GetModuleContext()->GetServiceReferences<InteractionEventObserver>();
for (std::list<mitk::ServiceReference>::iterator it = listEventObserver.begin(); it != listEventObserver.end(); ++it)
{
DisplayInteractor* displayInteractor = dynamic_cast<DisplayInteractor*>(GetModuleContext()->GetService<InteractionEventObserver>(*it));
// filtering: only adjust the DisplayInteractor
if (displayInteractor != NULL)
{
displayInteractor->SetEventConfig(newConfig);
}
}
\endcode
\section SectionImplementationDataInteractor How to implement a new DataInteractor
This second part of the tutorial step goes beyond the activation of an interactor, that modifies data by user interaction) as shown above. It shows what needs to be implemented to add a new way of interaction within your MITK application.
-Please see \ref DataInteractionPage as an introduction to the MITK interaction mechanism, you may also want to read \ref DataInteractionTechnicalPage.
+Please see \ref DataInteractionPage as an introduction to the MITK interaction mechanism.
This tutorial is structured as follows: The first section deals with config files, describing all the parameters of events and how to use them
in a configuration file. In the second section the basics are described that are needed to write a state machine pattern. The last section
deals with brining configuration, state machine pattern and code together and gives an exemplary implementation of a mitk::DataInteractor.
\section ConfigFileDescriptionSection How to create a Config-File
\subsection EventDescriptionSection Event Description
Events are described by their parameters. Each event type has its own set of parameters that can be set in the configuration file.
If a parameter is omitted it is set to its default value. All possible parameters are listed and described below. Event parameters
are also described in the documentation of the event class itself.
Mandatory for each event description is the event class and the event variant. The parameters of an event are set by attribute tags.
\note Refer to \ref EventClassSection for the meaning of event class.
\b Mouse \b Buttons \n
mitk::InteractionEvent::MouseButtons represent the buttons. They can be used for two attributes. First the EventButton attribute which describes
the button that triggered the event,
this always is a single button. Secondly the ButtonState attribute that describes which buttons were pressed at the moment the event has been generated.
For example assume the right mouse button and the middle mouse button are already pressed, now the left mouse button is pressed too and generates a second event,
this would be described as follows:
\code
<attribute name="EventButton" value="LeftMouseButton"/>
<attribute name="ButtonState" value="RightMouseButton,MiddleMouseButton"/>
\endcode
Note: Technically the LeftMouseButton is also pressed and should be listed in the ButtonState, but this is taken care of by the mitk::EventFactory .
<b> Key Events</b> \n
mitk::InteractionKeyEvent represents a pressed key, which key is pressed is provided with the Key attribute like this
\code
<attribute name="Key" value="A"/>
\endcode
or
\code
<attribute name="Key" value="Escape"/>
\endcode
\note Key Events do not require an explicit configuration, for all key events there exists
a predefined event variant with the name 'Std' + value, that is key a is named 'StdA'.
The names for special keys are listed here:
\dontinclude mitkInteractionEvent.h
\skipline // Special Keys
\until // End special keys
<b> Modifier Keys</b> \n
mitk::InteractionEvent::ModifierKeys represent the combination of pressed modifier keys, several modifier keys pressed at the same time
are denoted by listing them all separated by commas.
\code
<!-- shift and control key are pressed -->
<attribute name="Modifiers" value="shift,ctrl"/>
\endcode
\b ScrollDirection \n
This attribute is unique to the mitk::MouseWheelEvent and describes the direction in which the mouse wheel is rotated. In the event description actual only the direction is provided,
but the event is generated with the actual value, and this value can be retrieved from the object.
\code
<attribute name="ScrollDirection" value="up"/>
<!-- or -->
<attribute name="ScrollDirection" value="down"/>
\endcode
\subsection ExamplesSection Examples
Examples for key events:
\code
<config>
<!-- Event of key 'a' pressed -->
<event_variant class="InteractionKeyEvent" name="StdA">
<attribute name="Key" value="A"/>
</event_variant>
<!-- Event of key 'b' pressed while modifiers ctrl and shift are pressed-->
<event_variant class="InteractionKeyEvent" name="StdB">
<attribute name="Key" value="B"/>
<attribute name="Modifiers" value="shift,ctrl"/>
</event_variant>
</config>
\endcode
Examples for MousePress events:
\code
<!-- Standard left click -->
<config>
<event_variant class="MousePressEvent" name="StdMousePressPrimaryButton">
<attribute name="EventButton" value="LeftMouseButton"/>
</event_variant>
<!-- right click with control key pressed-->
<event_variant class="MousePressEvent" name="RightWithCTRL">
<attribute name="EventButton" value="RightMouseButton"/>
<attribute name="Modifiers" value="ctrl"/>
</event_variant>
</config>
\endcode
There exists a standard configuration file for the most common events called GlobalConfig.xml that can be used to as a default and can be extended
by a specific definition.
\subsection ParameterDescriptionSection Parameter Description
It is also possible to store parameters in the config file. Those are stored using the param-tag, like this:
\code
<config name="example2">
<param name="property1" value="yes"/>
<param name="scrollModus" value="leftright"/>
</config>
\endcode
Within the application these properties can then be access via a mitk::PropertyList like this:
\code
// sm - state machine loaded with config file example2
mitk::PropertyList::Pointer properties = GetAttributes();
std::string prop1;
properties->GetStringProperty("property1",prop1);
\endcode
\section HowToStateMachine HowTo Write a State Machine
A state machine pattern is described in a XML file.
\subsection StateSection States
States are described using the state-tag. Each state has to have a name. Exactly one state has to be a start state in
each state machine to indicate the state in which the state machine is set when it is constructed.
So a valid, but rather useless state machine would like like this:
\code
<statemachine>
<state name="start" startstate="true"/>
</statemachine>
\endcode
Optionally a state can be assigned a special mode that influences the event distribution.
These modes are GRAB_INPUT , PREFER_INPUT and REGULAR (where REGULAR is default and does not need to be indicated).
See \ref DataInteractionTechnicalPage_DispatcherEventDistSection for a description of these modes. Use the special modes only when necessary as they prevent other DataInteractors to
receive events.
\code
<!-- example -->
<state name="someState" startstate="true" state_mode="GRAB_INPUT"/>
\endcode
\subsection TransitionSection Transitions
+
Transitions are part of a state and describe all possible state switches, and are therefore important for modeling an interaction scheme.
Transitions consist a part that describes the event which triggers the transition (event class and event variant) and a target which is state
to which the state machine switches after executing a transition.
An event class describes the event type (see mitk::InteractionEvent for the different classes) and the event variant is a specification thereof
and the exact description is taken from a config file. Together they determine which event can trigger this transition.
For example this state machine will switch from state A to state B when the StdMousePressPrimaryButton event (left mouse button is pressed) occurs.
-\subsubsection EventClassSection Event Class
+\subsection EventClassSection Event Class
+
The event class description supports the polymorphism of the event classes. Therefore state machine patters should be written in the most
general ways possible.
So for a given class hierarchy like this:
\dot
digraph {
node [shape=record, fontname=Helvetica, fontsize=10];
a [ label="{InteractionPositionEvent}"];
b [ label="{MousePressEvent}" ];
c [ label="MouseReleaseEvent" ];
d [ label="TouchEvent", style=dotted ];
a -> b;
a -> c;
a -> d;
}
\enddot
in the state machine pattern the mitk::InteractionPositionEvent can be declared as event class to restrict to the events which hold a position information.
The actual implementation is then given in the configuration file. In this case it allows to define events of the classes mitk::InteractionPositionEvent
itself, or mitk::MousePressEvent, mitk::MouseReleaseEvent, mitk::TouchEvent.
This has the advantage that the patterns remain the same no matter what input devices are used, and the state machine patterns can be configured
for newly added event classes as long as they match the class hierarchy (this ensures they hold the necessary properties).
\code
<statemachine>
<state name="A" startstate="true">
<transition event_class="MousePressEvent" event_variant="StdMousePressPrimaryButton" target="B"/>
<state/>
<state name="B" />
</statemachine>
\endcode
\subsection ActionSection Actions
Actions can be added to transitions and represent functions in the mitk::DataInteractor that are executed on taking a transition.
The following simple state machine will listen for left mouse clicks and execute two actions (and actually never stop).
\code
<statemachine>
<state name="start" startstate="true">
<transition event_class="MousePressEvent" event_variant="StdMousePressPrimaryButton" target="start">
<action name="addPoint"/>
<action name="countClicks"/>
</transition>
</state>
</statemachine>
\endcode
In order to tell the mitk::DataInteractor which function to execute these actions are made known to the mitk::DataInteractor using
the CONNECT_FUNCTION macro. This example assumes that there exists an ExampleInteractor which inherits from mitkDataInteractor.
This class implements the functions AddPoint and CountClicks. The actions are introduced by implementing the virtual method
ConnectActionsAndFunctions():
\code
void mitk::ExampleInteractor::ConnectActionsAndFunctions()
{
CONNECT_FUNCTION("addPoint", AddPoint);
CONNECT_FUNCTION("countClicks", CountClicks);
}
\endcode
\subsection ConditionSection Conditions
Conditions can be added to transitions and represent functions in the mitk::DataInteractor that are executed on taking a transition.
A condition is used to determine if a following action should be executed or not.
\code
<statemachine>
<state name="start" startstate="true">
<transition event_class="MousePressEvent" event_variant="StdMousePressPrimaryButton" target="start">
<condition name="checkPoint"/>
<action name="addPoint"/>
<action name="countClicks"/>
</transition>
</state>
</statemachine>
\endcode
In order to tell the mitk::DataInteractor which function to execute these conditions are made known to the mitk::DataInteractor using
the CONNECT_CONDITION macro. The ConnectActionsAndFunctions() method has to be augmented accordingly:
\code
void mitk::ExampleInteractor::ConnectActionsAndFunctions()
{
CONNECT_CONDITION("checkPoint", CheckPoint);
CONNECT_FUNCTION("addPoint", AddPoint);
CONNECT_FUNCTION("countClicks", CountClicks);
}
\endcode
\section ReferenceToIncludeFiles Integration of the pattern and configuration files
The usage of custom files slightly differs from the existing ones.
Custom pattern and config files have to be stored in the /Resources/Interactions directory of the Module that they were designed for.
When loading files from a module location into an interactor, the module has to be supplied as a parameter:
\code
m_CurrentInteractor = mitk::CustomDataInteractor::New();
m_CurrentInteractor->LoadStateMachine("CustomStateMachinePattern.xml", us::GetModuleContext()->GetModule());
m_CurrentInteractor->SetEventConfig("CustomConfig.xml", us::GetModuleContext()->GetModule());
\endcode
See \ref IncludeFiles for a description.
\section HowToDataInteractor Implementation of a new mitk::DataInteractor
DataInteractors are to inherit from mitk::DataInteractor. Their functionality is implemented in functions that follow this interface:
For Actions:
\code
bool SomeFunctionality(StateMachineAction* , InteractionEvent*);
\endcode
For Conditions:
\code
bool SomeFunctionality(const InteractionEvent*);
\endcode
Your functions are connected with actions and conditions by implementing the function ConnectActionsAndFunctions(), e.g.
\code
void mitk::ExampleInteractor::ConnectActionsAndFunctions()
{
CONNECT_CONDITION("checkPoint", CheckPoint);
CONNECT_FUNCTION("addPoint", AddPoint);
CONNECT_FUNCTION("enoughPoints", EnoughPoints);
}
\endcode
Now all that is left is to write a state machine pattern and a config file as is described in the tutorials.
To provide a useful example the mitk::PointSetDataInteractor is annotated with comments that describe the important parts for an implementation
of a mitk::DataInteractor.
-This step assumes knowledge of the Interaction concept described in \ref DataInteractionPage and some background of the implementation which is described in
-\ref DataInteractionPageTechnical. Please refer to these pages before proceeding.
+This step assumes knowledge of the Interaction concept described in \ref DataInteractionPage and some background of the implementation.
+Please refer to these pages before proceeding.
Now all that is left it to write a state machine pattern and a config file as is described in the tutorials.
\subsection ExampleInternalEvent Example Interactor using InternalEvent
A useful tool in creating DataInteractors is mitk::InternalEvent which allows the mitk::DataInteractor to send signals on its own.
The following will describe how to build a mitk::DataInteractor that allows to add points until a certain number of points is reached.
The number of accepted points is provided in the config file as a parameter.
So we start by writing a state machine pattern that add points until it receives an mitk::InternalEvent telling it, that enough points
have been added.
\code
<statemachine>
<state name="start" startstate="true" >
<transition event_class="MousePressEvent" event_variant="AddPointClick" target="start">
<condition name="checkPoint"/>
<action name="addPoint"/>
</transition>
<transition event_class="InternalEvent" event_variant="enoughPointsAdded" target="final">
<action name="enoughPoints"/>
</transition>
</state>
<state name="final">
<--! dead state, nothing happens any more, once we reached this -->
</state>
</statemachine>
\endcode
<b> </b>
In our config file we set the number of maximal points to 10, and define AddPointClick as a right mouse click with the
ctrl button pressed.
\code
<config>
<param name="NumberOfPoints" value="10">
<event_variant class="MousePressEvent" name="AddPointClick">
<attribute name="EventButton" value="RightMouseButton"/>
<attribute name="Modifiers" value="ctrl"/>
</event_variant>
</config>
\endcode
The implementation is described in the following. \see Step10.h \see Step10.cpp
\dontinclude Step10.h
Implementation of protected functions:
\skipline protected:
\until virtual void ConfigurationChanged();
<b> ConnectActionsAndFunctions </b> - Is inherited from mitk::InteractionStateMachine, here action strings from the xml are connected with
functions in the mitk::DataInteractor (as seen above). In our example this looks like this:
\dontinclude Step10.cpp
\skipline void mitk::ExampleInteractor::ConnectActionsAndFunctions()
\until }
<b> ConfigurationChanged </b> - Is called whenever a new configuration file is loaded (by the mitk::InteractionEventHandler super class),
this function allows to implement initialization code that depends on configuration values. In our example we want to set the limit of
allowed points:
\dontinclude Step10.cpp
\skipline void mitk::ExampleInteractor::ConfigurationChang
\until }
Next the actual functionality of the DataInteractor is implemented, by providing one function per action, following this prototype described before.
\dontinclude Step10.h
\skipline private:
\until bool CheckPoint(cons
\dontinclude Step10.cpp
\skipline bool mitk::ExampleInteractor::AddPoint(StateM
\until //-
If the conditions returns false the calling transition and the included actions will not be executed.
If a condition fails the event is considered as untreated, and will be offered to other Interactors.
\dontinclude Step10.cpp
\skipline bool mitk::ExampleInteractor::CheckPoint(
\until //end
Here we see an internal event used to signal that the point set reached the maximal number of allowed points.
The event is created and added to the Dispatchers event queue.
\dontinclude Step10.cpp
\skipline // create internal
\until positionEvent->GetSender(
\note Internal events do not need any mapping to event variants. Their signal name is equivalent with the event variant.
<b> There are also two documented classes implementing a mitk::DataInteractor and a mitk::InteractionEventObserver which can be looked at for further
understanding: </b>
\see mitk::PointSetDataInteractor
\see mitk::DisplayInteractor
Have fun with creating your own interaction and please think about contributing it to MITK!
<b>
If you meet any difficulties during this step, don't hesitate to ask on the MITK mailing list mitk-users@lists.sourceforge.net!
People there are kind and will try to help you. </b>
\ref Step09Page "[Previous step]" \ref TutorialPage "[Main tutorial page]"
*/
diff --git a/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/HowToNewProject.dox b/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/HowToNewProject.dox
index ca78ac4728..7bb8ca2707 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/HowToNewProject.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/HowToNewProject.dox
@@ -1,254 +1,254 @@
/**
\page HowToNewProject Creating a new MITK project
\tableofcontents
This page is intended to give a comprehensive guide to setting up your own MITK based
project. It will use the application framework provided by MITK and is probably the
preferred way for most users.
The first part of this document is a tutorial aimed at newcomers to MITK and possibly
%CMake and tries to give as much help as possible on setting up your own project. If
you are looking for more technical information about customizing MITK, the structure
of the superbuild or packaging you might want to read the
\ref HowToNewProjectAdvancedInformation.
If you have set up your MITK project already and want to start developing you could
take a look at \ref TutorialPage.
\section HowToNewProjectGettingStarted Getting Started
To bootstrap your project MITK offers two convenient options:
<ol>
<li> Use the MITK Plugin Generator, a command line tool used to generate a customized
MITK project and/or MITK plug-ins.
<li> Use the <a href="https://github.com/MITK/MITK-ProjectTemplate">MITK project template</a>
as an example project.
</ol>
Both options will provide you with a project which contains a "superbuild" mechanism
to automatically download, configure, and build MITK as a dependency of your own project.
The MITK Plugin Generator generates code using the supplied command line arguments,
whereas the MITK project template needs immediate modifications to customize it to
your naming schemes. However, the project template will potentially contain more
code demonstrating features of MITK.
\note Using the MITK Plugin Generator is recommended for beginners.
\section HowToNewProjectPrerequisites Prerequisites
What ever option you choose, a MITK-based project needs essentially the same
prerequisites as MITK itself. Please see \ref BuildInstructions_Prerequisites for
details.
\note If you use one of the two options above you will \b not \b need to build MITK
yourself. This will be done automatically.
\section HowToNewProjectCreatingSourceDir Preparing your source directory
In order to start developing with MITK, you first have to set up the source directory
for your project.
\subsection HowToNewProjectSourceUsingGenerator Using the MITK Plugin Generator
The usage of the Plugin Generator for creating a new project is described in
\ref NewPluginWithProject, please have a look there.
\subsection HowToNewProjectSourceUsingTemplate Using the MITK Project Template
Download the project as a tarball or zipball and extract it to your desired source
directory.
\note This is a <b>template</b>. You must modify it such that it fits the needs of
your particular project. Especially you should do a global search and replace for
the string "awesome" to rename the template application and plug-in. You may want
to rename some files too.
\section HowToNewProjectGeneratingCMake Generating your binary with CMake
After you have set up your source directory you can proceed to generate your binary
directory using %CMake. Depending on your operating system and preferences you might
want to use "cmake-gui" or "ccmake" (shell). This document assumes you are using
cmake-gui.
<ol>
<li> Start "cmake-gui" and enter your source (e.g. "D:\AwesomeProject") and binary
directory (e.g. "D:\AwesomeProject-superbuild").
<li> Upon first pressing "Configure" you will be prompted to select your generator.
This determines what project files will be generated by %CMake. Set this to the
development tool you are intending to use (e.g. "Visual Studio 2010 64Bit" or
"linux makefiles".
<li> Press "Configure" until no new variables appear and then "Generate". Now all
project files have been generated into your binary directory.
<li> Double-check that the right Qt version is used.
</ol>
Now you are ready to compile your code. Depending on your choice of tool this will
be done differently, we cover two possibilities here.
\subsection HowToNewProjectCompilingLinuxMakefiles Compiling using linux makefiles
<ol>
<li> In the shell, switch to your binary directory.
<li> type "make" and hit enter
</ol>
\subsection HowToNewProjectCompilingVisualStudio Compiling using visual studio
We assume your application is called "AwesomeApp" and your project "AwesomeProject"
and your binary directory is "D:\AwesomeProject-superbuild\". Replace names and
paths accordingly.
<ol>
<li> Close %CMake and open "D:\AwesomeProject-superbuild\AwesomeProject-superbuild.sln".
Your Visual Studio should appear and by pressing F7 you start the compilation.
This will clone the MITK source code, build it, and then start building your own
project.
<li> After the superbuild compilation has finished, close the superbuild solution file and start
the build solution file "D:\AwesomeProject-superbuild\AwesomeProject-build\AwesomeProject.sln"
<li> Set the "AwesomeApp" project as start-up project (right click > "Set as StartUp
Project") and press "F5" to start your MITK AwesomeApp.
</ol>
\note Just opening AwesomeProject.sln from your explorer by double-cliking won`t
allow you to start or debug your application because the required environment
variables would be missing. Use the supplied batch files or set your PATH variable
accordingly.
\section HowToNewProjectAddingMITKFunctionality I want to use some MITK plugin but
it is not available
Due to the sheer number of MITK plugins not every plugin is activated by default.
To activate a specific plugin (again replace paths as needed):
<ol>
<li> Start "cmake-gui" and set the binary directory to
"D:\AwesomeProject-superbuild\MITK-superbuild\MITK-build\", the source will
adjust automatically and you will see new settings appear.
<li> Navigate to the plugin you want to use (e.g. "MITK_BUILD_org.mitk.gui.qt.segmentation")
and tick the checkbox behind it
<li> Press "Configure" until no new variables appear and then "Generate".
<li> Build MITK using your development tool (as in
\ref HowToNewProjectCompilingLinuxMakefiles or \ref HowToNewProjectCompilingVisualStudio
only in the "D:\AwesomeProject-superbuild\MITK-superbuild\MITK-build\" directory )
<li> Start "cmake-gui" and set the binary directory to
"D:\AwesomeProject-superbuild\AwesomeProject-build\", the source will adjust
automatically and you will see new settings appear.
<li> Press "Configure" until no new variables appear and then "Generate".
<li> Build your project
<li> Start your application
</ol>
\note If you want to use an application provided by MITK (e.g. MITK Workbench) you
have to tick the appropriate checkbox as well (in this case MITK_BUILD_APP_Workbench)
and build MITK. Do note, that this application will be located in the bin directory
of the "D:\AwesomeProject-superbuild\MITK-superbuild\MITK-build\" folder.
\section HowToNewProjectAdvancedInformation Information for advanced users
\subsection HowToNewProjectCustomizingMITK Customizing MITK
The %CMake scripts from the Plugin Generator of the project template provide some
handy options which allow you to customize the MITK build used in your project.
You can either inject an already build MITK to be used by your project or configure
some MITK options directly in your project's superbuild configuration if MITK is
going to be build inside your project.
-\subsubsection HowToNewProjectCustomizingMITKInjectMITK Inject a MITK build
+\subsection HowToNewProjectCustomizingMITKInjectMITK Inject a MITK build
By setting the \b EXTERNAL_MITK_DIR \b variable in your project's superbuild
%CMake configuration to a MITK build directory (containing the MITKConfig.cmake)
you can skip the MITK build process.
If MITK is the only external project in your project, you might want to disable
the superbuild of your project completely (set <your-proj-name>_USE_SUPERBUILD
to OFF or edit your CMakeLists.txt file to set it to OFF by default) and set
the \b MITK_DIR \b %CMake variable to your MITK build directory.
-\subsubsection HowToNewProjectCustomizingMITKConfigure Configure the MITK superbuild
+\subsection HowToNewProjectCustomizingMITKConfigure Configure the MITK superbuild
If MITK is being build inside your project's superbuild process, you can enable
the use of certain third-party libraries inside of MITK. The following variables
control the MITK configuration:
<ul>
<li> \b MITK_USE_BLUEBERRY Enable the use of the BlueBerry application framework
<li> \b MITK_USE_CTK Download, compile, and use CTK in MITK
<li> \b MITK_USE_DCMTK Download, compile, and use DCMTK in MITK
<li> \b MITK_USE_OpenCV Download, compile, and use OpenCV in MITK
<li> \b MITK_USE_Python3 Download and compile 1CableSwig and enable Python
wrapping in ITK, VTK, OpenCV, and MITK
<li> \b MITK_USE_Qt5 Use the Qt 5 framework in MITK
</ul>
You can also inject already build third-party libraries from inside your project's
superbuild in the MITK superbuild by using any of the following %CMake variables:
<ul>
<li> \b MITK_CTK_DIR Reuse a CTK build directory in MITK.
<li> \b MITK_CableSwig_DIR Reuse a 1CableSwig build directory in MITK.
<li> \b MITK_DCMTK_DIR Reuse a DCMKT build directory in MITK.
<li> \b MITK_GDCM_DIR Reuse a GDCM build directory in MITK.
<li> \b MITK_ITK_DIR Reuse a ITK build directory in MITK.
<li> \b MITK_OpenCV_DIR Reuse a OpenCV build directory in MITK.
<li> \b MITK_VTK_DIR Reuse a VTK build directory in MITK.
</ul>
If the corresponding \b MITK_USE_<proj> \b option is set to on, the MITK
superbuild will use the provided build directory instead of building the
project itself.
You can also control the source code location for MITK in your project's
superbuild configuration by using the following %CMake variables:
<ul>
<li> \b MITK_SOURCE_DIR The path to the MITK source directory. If the value
for this variable is non-empty, the variables below are ignored.
<li> \b MITK_GIT_REPOSITORY The Git repository containing the MITK source code.
<li> \b MITK_GIT_TAG The hash id, tag or branch name used for a checkout
from MITK_GIT_REPOSITORY.
</ul>
-\subsubsection HowToNewProjectProjectStructure Project Structure
+\subsection HowToNewProjectProjectStructure Project Structure
If you are using the superbuild feature of the generated project (the default),
you might want to familiarise yourself with the layout of your build tree.
The top-level build directory which you specified in %CMake when configuring
your project will contain all the required dependencies.
Suppose we call our project MyProject and the build directory is
"C:\MyProject-superbuild". Then the layout looks something like this:
MyProjectLayout.png The top-level directory contains the source code and the
build directories from the dependencies of your project. In the current case,
the only dependency of MyProject is MITK, which in turn has downloaded and built
its own dependencies (CTK, DCMTK, ITK, etc.). The "real" build tree for your
project is located in MyProject-superbuild/MyProject-build, so point the
%CMake-GUI to this build directory if you want to change the set of enabled
plug-ins for example.
Further, you should open the MyProject.sln solution file (for Visual Studio)
or execute "make" in the MyProject-superbuild/MyProject-build/ directory.
Only for the very first time or if you want to update and newly build the
project's dependencies should you use the project files in the
MyProject-superbuild directory directly.
The same applies for the MyProject-superbuild/MITK-superbuild directory. This
directory contains the MITK superbuild, nested inside your project's superbuild.
If you want to change %CMake options for MITK, use the
MyProject-superbuild/MITK-superbuild/MITK-build build directory.
\imageMacro{HowToNewProject-MyProjectLayout.png,"Layout of MyProject",4.02}
-\subsubsection HowToNewProjectPackaging Packaging
+\subsection HowToNewProjectPackaging Packaging
The project template and the generated projects by the Plugin Generator come
with full packaging support. You can create deployable packages of your project
for all supported operating systems my building the PACKAGE target. On Linux,
this will create a tarball, on MacOS a .dmg file, and on Windows a zipball and
an NSIS installer (if NSIS is installed and found).
You can read more about deployment \ref DeploymentPage "here".
*/
diff --git a/Documentation/doxygen.conf.in b/Documentation/doxygen.conf.in
index 22ac1ad644..8a46babe1b 100644
--- a/Documentation/doxygen.conf.in
+++ b/Documentation/doxygen.conf.in
@@ -1,2432 +1,2433 @@
# Doxyfile 1.8.8
# This file describes the settings to be used by the documentation system
# doxygen (www.doxygen.org) for a project.
#
# All text after a double hash (##) is considered a comment and is placed in
# front of the TAG it is preceding.
#
# All text after a single 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.
# The default value is: UTF-8.
DOXYFILE_ENCODING = UTF-8
# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by
# double-quotes, unless you are using Doxywizard) that should identify the
# project for which the documentation is generated. This name is used in the
# title of most generated pages and in a few other places.
# The default value is: My Project.
PROJECT_NAME = "Medical Imaging Interaction Toolkit"
# 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) path
# into which the generated documentation will be written. 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 causes
# performance problems for the file system.
# The default value is: NO.
CREATE_SUBDIRS = NO
# If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII
# characters to appear in the names of generated files. If set to NO, non-ASCII
# characters will be escaped, for example _xE3_x81_x84 will be used for Unicode
# U+3044.
# The default value is: NO.
ALLOW_UNICODE_NAMES = 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.
# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese,
# Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States),
# Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian,
# Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages),
# Korean, Korean-en (Korean with English messages), Latvian, Lithuanian,
# Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian,
# Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish,
# Ukrainian and Vietnamese.
# The default value is: English.
OUTPUT_LANGUAGE = English
# If the BRIEF_MEMBER_DESC tag is set to YES 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.
# The default value is: YES.
BRIEF_MEMBER_DESC = YES
# If the REPEAT_BRIEF tag is set to YES 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.
# The default value is: YES.
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 and 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.
# The default value is: NO.
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.
# The default value is: NO.
INLINE_INHERITED_MEMB = NO
# If the FULL_PATH_NAMES tag is set to YES 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
# The default value is: YES.
FULL_PATH_NAMES = NO
# 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.
#
# Note that you can specify absolute paths here, but also relative paths, which
# will be relative from the directory where doxygen is started.
# This tag requires that the tag FULL_PATH_NAMES is set to YES.
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 list of 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 is your file systems doesn't
# support long names like on DOS, Mac, or CD-ROM.
# The default value is: NO.
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-style will behave just like regular Qt-
# style comments (thus requiring an explicit @brief command for a brief
# description.)
# The default value is: NO.
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 Qt-style will behave just like regular Qt-style comments (thus
# requiring an explicit \brief command for a brief description.)
# The default value is: NO.
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 behavior. 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 behavior instead.
#
# Note that setting this tag to YES also means that rational rose comments are
# not recognized any more.
# The default value is: NO.
MULTILINE_CPP_IS_BRIEF = NO
# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the
# documentation from any documented member that it re-implements.
# The default value is: YES.
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.
# The default value is: NO.
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.
# Minimum value: 1, maximum value: 16, default value: 4.
TAB_SIZE = 8
# This tag can be used to specify a number of aliases that act 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" \
"embmainpage{1}=\page \1" \
"github{2}=<a href=\"https://github.com/MITK/MITK/blob/master/\1\">\2</a>" \
"deprecatedSince{1}=\xrefitem deprecatedSince\1 \"\" \"Functions deprecated as of \1\" \deprecated (as of \1) " \
"minimumCMakeVersion=@MITK_CMAKE_MINIMUM_REQUIRED_VERSION@" \
"minimumQt5Version=@MITK_QT5_MINIMUM_VERSION@" \
"imageMacro{3}=\image html \1 \2 \n \image latex \1 \2 width=\3cm" \
"developersguidemainpage{1}=\page \1 " \
"usersguidemainpage{1}=\page \1 " \
"nondependentPluginLink{3}= \ref \1 \"\3\" "
# 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.
# The default value is: NO.
OPTIMIZE_OUTPUT_FOR_C = NO
# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or
# Python sources only. Doxygen will then generate output that is more tailored
# for that language. For instance, namespaces will be presented as packages,
# qualified scopes will look different, etc.
# The default value is: NO.
OPTIMIZE_OUTPUT_JAVA = NO
# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
# sources. Doxygen will then generate output that is tailored for Fortran.
# The default value is: NO.
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.
# The default value is: NO.
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,
# C#, C, C++, D, PHP, Objective-C, Python, Fortran (fixed format Fortran:
# FortranFixed, free formatted Fortran: FortranFree, unknown formatted Fortran:
# Fortran. In the later case the parser tries to guess whether the code is fixed
# or free formatted code, this is the default for Fortran type files), VHDL. 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 For files without extension you can use no_extension as a placeholder.
#
# Note that for custom extensions you also need to set FILE_PATTERNS otherwise
# the files are not read by doxygen.
EXTENSION_MAPPING = cmake=c++
# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments
# according to the Markdown format, which allows for more readable
# documentation. See http://daringfireball.net/projects/markdown/ for details.
# The output of markdown processing is further processed by doxygen, so you can
# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in
# case of backward compatibilities issues.
# The default value is: YES.
MARKDOWN_SUPPORT = YES
# When enabled doxygen tries to link words that correspond to documented
# classes, or namespaces to their corresponding documentation. Such a link can
# be prevented in individual cases by by putting a % sign in front of the word
# or globally by setting AUTOLINK_SUPPORT to NO.
# The default value is: YES.
AUTOLINK_SUPPORT = YES
# 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);
# versus func(std::string) {}). This also make the inheritance and collaboration
# diagrams that involve STL classes more complete and accurate.
# The default value is: NO.
BUILTIN_STL_SUPPORT = YES
# If you use Microsoft's C++/CLI language, you should set this option to YES to
# enable parsing support.
# The default value is: NO.
CPP_CLI_SUPPORT = NO
# Set the SIP_SUPPORT tag to YES if your project consists of sip (see:
# http://www.riverbankcomputing.co.uk/software/sip/intro) 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.
# The default value is: NO.
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 will make
# doxygen to 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.
# The default value is: YES.
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.
# The default value is: NO.
DISTRIBUTE_GROUP_DOC = YES
# Set the SUBGROUPING tag to YES 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.
# The default value is: YES.
SUBGROUPING = YES
# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions
# are shown inside the group in which they are included (e.g. using \ingroup)
# instead of on a separate page (for HTML and Man pages) or section (for LaTeX
# and RTF).
#
# Note that this feature does not work in combination with
# SEPARATE_MEMBER_PAGES.
# The default value is: NO.
INLINE_GROUPED_CLASSES = NO
# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions
# with only public data fields or simple typedef fields will be shown inline in
# the documentation of the scope in which they are defined (i.e. file,
# namespace, or group documentation), provided this scope is documented. If set
# to NO, structs, classes, and unions are shown on a separate page (for HTML and
# Man pages) or section (for LaTeX and RTF).
# The default value is: NO.
INLINE_SIMPLE_STRUCTS = NO
# When TYPEDEF_HIDES_STRUCT tag 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.
# The default value is: NO.
TYPEDEF_HIDES_STRUCT = NO
# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This
# cache is used to resolve symbols given their name and scope. Since this can be
# an expensive process and often the same symbol appears multiple times in the
# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small
# doxygen will become slower. If the cache is too large, memory is wasted. The
# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range
# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536
# symbols. At the end of a run doxygen will report the cache usage and suggest
# the optimal cache size from a speed point of view.
# Minimum value: 0, maximum value: 9, default value: 0.
LOOKUP_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 respectively EXTRACT_STATIC tags are set to YES.
# Note: This will also disable the warnings about undocumented members that are
# normally produced when WARNINGS is set to YES.
# The default value is: NO.
EXTRACT_ALL = YES
# If the EXTRACT_PRIVATE tag is set to YES all private members of a class will
# be included in the documentation.
# The default value is: NO.
EXTRACT_PRIVATE = NO
# If the EXTRACT_PACKAGE tag is set to YES all members with package or internal
# scope will be included in the documentation.
# The default value is: NO.
EXTRACT_PACKAGE = NO
# If the EXTRACT_STATIC tag is set to YES all static members of a file will be
# included in the documentation.
# The default value is: NO.
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. Does not have any effect
# for Java sources.
# The default value is: YES.
EXTRACT_LOCAL_CLASSES = @MITK_DOXYGEN_INTERNAL_DOCS@
# 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 only methods in the interface are
# included.
# The default value is: NO.
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 namespace
# are hidden.
# The default value is: NO.
EXTRACT_ANON_NSPACES = NO
# If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all
# undocumented members inside documented classes or files. If set to NO 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.
# The default value is: NO.
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 these classes will be included in the various overviews. This option has
# no effect if EXTRACT_ALL is enabled.
# The default value is: NO.
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 these declarations will be
# included in the documentation.
# The default value is: NO.
HIDE_FRIEND_COMPOUNDS = @MITK_DOXYGEN_HIDE_FRIEND_COMPOUNDS@
# 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 these
# blocks will be appended to the function's detailed documentation block.
# The default value is: NO.
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 then the documentation
# will be excluded. Set it to YES to include the internal documentation.
# The default value is: NO.
INTERNAL_DOCS = @MITK_DOXYGEN_INTERNAL_DOCS@
# 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.
# The default value is: system dependent.
CASE_SENSE_NAMES = YES
# If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with
# their full class and namespace scopes in the documentation. If set to YES the
# scope will be hidden.
# The default value is: NO.
HIDE_SCOPE_NAMES = NO
# If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of
# the files that are included by a file in the documentation of that file.
# The default value is: YES.
SHOW_INCLUDE_FILES = YES
# If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each
# grouped member an include statement to the documentation, telling the reader
# which file to include in order to use the member.
# The default value is: NO.
SHOW_GROUPED_MEMB_INC = NO
# 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.
# The default value is: NO.
FORCE_LOCAL_INCLUDES = NO
# If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the
# documentation for inline members.
# The default value is: YES.
INLINE_INFO = YES
# If the SORT_MEMBER_DOCS tag is set to YES 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.
# The default value is: YES.
SORT_MEMBER_DOCS = YES
# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief
# descriptions of file, namespace and class members alphabetically by member
# name. If set to NO the members will appear in declaration order. Note that
# this will also influence the order of the classes in the class list.
# The default value is: NO.
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 constructors will appear in the
# respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS.
# Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief
# member documentation.
# Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting
# detailed member documentation.
# The default value is: 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 group names will
# appear in their defined order.
# The default value is: NO.
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 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.
# The default value is: NO.
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.
# The default value is: NO.
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.
# The default value is: YES.
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.
# The default value is: YES.
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.
# The default value is: YES.
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.
# The default value is: YES.
GENERATE_DEPRECATEDLIST= @MITK_DOXYGEN_GENERATE_DEPRECATEDLIST@
# The ENABLED_SECTIONS tag can be used to enable conditional documentation
# sections, marked by \if <section_label> ... \endif and \cond <section_label>
# ... \endcond blocks.
ENABLED_SECTIONS = @MITK_DOXYGEN_ENABLED_SECTIONS@
# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the
# initial value of a variable or macro / define can have 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 value of individual variables and macros / defines can be
# controlled using \showinitializer or \hideinitializer command in the
# documentation regardless of this setting.
# Minimum value: 0, maximum value: 10000, default value: 30.
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.
# The default value is: YES.
SHOW_USED_FILES = YES
# 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 value 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 value 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. For an example see the documentation.
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. To 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.
#
# Note that if you run doxygen from a directory containing a file called
# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE
# tag is left empty.
LAYOUT_FILE = "@MITK_SOURCE_DIR@/Documentation/MITKDoxygenLayout.xml"
# The CITE_BIB_FILES tag can be used to specify one or more bib files containing
# the reference definitions. This must be a list of .bib files. The .bib
# extension is automatically appended if omitted. This requires the bibtex tool
# to be installed. See also http://en.wikipedia.org/wiki/BibTeX for more info.
# For LaTeX the style of the bibliography can be controlled using
# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the
# search path. See also \cite for info how to create references.
CITE_BIB_FILES =
#---------------------------------------------------------------------------
# Configuration options related to warning and progress messages
#---------------------------------------------------------------------------
# The QUIET tag can be used to turn on/off the messages that are generated to
# standard output by doxygen. If QUIET is set to YES this implies that the
# messages are off.
# The default value is: NO.
QUIET = YES
# The WARNINGS tag can be used to turn on/off the warning messages that are
# generated to standard error ( stderr) by doxygen. If WARNINGS is set to YES
# this implies that the warnings are on.
#
# Tip: Turn warnings on while writing the documentation.
# The default value is: YES.
WARNINGS = YES
# If the WARN_IF_UNDOCUMENTED tag 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.
# The default value is: YES.
WARN_IF_UNDOCUMENTED = YES
# If the WARN_IF_DOC_ERROR tag 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.
# The default value is: YES.
WARN_IF_DOC_ERROR = YES
# This 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 doxygen will only warn about wrong or incomplete parameter
# documentation, but not about the absence of documentation.
# The default value is: NO.
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)
# The default value is: $file:$line: $text.
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 standard
# error (stderr).
WARN_LOGFILE =
#---------------------------------------------------------------------------
# Configuration options related to the input files
#---------------------------------------------------------------------------
# The INPUT tag is 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.
# Note: If this tag is empty the current directory is searched.
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. Doxygen uses
# libiconv (or the iconv built into libc) for the transcoding. See the libiconv
# documentation (see: http://www.gnu.org/software/libiconv) for the list of
# possible encodings.
# The default value is: UTF-8.
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 patterns (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++, *.java, *.ii,
# *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h, *.hh, *.hxx, *.hpp,
# *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc, *.m, *.markdown,
# *.md, *.mm, *.dox, *.py, *.f90, *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf,
# *.qsf, *.as and *.js.
FILE_PATTERNS = *.h \
*.dox \
*.md
# The RECURSIVE tag can be used to specify whether or not subdirectories should
# be searched for input files as well.
# The default value is: NO.
RECURSIVE = YES
# The EXCLUDE tag can be used to specify files and/or directories that should be
# 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.
#
# Note that relative paths are relative to the directory from which doxygen is
# run.
EXCLUDE = "@MITK_SOURCE_DIR@/Utilities/IpFunc/" \
"@MITK_SOURCE_DIR@/Utilities/IpSegmentation/" \
"@MITK_SOURCE_DIR@/Utilities/qtsingleapplication/" \
"@MITK_SOURCE_DIR@/Applications/PluginGenerator/" \
"@MITK_SOURCE_DIR@/Modules/CppMicroServices/core/doc/snippets/" \
"@MITK_SOURCE_DIR@/Modules/CppMicroServices/core/doc/doxygen/standalone/" \
"@MITK_SOURCE_DIR@/Modules/CppMicroServices/core/test/" \
"@MITK_SOURCE_DIR@/Modules/CppMicroServices/core/examples/" \
"@MITK_SOURCE_DIR@/Modules/CppMicroServices/core/src/util/jsoncpp.cpp" \
"@MITK_SOURCE_DIR@/Modules/CppMicroServices/third_party" \
"@MITK_SOURCE_DIR@/CMake/PackageDepends" \
"@MITK_SOURCE_DIR@/CMakeExternals" \
"@MITK_SOURCE_DIR@/Licenses" \
"@MITK_BINARY_DIR@/Documentation/Doxygen" \
"@MITK_BINARY_DIR@/bin/" \
"@MITK_BINARY_DIR@/PT/" \
"@MITK_BINARY_DIR@/GP/" \
"@MITK_BINARY_DIR@/_CPack_Packages/" \
@MITK_DOXYGEN_ADDITIONAL_EXCLUDE_DIRS@
# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
# directories that are symbolic links (a Unix file system feature) are excluded
# from the input.
# The default value is: NO.
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 = README* \
moc_* \
ui_* \
qrc_* \
wrap_* \
Register* \
*/files.cmake \
*/.git/* \
*_p.h \
*Private.* \
*/Internal/* \
*/internal/* \
*/Snippets/* \
*/snippets/* \
*/testing/* \
*/Testing/* \
*/test/* \
*/resource/* \
"@MITK_BINARY_DIR@/*.cmake" \
@MITK_DOXYGEN_EXCLUDE_PATTERNS@
# 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
#
# Note that the wildcards are matched against the file with absolute path, so to
# exclude all test directories use the pattern */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@/Examples/" \
"@MITK_SOURCE_DIR@/Examples/Tutorial/" \
"@MITK_SOURCE_DIR@/Examples/Plugins/" \
"@MITK_SOURCE_DIR@/Examples/QtFreeRender/" \
"@MITK_SOURCE_DIR@/Modules/Core/" \
"@MITK_SOURCE_DIR@/Modules/CppMicroServices/core/doc/snippets/" \
"@MITK_SOURCE_DIR@/Modules/CppMicroServices/core/examples/" \
+ "@MITK_SOURCE_DIR@/Modules/CppMicroServices/" \
"@MITK_SOURCE_DIR@/Modules/OpenCL/Documentation/doxygen/snippets/" \
"@MITK_SOURCE_DIR@/Modules/IGT/Tutorial/" \
"@MITK_SOURCE_DIR@/Plugins/org.mitk.gui.common/src/" \
"@MITK_SOURCE_DIR@/Plugins/org.mitk.gui.qt.igtexamples/" \
"@MITK_SOURCE_DIR@/Plugins/org.mitk.gui.qt.igttracking/"
# 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.
# The default value is: NO.
EXAMPLE_RECURSIVE = YES
# The IMAGE_PATH tag can be used to specify one or more files or directories
# that contain images that are to be included in the documentation (see the
# \image command).
IMAGE_PATH = "@MITK_SOURCE_DIR@/Documentation/Doxygen/" \
"@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.
#
# Note that the filter must not add or remove lines; it is applied before the
# code is scanned, but not when the output code is generated. If lines are added
# or removed, the anchors will not be placed correctly.
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 information on how
# filters are used. If the FILTER_PATTERNS tag is empty or if none 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 also be used to filter the input files that are used for
# producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES).
# The default value is: NO.
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 tag requires that the tag FILTER_SOURCE_FILES is set to YES.
FILTER_SOURCE_PATTERNS =
# If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that
# is part of the input, its contents will be placed on the main page
# (index.html). This can be useful if you have a project on for instance GitHub
# and want to reuse the introduction page also for the doxygen output.
USE_MDFILE_AS_MAINPAGE =
#---------------------------------------------------------------------------
# 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 that
# also VERBATIM_HEADERS is set to NO.
# The default value is: NO.
SOURCE_BROWSER = YES
# Setting the INLINE_SOURCES tag to YES will include the body of functions,
# classes and enums directly into the documentation.
# The default value is: NO.
INLINE_SOURCES = NO
# Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any
# special comment blocks from generated source code fragments. Normal C, C++ and
# Fortran comments will always remain visible.
# The default value is: YES.
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.
# The default value is: NO.
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.
# The default value is: NO.
REFERENCES_RELATION = YES
# If the REFERENCES_LINK_SOURCE tag is set to YES 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.
# The default value is: YES.
REFERENCES_LINK_SOURCE = YES
# If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the
# source code will show a tooltip with additional information such as prototype,
# brief description and links to the definition and documentation. Since this
# will make the HTML file larger and loading of large files a bit slower, you
# can opt to disable this feature.
# The default value is: YES.
# This tag requires that the tag SOURCE_BROWSER is set to YES.
SOURCE_TOOLTIPS = 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.
#
# To use it do the following:
# - Install the latest version of global
# - Enable SOURCE_BROWSER and USE_HTAGS in the config file
# - Make sure the INPUT points to the root of the source tree
# - Run doxygen as normal
#
# Doxygen will invoke htags (and that will in turn invoke gtags), so these
# tools must be available from the command line (i.e. in the search path).
#
# The result: instead of the source browser generated by doxygen, the links to
# source code will now point to the output of htags.
# The default value is: NO.
# This tag requires that the tag SOURCE_BROWSER is set to YES.
USE_HTAGS = NO
# If the VERBATIM_HEADERS tag is set the YES 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.
# See also: Section \class.
# The default value is: YES.
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.
# The default value is: YES.
ALPHABETICAL_INDEX = YES
# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in
# which the alphabetical index list will be split.
# Minimum value: 1, maximum value: 20, default value: 5.
# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
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 a prefix (or a list of prefixes) that should be ignored
# while generating the index headers.
# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
IGNORE_PREFIX =
#---------------------------------------------------------------------------
# Configuration options related to the HTML output
#---------------------------------------------------------------------------
# If the GENERATE_HTML tag is set to YES doxygen will generate HTML output
# The default value is: YES.
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.
# The default directory is: html.
# This tag requires that the tag GENERATE_HTML is set to YES.
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).
# The default value is: .html.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_FILE_EXTENSION = .html
# The HTML_HEADER tag can be used to specify a user-defined HTML header file for
# each generated HTML page. If the tag is left blank doxygen will generate a
# standard header.
#
# To get valid HTML the header file that includes any scripts and style sheets
# that doxygen needs, which is dependent on the configuration options used (e.g.
# the setting GENERATE_TREEVIEW). It is highly recommended to start with a
# default header using
# doxygen -w html new_header.html new_footer.html new_stylesheet.css
# YourConfigFile
# and then modify the file new_header.html. See also section "Doxygen usage"
# for information on how to generate the default header that doxygen normally
# uses.
# Note: The header is subject to change so you typically have to regenerate the
# default header when upgrading to a newer version of doxygen. For a description
# of the possible markers and block names see the documentation.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_HEADER =
# The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each
# generated HTML page. If the tag is left blank doxygen will generate a standard
# footer. See HTML_HEADER for more information on how to generate a default
# footer and what special commands can be used inside the footer. See also
# section "Doxygen usage" for information on how to generate the default footer
# that doxygen normally uses.
# This tag requires that the tag GENERATE_HTML is set to YES.
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 left blank doxygen will generate a default style sheet.
# See also section "Doxygen usage" for information on how to generate the style
# sheet that doxygen normally uses.
# Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as
# it is more robust and this tag (HTML_STYLESHEET) will in the future become
# obsolete.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_STYLESHEET =
# The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined
# cascading style sheets that are included after the standard style sheets
# created by doxygen. Using this option one can overrule certain style aspects.
# This is preferred over using HTML_STYLESHEET since it does not replace the
# standard style sheet and is therefor more robust against future updates.
# Doxygen will copy the style sheet files to the output directory.
# Note: The order of the extra stylesheet files is of importance (e.g. the last
# stylesheet in the list overrules the setting of the previous ones in the
# list). For an example see the documentation.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_EXTRA_STYLESHEET = @MITK_DOXYGEN_STYLESHEET@
# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
# other source files which should be copied to the HTML output directory. Note
# that these files will be copied to the base HTML output directory. Use the
# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
# files. In the HTML_STYLESHEET file, use the file name only. Also note that the
# files will be copied as-is; there are no commands or markers available.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_EXTRA_FILES = "@MITK_SOURCE_DIR@/Documentation/Doxygen/mitkLogo.jpg"
# 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.
# Minimum value: 0, maximum value: 359, default value: 220.
# This tag requires that the tag GENERATE_HTML is set to YES.
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.
# Minimum value: 0, maximum value: 255, default value: 100.
# This tag requires that the tag GENERATE_HTML is set to YES.
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.
# Minimum value: 40, maximum value: 240, default value: 80.
# This tag requires that the tag GENERATE_HTML is set to YES.
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.
# The default value is: YES.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_TIMESTAMP = 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.
# The default value is: NO.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_DYNAMIC_SECTIONS = @MITK_DOXYGEN_HTML_DYNAMIC_SECTIONS@
# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries
# shown in the various tree structured indices initially; the user can expand
# and collapse entries dynamically later on. Doxygen will expand the tree to
# such a level that at most the specified number of entries are visible (unless
# a fully collapsed tree already exceeds this amount). So setting the number of
# entries 1 will produce a full collapsed tree by default. 0 is a special value
# representing an infinite number of entries and will result in a full expanded
# tree by default.
# Minimum value: 0, maximum value: 9999, default value: 100.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_INDEX_NUM_ENTRIES = 100
# 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 (see: http://developer.apple.com/tools/xcode/), 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.
# The default value is: NO.
# This tag requires that the tag GENERATE_HTML is set to YES.
GENERATE_DOCSET = NO
# This tag determines the name of the docset 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.
# The default value is: Doxygen generated docs.
# This tag requires that the tag GENERATE_DOCSET is set to YES.
DOCSET_FEEDNAME = "Doxygen generated docs"
# 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.
# The default value is: org.doxygen.Project.
# This tag requires that the tag GENERATE_DOCSET is set to YES.
DOCSET_BUNDLE_ID = org.doxygen.Project
# The DOCSET_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.
# The default value is: org.doxygen.Publisher.
# This tag requires that the tag GENERATE_DOCSET is set to YES.
DOCSET_PUBLISHER_ID = org.doxygen.Publisher
# The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher.
# The default value is: Publisher.
# This tag requires that the tag GENERATE_DOCSET is set to YES.
DOCSET_PUBLISHER_NAME = Publisher
# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
# additional HTML index files: index.hhp, index.hhc, and index.hhk. The
# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
# (see: http://www.microsoft.com/en-us/download/details.aspx?id=21138) on
# Windows.
#
# The HTML Help Workshop contains a compiler that can convert all HTML output
# generated by doxygen into a single compiled HTML file (.chm). Compiled HTML
# files are now used as the Windows 98 help format, and will replace the old
# Windows help format (.hlp) on all Windows platforms in the future. Compressed
# HTML files also contain an index, a table of contents, and you can search for
# words in the documentation. The HTML workshop also contains a viewer for
# compressed HTML files.
# The default value is: NO.
# This tag requires that the tag GENERATE_HTML is set to YES.
GENERATE_HTMLHELP = NO
# 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.
# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
CHM_FILE =
# 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.
# The file has to be specified with full path.
# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
HHC_LOCATION =
# 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).
# The default value is: NO.
# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
GENERATE_CHI = NO
# The CHM_INDEX_ENCODING is used to encode HtmlHelp index ( hhk), content ( hhc)
# and project file content.
# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
CHM_INDEX_ENCODING =
# 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. Furthermore it
# enables the Previous and Next buttons.
# The default value is: NO.
# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
BINARY_TOC = NO
# The TOC_EXPAND flag can be set to YES to add extra items for group members to
# the table of contents of the HTML help documentation and to the tree view.
# The default value is: NO.
# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
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.
# The default value is: NO.
# This tag requires that the tag GENERATE_HTML is set to YES.
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.
# This tag requires that the tag GENERATE_QHP is set to YES.
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 Qt Help Project / Namespace
# (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#namespace).
# The default value is: org.doxygen.Project.
# This tag requires that the tag GENERATE_QHP is set to YES.
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 Qt Help Project / Virtual
# Folders (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#virtual-
# folders).
# The default value is: doc.
# This tag requires that the tag GENERATE_QHP is set to YES.
QHP_VIRTUAL_FOLDER = MITK
# If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom
# filter to add. For more information please see Qt Help Project / Custom
# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
# filters).
# This tag requires that the tag GENERATE_QHP is set to YES.
QHP_CUST_FILTER_NAME =
# The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the
# custom filter to add. For more information please see Qt Help Project / Custom
# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
# filters).
# This tag requires that the tag GENERATE_QHP is set to YES.
QHP_CUST_FILTER_ATTRS =
# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
# project's filter section matches. Qt Help Project / Filter Attributes (see:
# http://qt-project.org/doc/qt-4.8/qthelpproject.html#filter-attributes).
# This tag requires that the tag GENERATE_QHP is set to YES.
QHP_SECT_FILTER_ATTRS =
# 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.
# This tag requires that the tag GENERATE_QHP is set to YES.
QHG_LOCATION = @QT_HELPGENERATOR_EXECUTABLE@
# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be
# generated, together with the HTML files, they 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.
# The default value is: NO.
# This tag requires that the tag GENERATE_HTML is set to YES.
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. Each documentation set should have its own identifier.
# The default value is: org.doxygen.Project.
# This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES.
ECLIPSE_DOC_ID = org.doxygen.Project
# If you want full control over the layout of the generated HTML pages it might
# be necessary to disable the index and replace it with your own. The
# DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top
# of each HTML page. A value of NO enables the index and the value YES disables
# it. Since the tabs in the index contain the same information as the navigation
# tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES.
# The default value is: NO.
# This tag requires that the tag GENERATE_HTML is set to YES.
DISABLE_INDEX = NO
# 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. Via custom stylesheets (see HTML_EXTRA_STYLESHEET) one can
# further fine-tune the look of the index. As an example, the default style
# sheet generated by doxygen has an example that shows how to put an image at
# the root of the tree instead of the PROJECT_NAME. Since the tree basically has
# the same information as the tab index, you could consider setting
# DISABLE_INDEX to YES when enabling this option.
# The default value is: NO.
# This tag requires that the tag GENERATE_HTML is set to YES.
GENERATE_TREEVIEW = YES
# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values 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.
# Minimum value: 0, maximum value: 20, default value: 4.
# This tag requires that the tag GENERATE_HTML is set to YES.
ENUM_VALUES_PER_LINE = 4
# 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.
# Minimum value: 0, maximum value: 1500, default value: 250.
# This tag requires that the tag GENERATE_HTML is set to YES.
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.
# The default value is: NO.
# This tag requires that the tag GENERATE_HTML is set to YES.
EXT_LINKS_IN_WINDOW = NO
# Use this tag to change the font size of LaTeX formulas included as images in
# the HTML documentation. 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.
# Minimum value: 8, maximum value: 50, default value: 10.
# This tag requires that the tag GENERATE_HTML is set to YES.
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 directory before the changes have effect.
# The default value is: YES.
# This tag requires that the tag GENERATE_HTML is set to YES.
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 may also need to install MathJax separately and configure the path
# to it using the MATHJAX_RELPATH option.
# The default value is: NO.
# This tag requires that the tag GENERATE_HTML is set to YES.
USE_MATHJAX = YES
# When MathJax is enabled you can set the default output format to be used for
# the MathJax output. See the MathJax site (see:
# http://docs.mathjax.org/en/latest/output.html) for more details.
# Possible values are: HTML-CSS (which is slower, but has the best
# compatibility), NativeMML (i.e. MathML) and SVG.
# The default value is: HTML-CSS.
# This tag requires that the tag USE_MATHJAX is set to YES.
MATHJAX_FORMAT = HTML-CSS
# 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
# Content Delivery Network so you can quickly see the result without installing
# MathJax. However, it is strongly recommended to install a local copy of
# MathJax from http://www.mathjax.org before deployment.
# The default value is: http://cdn.mathjax.org/mathjax/latest.
# This tag requires that the tag USE_MATHJAX is set to YES.
MATHJAX_RELPATH = http://www.mathjax.org/mathjax
# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
# extension names that should be enabled during MathJax rendering. For example
# MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols
# This tag requires that the tag USE_MATHJAX is set to YES.
MATHJAX_EXTENSIONS =
# The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces
# of code that will be used on startup of the MathJax code. See the MathJax site
# (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an
# example see the documentation.
# This tag requires that the tag USE_MATHJAX is set to YES.
MATHJAX_CODEFILE =
# 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. It is possible to
# search using the keyboard; to jump to the search box use <access key> + S
# (what the <access key> is depends on the OS and browser, but it is typically
# <CTRL>, <ALT>/<option>, or both). Inside the search box use the <cursor down
# key> to jump into the search results window, the results can be navigated
# using the <cursor keys>. Press <Enter> to select an item or <escape> to cancel
# the search. The filter options can be selected when the cursor is inside the
# search box by pressing <Shift>+<cursor down>. Also here use the <cursor keys>
# to select a filter and <Enter> or <escape> to activate or cancel the filter
# option.
# The default value is: YES.
# This tag requires that the tag GENERATE_HTML is set to YES.
SEARCHENGINE = YES
# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
# implemented using a web server instead of a web client using Javascript. There
# are two flavors of web server based searching depending on the EXTERNAL_SEARCH
# setting. When disabled, doxygen will generate a PHP script for searching and
# an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing
# and searching needs to be provided by external tools. See the section
# "External Indexing and Searching" for details.
# The default value is: NO.
# This tag requires that the tag SEARCHENGINE is set to YES.
SERVER_BASED_SEARCH = NO
# When EXTERNAL_SEARCH tag is enabled doxygen will no longer generate the PHP
# script for searching. Instead the search results are written to an XML file
# which needs to be processed by an external indexer. Doxygen will invoke an
# external search engine pointed to by the SEARCHENGINE_URL option to obtain the
# search results.
#
# Doxygen ships with an example indexer ( doxyindexer) and search engine
# (doxysearch.cgi) which are based on the open source search engine library
# Xapian (see: http://xapian.org/).
#
# See the section "External Indexing and Searching" for details.
# The default value is: NO.
# This tag requires that the tag SEARCHENGINE is set to YES.
EXTERNAL_SEARCH = NO
# The SEARCHENGINE_URL should point to a search engine hosted by a web server
# which will return the search results when EXTERNAL_SEARCH is enabled.
#
# Doxygen ships with an example indexer ( doxyindexer) and search engine
# (doxysearch.cgi) which are based on the open source search engine library
# Xapian (see: http://xapian.org/). See the section "External Indexing and
# Searching" for details.
# This tag requires that the tag SEARCHENGINE is set to YES.
SEARCHENGINE_URL =
# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
# search data is written to a file for indexing by an external tool. With the
# SEARCHDATA_FILE tag the name of this file can be specified.
# The default file is: searchdata.xml.
# This tag requires that the tag SEARCHENGINE is set to YES.
SEARCHDATA_FILE = searchdata.xml
# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the
# EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
# useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
# projects and redirect the results back to the right project.
# This tag requires that the tag SEARCHENGINE is set to YES.
EXTERNAL_SEARCH_ID =
# The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
# projects other than the one defined by this configuration file, but that are
# all added to the same external search index. Each project needs to have a
# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id of
# to a relative location where the documentation can be found. The format is:
# EXTRA_SEARCH_MAPPINGS = tagname1=loc1 tagname2=loc2 ...
# This tag requires that the tag SEARCHENGINE is set to YES.
EXTRA_SEARCH_MAPPINGS =
#---------------------------------------------------------------------------
# Configuration options related to the LaTeX output
#---------------------------------------------------------------------------
# If the GENERATE_LATEX tag is set to YES doxygen will generate LaTeX output.
# The default value is: YES.
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.
# The default directory is: latex.
# This tag requires that the tag GENERATE_LATEX is set to YES.
LATEX_OUTPUT = latex
# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
# invoked.
#
# 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.
# The default file is: latex.
# This tag requires that the tag GENERATE_LATEX is set to YES.
LATEX_CMD_NAME = latex
# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
# index for LaTeX.
# The default file is: makeindex.
# This tag requires that the tag GENERATE_LATEX is set to YES.
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.
# The default value is: NO.
# This tag requires that the tag GENERATE_LATEX is set to YES.
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 (210 x 297 mm), letter (8.5 x 11 inches), legal (8.5 x
# 14 inches) and executive (7.25 x 10.5 inches).
# The default value is: a4.
# This tag requires that the tag GENERATE_LATEX is set to YES.
PAPER_TYPE = a4
# The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
# that should be included in the LaTeX output. To get the times font for
# instance you can specify
# EXTRA_PACKAGES=times
# If left blank no extra packages will be included.
# This tag requires that the tag GENERATE_LATEX is set to YES.
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. See
# section "Doxygen usage" for information on how to let doxygen write the
# default header to a separate file.
#
# Note: Only use a user-defined header if you know what you are doing! The
# following commands have a special meaning inside the header: $title,
# $datetime, $date, $doxygenversion, $projectname, $projectnumber,
# $projectbrief, $projectlogo. Doxygen will replace $title with the empy string,
# for the replacement values of the other commands the user is refered to
# HTML_HEADER.
# This tag requires that the tag GENERATE_LATEX is set to YES.
LATEX_HEADER =
# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for the
# generated LaTeX document. The footer should contain everything after the last
# chapter. If it is left blank doxygen will generate a standard footer. See
# LATEX_HEADER for more information on how to generate a default footer and what
# special commands can be used inside the footer.
#
# Note: Only use a user-defined footer if you know what you are doing!
# This tag requires that the tag GENERATE_LATEX is set to YES.
LATEX_FOOTER =
# The LATEX_EXTRA_FILES tag can be used to specify one or more extra images or
# other source files which should be copied to the LATEX_OUTPUT output
# directory. Note that the files will be copied as-is; there are no commands or
# markers available.
# This tag requires that the tag GENERATE_LATEX is set to YES.
LATEX_EXTRA_FILES =
# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated is
# prepared for conversion to PDF (using ps2pdf or pdflatex). 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.
# The default value is: YES.
# This tag requires that the tag GENERATE_LATEX is set to YES.
PDF_HYPERLINKS = NO
# If the USE_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate
# the PDF file directly from the LaTeX files. Set this option to YES to get a
# higher quality PDF documentation.
# The default value is: YES.
# This tag requires that the tag GENERATE_LATEX is set to YES.
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.
# The default value is: NO.
# This tag requires that the tag GENERATE_LATEX is set to YES.
LATEX_BATCHMODE = NO
# If the LATEX_HIDE_INDICES tag is set to YES then doxygen will not include the
# index chapters (such as File Index, Compound Index, etc.) in the output.
# The default value is: NO.
# This tag requires that the tag GENERATE_LATEX is set to YES.
LATEX_HIDE_INDICES = NO
# If the LATEX_SOURCE_CODE tag 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.
# The default value is: NO.
# This tag requires that the tag GENERATE_LATEX is set to YES.
LATEX_SOURCE_CODE = NO
# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
# bibliography, e.g. plainnat, or ieeetr. See
# http://en.wikipedia.org/wiki/BibTeX and \cite for more info.
# The default value is: plain.
# This tag requires that the tag GENERATE_LATEX is set to YES.
LATEX_BIB_STYLE = plain
#---------------------------------------------------------------------------
# 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 too pretty with other RTF
# readers/editors.
# The default value is: NO.
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.
# The default directory is: rtf.
# This tag requires that the tag GENERATE_RTF is set to YES.
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.
# The default value is: NO.
# This tag requires that the tag GENERATE_RTF is set to YES.
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 some other Word compatible readers that support those
# fields.
#
# Note: WordPad (write) and others do not support links.
# The default value is: NO.
# This tag requires that the tag GENERATE_RTF is set to YES.
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.
#
# See also section "Doxygen usage" for information on how to generate the
# default style sheet that doxygen normally uses.
# This tag requires that the tag GENERATE_RTF is set to YES.
RTF_STYLESHEET_FILE =
# Set optional variables used in the generation of an RTF document. Syntax is
# similar to doxygen's config file. A template extensions file can be generated
# using doxygen -e rtf extensionFile.
# This tag requires that the tag GENERATE_RTF is set to YES.
RTF_EXTENSIONS_FILE =
#---------------------------------------------------------------------------
# Configuration options related to the man page output
#---------------------------------------------------------------------------
# If the GENERATE_MAN tag is set to YES doxygen will generate man pages for
# classes and files.
# The default value is: NO.
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. A directory man3 will be created inside the directory specified by
# MAN_OUTPUT.
# The default directory is: man.
# This tag requires that the tag GENERATE_MAN is set to YES.
MAN_OUTPUT = man
# The MAN_EXTENSION tag determines the extension that is added to the generated
# man pages. In case the manual section does not start with a number, the number
# 3 is prepended. The dot (.) at the beginning of the MAN_EXTENSION tag is
# optional.
# The default value is: .3.
# This tag requires that the tag GENERATE_MAN is set to YES.
MAN_EXTENSION = .3
# The MAN_SUBDIR tag determines the name of the directory created within
# MAN_OUTPUT in which the man pages are placed. If defaults to man followed by
# MAN_EXTENSION with the initial . removed.
# This tag requires that the tag GENERATE_MAN is set to YES.
MAN_SUBDIR =
# 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 value is: NO.
# This tag requires that the tag GENERATE_MAN is set to YES.
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.
# The default value is: NO.
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.
# The default directory is: xml.
# This tag requires that the tag GENERATE_XML is set to YES.
XML_OUTPUT = xml
# 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.
# The default value is: YES.
# This tag requires that the tag GENERATE_XML is set to YES.
XML_PROGRAMLISTING = YES
#---------------------------------------------------------------------------
# Configuration options related to the DOCBOOK output
#---------------------------------------------------------------------------
# If the GENERATE_DOCBOOK tag is set to YES doxygen will generate Docbook files
# that can be used to generate PDF.
# The default value is: NO.
GENERATE_DOCBOOK = NO
# The DOCBOOK_OUTPUT tag is used to specify where the Docbook pages will be put.
# If a relative path is entered the value of OUTPUT_DIRECTORY will be put in
# front of it.
# The default directory is: docbook.
# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
DOCBOOK_OUTPUT = docbook
# If the DOCBOOK_PROGRAMLISTING tag is set to YES doxygen will include the
# program listings (including syntax highlighting and cross-referencing
# information) to the DOCBOOK output. Note that enabling this will significantly
# increase the size of the DOCBOOK output.
# The default value is: NO.
# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
DOCBOOK_PROGRAMLISTING = NO
#---------------------------------------------------------------------------
# Configuration options for the AutoGen Definitions output
#---------------------------------------------------------------------------
# If the GENERATE_AUTOGEN_DEF tag is set to YES doxygen will generate an AutoGen
# Definitions (see http://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.
# The default value is: NO.
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.
# The default value is: NO.
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.
# The default value is: NO.
# This tag requires that the tag GENERATE_PERLMOD is set to YES.
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.
# The default value is: YES.
# This tag requires that the tag GENERATE_PERLMOD is set to YES.
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.
# This tag requires that the tag GENERATE_PERLMOD is set to YES.
PERLMOD_MAKEVAR_PREFIX =
#---------------------------------------------------------------------------
# Configuration options related to the preprocessor
#---------------------------------------------------------------------------
# If the ENABLE_PREPROCESSING tag is set to YES doxygen will evaluate all
# C-preprocessor directives found in the sources and include files.
# The default value is: YES.
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 only conditional compilation will be
# performed. Macro expansion can be done in a controlled way by setting
# EXPAND_ONLY_PREDEF to YES.
# The default value is: NO.
# This tag requires that the tag ENABLE_PREPROCESSING is set 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.
# The default value is: NO.
# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
EXPAND_ONLY_PREDEF = NO
# If the SEARCH_INCLUDES tag is set to YES the includes files in the
# INCLUDE_PATH will be searched if a #include is found.
# The default value is: YES.
# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
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.
# This tag requires that the tag SEARCH_INCLUDES is set to YES.
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.
# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
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 e.g.
# 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.
# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
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();" \
"itkFactorylessNewMacro(type)=static Pointer New();" \
"itkCloneMacro(type)=Pointer Clone() const;" \
"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 \
"US_PREPEND_NAMESPACE(x)=us::x" \
"US_BEGIN_NAMESPACE= namespace us {" \
"US_END_NAMESPACE=}" \
"US_BASECLASS_NAME=itk::LightObject" \
US_EXPORT= \
"DEPRECATED(func)=func" \
@US_PLATFORM@
# 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.
# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
EXPAND_AS_DEFINED =
# If the SKIP_FUNCTION_MACROS tag is set to YES 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. Such function macros
# are typically used for boiler-plate code, and will confuse the parser if not
# removed.
# The default value is: YES.
# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
SKIP_FUNCTION_MACROS = YES
#---------------------------------------------------------------------------
# Configuration options related to external references
#---------------------------------------------------------------------------
# The TAGFILES tag can be used to specify one or more tag files. For each tag
# file the location of the external documentation should be added. 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. See the
# section "Linking to external documentation" for more information about the use
# of tag files.
# Note: 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 =
# When a file name is specified after GENERATE_TAGFILE, doxygen will create a
# tag file that is based on the input files it reads. See section "Linking to
# external documentation" for more information about the usage of tag files.
GENERATE_TAGFILE = @MITK_DOXYGEN_TAGFILE_NAME@
# If the ALLEXTERNALS tag is set to YES all external class will be listed in the
# class index. If set to NO only the inherited external classes will be listed.
# The default value is: NO.
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.
# The default value is: YES.
EXTERNAL_GROUPS = NO
# If the EXTERNAL_PAGES tag is set to YES all external pages will be listed in
# the related pages index. If set to NO, only the current project's pages will
# be listed.
# The default value is: YES.
EXTERNAL_PAGES = YES
#---------------------------------------------------------------------------
# Configuration options related to the dot tool
#---------------------------------------------------------------------------
# If the CLASS_DIAGRAMS tag is set to YES doxygen will generate a class diagram
# (in HTML 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.
# The default value is: YES.
CLASS_DIAGRAMS = YES
# You can include diagrams made with dia in doxygen documentation. Doxygen will
# then run dia to produce the diagram and insert it in the documentation. The
# DIA_PATH tag allows you to specify the directory where the dia binary resides.
# If left empty dia is assumed to be found in the default search path.
DIA_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.
# The default value is: YES.
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 (see:
# http://www.graphviz.org/), 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 value is: NO.
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 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.
# Minimum value: 0, maximum value: 32, default value: 0.
# This tag requires that the tag HAVE_DOT is set to YES.
DOT_NUM_THREADS = @MITK_DOXYGEN_DOT_NUM_THREADS@
# When you want a differently looking font in the dot files that doxygen
# generates 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.
# The default value is: Helvetica.
# This tag requires that the tag HAVE_DOT is set to YES.
DOT_FONTNAME = Helvetica
# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
# dot graphs.
# Minimum value: 4, maximum value: 24, default value: 10.
# This tag requires that the tag HAVE_DOT is set to YES.
DOT_FONTSIZE = 10
# By default doxygen will tell dot to use the default font as specified with
# DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set
# the path where dot can find it using this tag.
# This tag requires that the tag HAVE_DOT is set to YES.
DOT_FONTPATH =
# If the CLASS_GRAPH tag is 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 CLASS_DIAGRAMS tag to NO.
# The default value is: YES.
# This tag requires that the tag HAVE_DOT is set to YES.
CLASS_GRAPH = YES
# If the COLLABORATION_GRAPH tag is 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.
# The default value is: YES.
# This tag requires that the tag HAVE_DOT is set to YES.
COLLABORATION_GRAPH = YES
# If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for
# groups, showing the direct groups dependencies.
# The default value is: YES.
# This tag requires that the tag HAVE_DOT is set to YES.
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.
# The default value is: NO.
# This tag requires that the tag HAVE_DOT is set to YES.
UML_LOOK = @MITK_DOXYGEN_UML_LOOK@
# If the UML_LOOK tag is enabled, the fields and methods are shown inside the
# class node. If there are many fields or methods and many nodes the graph may
# become too big to be useful. The UML_LIMIT_NUM_FIELDS threshold limits the
# number of items for each type to make the size more manageable. Set this to 0
# for no limit. Note that the threshold may be exceeded by 50% before the limit
# is enforced. So when you set the threshold to 10, up to 15 fields may appear,
# but if the number exceeds 15, the total amount of fields shown is limited to
# 10.
# Minimum value: 0, maximum value: 100, default value: 10.
# This tag requires that the tag HAVE_DOT is set to YES.
UML_LIMIT_NUM_FIELDS = 10
# If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and
# collaboration graphs will show the relations between templates and their
# instances.
# The default value is: NO.
# This tag requires that the tag HAVE_DOT is set to YES.
TEMPLATE_RELATIONS = YES
# If the INCLUDE_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES 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.
# The default value is: YES.
# This tag requires that the tag HAVE_DOT is set to YES.
INCLUDE_GRAPH = NO
# If the INCLUDED_BY_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES 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.
# The default value is: YES.
# This tag requires that the tag HAVE_DOT is set to YES.
INCLUDED_BY_GRAPH = NO
# If the CALL_GRAPH tag is 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.
# The default value is: NO.
# This tag requires that the tag HAVE_DOT is set to YES.
CALL_GRAPH = NO
# If the CALLER_GRAPH tag is 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.
# The default value is: NO.
# This tag requires that the tag HAVE_DOT is set to YES.
CALLER_GRAPH = NO
# If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical
# hierarchy of all classes instead of a textual one.
# The default value is: YES.
# This tag requires that the tag HAVE_DOT is set to YES.
GRAPHICAL_HIERARCHY = NO
# If the DIRECTORY_GRAPH tag is 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.
# The default value is: YES.
# This tag requires that the tag HAVE_DOT is set to YES.
DIRECTORY_GRAPH = YES
# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
# generated by dot.
# Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order
# to make the SVG files visible in IE 9+ (other browsers do not have this
# requirement).
# Possible values are: png, jpg, gif and svg.
# The default value is: png.
# This tag requires that the tag HAVE_DOT is set to YES.
DOT_IMAGE_FORMAT = png
# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
# enable generation of interactive SVG images that allow zooming and panning.
#
# Note that this requires a modern browser other than Internet Explorer. Tested
# and working are Firefox, Chrome, Safari, and Opera.
# Note: For IE 9+ you need to set HTML_FILE_EXTENSION to xhtml in order to make
# the SVG files visible. Older versions of IE do not have SVG support.
# The default value is: NO.
# This tag requires that the tag HAVE_DOT is set to YES.
INTERACTIVE_SVG = NO
# The DOT_PATH tag 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.
# This tag requires that the tag HAVE_DOT is set to YES.
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).
# This tag requires that the tag HAVE_DOT is set to YES.
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 DIAFILE_DIRS tag can be used to specify one or more directories that
# contain dia files that are included in the documentation (see the \diafile
# command).
DIAFILE_DIRS =
# When using plantuml, the PLANTUML_JAR_PATH tag should be used to specify the
# path where java can find the plantuml.jar file. If left blank, it is assumed
# PlantUML is not used or called during a preprocessing step. Doxygen will
# generate a warning when it encounters a \startuml command in this case and
# will not generate output for the diagram.
# This tag requires that the tag HAVE_DOT is set to YES.
PLANTUML_JAR_PATH =
# 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.
# Minimum value: 0, maximum value: 10000, default value: 50.
# This tag requires that the tag HAVE_DOT is set to YES.
DOT_GRAPH_MAX_NODES = 120
# 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.
# Minimum value: 0, maximum value: 1000, default value: 0.
# This tag requires that the tag HAVE_DOT is set to YES.
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).
# The default value is: NO.
# This tag requires that the tag HAVE_DOT is set to YES.
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.
# The default value is: NO.
# This tag requires that the tag HAVE_DOT is set to YES.
DOT_MULTI_TARGETS = NO
# If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page
# explaining the meaning of the various boxes and arrows in the dot generated
# graphs.
# The default value is: YES.
# This tag requires that the tag HAVE_DOT is set to YES.
GENERATE_LEGEND = YES
# If the DOT_CLEANUP tag is set to YES doxygen will remove the intermediate dot
# files that are used to generate the various graphs.
# The default value is: YES.
# This tag requires that the tag HAVE_DOT is set to YES.
DOT_CLEANUP = YES
diff --git a/Examples/Plugins/org.mitk.example.gui.extensionpointdefinition/schema/changetext.exsd b/Examples/Plugins/org.mitk.example.gui.extensionpointdefinition/schema/changetext.exsd
index 5e1acd1a18..341ac2a2e0 100644
--- a/Examples/Plugins/org.mitk.example.gui.extensionpointdefinition/schema/changetext.exsd
+++ b/Examples/Plugins/org.mitk.example.gui.extensionpointdefinition/schema/changetext.exsd
@@ -1,109 +1,85 @@
<?xml version='1.0' encoding='UTF-8'?>
<schema targetNamespace="org.mitk.example.extensionpointdefinition" xmlns="http://www.w3.org/2001/XMLSchema">
<annotation>
<appinfo>
<meta.schema plugin="org.mitk.example.extensionpointdefinition" id="changetext" name="Change Text of Label"/>
</appinfo>
- <documentation>
- This extension point is used as an example for the extension point declaration (BlueBerry examples).
- </documentation>
+
</annotation>
<element name="extension">
<complexType>
<sequence>
<element ref="changetext" minOccurs="0" maxOccurs="unbounded"/>
</sequence>
<attribute name="point" type="string" use="required">
<annotation>
- <documentation>
- a fully qualified identifier of the target extension point
- </documentation>
+
</annotation>
</attribute>
<attribute name="id" type="string">
<annotation>
- <documentation>
- an optional identifier of the extension instance
- </documentation>
+
</annotation>
</attribute>
<attribute name="name" type="string">
<annotation>
- <documentation>
- an optional name of the extension instance
- </documentation>
+
<appinfo>
<meta.attribute translatable="true"/>
</appinfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="changetext">
<complexType>
<sequence>
<element ref="description" minOccurs="0" maxOccurs="1"/>
</sequence>
<attribute name="id" type="string" use="required">
<annotation>
- <documentation>
- the identifier of the text changer
- </documentation>
+
</annotation>
</attribute>
<attribute name="name" type="string" use="required">
<annotation>
- <documentation>
- the name of the text changer
- </documentation>
+
<appinfo>
<meta.attribute translatable="true"/>
</appinfo>
</annotation>
</attribute>
<attribute name="class" type="string" use="required">
<annotation>
- <documentation>
- a fully qualified name of the class that implements
-<samp>IChangeText</samp>.
- </documentation>
+
</annotation>
</attribute>
</complexType>
</element>
<element name="description" type="string">
<annotation>
<appinfo>
<meta.element translatable="true"/>
</appinfo>
- <documentation>
- An optional subelement whose body should contain text providing a short description.
- </documentation>
+
</annotation>
</element>
<annotation>
<appinfo>
<meta.section type="apiInfo"/>
</appinfo>
- <documentation>
- The value of the <samp>class</samp> attribute must be a
-fully qualified name of the class that implements
-<samp>IChangeText</samp>.
- </documentation>
+
</annotation>
<annotation>
<appinfo>
<meta.section type="copyright"/>
</appinfo>
- <documentation>
- Copyright (c) German Cancer Research Center (DKFZ)<br>
-All rights reserved.
- </documentation>
+
</annotation>
</schema>
diff --git a/Modules/Chart/documentation/mitkChart.dox b/Modules/Chart/documentation/mitkChart.dox
index affdaa3755..52c41353eb 100644
--- a/Modules/Chart/documentation/mitkChart.dox
+++ b/Modules/Chart/documentation/mitkChart.dox
@@ -1,256 +1,256 @@
/**
\page ChartModule Chart Module
\tableofcontents
\section ChartModule_brief Description
The MITK chart module is able to show different types of charts in a widget with customizable labels.
\imageMacro{complexExample.png,"Example chart",10}
\subsection Chart_Technical Technical background
The module uses the java script library <a href="https://plot.ly/javascript/">plotly</a> to display the chart in a <a href="https://doc.qt.io/qt-5/qwebengineview.html">QWebEngineView</a> (that renders html/js content).
For examples, please visit https://plot.ly/javascript/.
\subsection Chart_GUI GUI
\note Be sure that the dependency to the Chart Module is resolved in the CMakeLists.txt of the plugin: <code>MODULE_DEPENDS MitkChart</code>.
Open the ui file of the plugin. Then add a widget (we always use the name <code>chartWidget</code> in the following) at the desired position. Change the class of the widget to a user-defined widget (right click → user defined classes, see https://doc.qt.io/qt-5/designer-using-custom-widgets.html). Set "QWidget" as base class. Set "QmitkChartWidget" as class name and "QmitkChartWidget.h" as include file.
\imageMacro{userDefinedWidget.png,"User defined widget",10}
\subsection Chart_data Data
The most important functionality is to add data to the chartWidget. Either one dimensional or two dimensional data can be used. One-dimensional data has the same interval between values on the x-axis (and no x-axis values) while the two-dimensional data has arbitrary x-axis difference values (and given x-axis values).
An example for one-dimensional data is the temperature for each month of a year: <code>std::vector<double> temperatureHD = {1.8, 3.1, 6.3, 10.2, 14.5, 17.4, 19.4, 18.9, 15.5, 11.2, 5.8, 2.6}</code>. The first entry corresponds (implicitly) to the temperature in january, two second to the temperature in february the last entry to the temperature in december. Thus, the x values have same intervals. The given temperature values are defined as y-axis values.
An example for two-dimensional data is the people living in a city in different years: <code>std::map<double,double> peopleHeidelberg={{1975, 129368 }, { 1985, 134724 },{ 1990, 136796 },{ 2010, 147312 }}.</code>
Thus, the x-values are given as their intervals are different (10 years, 5 years, 10 years). Each x value is connected to an y-value that represents the amount of people (1975 → 129368, 1985 → 134724, ...).
Data is added by calling <code>chartWidget->AddData1D(temperatureHD, "Heidelberg")</code> or <code>chartWidget->AddData2D(peopleHeidelberg, "Heidelberg")</code>, where the second argument is a label for the data entry.
\imageMacro{2DDataExample.png,"2D data example: Heidelberg has fewer entries and their x-range (years) is smaller than Freiburg",8}
As the data labels are used as identifier, they have to be unique. This is checked. If non-unique entries are entered, they are made unique by adding numbers. Example:
\code{.cpp}
chartWidget->AddData1D(temperatureHD, "Heidelberg")
chartWidget->AddData1D(temperatureOslo, "Heidelberg")
\endcode
will result in the labels "Heidelberg" and "Heidelberg0", whereas "Heidelberg0" refers to <code>temperatureOslo</code>.
If you want to add more data, just call <code>chartWidget->AddData1D(data, label, chartType)</code> or <code>chartWidget->AddData2D(data, label, chartType)</code> as often as desired. Then, call <code>chartWidget->Show()</code>. The ranges of x- and y-axis are adjusted automatically.
To delete single data entries, call <code>chartWidget->RemoveData(label)</code> and update the chart area with <code>chartWidget->Show()</code>. All data can be cleared by calling <code>chartWidget->Clear()</code>.
\subsection Chart_type Chart type
The default chart type is <code>bar</code>. To use a different type, you have to change it.
Seven chart types are available:
<ul>
<li> <code>bar</code>
<li> <code>line</code>
<li> <code>spline</code>
<li> <code>pie</code>
<li> <code>are</code>
<li> <code>area_spline</code>
<li> <code>scatter</code>
</ul>
See below examples of all types:
\imageMacro{barChartTemperature.png,"Example bar chart",4}
\imageMacro{lineChartTemperature.png,"Example line chart",4}
\imageMacro{splineChartTemperature.png,"Example spline chart",4}
\imageMacro{pieChartExample.png,"Example pie chart",4}
\imageMacro{areaChartTemperature.png,"Example area chart",4}
\imageMacro{areaSplineChartTemperature.png,"Example spline area chart",4}
\imageMacro{scatterChartTemperature.png,"Example scatter chart",4}
Call e.g. <code>chartWidget->SetChartType(label, QmitkChartWidget::ChartType::line)</code> for changing the chart type. Note that it is not directly displayed. To change the chart type for all data entries and display the result, call <code>chartWidget->SetChartTypeForAllDataAndReload(QmitkChartWidget::ChartType::line)</code>.
All chart types except pie chart can be also used mixed (different chart types in the same chart). Pie charts are handled differently. The input data sum is regarded as 100%. The values of all data entries are summed. Example:
\code{.cpp}
chartWidget->AddData1D({5}, "entry1", QmitkChartWidget::ChartType::pie);
chartWidget->AddData1D({2}, "entry2", QmitkChartWidget::ChartType::pie);
chartWidget->AddData1D({3}, "entry3", QmitkChartWidget::ChartType::pie);
\endcode
The pie chart has then entries of 50%, 20% and 30%. Calling <code>chartWidget->AddData1D({5,2,3}, "entry", QmitkChartWidget::ChartType::pie)</code> leads to a pie chart with one class having 100%. Calling
\code{.cpp}
chartWidget->AddData1D({2,2,1}, "entry1", QmitkChartWidget::ChartType::pie);
chartWidget->AddData1D({1,1}, "entry2", QmitkChartWidget::ChartType::pie);
chartWidget->AddData1D({3}, "entry3", QmitkChartWidget::ChartType::pie);
\endcode
leads to the first result again (50%, 20% and 30%) as entries are summed.
\warning pie charts differ significantly from the other chart types. Be aware of the differences.
\subsection Chart_labels Labels
Four labels can be set to custom strings. These are
<ul>
<li> the data labels,
<li> the x-axis label,
<li> the y-axis label and
<li> the title of the chart
</ul>
-Data labels provide the name for data legend entries ("Heidelberg" for our 1D data \ref{Chart_data} as it is the average temperature in Heidelberg) and are given by the second argument of AddData1D and AddData2D. They are also displayed in the legend. An example x-Axis and y-axis label would be <i>month</i> and <i>temperature</i>, respectively.
+Data labels provide the name for data legend entries ("Heidelberg" for our 1D data \ref Chart_data as it is the average temperature in Heidelberg) and are given by the second argument of AddData1D and AddData2D. They are also displayed in the legend. An example x-Axis and y-axis label would be <i>month</i> and <i>temperature</i>, respectively.
The data label argument is mandatory. All other labels are optional and empty strings by default.
<code>chartWidget->SetXAxisLabel("month")</code> and <code>chartWidget->SetYAxisLabel("temperature")</code> ensures the labeling of x- and y-Axis in the chart. No labels are defined as default.
<code>chartWidget->SetTitle("temperature chart")</code> adds a title to the chart.
\note The legend position (of data labels) can be set by <code>chartWidget->SetLegendPosition(QmitkChartWidget::LegendPosition::bottom)</code>.
\note To hide the legend, call <code>chartWidget->SetShowLegend(false)</code>.
\subsection Chart_show Displaying the chart
Finally, the chart is displayed by calling <code>chartWidget->Show(bool)</code>. If the optional parameter is set to true, a subchart is shown additionally. That's useful for ensuring the overview if the user wants to zoom in.
\subsection Chart_dataAttributes Changing visualization attributes of data
Besides the chart type, the following attributes of a data entry can be changed:
<ul>
<li>color,
<li>linesyle and
<li>data points shown
</ul>
this is done by referencing the data entry by its label (e.g. "Heidelberg" above): <code>chartWidget->SetColor("Heidelberg", "green")</code>, <code>chartWidget->SetColor("Heidelberg", "#FF4500")</code>, <code>chartWidget->SetLineStyle("Heidelberg", LineStyle::dashed)</code> and <code>chartWidget->SetShowDataPoints(false)</code>.
\note SetShowDataPoints is a global attribute and valid for all data entries due to technical reasons.
Colors are chosen automatically by plotly if not given. However, if some data entries have given colors and some have not, same colors may appear for different data entries. Color can be given as strings (natural names like <i>red</i> or hexadecimal numbers like \c \#FF0000 . For color selection, the following reference is helpful: https://www.w3schools.com/cssref/css_colors.asp)
Line style only can be set if ChartType is <code>QmitkChartWidget::ChartType::line</code>. It is ignored otherwise. Also, if a non-existing label is given, the command is ignored. The default linestyle is <code>LineStyle::solid</code>.
\section Chart_example Example
\subsection Chart_exampleBarChart Bar chart
To create and visualize a bar chart with two data sets, x/y-axis labels and data labels, the following code is used:
\code{.cpp}
std::vector<double> temperatureHD = {1.8, 3.1, 6.3, 10.2, 14.5, 17.4, 19.4, 18.9, 15.5, 11.2, 5.8, 2.6};
std::vector<double> temperatureOslo = {-4.3, -4, -0.2, 4.6, 10.8, 15.2, 16.4, 15.2, 10.8, 6.4, 0.7, -2.8};
chartWidget->AddData1D(temperatureHD, "Heidelberg", QmitkChartWidget::ChartType::bar);
chartWidget->AddData1D(temperatureOslo, "Oslo", QmitkChartWidget::ChartType::bar);
chartWidget->SetXAxisLabel("month");
chartWidget->SetYAxisLabel("temperature");
chartWidget->Show();
\endcode
The order when AddData1D() is called influences the colors of the bars and the order of the shown data. The third argument of <code>chartWidget->AddData1D()</code> is superfluous and only for completeness as <code>QmitkChartWidget::ChartType::bar</code> is the default chart type. After <code>Show()</code> is called, the chart is visualized.
The chart type for all data entries can be changed to spline and directly showed:
\code{.cpp}
chartWidget->SetChartTypeForAllDataAndReload(QmitkChartWidget::ChartType::spline);
\endcode
the equivalent code is:
\code{.cpp}
chartWidget->SetChartType("Heidelberg", QmitkChartWidget::ChartType::spline);
chartWidget->SetChartType("Oslo", QmitkChartWidget::ChartType::spline);
chartWidget->Show();
\endcode
The temperature of another city can be added:
\code{.cpp}
std::vector<double> temperatureRome = {8.1, 8.7, 8.7, 11.6, 18.8, 22.8, 25.4, 25.7, 21.4, 17.6, 12.6, 8.9};
chartWidget->AddData1D(temperatureRome, "Rome");
chartWidget->Show(true);
\endcode
As <code>Show(true)</code> is used, a subchart is shown.
\subsection Chart_examplePieChart Pie chart
A pie chart (the same as in \ref Chart_type ) can be generated with the following code:
\code{.cpp}
chartWidget->AddData1D({5}, "Heidelberg", QmitkChartWidget::ChartType::pie);
chartWidget->AddData1D({3}, "Oslo", QmitkChartWidget::ChartType::pie);
chartWidget->AddData1D({2}, "New York", QmitkChartWidget::ChartType::pie);
chartWidget->Show();
\endcode
\note Only one pie chart at a time can be displayed.
\subsection Chart_exampleMixedChart Mixed chart
Chart types and attributes like colors and line styles can be mixed as seen in the code example below (example result is the chart in \ref ChartModule_brief ):
\code{.cpp}
std::vector<double> temperatureHD = {1.8, 3.1, 6.3, 10.2, 14.5, 17.4, 19.4, 18.9, 15.5, 11.2, 5.8, 2.6};
std::vector<double> temperatureOslo = {-4.3, -4, -0.2, 4.6, 10.8, 15.2, 16.4, 15.2, 10.8, 6.4, 0.7, -2.8};
chartWidget->AddData1D(temperatureHD, "Heidelberg", QmitkChartWidget::ChartType::line);
chartWidget->AddData1D(temperatureOslo, "Oslo", QmitkChartWidget::ChartType::area);
chartWidget->SetColor("Heidelberg", "green");
chartWidget->SetColor("Oslo", "blue");
chartWidget->SetLineStyle("Heidelberg", QmitkChartWidget::LineStyle::dashed);
chartWidget->SetXAxisLabel("month");
chartWidget->SetYAxisLabel("temperature");
chartWidget->Show();
\endcode
\note Pie chart as chart type is an exception. Pie charts can't be displayed with other data entries having other chart types.
\subsection Chart_exampleRemoveData Removing data
Data also can be removed again (using the previous example \ref Chart_exampleMixedChart as base):
\code{.cpp}
chartWidget->RemoveData("Heidelberg");
chartWidget->Show();
\endcode
Only the date entries labeled "Oslo" remain.
Also all data can be removed:
\code{.cpp}
chartWidget->Clear();
chartWidget->Show();
\endcode
The chart is empty now.
\subsection Chart_example2DData Chart with 2D data
A line chart with two-dimensional data is the following example (the same as in \ref Chart_data ):
\code{.cpp}
std::map<double, double> peopleHD = { {1975, 129368 }, { 1985, 134724 },{ 1990, 136796 },{ 2010, 147312 } };
std::map<double, double> peopleFreiburg = { { 1969, 165960 },{ 1973, 174997 },{ 1982, 178545 },{ 2001, 208294 },{ 2015, 222203 } };
chartWidget->AddData2D(peopleHD, "Heidelberg", QmitkChartWidget::ChartType::line);
chartWidget->AddData2D(peopleFreiburg, "Freiburg", QmitkChartWidget::ChartType::line);
chartWidget->SetXAxisLabel("year");
chartWidget->SetYAxisLabel("people");
chartWidget->Show();
\endcode
Hence, 2D data is having the following assignment: year → people. In the vector peopleHD, four values are defined, in the vector peopleFreiburg, five values are defined. The defined years are different for Heidelberg (1975-2010) than for Freiburg (1969-2015).
\warning mixing AddData2D and AddData1D in a chart is strongly discouraged. It will work, however the visualization may be odd due to implicit and explicit given x values.
\subsection Chart_imageStatistics image statistics plugin
An example of the use of QmitkChartWidget in MITK can be found in the image statistics plugin. The \c chartWidget is named \c m_Controls->m_JSHistogram there.
*/
diff --git a/Modules/Chart/include/QmitkChartWidget.h b/Modules/Chart/include/QmitkChartWidget.h
index c3471ef820..a4276f1d2a 100644
--- a/Modules/Chart/include/QmitkChartWidget.h
+++ b/Modules/Chart/include/QmitkChartWidget.h
@@ -1,356 +1,358 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QmitkC3jsWidget_h
#define QmitkC3jsWidget_h
#include <map>
#include <memory>
#include <QWidget>
#include <MitkChartExports.h>
class QmitkChartxyData;
/*!
\brief QmitkChartWidget is a widget to display various charts based on the javascript chart library plotly.
* \details Data is added via AddData1D() or AddData2D().\n
* There can be multiple charts (of different types with different properties) created by calling AddData1D or AddData2D multiple times.\n\n
* The following chart types are supported:
* * line chart
* * bar chart
* * spline chart
* * pie chart
* * scatter chart
* * area chart
* * area spline chart.
*
* Technical details: The javascript code is embedded in a QWebEngineView. The actual js code is implemented in resource\Chart.js.
* \sa https://plot.ly/javascript/ for further information about the used javaScript library.
* \ingroup Modules/Chart
*/
class MITKCHART_EXPORT QmitkChartWidget : public QWidget
{
Q_OBJECT
public:
/*!
* \brief enum of diagram types.
*/
enum class ChartType {
bar, /*!< bar chart, see https://plot.ly/javascript/bar-charts/ */
line, /*!< line chart, see https://plot.ly/javascript/line-charts/ */
spline, /*!< spline chart (smoothed line chart), see https://plot.ly/~jduelfer/23/spline/#/ */
pie, /*!< pie chart, see https://plot.ly/javascript/pie-charts/ */
area, /*!< area chart, see https://plot.ly/javascript/filled-area-plots/ */
area_spline, /*!< area-spline chart, similar to https://plot.ly/~jduelfer/23/spline/#/ */
scatter /*!< scatter chart, see https://plot.ly/javascript/line-and-scatter/ */
};
/*!
* \brief enum of chart style (modifies background and line color).
*/
enum class ColorTheme {
darkstyle, /*!< background color: dark gray, foreground color: white*/
lightstyle /*!< background color: white, foreground color: black */
};
enum class LineStyle {
solid,
dashed
};
enum class MarkerSymbol {
circle,
diamond,
cross,
square,
pentagon,
star,
x,
diamond_tall,
star_diamond,
star_triangle_up,
star_triangle_down,
asterisk,
cross_thin,
x_thin
};
enum class ChartColor {
red,
orange,
yellow,
green,
blue,
purple,
brown,
magenta,
tan,
cyan,
olive,
maroon,
navy,
aquamarine,
turqouise,
silver,
lime,
teal,
indigo,
violet,
pink,
black,
white,
grey
};
enum class AxisScale {
linear,
log
};
/*!
* \brief enum of legend position.
* See https://plot.ly/javascript/legend/
*/
enum class LegendPosition {
bottomMiddle,
bottomRight,
topRight,
topLeft,
middleRight
};
explicit QmitkChartWidget(QWidget* parent = nullptr);
//for UnitTests
explicit QmitkChartWidget(QWidget *parent, bool unitTest);
~QmitkChartWidget() override;
/*!
* \brief Adds 1D data to the widget
* \details internally, the list is converted to a map with increasing integers keys starting at 0.
+ * \param data1D
* \param label the name of the data that is also used as identifier.
* \param chartType the chart type that should be used for this data entry
* \note the data can be cleared with ClearDiagram()
* \note If the label name already exists, the name is replaced with a unique one by concatenating numbers to it.
* \warning Pie chart is significantly different than the other chart types. Here, the data given by AddData1D is summed. Each entry represents a different category.
*/
void AddData1D(const std::vector<double>& data1D, const std::string& label, ChartType chartType = ChartType::bar);
/*!
* \brief Updates data of an existing label
* \param data1D the 1D data , \sa AddData1D
* \param label the (existing) label
* \note if the label does not exist, nothing happens
*/
void UpdateData1D(const std::vector<double> &data1D, const std::string &label);
/*!
* \sa UpdateData1D
* \sa AddData2D
*/
void UpdateData2D(const std::vector< std::pair<double, double> > &data2D, const std::string &label);
void UpdateChartExampleData(const std::vector< std::pair<double, double> >& data2D,
const std::string& label,
const std::string& type,
const std::string& color,
const std::string& lineStyle,
const std::string& pieLabelsData = 0);
/*!
* \brief Adds 2D data to the widget. Call repeatedly for displaying multiple charts.
* \details each entry represents a data point: key: value --> x-value: y-value.
+ * \param data2D
* \param label the name of the data that is also used as identifier.
* \param chartType the chart type that should be used for this data entry
* \note the data can be cleared with ClearDiagram()
* \note If the label name already exists, the name is replaced with a unique one by concatenating numbers to it.
* \warning Pie chart is significantly different than the other chart types. Here, the data given by AddData1D is summed. Each entry represents a different category.
*/
void AddData2D(const std::vector< std::pair<double, double> > &data2D,
const std::string &label,
ChartType chartType = ChartType::bar);
//Add Function for the ChartExample
void AddChartExampleData(const std::vector< std::pair<double, double> >& data2D,
const std::string& label,
const std::string& type,
const std::string& color,
const std::string& style,
const std::string& pieLabelsData = 0);
/*!
* \brief Removes data from the widget, works for 1D and 2D Data
* \param label the name of the data that is also used as identifier.
* \note All data can be cleared with ClearDiagram()
* \throws Invalid Argument Exception when the label cannot be found
*/
void RemoveData(const std::string& label);
void UpdateLabel(const std::string& existingLabel, const std::string& newLabel);
QmitkChartxyData *GetDataElementByLabel(const std::string& label) const;
/*!
* \brief Sets the color of one data entry (identifier is previously assigned label)
- * \details the color name can be "red" or a hex number (#FF0000).
+ * \details the color name can be "red" or a hex number (\c \#FF0000 ).
* \warning Either define all data entries with a color or no data entry. If a mixed approach is used,
* plotly choses the color of the data entry (that could be the same as a user defined color).
* \note If an unknown label is given, nothing happens.
* \sa https://www.w3schools.com/cssref/css_colors.asp
*/
void SetColor(const std::string& label, const std::string& colorName);
/*!
* \brief Sets the line style of one data entry (identifier is previously assigned label)
* \details two line styles are possible: LineStyle::solid and LineStyle::dashed.
* The default line style is solid.
* \note If an unknown label is given, nothing happens.
* \warning only sets the line style if the current chart type is ChartType::line.
* However, the line style remains also if the chart changes (e.g. new chart type)
*/
void SetLineStyle(const std::string& label, LineStyle style);
/*!
* \brief Sets the marker style of one data entry (identifier is previously assigned label)
* \note If an unknown label is given, nothing happens.
*/
void SetMarkerSymbol(const std::string &label, MarkerSymbol symbol);
/*!
* \brief Sets the axis scale to either linear (default) or logarithmic.
* \sa https://plot.ly/javascript/log-plot/
*/
void SetYAxisScale(AxisScale scale);
void SetXAxisLabel(const std::string& label);
void SetYAxisLabel(const std::string& label);
/*!
* \brief Sets labels for pie chart data.
* \note in AddData1D, the label still has to be given that acts as a unique id. However, the label is omitted then.
*/
void SetPieLabels(const std::vector<std::string> &pieLabels, const std::string &label);
/*!
* \brief Sets a title for the chart.
*/
void SetTitle(const std::string &title);
/*!
* \brief Sets the chart type for a data entry
* \details for available types, see ChartType
* \note If an unknown label is given, nothing happens.
* \warning Pie chart is significantly different than the other chart types. Here, the data given by AddData1D is summed. Each entry represents a different category.
* \sa DiagramType for available types
*/
void SetChartType(const std::string& label, ChartType type);
/*!
* \brief Sets error bars for data in x direction
* \note If only error plus is provided, the error bars are symmetrical
* \param label the name of the data that is also used as identifier.
* \param errorPlus the error in positive direction
* \param errorMinus the error in negative direction. Same as error plus if omitted
*/
void SetXErrorBars(const std::string &label, const std::vector<double> &errorPlus, const std::vector<double>& errorMinus = std::vector<double>());
/*!
* \brief Sets error bars for data in y direction
* \details for parameters, see SetXErrorBars
* \note If only error plus is provided, the error bars are symmetrical
*/
void SetYErrorBars(const std::string &label, const std::vector<double> &errorPlus, const std::vector<double> &errorMinus = std::vector<double>());
/*!
* \brief Sets the legend position.
* \details Default position is bottom.
* \sa LegendPosition for available types
*/
void SetLegendPosition(LegendPosition position);
void SetShowLegend(bool show);
void SetStackedData(bool stacked);
/*!
* \brief Displays the chart in the widget
* \param showSubChart if a subchart is displayed inside the widget or not.
* \note if no data has been provided, (\sa AddData1D AddData2D), an empty chart is displayed.
*/
void Show(bool showSubChart=false);
/*!
* \brief Either displays the dataPoints or not
* \param showDataPoints if dataPoints are displayed inside the widget or not.
* \details: example for not showing points: https://plot.ly/javascript/line-charts/#styling-line-plot
* example for showing the points: https://plot.ly/javascript/pointcloud/
*/
void SetShowDataPoints(bool showDataPoints);
/*!
* \brief Clears all data inside and resets the widget.
*/
void Clear();
/*!
* \brief Sets the theme of the widget.
* \details default is dark theme as in MITK.
* \warning has to be called before Show() or Reload() to work
*/
void SetTheme(ColorTheme themeEnabled);
/*!
* \brief Sets whether the subchart shall be shown.
* \details Changes the state of the current chart object.
* \note Needs to be reloaded with Reload() to display changes.
*/
void SetShowSubchart(bool showSubChart);
/*!
* \brief Sets whether the error bars shall be shown.
* \details Changes the state of the current chart object.
* \note Needs to be reloaded with Reload() to display changes.
* \param showErrorBars if error bars are displayed or not.
*/
void SetShowErrorBars(bool showErrorBars);
/*!
* \brief Sets the min and max x values of the chart
* \details Zooms in to view the values between minValue and maxValue in x direction
*/
void SetMinMaxValueXView(double minValueX,double maxValueX);
/*!
* \brief Sets the min and max y values of the chart
* \details Zooms in to view the values between minValue and maxValue in y direction
*/
void SetMinMaxValueYView(double minValueY, double maxValueY);
/*!
* \brief Reloads the chart in the widget
* \details reloading may be needed to display added data in an existing chart
*/
void Reload();
QSize sizeHint() const override;
void SavePlotAsImage();
public slots:
void OnLoadFinished(bool isLoadSuccessful);
void OnPageSuccessfullyLoaded();
signals:
void PageSuccessfullyLoaded();
private:
/*! source: https://stackoverflow.com/questions/29383/converting-bool-to-text-in-c*/
std::string convertBooleanValue(bool value) const;
class Impl;
std::unique_ptr<Impl> m_Impl;
};
#endif
diff --git a/Modules/CommandLine/include/mitkCommandLineParser.h b/Modules/CommandLine/include/mitkCommandLineParser.h
index f5c1418d5e..ddba149101 100644
--- a/Modules/CommandLine/include/mitkCommandLineParser.h
+++ b/Modules/CommandLine/include/mitkCommandLineParser.h
@@ -1,389 +1,392 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
/*=========================================================================
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 __mitkCommandLineParser_h
#define __mitkCommandLineParser_h
#include <map>
#include <usAny.h>
#include <MitkCommandLineExports.h>
#include <mitkVersion.h>
/**
*
* The MITK command line parser, based on 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>Create a help text for the command line arguments with support for
* grouping arguments.</li>
* </ul>
*
* The main difference between the MITK command line parser and the CTK command line
* parser is that the former does not depend on Qt. Apart from that an image type was
* added and XML output improved for automatic GUI generation.
*
* std::out is used for output to keep dependencies to a minimum.
*/
class MITKCOMMANDLINE_EXPORT mitkCommandLineParser
{
public:
enum Type
{
String = 0,
Bool = 1,
StringList = 2,
Int = 3,
Float = 4,
Directory = 5,
File = 6,
Image = 7
};
enum Channel
{
None = 0,
Input = 1,
Output = 2
};
typedef std::vector<std::string> StringContainerType;
mitkCommandLineParser();
~mitkCommandLineParser();
/**
* Parse a given list of command line arguments.
*
* This method parses a list of string 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 map object is returned.
*
* The keys in the returned map object correspond to the long argument string,
* if it is not empty. Otherwise, the short argument string is used as key. The
* us::Any values can safely be converted to the type specified in the
* <code>addArgument()</code> method call.
*
* @param arguments A StringContainerType containing command line arguments.
* @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 map object mapping the long argument (if empty, the short one)
* to a us::Any containing the value.
*/
std::map<std::string, us::Any> parseArguments(const StringContainerType &arguments, bool *ok = nullptr);
/**
* Convenient method allowing to parse a given list of command line arguments.
* @see parseArguments(const StringContainerType &, bool*)
*/
std::map<std::string, us::Any> parseArguments(int argc, char **argv, bool *ok = nullptr);
/**
* 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 StringContainerType&, bool*)
*/
std::string 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 StringContainerType &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.
*/
bool argumentAdded(const std::string &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.
*/
bool argumentParsed(const std::string &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>us::Any::String</td><td>1</td><td>.*</td><td>--test-string StringParameter</td></tr>
* <tr><td>us::Any::Bool</td><td>0</td><td>does not apply</td><td>--enable-something</td></tr>
* <tr><td>us::Any::StringList</td><td>-1</td><td>.*</td><td>--test-list string1 string2</td></tr>
* <tr><td>us::Any::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 us::Any 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 argLabel The label of this argument, when auto generated interface is used.
* @param argHelp A help string describing the argument.
* @param defaultValue A default value for the argument.
+ * @param optional
* @param ignoreRest All arguments after the current one will be ignored.
* @param deprecated Declares the argument deprecated.
+ * @param channel
*
* @see setExactMatchRegularExpression()
* @see addDeprecatedArgument()
* @throws std::logic_error If the us::Any type of <code>defaultValue</code>
* does not match <code>type</code>, a <code>std::logic_error</code> is thrown.
*/
void addArgument(const std::string &longarg,
const std::string &shortarg,
Type type,
const std::string &argLabel,
const std::string &argHelp = std::string(),
const us::Any &defaultValue = us::Any(),
bool optional = true,
bool ignoreRest = false,
bool deprecated = false,
mitkCommandLineParser::Channel channel = mitkCommandLineParser::Channel::None);
/**
* 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 argLabel
* @param argHelp A help string describing alternatives to the deprecated argument.
*/
void addDeprecatedArgument(const std::string &longarg,
const std::string &shortarg,
const std::string &argLabel,
const std::string &argHelp);
/**
* Returns the vector of current Command line Parameter
*
*/
std::vector < std::map<std::string, us::Any> > getArgumentList();
/**
* 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 std::string &argument,
const std::string &expression,
const std::string &exactMatchFailedMessage);
/**
* The field width for the argument names without the help text.
*
* @return The argument names field width in the help text.
*/
std::string::size_type 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.
*/
std::string helpText() 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 mitkCommandLineParser 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", us::Any::String);
* StringContainerType 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 std::string &longPrefix, const std::string &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 std::string &description);
/**
* Ends the current group.
*
* @see beginGroup(const std::string&)
*/
void endGroup();
/**
* 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 StringContainerType &, bool*)
*/
void setStrictModeEnabled(bool strictMode);
/**
* Is used to generate an XML output for any commandline program.
*/
void generateXmlOutput();
/**
* Is used to set the title of the auto generated interface.
*
* @param title The title of the app.
*/
void setTitle(std::string title);
/**
* Is used to set the contributor for the help view in the auto generated interface.
*
* @param contributor Contributor of the app.
*/
void setContributor(std::string contributor);
/**
* Is used to categorize the apps in the commandline module.
*
* @param category The category of the app.
*/
void setCategory(std::string category);
/**
* Is used as the help text in the auto generated interface.
*
* @param description A short description for the app.
*/
void setDescription(std::string description);
/**
* Is used to group several Parameters in one groupbox in the auto generated interface.
* Default name is "Parameters", with the tooltip: "Groupbox containing parameters."
*
* To change the group of several arguments, call this method before the arguments are added.
*
* @param name The name of the groupbox.
* @param tooltip The tooltip of the groupbox.
*/
void changeParameterGroup(std::string name, std::string tooltip);
protected:
class ctkInternal;
ctkInternal *Internal;
std::string Title;
std::string Contributor;
std::string Category;
std::string Description;
std::string ParameterGroupName;
std::string ParameterGroupDescription;
};
#endif
diff --git a/Modules/Core/TestingHelper/include/mitkTestingMacros.h b/Modules/Core/TestingHelper/include/mitkTestingMacros.h
index 8607ec8906..f838eeffe0 100644
--- a/Modules/Core/TestingHelper/include/mitkTestingMacros.h
+++ b/Modules/Core/TestingHelper/include/mitkTestingMacros.h
@@ -1,391 +1,392 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef mitkTestingMacros_h
#define mitkTestingMacros_h
#include <exception>
#include <iostream>
#include <string>
#include <itkMacro.h>
#include <mitkException.h>
#include <mitkTestNotRunException.h>
#include <mitkTestCaller.h>
#include <mitkTestManager.h>
#include <cppunit/extensions/HelperMacros.h>
#include <cppunit/ui/text/TestRunner.h>
namespace mitk
{
/** @brief Indicate a failed test. */
class TestFailedException : public std::exception
{
public:
TestFailedException() {}
};
}
/**
* @brief Output some text without generating a terminating newline. Include
*
* @ingroup MITKTestingAPI
*/
#define MITK_TEST_OUTPUT_NO_ENDL(x) std::cout x;
/**
* @brief Output some text.
*
* @ingroup MITKTestingAPI
*/
#define MITK_TEST_OUTPUT(x) MITK_TEST_OUTPUT_NO_ENDL(x << "\n")
/**
* @brief Do some general test preparations. Must be called first in the
* main test function.
*
* @deprecatedSince{2013_09} Use MITK_TEST_SUITE_REGISTRATION instead.
* @ingroup MITKTestingAPI
*/
#define MITK_TEST_BEGIN(testName) \
std::string mitkTestName(#testName); \
mitk::TestManager::GetInstance()->Initialize(); \
try \
{
/**
* @brief Fail and finish test with message MSG
*
* @deprecatedSince{2013_09} Use CPPUNIT_FAIL instead
* @ingroup MITKTestingAPI
*/
#define MITK_TEST_FAILED_MSG(MSG) \
MITK_TEST_OUTPUT(MSG) \
throw mitk::TestFailedException();
/**
* @brief Must be called last in the main test function.
*
* @deprecatedSince{2013_09} Use MITK_TEST_SUITE_REGISTRATION instead.
* @ingroup MITKTestingAPI
*/
#define MITK_TEST_END() \
} \
catch (const mitk::TestFailedException &) \
{ \
MITK_TEST_OUTPUT(<< "Further test execution skipped.") \
mitk::TestManager::GetInstance()->TestFailed(); \
} \
catch (const std::exception &ex) \
{ \
MITK_TEST_OUTPUT(<< "std::exception occured " << ex.what()) \
mitk::TestManager::GetInstance()->TestFailed(); \
} \
if (mitk::TestManager::GetInstance()->NumberOfFailedTests() > 0) \
{ \
MITK_TEST_OUTPUT(<< mitkTestName << ": [DONE FAILED] , subtests passed: " \
<< mitk::TestManager::GetInstance()->NumberOfPassedTests() \
<< " failed: " \
<< mitk::TestManager::GetInstance()->NumberOfFailedTests()) \
return EXIT_FAILURE; \
} \
else \
{ \
MITK_TEST_OUTPUT(<< mitkTestName << ": " << mitk::TestManager::GetInstance()->NumberOfPassedTests() \
<< " tests [DONE PASSED]") \
return EXIT_SUCCESS; \
}
/**
* @deprecatedSince{2013_09} Use CPPUNIT_ASSERT or CPPUNIT_ASSERT_MESSAGE instead.
*/
#define MITK_TEST_CONDITION(COND, MSG) \
MITK_TEST_OUTPUT_NO_ENDL(<< MSG) \
if (!(COND)) \
{ \
mitk::TestManager::GetInstance()->TestFailed(); \
MITK_TEST_OUTPUT(<< " [FAILED]\n" \
<< "In " \
<< __FILE__ \
<< ", line " \
<< __LINE__ \
<< ": " #COND " : [FAILED]") \
} \
else \
{ \
MITK_TEST_OUTPUT(<< " [PASSED]") \
mitk::TestManager::GetInstance()->TestPassed(); \
}
/**
* @deprecatedSince{2013_09} Use CPPUNIT_ASSERT or CPPUNIT_ASSERT_MESSAGE instead.
*/
#define MITK_TEST_CONDITION_REQUIRED(COND, MSG) \
MITK_TEST_OUTPUT_NO_ENDL(<< MSG) \
if (!(COND)) \
{ \
MITK_TEST_FAILED_MSG(<< " [FAILED]\n" \
<< " +--> in " \
<< __FILE__ \
<< ", line " \
<< __LINE__ \
<< ", expression is false: \"" #COND "\"") \
} \
else \
{ \
MITK_TEST_OUTPUT(<< " [PASSED]") \
mitk::TestManager::GetInstance()->TestPassed(); \
}
/**
* \brief Begin block which should be checked for exceptions
*
* @deprecatedSince{2013_09} Use CPPUNIT_ASSERT_THROW instead.
* @ingroup MITKTestingAPI
*
* This macro, together with MITK_TEST_FOR_EXCEPTION_END, can be used
* to test whether a code block throws an expected exception. The test FAILS if the
* exception is NOT thrown. A simple example:
*
MITK_TEST_FOR_EXCEPTION_BEGIN(itk::ImageFileReaderException)
typedef itk::ImageFileReader< itk::Image<unsigned char,2> > ReaderType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName("/tmp/not-existing");
reader->Update();
MITK_TEST_FOR_EXCEPTION_END(itk::ImageFileReaderException)
*
*/
#define MITK_TEST_FOR_EXCEPTION_BEGIN(EXCEPTIONCLASS) \
try \
{
/**
* @deprecatedSince{2013_09}
*/
#define MITK_TEST_FOR_EXCEPTION_END(EXCEPTIONCLASS) \
mitk::TestManager::GetInstance()->TestFailed(); \
MITK_TEST_OUTPUT(<< "Expected an '" << #EXCEPTIONCLASS << "' exception. [FAILED]") \
} \
catch (const EXCEPTIONCLASS &) \
{ \
MITK_TEST_OUTPUT(<< "Caught an expected '" << #EXCEPTIONCLASS << "' exception. [PASSED]") \
mitk::TestManager::GetInstance()->TestPassed(); \
}
/**
* @brief Simplified version of MITK_TEST_FOR_EXCEPTION_BEGIN / END for
* a single statement
*
* @deprecatedSince{2013_09} Use CPPUNIT_ASSERT_THROW instead.
* @ingroup MITKTestingAPI
*/
#define MITK_TEST_FOR_EXCEPTION(EXCEPTIONCLASS, STATEMENT) \
MITK_TEST_FOR_EXCEPTION_BEGIN(EXCEPTIONCLASS) \
STATEMENT; \
MITK_TEST_FOR_EXCEPTION_END(EXCEPTIONCLASS)
/**
* @brief Testing macro to test if two objects are equal.
*
* @ingroup MITKTestingAPI
*
* This macro uses mitk::eps and the corresponding mitk::Equal methods for all
* comparisons and will give verbose output on the dashboard/console.
* Feel free to implement mitk::Equal for your own datatype or purpose.
*
* @param EXPECTED First object.
* @param ACTUAL Second object.
* @param MSG Message to appear with the test.
* @throw Throws mitkException if a nullptr pointer is given as input.
*/
#define MITK_ASSERT_EQUAL(EXPECTED, ACTUAL, MSG) \
if (((EXPECTED).IsNull()) || ((ACTUAL).IsNull())) \
{ \
mitkThrow() << "mitk::Equal does not work with nullptr pointer input."; \
} \
CPPUNIT_ASSERT_MESSAGE(MSG, mitk::Equal(*(EXPECTED), *(ACTUAL), mitk::eps, true))
/**
* @brief Testing macro to test if two objects are not equal.
*
* @ingroup MITKTestingAPI
*
* This macro uses mitk::eps and the corresponding mitk::Equal methods for all
* comparisons and will give verbose output on the dashboard/console.
*
* @deprecatedSince{2013_09} Use MITK_ASSERT_NOT_EQUAL instead.
*
* @param OBJ1 First object.
* @param OBJ2 Second object.
* @param MSG Message to appear with the test.
*
* \sa MITK_TEST_EQUAL
*/
#define MITK_TEST_NOT_EQUAL(OBJ1, OBJ2, MSG) \
CPPUNIT_ASSERT_MESSAGE(MSG, !mitk::Equal(*(OBJ1), *(OBJ2), mitk::eps, true))
/**
* @brief Testing macro to test if two objects are not equal.
*
* @ingroup MITKTestingAPI
*
* This macro uses mitk::eps and the corresponding mitk::Equal methods for all
* comparisons and will give verbose output on the dashboard/console.
*
* @param OBJ1 First object.
* @param OBJ2 Second object.
* @param MSG Message to appear with the test.
* @throw Throws mitkException if a nullptr pointer is given as input.
*
* \sa MITK_ASSERT_EQUAL
*/
#define MITK_ASSERT_NOT_EQUAL(OBJ1, OBJ2, MSG) \
if (((OBJ1).IsNull()) || ((OBJ2).IsNull())) \
{ \
mitkThrow() << "mitk::Equal does not work with nullptr pointer input."; \
} \
CPPUNIT_ASSERT_MESSAGE(MSG, !mitk::Equal(*(OBJ1), *(OBJ2), mitk::eps, true))
/**
* @brief Registers the given test suite.
*
* @ingroup MITKTestingAPI
*
* @param TESTSUITE_NAME The name of the test suite class, without "TestSuite"
* at the end.
*/
#define MITK_TEST_SUITE_REGISTRATION(TESTSUITE_NAME) \
int TESTSUITE_NAME##Test(int /*argc*/, char * /*argv*/ []) \
{ \
int result = 0; \
try \
{ \
CppUnit::TextUi::TestRunner runner; \
runner.addTest(TESTSUITE_NAME##TestSuite::suite()); \
result = runner.run() ? 0 : 1; \
} \
catch (const mitk::TestNotRunException& e) \
{ \
MITK_WARN << "Test not run: " << e.GetDescription(); \
result = 77; \
} \
return result; \
}
/**
* @brief Adds a test to the current test suite.
*
* @ingroup MITKTestingAPI
*
* Use this macro after the CPPUNIT_TEST_SUITE() macro to add test cases.
* The macro internally just calls the CPPUNIT_TEST macro.
*
* @param TESTMETHOD The name of the member funtion test.
*/
#define MITK_TEST(TESTMETHOD) CPPUNIT_TEST(TESTMETHOD)
/**
* @brief Adds a parameterized test to the current test suite.
*
* @ingroup MITKTestingAPI
*
* Use this macro after the CPPUNIT_TEST_SUITE() macro to add test cases
* which need custom parameters.
*
* @param TESTMETHOD The name of the member function test.
* @param ARGS A std::vector<std::string> object containing test parameter.
*
* @note Use the macro MITK_PARAMETERIZED_TEST only if you know what
* you are doing. If you are not sure, use MITK_TEST instead.
*/
#define MITK_PARAMETERIZED_TEST(TESTMETHOD, ARGS) \
\
{ \
std::string testName = #TESTMETHOD; \
for (std::size_t i = 0; i < ARGS.size(); ++i) \
{ \
testName += "_" + ARGS[i]; \
} \
CPPUNIT_TEST_SUITE_ADD_TEST((new mitk::TestCaller<TestFixtureType>( \
context.getTestNameFor(testName), &TestFixtureType::TESTMETHOD, context.makeFixture(), args))); \
}
/**
* @brief Adds a parameterized test to the current test suite.
*
* @ingroup MITKTestingAPI
*
* Use this macro after the CPPUNIT_TEST_SUITE() macro to add test cases
* which need parameters from the command line.
*
* @warning Use the macro MITK_PARAMETERIZED_CMD_LINE_TEST only
* if you know what you are doing. If you are not sure, use
* MITK_TEST instead. MITK_PARAMETERIZED_CMD_LINE_TEST is meant
* for migrating from ctest to CppUnit. If you implement new
* tests, the MITK_TEST macro will be sufficient.
*
* @param TESTMETHOD The name of the member function test.
*/
#define MITK_PARAMETERIZED_CMD_LINE_TEST(TESTMETHOD) \
CPPUNIT_TEST_SUITE_ADD_TEST((new mitk::TestCaller<TestFixtureType>( \
context.getTestNameFor(#TESTMETHOD), &TestFixtureType::TESTMETHOD, context.makeFixture())));
/**
* @brief Adds a parameterized test to the current test suite.
*
* @ingroup MITKTestingAPI
*
* Use this macro after the CPPUNIT_TEST_SUITE() macro to add test cases
* which need one custom parameter.
*
* @param TESTMETHOD The name of the member function test.
* @param arg1 A custom string parameter being passed to the fixture.
*
* @note Use the macro MITK_PARAMETERIZED_TEST_1 only if you know what
* you are doing. If you are not sure, use MITK_TEST instead.
*
* @see MITK_PARAMETERIZED_TEST
*/
#define MITK_PARAMETERIZED_TEST_1(TESTMETHOD, arg1) \
\
{ \
std::vector<std::string> args; \
args.push_back(arg1); \
MITK_PARAMETERIZED_TEST(TESTMETHOD, args) \
}
/**
* @brief Adds a parameterized test to the current test suite.
*
* @ingroup MITKTestingAPI
*
* Use this macro after the CPPUNIT_TEST_SUITE() macro to add test cases
* which need two custom parameter.
*
* @param TESTMETHOD The name of the member function test.
* @param arg1 A custom string parameter being passed to the fixture.
+ * @param arg2
*
* @note Use the macro MITK_PARAMETERIZED_TEST_2 only if you know what
* you are doing. If you are not sure, use MITK_TEST instead.
*
* @see MITK_PARAMETERIZED_TEST
*/
#define MITK_PARAMETERIZED_TEST_2(TESTMETHOD, arg1, arg2) \
\
{ \
std::vector<std::string> args; \
args.push_back(arg1); \
args.push_back(arg2); \
MITK_PARAMETERIZED_TEST(TESTMETHOD, args) \
}
#endif
diff --git a/Modules/Core/doc/Doxygen/ModuleAdaptors.dox b/Modules/Core/doc/Doxygen/ModuleAdaptors.dox
index de2854d62b..7b94a57e62 100644
--- a/Modules/Core/doc/Doxygen/ModuleAdaptors.dox
+++ b/Modules/Core/doc/Doxygen/ModuleAdaptors.dox
@@ -1,139 +1,139 @@
/**
\defgroup Adaptor Adaptor Classes
\ingroup ProcessAdaptor
\brief This subcategory includes adaptor classes for the integration of algorithms from
other toolkits, especially ITK.
The task of most of the classes in this category is to deal with the conversion between
the (templated) itk::Image and the (not-templated) mitk::Image.
Methods for conversion are provided for both directions:
\li \ref MitkToItk
\li \ref ItkToMitk
Care has to be taken regarding the involved coordinate systems, see \ref ItkToMitkCoordinateSystems.
For limitations on ITK-type conversion see the section \ref ModuleAdaptorLimitations.
VTK-based access to MITK images is straightforward: simply ask your mitk::Image for a
\a vtkImageData by calling Image:GetVtkImageData. Similarily, to get a \a vtkPolyData
from the MITK class for storing surfaces, mitk::Surface, call Surface::GetVtkPolyData.
\section MitkToItk MITK to ITK adaptors
Pixel type and dimension of MITK images can be specified at run time whereas ITK images
are templated over the pixel type and the dimension, thus in ITK both need to be specified
at compile time.
There two different situations, which are covered in the following sub-sections:
\li Either you know the pixel type/dimension the ITK image should have at compile time for
some reason (e.g., you always create MITK images of a specific pixel type/dimension)
\li or the pixel type/dimension of an MITK image is really unkown and the ITK image should
have the same (unkown) type.
\subsection MitkToFixedItk Converting MITK images to ITK images with known type
If you know the type (pixel type and dimension) of the MITK image you have two options:
\li mitk::ImageToItk<TOutputImage>: is a process class that takes an mitk::Image as input
and produces an itk::Image of the given type \a TOutputImage as output (to be accessed
using \a GetOutput()). In case the MITK image does not have the same type as
\a TOutputImage an exception will be thrown.
\li mitk::CastToItkImage: this function has two parameters, the mitk::Image (input) and a
smartpointer to an itk::Image (output, does not need to be initialized). In case the
MITK image does not have the same type as the ITK image it will be casted
(if possible; done via itk::CastImageFilter).
Thus, mitk::CastToItkImage is the more powerful variant: here it is sufficient that you know
what you want to have (the ITK data type), to which the MITK image will be casted, if needed.
\subsection MitkToUnkownItk Accessing an MITK image as an ITK image (type unkown)
If you do not know the pixel type/dimension of an MITK image in advance and the ITK image should
have the same (unkown) type, e.g., to run a filter on the MITK image data, we cannot really convert
to one ITK image. This is simply, because we cannot instantiate an itk::Image object with unkown
pixel type/dimension.
Nevertheless, MITK provides a way to access an MITK image as if it was an ITK image of unkown type.
To do so, first define an access method, which is templated as an ITK image is:
\code
template<typename TPixel, unsigned int VImageDimension>
MyAccessMethod(itk::Image<TPixel, VImageDimension>* itkImage)
{
...
}
\endcode
If you don't understand this template syntax, we need to refer you to an C++ text book. Understanding
template syntax is crucial to successfully using ITK.
To call this templated method with an (untemplated) mitk::Image, you can use the #AccessByItk macro
(or one of its variants) from mitkImageAccessByItk.h. This macro checks for the actual image type of
the mitk::Image and does any neccessary conversions. This works for all configured pixel types (default
is char, unsigned char, short, unsigned short, int, unsigned int, float, and double) and dimensions
(default is 2 and 3). You can change the considered default pixel types and dimensions by modifying
the CMake variables MITK_ACCESSBYITK_*.
\code
AccessByItk(mitkImage, MyAccessMethod)
\endcode
-An example is given in \ref Step6Page.
+An example is given in \ref Step06Page.
The AccessBy... macros create quite a lot of code: the user defined access method has to be compiled for
all considered pixel types \em times the supported dimensions (default is 2 and 3). Therefore, depending
on the complexity of the access method, some compilers may run into problems with memory.
One workaround is to use explicit instantiation and distribute it on multiple files. The macro
-#InstantiateAccessFunction and its variants are for this purpose. An example is again given in \ref Step6Page.
+#InstantiateAccessFunction and its variants are for this purpose. An example is again given in \ref Step06Page.
Another workaround is to reduce the created code by fixing either the type (#AccessFixedTypeByItk) or
dimension (#AccessFixedDimensionByItk).
There is one variant of AccessByItk... for passing additional parameters
to the access-function, called #AccessFixedTypeByItk_n.
\link mitkImage.h \endlink
\link mitkImageCast.h \endlink
\link mitkImageToItk.h \endlink
\link mitkITKImageImport.h \endlink
\section ItkToMitk ITK to MITK adaptors
Converting ITK images to MITK is easier than the other way round. Basically, you have three options:
\li mitk::ITKImageImport<TInputImage>: is a process class that takes an itk::Image of the given type
\a TOutputImage as input and produces an mitk::Image as output (to be accessed using \a GetOutput()).
The image data contained in the itk::Image is referenced, not copied.
\li mitk::ImportItkImage: this function takes the itk::Image as input and returns an mitk::Image. Internally,
it uses the class just described. So again, the image data contained in the itk::Image is referenced, not
copied.
\li mitk::CastToMitkImage: this function has two parameters, the itk::Image (input) and a smartpointer to an
mitk::Image (output, does not need to be initialized). In contrast to the other described methods,
this function copies the image data!
\section ItkToMitkCoordinateSystems ITK image vs MITK coordinate systems
Converting coordinates from the ITK physical coordinate system (which does not support rotated images) to the
MITK world coordinate system should be performed via the Geometry3D of the Image,
see mitk::Geometry3D::WorldToItkPhysicalPoint.
\section ModuleAdaptorLimitations Limitations
The \ref MitkToItk for unspecified types have to do type multiplexing at compile time. This is done for a
limited number of pixel types and dimensions, defined during the CMake configuration process.
Especially, color image types are not multiplexed. This is because many algorithms do not support color images
(e.g. with data type itk::RGBPixel) because they do not have a scalar data type. If your algorithm do support
color and you want to multiplex over all scalar as well as the color data type, try the following:
\code
try
{
AccessFixedPixelTypeByItk(myMitkImageThatMaybeColor, // The MITK image which may be a color image
myAlgorithmFunction, // The template method being able to handle color
MITK_ACCESSBYITK_PIXEL_TYPES_SEQ // The default pixel type sequence
(itk::RGBPixel<unsigned char>) // The additional type sequence
)
}
catch(const mitk::AccessByItkException& e)
{
// add error handling here
}
\endcode
*/
diff --git a/Modules/Core/doc/Doxygen/ModuleVisualization.dox b/Modules/Core/doc/Doxygen/ModuleVisualization.dox
index 72fb312d85..707a70b266 100644
--- a/Modules/Core/doc/Doxygen/ModuleVisualization.dox
+++ b/Modules/Core/doc/Doxygen/ModuleVisualization.dox
@@ -1,45 +1,45 @@
/**
\defgroup Visualization Visualization and Visualization Organization Classes
\ingroup Core
\brief This category includes renderwindows (currently one for OpenGL), renderers (currently only one,
for OpenGL-based renderwindows), mappers and classes for navigating in the data.
\section overviewVisualization Rationale and overview
Mappers visualize data objects of a specific classes by creating rendering primitives that
interface to the graphics library (e.g., OpenGL, vtk).
Renderers organize the rendering process. A Renderer contains a reference to a (sub-) data tree
and asks the mappers of the data objects to render the data into the renderwindow it is associated to.
-More details can be found in the section on \ref Rendering.
+More details can be found in the section on \ref QVTKRendering.
\subsection inthisgroupVisualization What belongs into this group
\section implementVisualization Practical issues
\section futureVisualization Plans for the future
- Abort mechanism
- level-of-detail rendering mechanism
- allow multiple renderers per renderwindow
- modified detection mechanism:
- allow to detect whether a modification of data/property/dislaygeometry
/camera requires to re-render. E.g., mark whether a property effects
the rendering.
- analyze which type of modification requires which kind of action, e.g.:
if the displaygeometry or the color has changed, we do not need to
resample an image, but we do need to redraw. The first step is to
analyze which types of modifications (e.g., displaygeometry changed,
properties changed; can we group these?) and actions exist.
- improved design of navigation controllers, probably more focused on
steppers (then on BaseController). Have in mind:
- rotatable slices
- dependent views: e.g., sequence of renderers showing series of
consecutive slices (maybe realized as master stepper and
dependent offset steppers)
- consider time vs. slice stepping
- use stepper mechanism for additional purposes, e.g., for animating
transfer functions
*/
diff --git a/Modules/Core/doc/Doxygen/ModuleVisualizationMapper.dox b/Modules/Core/doc/Doxygen/ModuleVisualizationMapper.dox
index 8f6a285c77..f5980f90f2 100644
--- a/Modules/Core/doc/Doxygen/ModuleVisualizationMapper.dox
+++ b/Modules/Core/doc/Doxygen/ModuleVisualizationMapper.dox
@@ -1,25 +1,25 @@
/**
\defgroup Mapper Mapper Classes
\ingroup Visualization
\brief In the MITK rendering concept, Mappers are responsible for actually rendering data onto the screen.
\section overviewVisualizationMapper Overview
Mappers differ in the type of data they are capable of rendering (e.g. volume data, polygonal data) and the mode of how data is rendered (e.g. 2D or 3D). For example, the ImageMapperGL2D renders volume data in a 2D view, i.e. it extracts a slice of the volume (as determined by the Geometry of the associated Renderer) and displays it as a 2D plane. All Mapper classes are arranged in a class hierarchy according to these criterions.
\section integrationVisualizationMapper Integration into the rendering process
-Mapper objects are owned by the DataNode which contains the data they have to render. An overview over this composition is given in the section \ref Renderer. Each DataNode can have (and usually has) multiple Mappers attached, each responsible for different modes of rendering. In most cases this would be one 2D Mapper and one 3D Mapper, but other Mappers are possible, too.
+Mapper objects are owned by the DataNode which contains the data they have to render. An overview over this composition is given in the section \ref QVTKRendering. Each DataNode can have (and usually has) multiple Mappers attached, each responsible for different modes of rendering. In most cases this would be one 2D Mapper and one 3D Mapper, but other Mappers are possible, too.
Which Mapper of a DataNode to use is determined by an ID; the Renderer of a 2D window would for example ask the DataNode to return an appropriate 2D Mapper.
-More details can be found in the section on \ref Rendering.
+More details can be found in the section on \ref QVTKRendering.
\section todoVisualizationMapper Future plans
The need to Update() a Mapper can be justified by property changes in the associated data items. However, property changes are not uniformly taken into account when deciding on whether to execute Update() or not. The changes are data specific and difficult to generalize. As an effect, many Update() calls are not really necessary and might slow down the rendering process significantly. One solution to this problem might be a mechanism which allows Mappers to register themselves to relevant data properties, so as to be notified whenever a change occurs. If no modification did occur since the last Update(), and the data itself has remained unchanged, no re-initialization (of the rendering pipeline for example) needs to be performed.
*/
diff --git a/Modules/Core/doc/Doxygen/ModuleVisualizationRenderer.dox b/Modules/Core/doc/Doxygen/ModuleVisualizationRenderer.dox
index e1e2428197..02329791f5 100644
--- a/Modules/Core/doc/Doxygen/ModuleVisualizationRenderer.dox
+++ b/Modules/Core/doc/Doxygen/ModuleVisualizationRenderer.dox
@@ -1,42 +1,42 @@
/**
\defgroup Renderer Renderer and RenderWindow Classes
\ingroup Visualization
\brief The MITK rendering model resembles the mechisms found in VTK. This section describes the core components for coordinating rendering processes and render windows.
\section overviewVisualizationRenderer Overview
To visualize a dataset it needs to be stored in the DataTree. Depending on the application, the whole DataTree may be displayed, or merely parts of it. The rendering of individual data items (e.g. volumes or polygon models) is conducted by specific Mappers: each kind of visualizable data has its own corresponding Mapper implementation (see \ref Mapper).
MITK is designed to intrinsically provide different views on data. For example, a volume dataset is volume rendered in a 3D view, and displayed slice-wise in a 2D view. A polygon model would be displayed as a contour in 2D (i.e., the intersection of the 3D model and the respective 2D plane). This principle applies to all kinds of data, thereby ensuring a consistent visual representation regardless of the view type. It is realized by providing Mappers for each combination of data type and view type. Every item of the DataTree is associated with a list of Mappers, each capable of rendering the data item in a specific view.
RenderWindows represent the rendering target: an area of the user interface into which data is rendered. The actual rendering process is controlled by Renderers, specifically by mitkVtkPropRenderer, which is a concrete implementation BaseRenderer and iterates over the elements of the DataTree to render each using the associated Mapper. Eeach data item of the DataTree has Geometry objects attached to it which describe the geometry of the data (e.g. its bounding box, location, or spatial conversion hints).
\section vtkVisualizationRenderer Encapsulating VTK Rendering Mechanisms
As a framework, MITK aims at making use of the visualization capabilities of VTK as much as possible. For the application developer building on top of MITK, the way of how to utilize specific VTK features should be straightforward and familiar. Therefore, most of the MITK rendering components closely resemble or integrate corresponding VTK components.
Just like VTK, MITK defines Renderers and Mappers. These classes do not derive from their VTK counterparts, but integrate them and have similar scopes of responsibility. While the VTK rendering mechanism is mainly focused on establishing a pipeline of rendering components (data, filters, mappers, and renderers), MITK has a central DataTree and provides convenient ways of rendering different items of the tree according to their type. Internally, the VTK rendering pipeline is used, though it is more hidden from the application developer who merely makes use of existing rendering capabilities.
-As of MITK 0.8, the class vtkMitkRenderProp (a derivation of vtkProp) represents the single prop object in the VTK rendering pipeline responsible for coordinating the rendering of all objects in MITK's DataTree. The advantage of this approach is that all rendering management is done in the usual VTK rendering pipeline style, while the control of how data is actually rendered is entirely on MITK side. For example, MITK Mapper classes may either use VTK classes for rendering (actors, properties, ...), or do their rendering entirely in OpenGL where appropriate (e.g. in 2D Mapper classes). For further details refer to the page \ref Rendering.
+As of MITK 0.8, the class vtkMitkRenderProp (a derivation of vtkProp) represents the single prop object in the VTK rendering pipeline responsible for coordinating the rendering of all objects in MITK's DataTree. The advantage of this approach is that all rendering management is done in the usual VTK rendering pipeline style, while the control of how data is actually rendered is entirely on MITK side. For example, MITK Mapper classes may either use VTK classes for rendering (actors, properties, ...), or do their rendering entirely in OpenGL where appropriate (e.g. in 2D Mapper classes). For further details refer to the page \ref QVTKRendering.
\section renderingManagerVisualizationRenderer Controlling it All: RenderingManager
On a higher level, all rendering in MITK is managed and supervised by the RenderingManager. Its main task is to provide a central instance where any part of the application can request a repaint of a particular RenderWindow. Thereby, requests can be issued from multiple independent subroutines at one time, and only result in one repainting call, rather than induce many unnecessary rendering passes.
Another task is the supervision of ongoing rendering activities. For large datasets, high quality rendering might become very slow and thus impede smooth user interactions. To alleviate this, level-of-detail rendering and abort-mechanisms are introduced and controlled by the RenderingManager to achieve interactive frame rate and response times. Note that these features are not yet available but currently under development.
The rendering process could be further simplified by making the DataTree automatically detect data changes that require the data to be re-drawn. The fundamentals for such a mechanism already exist but still for many modifications a repainting request has to be issued by the entity causing it.
\section implementationManagerVisualizationRenderer Platform-Specific Implementation
MITK tries to integrate seamlessly into the normal VTK rendering pipeline. The whole MITK data(tree) is capsuled into one customized vtkProp, the so-called vtkMitkRenderProp which is then integrated into VTK pipeline.
The VTK integration into GUI systems, like e.g. QT, is therefore equal to normal VTK usage. As an example, the MITK MainApp requires the QT-VTK widget (provided by VTK) for integration of renderWindows into GUI.
Further information on this can be found in section "Related Pages" "Rendering in MITK by means of the QT-VTK widget".
*/
\ No newline at end of file
diff --git a/Modules/Core/doc/Doxygen/Modules.dox b/Modules/Core/doc/Doxygen/Modules.dox
index 00dabce1db..fb613de407 100644
--- a/Modules/Core/doc/Doxygen/Modules.dox
+++ b/Modules/Core/doc/Doxygen/Modules.dox
@@ -1,105 +1,105 @@
/**
\defgroup Core Core
\ingroup MITKModules
\brief This category includes classes of the MITK Core module.
The MITK Core module contains abstractions for common data types and their
geometries, I/O facilities for loading and saving data in various formats,
infrastructures for handling user interaction and undo/redo operations,
GUI toolkit independent visualization classes, and a generic service registry.
In almost all cases, additional MITK modules will make use of classes contained
in the Core module.
*/
/**
\defgroup Data Data Classes
\ingroup Core
\brief This subcategory includes the data classes, e.g., for images (mitk::Image),
surfaces (mitk::Surface), vessel-trees (mitk::VesselTreeData), etc.
Data access classes are only included, if there is no equivalent in itk (see
- \ref ProcessAndAdaptorClasses "Process and Adaptor Classes" below).
+ \ref ProcessAdaptor "Process and Adaptor Classes" below).
*/
/**
\defgroup IO IO Classes
\ingroup Core
\brief This subcategory includes the IO classes to read or write data objects.
*/
/**
\defgroup DeprecatedIO Deprecated IO Classes
\ingroup Core
\brief This subcategory includes the Deprecated IO classes to read or write data objects.
*/
/**
\defgroup DataStorage Data Storage Classes
\ingroup Core
\brief This subcategory includes the classes to store and retrieve objects from the mitk::DataStorage
*/
/**
\defgroup ProcessAdaptor Process and Adaptor Classes
\ingroup Core
\brief This category includes process (algorithm) classes developed specifically for mitk and
(mainly) adaptor classes for the integration of algorithms from other toolkits
(currently vtk, itk).
The itk adaptor classes are also useful for data access to mitk data objects.
*/
/**
\defgroup Process Process Classes
\ingroup ProcessAdaptor
\brief This subcategory includes process (algorithm) classes developed specifically for mitk.
*/
/**
\defgroup InteractionUndo Interaction and Undo Classes
\ingroup Core
\brief This category includes classes that support the developer to create
software that allows the user to interact with the data.
This includes complex interactions that have multiple states (e.g., moving a handle of an
active contour vs changing its local elasicity) and a concept to realize an undo/redo-mechanism.
A detailed description of the rationale for these classes can be found in
\ref InteractionPage.
*/
/**
\defgroup Interaction Interaction Classes
\ingroup InteractionUndo
\brief This subcategory includes interaction classes (subclasses of mitk::StateMachine) that change
the data according to the input of the user.
For undo-support, the change is done by sending an OperationEvent to the respective
data object, which changes itself accordingly.
A detailed description of the rationale for these classes can be found in
\ref InteractionPage.
*/
/**
\defgroup Undo Undo Classes
\ingroup InteractionUndo
\brief This subcategory includes the undo/redo-specific classes.
For undo-support, the change is done by sending an OperationEvent to the respective data object,
which changes itself accordingly.
A detailed description of the rationale for these classes can be found in
\ref InteractionPage.
*/
diff --git a/Modules/Core/include/mitkITKImageImport.h b/Modules/Core/include/mitkITKImageImport.h
index 3d408f9bc5..354905002d 100644
--- a/Modules/Core/include/mitkITKImageImport.h
+++ b/Modules/Core/include/mitkITKImageImport.h
@@ -1,201 +1,217 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef MITKITKIMAGEIMPORT_H_HEADER_INCLUDED_C1E4861D
#define MITKITKIMAGEIMPORT_H_HEADER_INCLUDED_C1E4861D
#include "itkImageToImageFilterDetail.h"
#include "mitkImageSource.h"
#include <MitkCoreExports.h>
namespace mitk
{
/**
* @brief Pipelined import of itk::Image
*
* The image data contained in the itk::Image is referenced,
* not copied.
* The easiest way of use is by the function
* mitk::ImportItkImage
* \code
* mitkImage = mitk::ImportItkImage(itkImage);
* \endcode
* \sa ImportItkImage
* @ingroup Adaptor
*/
template <class TInputImage>
class MITK_EXPORT ITKImageImport : public ImageSource
{
public:
mitkClassMacro(ITKImageImport, ImageSource);
itkFactorylessNewMacro(Self);
itkCloneMacro(Self);
/// \brief The type of the input image.
typedef TInputImage InputImageType;
typedef typename InputImageType::Pointer InputImagePointer;
typedef typename InputImageType::ConstPointer InputImageConstPointer;
typedef typename InputImageType::RegionType InputImageRegionType;
typedef typename InputImageType::PixelType InputImagePixelType;
/** ImageDimension constants */
itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension);
itkStaticConstMacro(RegionDimension, unsigned int, mitk::SlicedData::RegionDimension);
/** \brief Set the input itk::Image of this image importer. */
InputImageType *GetInput(void);
/** \brief Set the input itk::Image of this image importer. */
void SetInput(const InputImageType *);
using itk::ProcessObject::SetInput;
/**
* \brief Set the Geometry of the result image (optional)
*
* The Geometry has to fit the dimension and size of
* the input image. The Geometry will be cloned, not
* referenced!
*
* Providing the Geometry is optional.
* The default behavior is to set the geometry by
* the itk::Image::GetDirection() information.
*/
void SetGeometry(const BaseGeometry *geometry);
protected:
ITKImageImport();
~ITKImageImport() override;
void GenerateOutputInformation() override;
void GenerateInputRequestedRegion() override;
void GenerateData() override;
void SetNthOutput(DataObjectPointerArraySizeType num, itk::DataObject *output) override;
/** Typedef for the region copier function object that converts an
* output region to an input region. */
typedef itk::ImageToImageFilterDetail::ImageRegionCopier<itkGetStaticConstMacro(InputImageDimension),
itkGetStaticConstMacro(RegionDimension)>
OutputToInputRegionCopierType;
BaseGeometry::Pointer m_Geometry;
};
/**
* @brief Imports an itk::Image (with a specific type) as an mitk::Image.
* @ingroup Adaptor
*
* Instantiates instance of ITKImageImport.
* mitk::ITKImageImport does not cast pixel types etc., it just imports
* image data. If you get a compile error, try image.GetPointer().
*
- * \param update: if \a true, fill mitk::Image, which will execute the
+ * \param itkimage
+ * \param geometry
+ *
+ * \param update if \a true, fill mitk::Image, which will execute the
* up-stream pipeline connected to the input itk::Image. Otherwise you
* need to make sure that Update() is called on the mitk::Image before
* its data is being used, e.g., by connecting it to an mitk-pipeline
* and call Update of a downstream filter at some time.
* \sa itk::Image::CastToMitkImage
*/
template <typename ItkOutputImageType>
Image::Pointer ImportItkImage(const itk::SmartPointer<ItkOutputImageType> &itkimage,
const BaseGeometry *geometry = nullptr,
bool update = true);
/**
* @brief Imports an itk::Image (with a specific type) as an mitk::Image.
* @ingroup Adaptor
*
* Instantiates instance of ITKImageImport
* mitk::ITKImageImport does not cast pixel types etc., it just imports
* image data. If you get a compile error, try image.GetPointer().
+ *
+ * \param itkimage
+ * \param geometry
*
- * \param update: if \a true, fill mitk::Image, which will execute the
+ * \param update if \a true, fill mitk::Image, which will execute the
* up-stream pipeline connected to the input itk::Image. Otherwise you
* need to make sure that Update() is called on the mitk::Image before
* its data is being used, e.g., by connecting it to an mitk-pipeline
* and call Update of a downstream filter at some time.
*
*
* \note If the source (itk image) and the target (mitk image) do not share the same scope, the
* mitk::GrabItkImageMemory
* function
* has to be used instead. Otherwise the image memory managed by the itk image is lost at a scope level change. This
* affects especially the
* usage in combination with AccessByItk macros as in following example code
*
- * \snippet Testing/mitkGrabItkImageMemoryTest.cpp OutOfScopeCall
+ * \snippet test/mitkGrabItkImageMemoryTest.cpp OutOfScopeCall
*
* which calls an ITK-like filter
*
- * \snippet Testing/mitkGrabItkImageMemoryTest.cpp ItkThresholdFilter
+ * \snippet test/mitkGrabItkImageMemoryTest.cpp ItkThresholdFilter
*
*
* \sa itk::Image::CastToMitkImage
* \sa GrabItkImageMemory
*/
template <typename ItkOutputImageType>
Image::Pointer ImportItkImage(const ItkOutputImageType *itkimage,
const BaseGeometry *geometry = nullptr,
bool update = true);
/**
* @brief Grabs the memory of an itk::Image (with a specific type)
* and puts it into an mitk::Image.
* @ingroup Adaptor
*
* The memory is managed by the mitk::Image after calling this
* function. The itk::Image remains valid until the mitk::Image
* decides to free the memory.
- * \param update: if \a true, fill mitk::Image, which will execute the
+ *
+ * \param itkimage
+ * \param mitkImage
+ * \param geometry
+ *
+ * \param update if \a true, fill mitk::Image, which will execute the
* up-stream pipeline connected to the input itk::Image. Otherwise you
* need to make sure that Update() is called on the mitk::Image before
* its data is being used, e.g., by connecting it to an mitk-pipeline
* and call Update of a downstream filter at some time.
* \sa ImportItkImage
*/
template <typename ItkOutputImageType>
Image::Pointer GrabItkImageMemory(itk::SmartPointer<ItkOutputImageType> &itkimage,
mitk::Image *mitkImage = nullptr,
const BaseGeometry *geometry = nullptr,
bool update = true);
/**
* @brief Grabs the memory of an itk::Image (with a specific type)
* and puts it into an mitk::Image.
* @ingroup Adaptor
*
* The memory is managed by the mitk::Image after calling this
* function. The itk::Image remains valid until the mitk::Image
* decides to free the memory.
- * \param update: if \a true, fill mitk::Image, which will execute the
+ *
+ * \param itkimage
+ * \param mitkImage
+ * \param geometry
+ *
+ * \param update if \a true, fill mitk::Image, which will execute the
* up-stream pipeline connected to the input itk::Image. Otherwise you
* need to make sure that Update() is called on the mitk::Image before
* its data is being used, e.g., by connecting it to an mitk-pipeline
* and call Update of a downstream filter at some time.
* \sa ImportItkImage
*/
template <typename ItkOutputImageType>
Image::Pointer GrabItkImageMemory(ItkOutputImageType *itkimage,
mitk::Image *mitkImage = nullptr,
const BaseGeometry *geometry = nullptr,
bool update = true);
} // namespace mitk
#ifndef MITK_MANUAL_INSTANTIATION
#include "mitkITKImageImport.txx"
#endif
#endif /* MITKITKIMAGEIMPORT_H_HEADER_INCLUDED_C1E4861D */
diff --git a/Modules/Core/include/mitkImageAccessByItk.h b/Modules/Core/include/mitkImageAccessByItk.h
index aae0c058f1..388e92c867 100644
--- a/Modules/Core/include/mitkImageAccessByItk.h
+++ b/Modules/Core/include/mitkImageAccessByItk.h
@@ -1,706 +1,706 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef MITKIMAGEACCESSBYITK_H_HEADER_INCLUDED
#define MITKIMAGEACCESSBYITK_H_HEADER_INCLUDED
#include <itkCastImageFilter.h>
#include <mitkImageToItk.h>
#include <mitkPPArgCount.h>
#include <boost/preprocessor/expand.hpp>
#include <boost/preprocessor/seq/for_each.hpp>
#include <boost/preprocessor/seq/for_each_product.hpp>
#include <boost/preprocessor/seq/to_tuple.hpp>
#include <boost/preprocessor/stringize.hpp>
#include <boost/preprocessor/tuple/rem.hpp>
#include <sstream>
namespace mitk
{
/**
* \brief Exception class thrown in #AccessByItk macros.
*
* This exception can be thrown by the invocation of the #AccessByItk macros,
* if the MITK image is of non-expected dimension or pixel type.
*
* \ingroup Adaptor
*/
class AccessByItkException : public virtual std::runtime_error
{
public:
AccessByItkException(const std::string &msg) : std::runtime_error(msg) {}
~AccessByItkException() throw() override {}
};
}
#ifndef DOXYGEN_SKIP
#define _accessByItkPixelTypeException(pixelType, pixelTypeSeq) \
{ \
std::string msg("Pixel type "); \
msg.append(pixelType.GetPixelTypeAsString()); \
msg.append(" is not in " BOOST_PP_STRINGIZE(pixelTypeSeq)); \
throw mitk::AccessByItkException(msg); \
}
#define _accessByItkDimensionException(dim, validDims) \
{ \
std::stringstream msg; \
msg << "Dimension " << (dim) << " is not in " << validDims; \
throw mitk::AccessByItkException(msg.str()); \
}
#define _checkSpecificDimensionIter(r, mitkImage, dim) \
if (mitkImage->GetDimension() == dim) \
; \
else
#define _checkSpecificDimension(mitkImage, dimSeq) \
BOOST_PP_SEQ_FOR_EACH(_checkSpecificDimensionIter, mitkImage, dimSeq) \
_accessByItkDimensionException(mitkImage->GetDimension(), BOOST_PP_STRINGIZE(dimSeq))
#define _msvc_expand_bug(macro, arg) BOOST_PP_EXPAND(macro arg)
//-------------------------------- 0-Arg Versions --------------------------------------
#define _accessByItk(itkImageTypeFunctionAndImageSeq, pixeltype, dimension) \
if (pixelType == mitk::MakePixelType<pixeltype, dimension>(pixelType.GetNumberOfComponents()) && \
BOOST_PP_SEQ_TAIL(itkImageTypeFunctionAndImageSeq)->GetDimension() == dimension) \
{ \
BOOST_PP_SEQ_HEAD(itkImageTypeFunctionAndImageSeq) \
(mitk::ImageToItkImage<pixeltype, dimension>(BOOST_PP_SEQ_TAIL(itkImageTypeFunctionAndImageSeq)).GetPointer()); \
} \
else
#define _accessByItkArgs(itkImageTypeFunction, type) (itkImageTypeFunction, BOOST_PP_TUPLE_REM(2) type)
// product will be of the form ((itkImageTypeFunction)(mitkImage))(short)(2) for pixel type short and dimension 2
#ifdef _MSC_VER
#define _accessByItkProductIter(r, product) \
_msvc_expand_bug( \
_accessByItk, \
_msvc_expand_bug(_accessByItkArgs, (BOOST_PP_SEQ_HEAD(product), BOOST_PP_SEQ_TO_TUPLE(BOOST_PP_SEQ_TAIL(product)))))
#else
#define _accessByItkProductIter(r, product) \
BOOST_PP_EXPAND( \
_accessByItk _accessByItkArgs(BOOST_PP_SEQ_HEAD(product), BOOST_PP_SEQ_TO_TUPLE(BOOST_PP_SEQ_TAIL(product))))
#endif
#define _accessFixedTypeByItk(itkImageTypeFunction, mitkImage, pixelTypeSeq, dimSeq) \
BOOST_PP_SEQ_FOR_EACH_PRODUCT(_accessByItkProductIter, (((itkImageTypeFunction)(mitkImage)))(pixelTypeSeq)(dimSeq))
//-------------------------------- n-Arg Versions --------------------------------------
#define _accessByItk_n(itkImageTypeFunctionAndImageSeq, pixeltype, dimension, args) \
if (pixelType == mitk::MakePixelType<pixeltype, dimension>(pixelType.GetNumberOfComponents()) && \
BOOST_PP_SEQ_TAIL(itkImageTypeFunctionAndImageSeq)->GetDimension() == dimension) \
{ \
BOOST_PP_SEQ_HEAD(itkImageTypeFunctionAndImageSeq) \
(mitk::ImageToItkImage<pixeltype, dimension>(BOOST_PP_SEQ_TAIL(itkImageTypeFunctionAndImageSeq)).GetPointer(), \
BOOST_PP_TUPLE_REM(BOOST_PP_SEQ_HEAD(args)) BOOST_PP_SEQ_TAIL(args)); \
} \
else
#define _accessByItkArgs_n(itkImageTypeFunction, type, args) (itkImageTypeFunction, BOOST_PP_TUPLE_REM(2) type, args)
// product will be of the form (((itkImageTypeFunction)(mitkImage))(3)(a,b,c))(short)(2)
// for the variable argument list a,b,c and for pixel type short and dimension 2
#ifdef _MSC_VER
#define _accessByItkProductIter_n(r, product) \
_msvc_expand_bug(_accessByItk_n, \
_msvc_expand_bug(_accessByItkArgs_n, \
(BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_HEAD(product)), \
BOOST_PP_SEQ_TO_TUPLE(BOOST_PP_SEQ_TAIL(product)), \
BOOST_PP_SEQ_TAIL(BOOST_PP_SEQ_HEAD(product)))))
#else
#define _accessByItkProductIter_n(r, product) \
BOOST_PP_EXPAND(_accessByItk_n _accessByItkArgs_n(BOOST_PP_SEQ_HEAD(BOOST_PP_SEQ_HEAD(product)), \
BOOST_PP_SEQ_TO_TUPLE(BOOST_PP_SEQ_TAIL(product)), \
BOOST_PP_SEQ_TAIL(BOOST_PP_SEQ_HEAD(product))))
#endif
#define _accessFixedTypeByItk_n(itkImageTypeFunction, mitkImage, pixelTypeSeq, dimSeq, va_tuple) \
BOOST_PP_SEQ_FOR_EACH_PRODUCT( \
_accessByItkProductIter_n, \
((((itkImageTypeFunction)(mitkImage))(MITK_PP_ARG_COUNT va_tuple)va_tuple))(pixelTypeSeq)(dimSeq))
#endif // DOXYGEN_SKIP
/**
* \brief Access a MITK image by an ITK image
*
* Define a templated function or method (\a itkImageTypeFunction)
* within which the mitk-image (\a mitkImage) is accessed:
* \code
* template < typename TPixel, unsigned int VImageDimension >
* void ExampleFunction( itk::Image<TPixel, VImageDimension>* itkImage );
* \endcode
*
* The itk::Image passed to the function/method has the same
* data-pointer as the mitk-image. Depending on the const-ness of the
* \c mitkImage, your templated access function needs to take a const or
* non-const itk::Image pointer and you will get read-only or full read/write
* access to the data vector of the mitk-image using the itk-image.
*
* Example code using the access function above:
* \code
* mitk::Image* inputMitkImage = ...
* try
* {
* AccessByItk(inputMitkImage, ExampleFunction);
* }
* catch (const mitk::AccessByItkException& e)
* {
* // mitk::Image is of wrong pixel type or dimension,
* // insert error handling here
* }
* \endcode
*
* \param mitkImage The MITK input image.
* \param itkImageTypeFunction The templated access-function to be called.
*
* \throws mitk::AccessByItkException If mitkImage is of unsupported pixel type or dimension.
*
* \note If your inputMitkImage is an mitk::Image::Pointer, use
* inputMitkImage.GetPointer()
* \note If you need to pass additional parameters to your
* access-function (\a itkImageTypeFunction), use #AccessByItk_n.
* \note If you know the dimension of your input mitk-image,
* it is better to use AccessFixedDimensionByItk (less code
* is generated).
* \sa AccessFixedDimensionByItk
* \sa AccessFixedTypeByItk
* \sa AccessFixedPixelTypeByItk
* \sa AccessByItk_n
*
* \ingroup Adaptor
*/
#define AccessByItk(mitkImage, itkImageTypeFunction) \
AccessFixedTypeByItk( \
mitkImage, itkImageTypeFunction, MITK_ACCESSBYITK_PIXEL_TYPES_SEQ, MITK_ACCESSBYITK_DIMENSIONS_SEQ)
/**
* \brief Access a mitk-image with known pixeltype (but unknown dimension) by an itk-image.
*
* For usage, see #AccessByItk.
*
* \param pixelTypeSeq A sequence of pixel types, like (short)(char)(int)
* \param mitkImage The MITK input image.
* \param itkImageTypeFunction The templated access-function to be called.
*
* \throws mitk::AccessByItkException If mitkImage is of unsupported pixel type or dimension.
*
* If the image has a different pixel type, a mitk::AccessByItkException exception is
* thrown. If you do not know the pixel type for sure, use #AccessByItk.
*
* \sa AccessByItk
* \sa AccessFixedDimensionByItk
* \sa AccessFixedTypeByItk
* \sa AccessFixedPixelTypeByItk_n
*
* \ingroup Adaptor
*/
#define AccessFixedPixelTypeByItk(mitkImage, itkImageTypeFunction, pixelTypeSeq) \
AccessFixedTypeByItk(mitkImage, itkImageTypeFunction, pixelTypeSeq, MITK_ACCESSBYITK_DIMENSIONS_SEQ)
/**
* \brief Access a mitk-image with an integral pixel type by an itk-image
*
* See #AccessByItk for details.
*
* \param mitkImage The MITK input image.
* \param itkImageTypeFunction The templated access-function to be called.
*
* \throws mitk::AccessByItkException If mitkImage is of unsupported pixel type or dimension.
*
* \sa AccessFixedPixelTypeByItk
* \sa AccessByItk
* \sa AccessIntegralPixelTypeByItk_n
*/
#define AccessIntegralPixelTypeByItk(mitkImage, itkImageTypeFunction) \
AccessFixedTypeByItk( \
mitkImage, itkImageTypeFunction, MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES_SEQ, MITK_ACCESSBYITK_DIMENSIONS_SEQ)
/**
* \brief Access a mitk-image with a floating point pixel type by an ITK image
*
* See #AccessByItk for details.
*
* \param mitkImage The MITK input image.
* \param itkImageTypeFunction The templated access-function to be called.
*
* \throws mitk::AccessByItkException If mitkImage is of unsupported pixel type or dimension.
*
* \sa AccessFixedPixelTypeByItk
* \sa AccessByItk
* \sa AccessFloatingPixelTypeByItk_n
*/
#define AccessFloatingPixelTypeByItk(mitkImage, itkImageTypeFunction) \
AccessFixedTypeByItk( \
mitkImage, itkImageTypeFunction, MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES_SEQ, MITK_ACCESSBYITK_DIMENSIONS_SEQ)
#define AccessVectorPixelTypeByItk(mitkImage, itkImageTypeFunction) \
AccessFixedTypeByItk( \
mitkImage, itkImageTypeFunction, MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES_SEQ, MITK_ACCESSBYITK_DIMENSIONS_SEQ)
/**
* \brief Access a mitk-image with known dimension by an itk-image
*
* For usage, see #AccessByItk.
*
* \param dimension Dimension of the mitk-image. If the image has a different dimension,
* a mitk::AccessByItkException exception is thrown.
* \param mitkImage The MITK input image.
* \param itkImageTypeFunction The templated access-function to be called.
*
* \throws mitk::AccessByItkException If mitkImage is of unsupported pixel type or dimension.
*
* \note If you do not know the dimension for sure, use #AccessByItk.
*
* \sa AccessByItk
* \sa AccessFixedDimensionByItk_n
* \sa AccessFixedTypeByItk
* \sa AccessFixedPixelTypeByItk
*
* \ingroup Adaptor
*/
#define AccessFixedDimensionByItk(mitkImage, itkImageTypeFunction, dimension) \
AccessFixedTypeByItk(mitkImage, itkImageTypeFunction, MITK_ACCESSBYITK_PIXEL_TYPES_SEQ, (dimension))
#define AccessVectorFixedDimensionByItk(mitkImage, itkImageTypeFunction, dimension) \
AccessFixedTypeByItk(mitkImage, itkImageTypeFunction, MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES_SEQ, (dimension))
/**
* \brief Access a mitk-image with known type (pixel type and dimension) by an itk-image.
*
* The provided mitk-image must be in the set of types created by taking the
* cartesian product of the pixel type sequence and the dimension sequence.
* For example, a call to
* \code
* AccessFixedTypeByItk(myMitkImage, MyAccessFunction, (short)(int), (2)(3))
* \endcode
* asserts that the type of myMitkImage (pixeltype,dim) is in the set {(short,2),(short,3),(int,2),(int,3)}.
* For more information, see #AccessByItk.
*
* \param pixelTypeSeq A sequence of pixel types, like (short)(char)(int).
* \param dimSeq A sequence of dimensions, like (2)(3).
* \param mitkImage The MITK input image.
* \param itkImageTypeFunction The templated access-function to be called.
*
* \throws mitk::AccessByItkException If mitkImage is of unsupported pixel type or dimension.
*
* If the image has a different dimension or pixel type,
* a mitk::AccessByItkException exception is thrown.
*
* \note If you do not know the dimension for sure, use #AccessByItk.
*
* \sa AccessByItk
* \sa AccessFixedDimensionByItk
* \sa AccessFixedTypeByItk_n
* \sa AccessFixedPixelTypeByItk
*
* \ingroup Adaptor
*/
#define AccessFixedTypeByItk(mitkImage, itkImageTypeFunction, pixelTypeSeq, dimSeq) \
\
{ \
const mitk::PixelType &pixelType = mitkImage->GetPixelType(); \
_checkSpecificDimension(mitkImage, dimSeq); \
_accessFixedTypeByItk(itkImageTypeFunction, mitkImage, pixelTypeSeq, dimSeq) \
_accessByItkPixelTypeException(mitkImage->GetPixelType(), pixelTypeSeq) \
}
//------------------------------ n-Arg Access Macros -----------------------------------
/**
* \brief Access a MITK image by an ITK image with one or more parameters.
*
* Define a templated function or method (\a itkImageTypeFunction) with one ore more
* additional parameters, within which the mitk-image (\a mitkImage) is accessed:
* \code
* template < typename TPixel, unsigned int VImageDimension >
* void ExampleFunction( itk::Image<TPixel, VImageDimension>* itkImage, SomeType param);
* \endcode
*
* The itk::Image passed to the function/method has the same
* data-pointer as the mitk-image. So you have full read- and write-
* access to the data vector of the mitk-image using the itk-image.
* Call by:
* \code
* SomeType param = ...
* mitk::Image* inputMitkImage = ...
* try
* {
* AccessByItk_n(inputMitkImage, ExampleFunction, (param));
* }
* catch (const mitk::AccessByItkException& e)
* {
* // mitk::Image is of wrong pixel type or dimension,
* // insert error handling here
* }
* \endcode
*
* \param va_tuple A variable length tuple containing the arguments to be passed
* to the access function itkImageTypeFunction, e.g. ("first", 2, THIRD).
* \param mitkImage The MITK input image.
* \param itkImageTypeFunction The templated access-function to be called.
*
* \throws mitk::AccessByItkException If mitkImage is of unsupported pixel type or dimension.
*
* \note If your inputMitkImage is an mitk::Image::Pointer, use
* inputMitkImage.GetPointer()
* \note If you know the dimension of your input mitk-image,
* it is better to use AccessFixedDimensionByItk_n (less code
* is generated).
* \sa AccessFixedDimensionByItk_n
* \sa AccessFixedTypeByItk_n
* \sa AccessFixedPixelTypeByItk_n
* \sa AccessByItk
*
* \ingroup Adaptor
*/
#define AccessByItk_n(mitkImage, itkImageTypeFunction, va_tuple) \
AccessFixedTypeByItk_n( \
mitkImage, itkImageTypeFunction, MITK_ACCESSBYITK_PIXEL_TYPES_SEQ, MITK_ACCESSBYITK_DIMENSIONS_SEQ, va_tuple)
/**
* \brief Access a mitk-image with known pixeltype (but unknown dimension) by an itk-image
* with one or more parameters.
*
* For usage, see #AccessByItk_n.
*
* \param va_tuple A variable length tuple containing the arguments to be passed
* to the access function itkImageTypeFunction, e.g. ("first", 2, THIRD).
* \param pixelTypeSeq A sequence of pixel types, like (short)(char)(int).
* \param mitkImage The MITK input image.
* \param itkImageTypeFunction The templated access-function to be called.
*
* \throws mitk::AccessByItkException If mitkImage is of unsupported pixel type or dimension.
*
* If the image has a different pixel type, a mitk::AccessByItkException exception is
* thrown. If you do not know the pixel type for sure, use #AccessByItk_n.
*
* \sa AccessByItk_n
* \sa AccessFixedDimensionByItk_n
* \sa AccessFixedTypeByItk_n
* \sa AccessFixedPixelTypeByItk
*
* \ingroup Adaptor
*/
#define AccessFixedPixelTypeByItk_n(mitkImage, itkImageTypeFunction, pixelTypeSeq, va_tuple) \
AccessFixedTypeByItk_n(mitkImage, itkImageTypeFunction, pixelTypeSeq, MITK_ACCESSBYITK_DIMENSIONS_SEQ, va_tuple)
/**
* \brief Access an mitk::Image with an integral pixel type by an ITK image with
* one or more parameters.
*
* See #AccessByItk_n for details.
*
* \param va_tuple A variable length tuple containing the arguments to be passed
* to the access function itkImageTypeFunction, e.g. ("first", 2, THIRD).
* \param mitkImage The MITK input image.
* \param itkImageTypeFunction The templated access-function to be called.
*
* \throws mitk::AccessByItkException If mitkImage is of unsupported pixel type or dimension.
*
* \sa AccessFixedPixelTypeByItk_n
* \sa AccessByItk_n
* \sa AccessIntegralPixelTypeByItk
*/
#define AccessIntegralPixelTypeByItk_n(mitkImage, itkImageTypeFunction, va_tuple) \
AccessFixedTypeByItk_n(mitkImage, \
itkImageTypeFunction, \
MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES_SEQ, \
MITK_ACCESSBYITK_DIMENSIONS_SEQ, \
va_tuple)
/**
* \brief Access an mitk::Image with a floating point pixel type by an ITK image
* with one or more parameters.
*
* See #AccessByItk_n for details.
*
* \param va_tuple A variable length tuple containing the arguments to be passed
* to the access function itkImageTypeFunction, e.g. ("first", 2, THIRD).
* \param mitkImage The MITK input image.
* \param itkImageTypeFunction The templated access-function to be called.
*
* \throws mitk::AccessByItkException If mitkImage is of unsupported pixel type or dimension.
*
* \sa AccessFixedPixelTypeByItk_n
* \sa AccessByItk_n
* \sa AccessFloatingPixelTypeByItk
*/
#define AccessFloatingPixelTypeByItk_n(mitkImage, itkImageTypeFunction, va_tuple) \
AccessFixedTypeByItk_n(mitkImage, \
itkImageTypeFunction, \
MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES_SEQ, \
MITK_ACCESSBYITK_DIMENSIONS_SEQ, \
va_tuple)
/**
* \brief Access a vector mitk::Image by an ITK vector image with one or more parameters.
*
* See #AccessByItk_n for details.
*
* \param va_tuple A variable length tuple containing the arguments to be passed
* to the access function itkImageTypeFunction, e.g. ("first", 2, THIRD).
* \param mitkImage The MITK input image.
* \param itkImageTypeFunction The templated access-function to be called.
*
* \throws mitk::AccessByItkException If mitkImage is of unsupported pixel type or dimension.
*
* \sa AccessFixedPixelTypeByItk_n
* \sa AccessByItk_n
*/
#define AccessVectorPixelTypeByItk_n(mitkImage, itkImageTypeFunction, va_tuple) \
AccessFixedTypeByItk_n(mitkImage, \
itkImageTypeFunction, \
MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES_SEQ, \
MITK_ACCESSBYITK_DIMENSIONS_SEQ, \
va_tuple)
/**
* \brief Access a mitk-image with known dimension by an itk-image with
* one or more parameters.
*
* For usage, see #AccessByItk_n.
*
* \param dimension Dimension of the mitk-image. If the image has a different dimension,
* a mitk::AccessByItkException exception is thrown.
* \param va_tuple A variable length tuple containing the arguments to be passed
* to the access function itkImageTypeFunction, e.g. ("first", 2, THIRD).
* \param mitkImage The MITK input image.
* \param itkImageTypeFunction The templated access-function to be called.
*
* \throws mitk::AccessByItkException If mitkImage is of unsupported pixel type or dimension.
*
* \note If you do not know the dimension for sure, use #AccessByItk_n.
*
* \sa AccessByItk_n
* \sa AccessFixedDimensionByItk
* \sa AccessFixedTypeByItk_n
* \sa AccessFixedPixelTypeByItk_n
*
* \ingroup Adaptor
*/
#define AccessFixedDimensionByItk_n(mitkImage, itkImageTypeFunction, dimension, va_tuple) \
AccessFixedTypeByItk_n(mitkImage, itkImageTypeFunction, MITK_ACCESSBYITK_PIXEL_TYPES_SEQ, (dimension), va_tuple)
/**
* \brief Access a vector mitk-image with known dimension by a ITK vector image with
* one or more parameters.
*
* For usage, see #AccessByItk_n.
*
* \param dimension Dimension of the mitk-image. If the image has a different dimension,
* a mitk::AccessByItkException exception is thrown.
* \param va_tuple A variable length tuple containing the arguments to be passed
* to the access function itkImageTypeFunction, e.g. ("first", 2, THIRD).
* \param mitkImage The MITK input image.
* \param itkImageTypeFunction The templated access-function to be called.
*
* \throws mitk::AccessByItkException If mitkImage is of unsupported pixel type or dimension.
*
* \note If you do not know the dimension for sure, use #AccessVectorPixelTypeByItk_n.
*
* \sa AccessByItk_n
* \sa AccessVectorPixelTypeByItk_n
* \sa AccessFixedTypeByItk_n
*
* \ingroup Adaptor
*/
#define AccessVectorFixedDimensionByItk_n(mitkImage, itkImageTypeFunction, dimension, va_tuple) \
AccessFixedTypeByItk_n( \
mitkImage, itkImageTypeFunction, MITK_ACCESSBYITK_VECTOR_PIXEL_TYPES_SEQ, (dimension), va_tuple)
/**
* \brief Access a mitk-image with known type (pixel type and dimension) by an itk-image
* with one or more parameters.
*
* For usage, see AccessFixedTypeByItk.
*
* \param pixelTypeSeq A sequence of pixel types, like (short)(char)(int).
* \param dimSeq A sequence of dimensions, like (2)(3).
* \param va_tuple A variable length tuple containing the arguments to be passed
* to the access function itkImageTypeFunction, e.g. ("first", 2, THIRD).
* \param mitkImage The MITK input image.
* \param itkImageTypeFunction The templated access-function to be called.
*
* \throws mitk::AccessByItkException If mitkImage is of unsupported pixel type or dimension.
*
* If the image has a different dimension or pixel type,
* a mitk::AccessByItkException exception is thrown.
*
* \note If you do not know the dimension for sure, use #AccessByItk_n.
*
* \sa AccessByItk_n
* \sa AccessFixedDimensionByItk_n
* \sa AccessFixedTypeByItk
* \sa AccessFixedPixelTypeByItk_n
*
* \ingroup Adaptor
*/
#define AccessFixedTypeByItk_n(mitkImage, itkImageTypeFunction, pixelTypeSeq, dimSeq, va_tuple) \
\
{ \
const mitk::PixelType &pixelType = mitkImage->GetPixelType(); \
_checkSpecificDimension(mitkImage, dimSeq); \
_accessFixedTypeByItk_n(itkImageTypeFunction, mitkImage, pixelTypeSeq, dimSeq, va_tuple) \
_accessByItkPixelTypeException(mitkImage->GetPixelType(), pixelTypeSeq) \
}
//------------------------- For back-wards compatibility -------------------------------
#define AccessByItk_1(mitkImage, itkImageTypeFunction, arg1) AccessByItk_n(mitkImage, itkImageTypeFunction, (arg1))
#define AccessFixedPixelTypeByItk_1(mitkImage, itkImageTypeFunction, pixelTypeSeq, arg1) \
AccessFixedPixelTypeByItk_n(mitkImage, itkImageTypeFunction, pixelTypeSeq, (arg1))
#define AccessFixedDimensionByItk_1(mitkImage, itkImageTypeFunction, dimension, arg1) \
AccessFixedDimensionByItk_n(mitkImage, itkImageTypeFunction, dimension, (arg1))
#define AccessFixedTypeByItk_1(mitkImage, itkImageTypeFunction, pixelTypeSeq, dimSeq, arg1) \
AccessFixedTypeByItk_n(mitkImage, itkImageTypeFunction, pixelTypeSeq, dimSeq, (arg1))
#define AccessByItk_2(mitkImage, itkImageTypeFunction, arg1, arg2) \
AccessByItk_n(mitkImage, itkImageTypeFunction, (arg1, arg2))
#define AccessFixedPixelTypeByItk_2(mitkImage, itkImageTypeFunction, pixelTypeSeq, arg1, arg2) \
AccessFixedPixelTypeByItk_n(mitkImage, itkImageTypeFunction, pixelTypeSeq, (arg1, arg2))
#define AccessFixedDimensionByItk_2(mitkImage, itkImageTypeFunction, dimension, arg1, arg2) \
AccessFixedDimensionByItk_n(mitkImage, itkImageTypeFunction, dimension, (arg1, arg2))
#define AccessFixedTypeByItk_2(mitkImage, itkImageTypeFunction, pixelTypeSeq, dimSeq, arg1, arg2) \
AccessFixedTypeByItk_n(mitkImage, itkImageTypeFunction, pixelTypeSeq, dimSeq, (arg1, arg2))
#define AccessByItk_3(mitkImage, itkImageTypeFunction, arg1, arg2, arg3) \
AccessByItk_n(mitkImage, itkImageTypeFunction, (arg1, arg2, arg3))
#define AccessFixedPixelTypeByItk_3(mitkImage, itkImageTypeFunction, pixelTypeSeq, arg1, arg2, arg3) \
AccessFixedPixelTypeByItk_n(mitkImage, itkImageTypeFunction, pixelTypeSeq, (arg1, arg2, arg3))
#define AccessFixedDimensionByItk_3(mitkImage, itkImageTypeFunction, dimension, arg1, arg2, arg3) \
AccessFixedDimensionByItk_n(mitkImage, itkImageTypeFunction, dimension, (arg1, arg2, arg3))
#define AccessFixedTypeByItk_3(mitkImage, itkImageTypeFunction, pixelTypeSeq, dimSeq, arg1, arg2, arg3) \
AccessFixedTypeByItk_n(mitkImage, itkImageTypeFunction, pixelTypeSeq, dimSeq, (arg1, arg2, arg3))
//----------------------------- Access two MITK Images ---------------------------------
#ifndef DOXYGEN_SKIP
#define _accessTwoImagesByItk(itkImageTypeFunction, pixeltype1, dim1, pixeltype2, dim2) \
if (pixelType1 == mitk::MakePixelType<itk::Image<pixeltype1, dim1>>() && \
pixelType2 == mitk::MakePixelType<itk::Image<pixeltype2, dim2>>() && constImage1->GetDimension() == dim1 && \
constImage2->GetDimension() == dim2) \
{ \
typedef itk::Image<pixeltype1, dim1> ImageType1; \
typedef itk::Image<pixeltype2, dim2> ImageType2; \
typedef mitk::ImageToItk<ImageType1> ImageToItkType1; \
typedef mitk::ImageToItk<ImageType2> ImageToItkType2; \
itk::SmartPointer<ImageToItkType1> imagetoitk1 = ImageToItkType1::New(); \
imagetoitk1->SetInput(nonConstImage1); \
imagetoitk1->Update(); \
itk::SmartPointer<ImageToItkType2> imagetoitk2 = ImageToItkType2::New(); \
imagetoitk2->SetInput(nonConstImage2); \
imagetoitk2->Update(); \
itkImageTypeFunction(imagetoitk1->GetOutput(), imagetoitk2->GetOutput()); \
} \
else
#define _accessTwoImagesByItkArgs2(itkImageTypeFunction, type1, type2) \
(itkImageTypeFunction, BOOST_PP_TUPLE_REM(2) type1, BOOST_PP_TUPLE_REM(2) type2)
#define _accessTwoImagesByItkArgs(product) \
BOOST_PP_EXPAND(_accessTwoImagesByItkArgs2 BOOST_PP_EXPAND( \
(BOOST_PP_SEQ_HEAD(product), BOOST_PP_TUPLE_REM(2) BOOST_PP_SEQ_TO_TUPLE(BOOST_PP_SEQ_TAIL(product)))))
// product is of the form (itkImageTypeFunction)((short,2))((char,2))
#ifdef _MSC_VER
#define _accessTwoImagesByItkIter(r, product) \
BOOST_PP_EXPAND(_accessTwoImagesByItk _msvc_expand_bug( \
_accessTwoImagesByItkArgs2, \
(BOOST_PP_SEQ_HEAD(product), \
_msvc_expand_bug(BOOST_PP_TUPLE_REM(2), BOOST_PP_EXPAND(BOOST_PP_SEQ_TO_TUPLE(BOOST_PP_SEQ_TAIL(product)))))))
#else
#define _accessTwoImagesByItkIter(r, product) BOOST_PP_EXPAND(_accessTwoImagesByItk _accessTwoImagesByItkArgs(product))
#endif
#define _accessTwoImagesByItkForEach(itkImageTypeFunction, tseq1, tseq2) \
BOOST_PP_SEQ_FOR_EACH_PRODUCT(_accessTwoImagesByItkIter, ((itkImageTypeFunction))(tseq1)(tseq2))
#endif // DOXYGEN_SKIP
/**
* \brief Access two mitk-images with known dimension by itk-images
*
* Define a templated function or method (\a itkImageTypeFunction)
* within which the mitk-images (\a mitkImage1 and \a mitkImage2) are accessed:
* \code
* template <typename TPixel1, unsigned int VImageDimension1, typename TPixel2, unsigned int VImageDimension2>
* void ExampleFunctionTwoImages(itk::Image<TPixel1, VImageDimension1>* itkImage1, itk::Image<TPixel2,
* VImageDimension2>* itkImage2);
* \endcode
*
* The itk::Image passed to the function/method has the same
* data-pointer as the mitk-image. So you have full read- and write-
* access to the data vector of the mitk-image using the itk-image.
* Call by:
* \code
* mitk::Image* inputMitkImage1 = ...
* mitk::Image* inputMitkImage2 = ...
* try
* {
* AccessTwoImagesFixedDimensionByItk(inputMitkImage1, inputMitkImage2, ExampleFunctionTwoImages, 3);
* }
* catch (const mitk::AccessByItkException& e)
* {
* // mitk::Image arguments are of wrong pixel type or dimension,
* // insert error handling here
* }
* \endcode
*
* \note If your inputMitkImage1 or inputMitkImage2 is a mitk::Image::Pointer, use
* inputMitkImage1.GetPointer().
*
* \param mitkImage1 The first MITK input image.
- * \param mitkImage1 The second MITK input image.
+ * \param mitkImage2 The second MITK input image.
* \param itkImageTypeFunction The name of the template access-function to be called.
* \param dimension Dimension of the two mitk-images.
*
* \throws mitk::AccessByItkException If mitkImage1 and mitkImage2 have different dimensions or
* one of the images is of unsupported pixel type or dimension.
*
* \sa #AccessByItk
*
* \ingroup Adaptor
*/
#define AccessTwoImagesFixedDimensionByItk(mitkImage1, mitkImage2, itkImageTypeFunction, dimension) \
\
{ \
const mitk::PixelType &pixelType1 = mitkImage1->GetPixelType(); \
const mitk::PixelType &pixelType2 = mitkImage2->GetPixelType(); \
const mitk::Image *constImage1 = mitkImage1; \
const mitk::Image *constImage2 = mitkImage2; \
mitk::Image *nonConstImage1 = const_cast<mitk::Image *>(constImage1); \
mitk::Image *nonConstImage2 = const_cast<mitk::Image *>(constImage2); \
nonConstImage1->Update(); \
nonConstImage2->Update(); \
_checkSpecificDimension(mitkImage1, (dimension)); \
_checkSpecificDimension(mitkImage2, (dimension)); \
_accessTwoImagesByItkForEach( \
itkImageTypeFunction, MITK_ACCESSBYITK_TYPES_DIMN_SEQ(dimension), MITK_ACCESSBYITK_TYPES_DIMN_SEQ(dimension)) \
{ \
std::string msg("Pixel type "); \
msg.append(pixelType1.GetComponentTypeAsString()); \
msg.append(" or pixel type "); \
msg.append(pixelType2.GetComponentTypeAsString()); \
msg.append(" is not in " BOOST_PP_STRINGIZE(MITK_ACCESSBYITK_TYPES_DIMN_SEQ(dimension))); \
throw mitk::AccessByItkException(msg); \
} \
}
#endif // of MITKIMAGEACCESSBYITK_H_HEADER_INCLUDED
diff --git a/Modules/CppMicroServices/core/doc/doxygen/MicroServices_ServiceHooks.md b/Modules/CppMicroServices/core/doc/doxygen/MicroServices_ServiceHooks.md
index 959d235c3d..3c29df35a0 100644
--- a/Modules/CppMicroServices/core/doc/doxygen/MicroServices_ServiceHooks.md
+++ b/Modules/CppMicroServices/core/doc/doxygen/MicroServices_ServiceHooks.md
@@ -1,92 +1,92 @@
Service Hooks {#MicroServices_ServiceHooks}
=============
The CppMicroServices library implements the Service Hook Service Specification Version 1.1 from
OSGi Core Release 5 for C++. Below is a summary of the concept - consult the OSGi specifications
for more details.
Service hooks provide mechanisms for module writers to closely interact with the CppMicroServices
service registry. These mechanisms are not intended for use by application modules but rather
by modules in need of *hooking* into the service registry and modifying the behaviour of
application modules.
Specific use case for service hooks include proxying of existing services by hiding the original
service and registering a *proxy service* with the same properties or providing services
*on demand* based on registered service listeners from external modules.
## Event Listener Hook
A module can intercept events being delivered to other modules by registering a ServiceEventListenerHook
object as a service. The CppMicroServices library will send all service events to all the registered
hooks using the reversed ordering of their ServiceReference objects. Note that event listener hooks
are called *after* the event was created but *before* it is filtered by the optional filter expression
-of the service listeners. Hence an event listener hook receives all \link ServiceEvent::REGISTERED
-REGISTERED\endlink, \link ServiceEvent::MODIFIED MODIFIED\endlink, \link ServiceEvent::UNREGISTERING
-UNREGISTERING\endlink, and \link ServiceEvent::MODIFIED_ENDMATCH MODIFIED_ENDMATCH\endlink events
+of the service listeners. Hence an event listener hook receives all \link us::ServiceEvent::REGISTERED
+REGISTERED \endlink, \link us::ServiceEvent::MODIFIED MODIFIED \endlink, \link us::ServiceEvent::UNREGISTERING
+UNREGISTERING \endlink, and \link us::ServiceEvent::MODIFIED_ENDMATCH MODIFIED_ENDMATCH \endlink events
regardelss of the presence of a service listener filter. It may then remove modules or specific
service listeners from the ServiceEventListenerHook::ShrinkableMapType object passed to the
ServiceEventListenerHook::Event method to hide
service events.
Implementers of the Event Listener Hook must ensure that modules continue to see a consistent set of
service events.
## Find Hook
Find Hook objects registered using the ServiceFindHook interface will be called when modules look up
service references via the ModuleContext::GetServiceReference or ModuleContext::GetServiceReferences
methods. The order in which the CppMicroServices library calls the find hooks is the reverse `operator<`
ordering of their ServiceReference objects. The hooks may remove service references from the
ShrinkableVector object passed to the ServiceFindHook::Find method to hide services from specific modules.
## Listener Hook
The CppMicroServices API provides information about the registration, unregistration, and modification
of services. However, it does not directly allow the introspection of modules to get information about
what services a module is waiting for. Waiting for a service to arrive (via a registered service listener)
before performing its function is a common pattern for modules. Listener Hooks provide a mechanism to
get informed about all existing, newly registerd, and removed service listeners.
A Listener Hook object registered using the ServiceListenerHook interface will be notified about service
listeners by being passed ServiceListenerHook::ListenerInfo objects. Each ListenerInfo object is related to
the registration / unregistration cycle of a specific service listener. That is, registering the same service
listener again, even with a different filter, will automatically unregister the previouse registration and
the newly registered service listener is related to a different ListenerInfo object. ListenerInfo objects
can be stored in unordered containers and compared with each other, e.g. to match ServiceListenerHook::Added
and ServiceListenerHook::Removed calls.
The Listener Hooks are called synchronously in the same order of their registration. However, in rare cases
the removal of a service listener may be reported before its corresponding addition. To handle this case,
the ListenerInfo::IsRemoved() method is provided which can be used in the ServiceListenerHook::Added
method to detect the out of order delivery. A simple strategy is to ignore removed events without
corresponding added events and ignore added events where the ListenerInfo object is already removed:
\snippet uServices-servicelistenerhook/main.cpp 1
## Architectural Notes
### Ordinary Services
All service hooks are treated as ordinary services. If the CppMicroServices library uses them, their
Service References will show that the CppMicroServices modules is using them, and if a hook is a
Service Factory, then the actual instance will be properly created.
The only speciality of the service hooks is that the CppMicroServices library does not use them for
the hooks themselves. That is, the Service Event and Service Find Hooks can not be used to hide the
services from the CppMicroServices library.
### Ordering
The hooks are very sensitive to ordering because they interact directly with the service registry.
In general, implementers of the hooks must be aware that other modules can be loaded before or after
the module which provides the hooks. To ensure early registration of the hooks, they should be registered
within the ModuleActivator::Load method of the program executable or a module being auto-loaded with
the executable.
### Multi Threading
All hooks must be thread-safe because the hooks can be called at any time. All hook methods must be
re-entrant, they can be entered at any time and in rare cases in the wrong order. The CppMicroServices
library calls all hook methods synchronously but the calls might be triggered from any user thread
interacting with the CppMicroServices API. The CppMicroServices API can be called from any of the
hook methods but implementers must be careful to not hold any lock while calling CppMicroServices methods.
diff --git a/Modules/CppMicroServices/core/doc/doxygen/examples/MicroServices_Example1.md b/Modules/CppMicroServices/core/doc/doxygen/examples/MicroServices_Example1.md
index 6e1abbf0ff..8b684bd413 100644
--- a/Modules/CppMicroServices/core/doc/doxygen/examples/MicroServices_Example1.md
+++ b/Modules/CppMicroServices/core/doc/doxygen/examples/MicroServices_Example1.md
@@ -1,97 +1,97 @@
Example 1 - Service Event Listener {#MicroServices_Example1}
==================================
This example creates a simple module that listens for service events.
This example does not do much at first, because it only prints out the details
of registering and unregistering services. In the next example we will create
a module that implements a service, which will cause this module to actually
do something. For now, we will just use this example to help us understand the
basics of creating a module and its activator.
A module gains access to the C++ Micro Services API using a unique instance
of ModuleContext. This unique module context can be used during static
initialization of the module or at any later point during the life-time of the
module. To execute code during static initialization (and de-initialization)
time, the module must provide an implementation of the ModuleActivator interface;
this interface has two methods, Load() and Unload(), that both receive the
module's context and are called when the module is loaded (statically initialized)
and unloaded, respectively.
\note You do not need to remember the ModuleContext instance within the
ModuleActivator::Load() method and provide custom access methods for later
retrieval. Use the GetModuleContext() function to easily retrieve the current
module's context.
In the following source code, our module implements
the ModuleActivator interface and uses the context to add itself as a listener
for service events (in the `eventlistener/Activator.cpp` file):
\snippet eventlistener/Activator.cpp Activator
After implementing the C++ source code for the module activator, we must *export*
the activator such that the C++ Micro Services library can create an instance
of it and call the `Load()` and `Unload()` methods:
\dontinclude eventlistener/Activator.cpp
\skipline US_EXPORT
Now we need to compile the source code. This example uses CMake as the build
system and the top-level CMakeLists.txt file could look like this:
-\dontinclude examples/CMakeLists.txt
+\dontinclude core/examples/CMakeLists.txt
\skip project
\until eventlistener
and the CMakeLists.txt file in the eventlistener subdirectory is:
\include eventlistener/CMakeLists.txt
The call to `#usFunctionGenerateModuleInit` is necessary to integrate the shared
library as a module within the C++ Micro Service library. If you are not using
CMake, you have to place a macro call to `#US_INITIALIZE_MODULE` yourself into the
module's source code, e.g. in `Activator.cpp`. Have a look at the
-\ref MicroServices_GettingStarted documentation for more details about using CMake
+Getting Started documentation for more details about using CMake
or other build systems (e.g. Makefiles) when writing modules.
To run the examples contained in the C++ Micro Services library, we use a small
driver program called `usCoreExamplesDriver`:
\verbatim
CppMicroServices-build> bin/usCoreExamplesDriver
> h
h This help text
l <id | name> Load the module with id <id> or name <name>
u <id> Unload the module with id <id>
s Print status information
q Quit
>
\endverbatim
Typing `s` at the command prompt lists the available, loaded, and unloaded modules.
To load the eventlistener module, type `l eventlistener` at the command prompt:
\verbatim
> s
Id | Name | Status
-----------------------------------
- | dictionaryclient | -
- | dictionaryclient2 | -
- | dictionaryclient3 | -
- | dictionaryservice | -
- | eventlistener | -
- | frenchdictionary | -
- | spellcheckclient | -
- | spellcheckservice | -
1 | CppMicroServices | LOADED
> l eventlistener
Starting to listen for service events.
>
\endverbatim
The above command loaded the eventlistener module (by loading its shared library).
Keep in mind, that this module will not do much at this point since it only
listens for service events and we are not registering any services. In the next
example we will register a service that will generate an event for this module to
receive. To exit the `usCoreExamplesDriver`, use the `q` command.
Next: \ref MicroServices_Example2
diff --git a/Modules/DICOMUI/include/QmitkDicomLocalStorageWidget.h b/Modules/DICOMUI/include/QmitkDicomLocalStorageWidget.h
index cd8b541fbc..86d2cedc3e 100644
--- a/Modules/DICOMUI/include/QmitkDicomLocalStorageWidget.h
+++ b/Modules/DICOMUI/include/QmitkDicomLocalStorageWidget.h
@@ -1,117 +1,117 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QmitkDicomLocalStorageWidget_h
#define QmitkDicomLocalStorageWidget_h
// #include <QmitkFunctionality.h>
#include "ui_QmitkDicomLocalStorageWidgetControls.h"
#include <MitkDICOMUIExports.h>
// include ctk
#include <ctkDICOMDatabase.h>
#include <ctkDICOMIndexer.h>
#include <ctkFileDialog.h>
// include QT
#include <QHash>
#include <QString>
#include <QStringList>
#include <QVariant>
#include <QWidget>
class QProgressDialog;
class QLabel;
/**
* \brief QmitkDicomLocalStorageWidget is a QWidget providing functionality for dicom storage and import.
*
* \sa QmitkFunctionality
* \ingroup Functionalities
*/
class MITKDICOMUI_EXPORT QmitkDicomLocalStorageWidget : public QWidget
{
// 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 Widget_ID;
/**
* \brief QmitkDicomLocalStorageWidget(QWidget *parent) constructor.
*
* \param parent is a pointer to the parent widget
*/
QmitkDicomLocalStorageWidget(QWidget *parent);
/**
* \brief QmitkDicomExternalDataWidget destructor.
*/
~QmitkDicomLocalStorageWidget() override;
/**
* \brief CreateQtPartControl(QWidget *parent) sets the view objects from ui_QmitkDicomExternalDataWidgetControls.h.
*
* \param parent is a pointer to the parent widget
*/
virtual void CreateQtPartControl(QWidget *parent);
/**
* \brief SetDatabaseDirectory sets database directory.
*
* \param newDatabaseDirectory contains path to new database directoy.
*/
void SetDatabaseDirectory(QString newDatabaseDirectory);
signals:
/// @brief emitted when import into database is finished.
void SignalFinishedImport();
/**
* @brief emitted when view button is clicked.
- * @param QHash containing dicom UIDs properties.
+ * @param _t1 containing dicom UIDs properties.
*/
- void SignalDicomToDataManager(QHash<QString, QVariant>);
+ void SignalDicomToDataManager(QHash<QString, QVariant> _t1);
/// \brief emitted if cancel button is pressed.
void SignalCancelImport();
public slots:
/// @brief Called when view button was clicked.
void OnViewButtonClicked();
/// @brief Called delete button was clicked.
void OnDeleteButtonClicked();
/// @brief Called when adding a dicom directory. Starts a thread adding the directory.
void OnStartDicomImport(const QString &dicomData);
/// @brief Called when adding a list of dicom files. Starts a thread adding the dicom files.
void OnStartDicomImport(const QStringList &dicomData);
/// @brief Called when the selection in the series table has changed
void OnSeriesSelectionChanged(const QStringList &);
protected:
void SetDatabase(QString databaseFile);
bool DeletePatients();
bool DeleteStudies();
bool DeleteSeries();
ctkDICOMDatabase *m_LocalDatabase;
ctkDICOMIndexer *m_LocalIndexer;
Ui::QmitkDicomLocalStorageWidgetControls *m_Controls;
};
#endif // _QmitkDicomLocalStorageWidget_H_INCLUDED
diff --git a/Modules/IGT/Documentation/doxygen/IGTTutorialStep1.dox b/Modules/IGT/Documentation/doxygen/IGTTutorialStep1.dox
index 70e2401526..0cdcbbddd0 100644
--- a/Modules/IGT/Documentation/doxygen/IGTTutorialStep1.dox
+++ b/Modules/IGT/Documentation/doxygen/IGTTutorialStep1.dox
@@ -1,70 +1,70 @@
/**
\page IGTTutorialStepFilterPipeline IGT filter pipeline
The IGT tutorial consists of four main parts for construction of a small navigation pipeline using a virtual tracking device.
The virtual tracking device produces random tool data (position and orientation) so no additional hardware is required.
The full code of this small navigation pipeline included in this tutorial can be found in MITK-Source/Modules/IGT/Tutorial/mitkIGTTutorialStep1.cpp.
At the very end of this page, you can find build instructions on how to run this example on your computer.
\snippet mitkIGTTutorialStep1.cpp What we will do
\section IGT_Tracking_Layer Tracking Layer
Firstly a new object "tracker" of the type mitk::VirtualTrackingDevice is created, then two tools, named "tool1" and "tool2",
are added to this tracker. Since the tracking device "tracker" is treated as a virtual tracking
device, tool1 and tool2 are just added to the object by method AddTool(name) and don't need further specification (e.g. real tools might need a calibration file).
\snippet mitkIGTTutorialStep1.cpp Part I Basic 1
\section IGT_Navigation_Layer Navigation Layer
\imageMacro{IGTTutorialStep1.png,"",15.90}
Secondly, a new source of the type mitk::TrackingDeviceSource has to be created with outputs for each single tool of a tracker.
The source sets the following tracking device by using method SetTrackingDevice as shown below.
So now, the source is initialized with the virtual tracking device. Next, the source is connected and tracking is started.
\snippet mitkIGTTutorialStep1.cpp Part I Basic 2
In part II, a displacemt filter (object "displacer") is constructed to change the positions of the filtered NavigationData objects
with an offset for each direction (X,Y,Z). The given filter has inputs and outputs for each tool, in this example we have two tools. Hence, there exist two inputs and outputs. Every output of the displacement filter object is connected to the recorder object in the next part.
\snippet mitkIGTTutorialStep1.cpp Part II
\section IGT_Record_Navigation_Data Record Navigation Data
In part III, all the NavigationData is recorded with the NavigationDataRecorder. In order to record, we simply create
an object "recorder" of the type mitk::NavigationDataRecorder and set the appropriate file to it. Now the displacer object is connected to the
recorder object, the method StartRecording() is called on the next line. Afterwards,
the recorder has to be updated a couple of times. In this example the recorder is updating 100 times through
a for-loop statement. This can also be seen as a simulation of a timer by using a for-loop.
\snippet mitkIGTTutorialStep1.cpp Part III: Record the data with the NavigationDataRecorder
\section IGT_Play_Navigation_Data Play Navigation Data
Part IV explains how the recoded file can be played for further use. After the object "player" of a type mitk::NavigationDataSequentialPlayer
is created, the required file has to be set to the player and playing has to be started. Here, there exists a new pipeline which functions by reading
the recorded file from the harddisc and plays it by using the player as source. During the play, the for-loop makes the file update as in part III.
\imageMacro{IGTTutorialStep1-2.png,"",9.53}
\snippet mitkIGTTutorialStep1.cpp Part IV: Play the data with the NavigationDataPlayer
\section IGTTutStep1Build IGT Example Build Instructions
This tutorial is an extra target which can be build separately. Make sure, you selected the Navigation option in cmake during your superbuild (set MITK_BUILD_CONFIGURATION to mitkNavigation modules) or select the MITK_BUILD_org.mitk.gui.qt.igtexamples on your MITK-build and make sure that all dependencies are build.
<b> Visual Studio: </b> Right click in your solution explorer on MITKIGTTutorialStep1 --> Set as start up project --> build & Start without debugging. A new window will open.
\imageMacro{IGTTutorialStep1_buildInstrWindows.png,"",5}
<b> Qt creator: </b> Select MITKIGTTutorialStep1 as Project (see screenshot below) and build and run the project. The output can be found in the QT creator console.
\imageMacro{IGTTutorialStep1_buildInstrLinux.png,"",5}
Your output should look similar to this:
\imageMacro{IGTTutorialStep1_output.png,"",9.53}
-\ref Return to the \ref IGTTutorialOverview "[IGT Tutorial Overview]"
+Return to the \ref IGTTutorialOverview "[IGT Tutorial Overview]"
*/
\ No newline at end of file
diff --git a/Modules/IGT/Documentation/doxygen/IGTTutorialStep2.dox b/Modules/IGT/Documentation/doxygen/IGTTutorialStep2.dox
index efc3896159..6b8e65be8b 100644
--- a/Modules/IGT/Documentation/doxygen/IGTTutorialStep2.dox
+++ b/Modules/IGT/Documentation/doxygen/IGTTutorialStep2.dox
@@ -1,55 +1,55 @@
/**
\page IGTTutorialStepVisualization IGT Visualization Filter and MITK Concepts
The following code shows how to insert IGT tracking data into an mitk::DataStorage and render the data with the mitk::NavigationDataObjectVisualizationFilter in an mitk::RenderWindow. The full code is shown below and can be found in MITK-Source/Modules/IGT/Tutorial/mitkIGTTutorialStep2.cpp.
This tutorial is an extra target which can be build separately (see \ref IGTTutStep1Build).
The example we are using here regards a moving tracker and a fixed object, and after tracking a transform to move the fixed object to the tracked one is calculated and applied.
\snippet mitkIGTTutorialStep2.cpp What we will do
The next image describes, what happens in this example. The blue and red object are labeled with "1" at their initial position. Next, the blue object will move (approximately along the yellow arrow) to the second position, while the red one stayes fixed. Now we calculate the transform of the blue cones initial and moved position (1 -> 2) and apply this transform to shift the red object to its final position (3). Now, the relative distance and orientation of the blue and red object is as it was in the beginning.
\imageMacro{IGTTutorialStep2_overview.png,"Overlay of the three steps in this example: 1. Initial position\, 2. Blue object moved along the yellow arc\, 3. Final position\, the red object is moved to get the initial relative position compared to the blue object.",9.53}
\section igtTut2sec1 Set up Render Window and Tracking Device
First of all, we create a new render window. For simplicity, we are not using the MITK workbench yet but run this example as a stand alone application. Hence, we need to create a render window and a data storage.
\snippet mitkIGTTutorialStep2.cpp Render Window
Next, we need to set up the tracking device like we did in the last tutorial step \ref IGTTutorialStepFilterPipeline . We set additionally some boundaries for the tracking.
\snippet mitkIGTTutorialStep2.cpp Setup Tracking Device
\section igtTut2sec2 Create Objects
Now we create a fixed and a moving object. For the moving (tracked) object, we decided for a blue cone. First, we set the name and color and add it to the data storage. Next, we need to create a visualitation filter to display it. Here, we connect in the visualization filter the output of our tracking device source to the cone representation.
\snippet mitkIGTTutorialStep2.cpp Moving Object
The fixed object is created accordingly, with a cylindrical shape and red color. As it is not tracked, we define an initial position and orientation, set it to the cylinder object and also store it as fixedNavigationData for later usage. As the object is not continuously updated, we don't need a visualization filter.
\snippet mitkIGTTutorialStep2.cpp Fixed Object
\section igtTut2sec3 The Tracking loop
Before we start tracking, we need to initialize the rendering manager.
\snippet mitkIGTTutorialStep2.cpp Initialize views
We now move the tracked blue cone object for 75 steps, update the rendering and print the position to the output console.
\snippet mitkIGTTutorialStep2.cpp Tracking
\section igtTut2sec4 Final Transform
Finally, we apply the new position of the tracked object (source->GetOutput) to the stored fixedNavigationData transform and update the rendering one last time.
\snippet mitkIGTTutorialStep2.cpp Calculate Transform
The red cylinder is now moved accodring to the tracked transform.
-\ref Return to the \ref IGTTutorialOverview "[IGT Tutorial Overview]"
+Return to the \ref IGTTutorialOverview "[IGT Tutorial Overview]"
*/
\ No newline at end of file
diff --git a/Modules/IGT/Documentation/doxygen/IGTTutorialStep3.dox b/Modules/IGT/Documentation/doxygen/IGTTutorialStep3.dox
index 5ff38de0f7..2f70a95456 100644
--- a/Modules/IGT/Documentation/doxygen/IGTTutorialStep3.dox
+++ b/Modules/IGT/Documentation/doxygen/IGTTutorialStep3.dox
@@ -1,17 +1,17 @@
/**
\page IGTTutorialStepSimplePlugin IGT QT Tutorial
This tutorial shows how to integrate IGT in your plugin. You can enable this example in cmake with the
option: MITK_BUILD_org.mitk.gui.qt.igtexamples.
\imageMacro{IGTTutorialStep3_cmake.png,"",15.90}
The code of the plugin/view is located in:
MITK-Source/Plugins/org.mitk.gui.qt.igtexamples/src/internal/QmitkIGTTutorialView .
The plugin will automatically be lodaed in the mitkWorkbench.
Please read the manual page on how to use this example: \ref org_imageguidedtherapytutorial
-\ref Return to the \ref IGTTutorialOverview "[IGT Tutorial Overview]"
+Return to the \ref IGTTutorialOverview "[IGT Tutorial Overview]"
*/
\ No newline at end of file
diff --git a/Modules/IGT/Documentation/doxygen/IGTTutorialStep4.dox b/Modules/IGT/Documentation/doxygen/IGTTutorialStep4.dox
index 68b9bfc2a9..6b6e87a2d5 100644
--- a/Modules/IGT/Documentation/doxygen/IGTTutorialStep4.dox
+++ b/Modules/IGT/Documentation/doxygen/IGTTutorialStep4.dox
@@ -1,17 +1,17 @@
/**
\page IGTTutorialStepTrackingLab Tracking Lab
The tracking lab is an IGT plugin containing various functions. You can enable this example in CMake with the
option: MITK_BUILD_org.mitk.gui.qt.igtexamples.
\imageMacro{IGTTutorialStep3_cmake.png,"",15.90}
The code of the plugin/view is located in:
MITK-Source/Plugins/org.mitk.gui.qt.igtexamples/src/internal/QmitkIGTTrackingLabView .
The plugin will automatically be lodaed in the mitkWorkbench.
Please read the manual page on how to use this example: \ref org_igttrackinglab
-\ref Return to the \ref IGTTutorialOverview "[IGT Tutorial Overview]"
+Return to the \ref IGTTutorialOverview "[IGT Tutorial Overview]"
*/
\ No newline at end of file
diff --git a/Modules/IGT/Documentation/doxygen/IGTTutorialStep5.dox b/Modules/IGT/Documentation/doxygen/IGTTutorialStep5.dox
index b3d6eff801..e7f0970e25 100644
--- a/Modules/IGT/Documentation/doxygen/IGTTutorialStep5.dox
+++ b/Modules/IGT/Documentation/doxygen/IGTTutorialStep5.dox
@@ -1,72 +1,67 @@
/**
\page IGTTutorialStepAdvanced A deeper look into the IGT Plugins
We already know the three views of the IGT tracking plugin from the first tutorial step (\ref org_mitk_gui_qt_igttracking): \ref org_mitk_views_igttrackingtoolbox , \ref org_mitk_views_igtnavigationtoolmanager and \ref org_mitk_views_navigationdataplayer . While the first tutorial step only dealt with the usage of these views, we now want to have a deeper look at some parts of the code.
\section Widgets IGT Widgets
A lot of the IGT functionality is available as a widget. So if you need some part of it for your own plugin, you might just want to include the widget. This is for example done for the QmitkNavigationToolCreationWidget, which is used in the \ref org_mitk_views_igttrackingtoolbox view as well as in the \ref org_mitk_views_igtnavigationtoolmanager view.
\imageMacro{IGTTutorialStep5_Widgets.png,"",15.90}
\section DataAccess Data access
The fist important question is, how to get the tools you want to use for your application. The most simple way is using the \ref org_mitk_views_igtnavigationtoolmanager to load, create or edit the tools and access it via the NavigationToolStorage. It's provided by a microservice and you can access it e.g. via the module context (make sure, your module depends on IGT):
us::ModuleContext* context = us::GetModuleContext();
std::vector<us::ServiceReference <mitk::NavigationToolStorage> > refs = context->GetServiceReferences<mitk::NavigationToolStorage>();
m_ToolStorage = context->GetService<mitk::NavigationToolStorage>(refs.front());
Then, simply access the tools by
m_ToolStorage->GetTool();
There are also many different functions available, e.g. providing the number of available tools or the name of the current tracking device. Just have a look at the documentation of the mitk::NavigationToolStorage if you are interested in it.
\section AutoLoad Autoload all parameters from last session
To increase the usability of the application, the tracking toolbox restores all parameters from the last session. Therefore, we will use the following code to save all parameters. It is also used in the specific tracking device widgets, but we will just have a look at one example, restoring some parameters like the Show-Tracking-Volume-Checkbox, the filename of the autosave path of the tool storage or the index of the tracking volume.
To store the settings, the following code is used:
\snippet QmitkMITKIGTTrackingToolboxView.cpp StoreUISettings
We will reload it with
\snippet QmitkMITKIGTTrackingToolboxView.cpp LoadUISettings
\section LoadToolStorage Load Tool Storage
This code will load a previously stored or autosaved tool storage:
\snippet QmitkMITKIGTTrackingToolboxView.cpp LoadToolStorage
\section ThreadedTracking Threaded Tracking
Usually, the tracking is done in a separate thread in order to still allow parallel usage of the workbench. If we track the devices in the same thread, the workbench might freeze.
That's why we use thread workers
\snippet QmitkMITKIGTTrackingToolboxView.cpp Thread 1
...which are connected to functions
\snippet QmitkMITKIGTTrackingToolboxView.cpp Thread 3
The thread will be startet, if we connect a tracking device by pushing the connect button or start tracking etc:
\snippet QmitkMITKIGTTrackingToolboxView.cpp Thread 4
...and finished afterwards:
\snippet QmitkMITKIGTTrackingToolboxView.cpp Thread 5
You can access the data from the worker thread if needed:
\snippet QmitkMITKIGTTrackingToolboxView.cpp Thread 6
Which of the functions is finally executed will be chosen in the ThreadFunc:
-\snippet QmitkMITKIGTTrackingToolboxView.cpp Thread 7
+\snippet QmitkMITKIGTTrackingToolboxViewWorker.cpp Thread 7
To deconstruct the workers, we first terminate the threads and then delete them
\snippet QmitkMITKIGTTrackingToolboxView.cpp Thread 2
-
-
-
-
-
-\ref Return to the \ref IGTTutorialOverview "[IGT Tutorial Overview]"
+Return to the \ref IGTTutorialOverview "[IGT Tutorial Overview]"
*/
\ No newline at end of file
diff --git a/Modules/IGT/Documentation/doxygen/IGTTutorialStep6.dox b/Modules/IGT/Documentation/doxygen/IGTTutorialStep6.dox
index 664f5d7186..357e961b44 100644
--- a/Modules/IGT/Documentation/doxygen/IGTTutorialStep6.dox
+++ b/Modules/IGT/Documentation/doxygen/IGTTutorialStep6.dox
@@ -1,10 +1,10 @@
/**
\page IGTTutorialStepOpenIGTLink OpenIGTLink Tutorial
\li \subpage org_openigtlinkexample
\li \subpage org_openigtlinkproviderexample
\li \subpage org_openigtlinkplugin
-\ref Return to the \ref IGTTutorialOverview "[IGT Tutorial Overview]"
+Return to the \ref IGTTutorialOverview "[IGT Tutorial Overview]"
*/
\ No newline at end of file
diff --git a/Modules/IGTUI/Qmitk/QmitkNDIConfigurationWidget.h b/Modules/IGTUI/Qmitk/QmitkNDIConfigurationWidget.h
index 8036b16dbf..dc13205abb 100644
--- a/Modules/IGTUI/Qmitk/QmitkNDIConfigurationWidget.h
+++ b/Modules/IGTUI/Qmitk/QmitkNDIConfigurationWidget.h
@@ -1,132 +1,131 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef _QmitkNDIConfigurationWidget_H_INCLUDED
#define _QmitkNDIConfigurationWidget_H_INCLUDED
#include "ui_QmitkNDIConfigurationWidget.h"
#include "mitkNDITrackingDevice.h"
#include "mitkTrackingDeviceSource.h"
#include "QStringList"
#include "MitkIGTUIExports.h"
#include "mitkNodePredicateBase.h"
#include "mitkNavigationTool.h"
class QmitkNDIToolDelegate;
namespace mitk
{
class DataStorage;
};
/**@deprecated This widget is deprecated. The features (1) connection to NDI tracking devices and
* (2) handling of navigation tools are available in the pluging org.mitk.gui.qt.igttracking
* in a current version. The new concept to access the tracking devices is to use microservices.
* This can be achieved very simple by using the QmitkNavigationDataSourceSelectionWidget. You
* can find an example in the IGT tutorial step 2 / org.mitk.gui.qt.igtexamples (view TrackingLab).
*
*\ingroup IGTUI
*/
class MITKIGTUI_EXPORT QmitkNDIConfigurationWidget : public QWidget
{
Q_OBJECT // this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
public:
QmitkNDIConfigurationWidget(QWidget* parent);
~QmitkNDIConfigurationWidget() override;
DEPRECATED(std::string GetDeviceName() const);
DEPRECATED(mitk::NDITrackingDevice* GetTracker() const);
DEPRECATED(mitk::DataStorage* GetDataStorage() const);
DEPRECATED(mitk::NodePredicateBase* GetPredicate() const);
DEPRECATED(const QStringList& GetToolTypes() const);
DEPRECATED(void SetToolTypes(const QStringList& types)); ///< set types list for type editor combobox
DEPRECATED(void SetDataStorage(mitk::DataStorage* ds)); ///< set datastorage for organ node editor
DEPRECATED(void SetPredicate(mitk::NodePredicateBase::Pointer p)); ///< set predicate for organ node editor
DEPRECATED(void SetTagPropertyName(const std::string& name)); ///< set name of the property that is used to tag selected nodes
DEPRECATED(void SetTagProperty(mitk::BaseProperty::Pointer prop)); ///< set the property that is used to tag selected nodes
DEPRECATED(const QString GetToolType(unsigned int index) const);
DEPRECATED(const QString GetToolName(unsigned int index) const);
QMap<QString, unsigned int> GetToolAndTypes() const;
DEPRECATED(QList<unsigned int> GetToolsByToolType(QString toolType) const);
DEPRECATED(mitk::DataNode* GetNode(unsigned int index) const);
signals:
void ToolsAdded(QStringList tools);
void ToolsChanged();
void Connected();
void Disconnected();
void RepresentationChanged( int row , mitk::Surface::Pointer surface ); // returns the row number of the clicked tableitem for changing tool representation
void SignalToolNameChanged(int id, QString name);
void SignalSavedTool(int id, QString surfaceFilename);
void SignalLoadTool(int id, mitk::DataNode::Pointer dn);
public slots:
void SetDeviceName(const char* dev); ///< set the device name (e.g. "COM1", "/dev/ttyS0") that will be used to connect to the tracking device
void ShowToolRepresentationColumn(); ///< show or hide the tooltable column "Tool Representation". This SLOT should be called after SIGNAL "Connected" is emitted
void EnableAddToolsButton(bool enable); ///< enables or disables the Add Tools button
void EnableDiscoverNewToolsButton(bool enable); ; ///< enables or disables the Discover new Tools button
protected slots:
void OnConnect();
void OnDisconnect();
void OnDiscoverTools();
void OnDiscoverDevices();
void OnAddPassiveTool();
void UpdateTrackerFromToolTable(const QModelIndex & topLeft, const QModelIndex & /*bottomRight*/);
void OnTableItemClicked(const QModelIndex & topLeft); ///< for clicking on tooltable items
void OnDisoverDevicesBtnInfo();
void OnTableCellChanged(int row, int column);
void OnSaveTool();
void OnLoadTool();
protected:
typedef QMap<QString, mitk::TrackingDeviceType> PortDeviceMap; // key is port name (e.g. "COM1", "/dev/ttyS0"), value will be filled with the type of tracking device at this port
/**Documentation
* \brief scans the ports provided as key in the portsAndDevices and fills the respective value of portsAndDevices with the tracking device type at that port
*
*
- * \param[in] portsAndDevices keys are used to query serial ports
- * \param[out] portsAndDevices values of the existing keys will be filled with the tracking device type
+ * \param[in,out] portsAndDevices keys are used to query serial ports, values of the existing keys will be filled with the tracking device type
*/
void ScanPortsForNDITrackingDevices(PortDeviceMap& portsAndDevices);
mitk::TrackingDeviceType ScanPort(QString port);
mitk::NavigationTool::Pointer GenerateNavigationTool(mitk::TrackingTool* tool);
QStringList GetToolNamesList(); ///< returns a string list with the names of all tools of the current tracking device
void CreateTracker(); ///< creates new NDITrackingDevice object
void SetupTracker(); ///< sets the parameters from the gui to the tracking device object
QString GetStatusText(); ///< construct a status text depending on the current state of the tracking device object
void UpdateWidgets();
void UpdateToolTable(); ///< read all tools from the tracking device object and display them in the gui
virtual void CreateQtPartControl(QWidget *parent);
virtual void CreateConnections(); ///< \brief Creation of the connections of main and control widget
void HidePolarisOptionsGroupbox( bool on ); ///< show or hide polaris options in the UI
void HideAuroraOptionsGroupbox( bool on ); ///< show or hide aurora options in the UI
Ui::QmitkNDIConfigurationWidget* m_Controls; ///< gui widgets
mitk::NDITrackingDevice::Pointer m_Tracker; ///< tracking device object
mitk::TrackingDeviceSource::Pointer m_Source;
QmitkNDIToolDelegate* m_Delegate;
QString m_SROMCellDefaultText;
QString m_RepresentatonCellDefaultText;
mitk::Surface::Pointer LoadSurfaceFromSTLFile(QString surfaceFilename);
};
#endif // _QmitkNDIConfigurationWidget_H_INCLUDED
diff --git a/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.h b/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.h
index aa32dbcc87..c05f4aecab 100644
--- a/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.h
+++ b/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.h
@@ -1,141 +1,142 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QmitkNavigationToolCreationWidget_H
#define QmitkNavigationToolCreationWidget_H
//QT headers
#include <QWidget>
//mitk headers
#include "MitkIGTUIExports.h"
#include <mitkNavigationTool.h>
#include <mitkNavigationToolStorage.h>
#include <mitkNodePredicateDataType.h>
#include "QmitkInteractiveTransformationWidget.h"
#include <QDialog>
//Microservices
#include <usGetModuleContext.h>
#include <usModule.h>
#include <usServiceProperties.h>
#include <usModuleContext.h>
//ui header
#include "ui_QmitkNavigationToolCreationWidget.h"
/** Documentation:
* \brief An object of this class offers an UI to create or modify NavigationTools.
*
* Be sure to call the initialize method before you start the widget
* otherwise some errors might occure.
*
* \ingroup IGTUI
*/
class MITKIGTUI_EXPORT QmitkNavigationToolCreationWidget : public QWidget
{
Q_OBJECT
public:
static const std::string VIEW_ID;
/** @brief Initializes the widget.
* @param dataStorage The data storage is needed to offer the possibility to choose surfaces from the data storage for tool visualization.
* @param supposedIdentifier This Identifier is supposed for the user. It is needed because every identifier in a navigation tool storage must be unique and we don't know the others.
+ * @param supposedName
*/
void Initialize(mitk::DataStorage* dataStorage, const std::string &supposedIdentifier, const std::string &supposedName = "NewTool");
/** @brief This Function will add a new node to the Data Manager with given name to enable a preview of the m_ToolToBeEdited
*/
void ShowToolPreview(std::string _name);
/** @brief Sets the default tracking device type. You may also define if it is changeable or not.*/
void SetTrackingDeviceType(mitk::TrackingDeviceType type, bool changeable = true);
QmitkNavigationToolCreationWidget(QWidget* parent = nullptr, Qt::WindowFlags f = nullptr);
~QmitkNavigationToolCreationWidget() override;
/** @brief Sets the default data of all input fields. The default data is used from the default tool which is given as parameter. */
void SetDefaultData(mitk::NavigationTool::Pointer DefaultTool);
/** @return Returns the created tool. Returns nullptr if no tool was created yet. */
mitk::NavigationTool::Pointer GetCreatedTool();
signals:
/** @brief This signal is emitted if the user finished the creation of the tool. */
void NavigationToolFinished();
/** @brief This signal is emitted if the user canceled the creation of the tool. */
void Canceled();
protected slots:
void OnLoadCalibrationFile();
void OnSurfaceUseToggled();
void OnLoadSurface();
void OnEditToolTip();
void OnEditToolTipFinished(mitk::AffineTransform3D::Pointer toolTip);
void OnCancel();
void OnFinished();
void GetValuesFromGuiElements();
private:
//############## private help methods #######################
/** Shows a message box with the given message s. */
void MessageBox(std::string s);
/** Set the tool landmark lists in the UI.*/
void FillUIToolLandmarkLists(mitk::PointSet::Pointer calLandmarks, mitk::PointSet::Pointer regLandmarks);
/** Returns the tool landmark lists from the UI.
* @param[out] calLandmarks Returns a pointer to the calibration landmarks point set.
* @param[out] regLandmarks Returns a pointer to the registration landmarks point set.
*/
void GetUIToolLandmarksLists(mitk::PointSet::Pointer& calLandmarks, mitk::PointSet::Pointer& regLandmarks);
/** Initializes the tool landmark lists in the UI. */
void InitializeUIToolLandmarkLists();
void RefreshTrackingDeviceCollection();
void SetGuiElements();
protected:
/// \brief Creation of the connections
virtual void CreateConnections();
virtual void CreateQtPartControl(QWidget *parent);
Ui::QmitkNavigationToolCreationWidgetControls* m_Controls;
/** @brief this pointer holds the tool which is edited. If finished is clicked, it will be copied to the final tool, if it is cancled, it is reseted and not used.
This can be regarded as the clipboard for all changes. */
mitk::NavigationTool::Pointer m_ToolToBeEdited;
/** @brief this pointer holds the tool which is created and returned */
mitk::NavigationTool::Pointer m_FinalTool;
QmitkInteractiveTransformationWidget* m_ToolTransformationWidget;
/** @brief holds the DataStorage */
mitk::DataStorage* m_DataStorage;
/** Hold the data nodes which are needed for the landmark widgets. */
mitk::DataNode::Pointer m_calLandmarkNode, m_regLandmarkNode;
};
#endif
diff --git a/Modules/IGTUI/Qmitk/QmitkTrackingDeviceConfigurationWidgetScanPortsWorker.h b/Modules/IGTUI/Qmitk/QmitkTrackingDeviceConfigurationWidgetScanPortsWorker.h
index 81c0427581..3c83e4bfad 100644
--- a/Modules/IGTUI/Qmitk/QmitkTrackingDeviceConfigurationWidgetScanPortsWorker.h
+++ b/Modules/IGTUI/Qmitk/QmitkTrackingDeviceConfigurationWidgetScanPortsWorker.h
@@ -1,50 +1,51 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QmitkTrackingDeviceConfigurationWidgetScanPortsWorker_H
#define QmitkTrackingDeviceConfigurationWidgetScanPortsWorker_H
#include <QWidget>
#include "mitkTrackingDevice.h"
#include "MitkIGTUIExports.h"
/**
* Worker thread class for scan ports.
*/
class MITKIGTUI_EXPORT QmitkTrackingDeviceConfigurationWidgetScanPortsWorker : public QObject
{
Q_OBJECT;
public:
QmitkTrackingDeviceConfigurationWidgetScanPortsWorker(){};
~QmitkTrackingDeviceConfigurationWidgetScanPortsWorker() override{};
public slots:
void ScanPortsThreadFunc();
signals:
/**
* @param Port Returns the port, returns -1 if no device was found.
+ * @param result
* @param PortType Returns the port type (0=usb,1=tty), returns -1 if the port type is not specified, e.g, in case of Windows.
*/
void PortsScanned(int Port, QString result, int PortType);
protected:
/** @brief Scans the given port for a NDI tracking device.
* @return Returns the type of the device if one was found. Returns TrackingSystemInvalid if none was found.
*/
mitk::TrackingDeviceType ScanPort(QString port);
};
#endif
diff --git a/Modules/ImageStatistics/mitkitkMaskImageFilter.h b/Modules/ImageStatistics/mitkitkMaskImageFilter.h
index 88bd86ea9f..68f2004590 100644
--- a/Modules/ImageStatistics/mitkitkMaskImageFilter.h
+++ b/Modules/ImageStatistics/mitkitkMaskImageFilter.h
@@ -1,289 +1,285 @@
/*=========================================================================
*
* Copyright Insight Software Consortium
*
* 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 __itkMaskImageFilter2_h
#define __itkMaskImageFilter2_h
#include "itkBinaryFunctorImageFilter.h"
#include "itkNumericTraits.h"
#include "itkVariableLengthVector.h"
#include <MitkImageStatisticsExports.h>
namespace itk
{
namespace Functor
{
/**
* \class MaskInput2
* \brief
* \ingroup ITKImageIntensity
*/
template< typename TInput, typename TMask, typename TOutput = TInput >
class MaskInput2
{
public:
typedef typename NumericTraits< TInput >::AccumulateType AccumulatorType;
MaskInput2()
{
m_MaskingValue = NumericTraits< TMask >::ZeroValue();
InitializeOutsideValue( static_cast<TOutput*>( nullptr ) );
}
~MaskInput2() {}
bool operator!=(const MaskInput2 &) const
{
return false;
}
bool operator==(const MaskInput2 & other) const
{
return !( *this != other );
}
inline TOutput operator()(const TInput & A, const TMask & B) const
{
if ( B == m_MaskingValue )
{
return static_cast< TOutput >( A );
}
else
{
return m_OutsideValue;
}
}
/** Method to explicitly set the outside value of the mask */
void SetOutsideValue(const TOutput & outsideValue)
{
m_OutsideValue = outsideValue;
}
/** Method to get the outside value of the mask */
const TOutput & GetOutsideValue() const
{
return m_OutsideValue;
}
/** Method to explicitly set the masking value */
void SetMaskingValue(const TMask & maskingValue)
{
m_MaskingValue = maskingValue;
}
/** Method to get the masking value */
const TMask & GetMaskingValue() const
{
return m_MaskingValue;
}
private:
template < typename TPixelType >
void InitializeOutsideValue( TPixelType * )
{
this->m_OutsideValue = NumericTraits< TPixelType >::ZeroValue();
}
template < typename TValue >
void InitializeOutsideValue( VariableLengthVector<TValue> * )
{
// set the outside value to be of zero length
this->m_OutsideValue = VariableLengthVector< TValue >(0);
}
TOutput m_OutsideValue;
TMask m_MaskingValue;
};
}
/** \class MaskImageFilter
* \brief Mask an image with a mask.
*
* This class is templated over the types of the
* input image type, the mask image type and the type of the output image.
* Numeric conversions (castings) are done by the C++ defaults.
*
* The pixel type of the input 2 image must have a valid definition of the
* operator != with zero. This condition is required because internally this
* filter will perform the operation
*
- * \code
+ * \code{.unparsed}
* if pixel_from_mask_image == masking_value
* pixel_output_image = pixel_input_image
* else
* pixel_output_image = outside_value
* \endcode
*
* The pixel from the input 1 is cast to the pixel type of the output image.
*
* Note that the input and the mask images must be of the same size.
*
*
* \sa MaskNegatedImageFilter
* \ingroup IntensityImageFilters
* \ingroup MultiThreaded
* \ingroup ITKImageIntensity
- *
- * \wiki
- * \wikiexample{ImageProcessing/MaskImageFilter,Apply a mask to an image}
- * \endwiki
*/
template< typename TInputImage, typename TMaskImage, typename TOutputImage = TInputImage >
class MITKIMAGESTATISTICS_EXPORT MaskImageFilter2:
public
BinaryFunctorImageFilter< TInputImage, TMaskImage, TOutputImage,
Functor::MaskInput2<
typename TInputImage::PixelType,
typename TMaskImage::PixelType,
typename TOutputImage::PixelType > >
{
public:
/** Standard class typedefs. */
typedef MaskImageFilter2 Self;
typedef BinaryFunctorImageFilter< TInputImage, TMaskImage, TOutputImage,
Functor::MaskInput2<
typename TInputImage::PixelType,
typename TMaskImage::PixelType,
typename TOutputImage::PixelType >
> Superclass;
typedef SmartPointer< Self > Pointer;
typedef SmartPointer< const Self > ConstPointer;
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** Runtime information support. */
itkTypeMacro(MaskImageFilter2,
BinaryFunctorImageFilter);
/** Typedefs **/
typedef TMaskImage MaskImageType;
/** Set/Get the mask image. Pixels set in the mask image will retain
* the original value of the input image while pixels not set in
* the mask will be set to the "OutsideValue".
*/
void SetMaskImage(const MaskImageType *maskImage)
{
// Process object is not const-correct so the const casting is required.
this->SetNthInput( 1, const_cast< MaskImageType * >( maskImage ) );
}
const MaskImageType * GetMaskImage()
{
return static_cast<const MaskImageType*>(this->ProcessObject::GetInput(1));
}
/** Method to explicitly set the outside value of the mask. Defaults to 0 */
void SetOutsideValue(const typename TOutputImage::PixelType & outsideValue)
{
if ( this->GetOutsideValue() != outsideValue )
{
this->Modified();
this->GetFunctor().SetOutsideValue(outsideValue);
}
}
const typename TOutputImage::PixelType & GetOutsideValue() const
{
return this->GetFunctor().GetOutsideValue();
}
/** Method to explicitly set the masking value of the mask. Defaults to 0 */
void SetMaskingValue(const typename TMaskImage::PixelType & maskingValue)
{
if ( this->GetMaskingValue() != maskingValue )
{
this->Modified();
this->GetFunctor().SetMaskingValue(maskingValue);
}
}
/** Method to get the masking value of the mask. */
const typename TMaskImage::PixelType & GetMaskingValue() const
{
return this->GetFunctor().GetMaskingValue();
}
void BeforeThreadedGenerateData() override
{
typedef typename TOutputImage::PixelType PixelType;
this->CheckOutsideValue( static_cast<PixelType*>(nullptr) );
}
#ifdef ITK_USE_CONCEPT_CHECKING
// Begin concept checking
itkConceptMacro( MaskEqualityComparableCheck,
( Concept::EqualityComparable< typename TMaskImage::PixelType > ) );
itkConceptMacro( InputConvertibleToOutputCheck,
( Concept::Convertible< typename TInputImage::PixelType,
typename TOutputImage::PixelType > ) );
// End concept checking
#endif
protected:
MaskImageFilter2() {}
~MaskImageFilter2() override {}
void PrintSelf(std::ostream & os, Indent indent) const override
{
Superclass::PrintSelf(os, indent);
os << indent << "OutsideValue: " << this->GetOutsideValue() << std::endl;
}
private:
MaskImageFilter2(const Self &); //purposely not implemented
void operator=(const Self &); //purposely not implemented
template < typename TPixelType >
void CheckOutsideValue( const TPixelType * ) {}
template < typename TValue >
void CheckOutsideValue( const VariableLengthVector< TValue > * )
{
// Check to see if the outside value contains only zeros. If so,
// resize it to have the same number of zeros as the output
// image. Otherwise, check that the number of components in the
// outside value is the same as the number of components in the
// output image. If not, throw an exception.
VariableLengthVector< TValue > currentValue =
this->GetFunctor().GetOutsideValue();
VariableLengthVector< TValue > zeroVector( currentValue.GetSize() );
zeroVector.Fill( NumericTraits< TValue >::ZeroValue() );
if ( currentValue == zeroVector )
{
zeroVector.SetSize( this->GetOutput()->GetVectorLength() );
zeroVector.Fill( NumericTraits< TValue >::ZeroValue() );
this->GetFunctor().SetOutsideValue( zeroVector );
}
else if ( this->GetFunctor().GetOutsideValue().GetSize() !=
this->GetOutput()->GetVectorLength() )
{
itkExceptionMacro(
<< "Number of components in OutsideValue: "
<< this->GetFunctor().GetOutsideValue().GetSize()
<< " is not the same as the "
<< "number of components in the image: "
<< this->GetOutput()->GetVectorLength());
}
}
};
} // end namespace itk
#endif
diff --git a/Modules/ImageStatisticsUI/Qmitk/QmitkDataGenerationJobBase.h b/Modules/ImageStatisticsUI/Qmitk/QmitkDataGenerationJobBase.h
index a9f1f61401..6f3f248b4b 100644
--- a/Modules/ImageStatisticsUI/Qmitk/QmitkDataGenerationJobBase.h
+++ b/Modules/ImageStatisticsUI/Qmitk/QmitkDataGenerationJobBase.h
@@ -1,74 +1,74 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QmitkDataGenerationJobBase_h
#define QmitkDataGenerationJobBase_h
//QT
#include <QRunnable>
#include <QObject>
#include <QMetaType>
//MITK
#include <mitkBaseData.h>
#include <MitkImageStatisticsUIExports.h>
/*!
\brief QmitkDataGenerationJobBase
Base class for generation jobs used by QmitkDataGenerationBase and derived classes.
*/
class MITKIMAGESTATISTICSUI_EXPORT QmitkDataGenerationJobBase : public QObject, public QRunnable
{
Q_OBJECT
public:
/** Result map that indicates all results generated by the job.
The key is a job specific label for the results.*/
using ResultMapType = std::map<std::string, mitk::BaseData::Pointer>;
virtual ResultMapType GetResults() const = 0;
/** Calls RunComputation() and takes care of the error handling and result signalling.*/
void run() final;
/*!
/brief Returns a flag the indicates if the job computation was successfull.*/
bool GetComputationSuccessFlag() const;
std::string GetLastErrorMessage() const;
signals:
void Error(QString err, const QmitkDataGenerationJobBase* job);
/*! @brief Signal is emitted when results are available.
@param results produced by the job and ready to be used.
- @param the job that produced the data
+ @param job the job that produced the data
*/
void ResultsAvailable(ResultMapType results, const QmitkDataGenerationJobBase* job);
protected:
QmitkDataGenerationJobBase() = default;
virtual ~QmitkDataGenerationJobBase() = default;
/**Does the real computation. Returns true if there where results produced.*/
virtual bool RunComputation() = 0;
std::string m_LastErrorMessage;
private:
bool m_ComputationSuccessful = false;
};
#endif
diff --git a/Modules/ImageStatisticsUI/Qmitk/QmitkDataGeneratorBase.h b/Modules/ImageStatisticsUI/Qmitk/QmitkDataGeneratorBase.h
index f3988f0060..e43e33cbc0 100644
--- a/Modules/ImageStatisticsUI/Qmitk/QmitkDataGeneratorBase.h
+++ b/Modules/ImageStatisticsUI/Qmitk/QmitkDataGeneratorBase.h
@@ -1,174 +1,175 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QmitkDataGeneratorBase_h
#define QmitkDataGeneratorBase_h
#include <mutex>
//QT
#include <QObject>
//MITK
#include <mitkDataStorage.h>
#include "QmitkDataGenerationJobBase.h"
#include <MitkImageStatisticsUIExports.h>
/*!
\brief QmitkDataGeneratorBase
BaseClass that implements the organisation of (statistic) data generation for pairs of images and ROIs.
The key idea is that this class ensures that for vector of given image ROI pairs (defined by derived classes)
a result instance (e.g ImageStatisticsContainer) will be calculated, if needed (e.g. because it is missing or
not uptodate anymore), and stored in the data storage passed to a generator instance. While derived classes i.a.
specify how to generate the image ROI pairs, how to detect latest results, what the next generation step is and
how to remove obsolete data from the storage, the base class takes care of the observation of the data storage
and orchestrates the whole checking and generation workflow.
In all the generation/orchestration process the data storage, passed to the generator, 1) serves as place where the final
results are stored and searched and 2) it resembles the state of the genertion process with these final results and WIP
place holder nodes that indicate planed or currently processed generation steps.
*/
class MITKIMAGESTATISTICSUI_EXPORT QmitkDataGeneratorBase : public QObject
{
Q_OBJECT
public:
QmitkDataGeneratorBase(const QmitkDataGeneratorBase& other) = delete;
QmitkDataGeneratorBase& operator=(const QmitkDataGeneratorBase& other) = delete;
virtual ~QmitkDataGeneratorBase();
using JobResultMapType = QmitkDataGenerationJobBase::ResultMapType;
mitk::DataStorage::Pointer GetDataStorage() const;
/** Indicates if the generator may trigger the update automatically (true). Reasons for an update are:
- Input data has been changed or modified
- Generation relevant settings in derived classes have been changed (must be implemented in derived classes)
*/
bool GetAutoUpdate() const;
/** Indicates if there is currently work in progress, thus data generation jobs are running or pending.
It is set to true when GenerationStarted is triggered and becomes false as soon as GenerationFinished is triggered.
*/
bool IsGenerating() const;
/** Checks data validity and triggers generation of data, if needed.
The generation itselfs will be done with a thread pool and is orchestrated by this class. To learn if the threads are finished and
everything is uptodate, listen to the signal GenerationFinished.
@return indicates if everything is already valid (true) or if the generation of new data was triggerd (false).*/
bool Generate() const;
/** Indicates if for a given image and ROI a valid final result is available.*/
virtual bool IsValidResultAvailable(const mitk::DataNode* imageNode, const mitk::DataNode* roiNode) const = 0;
public slots:
/** Sets the data storage the generator should monitor and where WIP placeholder nodes and final result nodes should be stored.*/
void SetDataStorage(mitk::DataStorage* storage);
void SetAutoUpdate(bool autoUpdate);
protected slots:
/** Used by QmitkDataGenerationJobBase to signal the generator that an error occured. */
void OnJobError(QString error, const QmitkDataGenerationJobBase* failedJob) const;
/** Used by QmitkDataGenerationJobBase to signal and communicate the results of there computation. */
void OnFinalResultsAvailable(JobResultMapType results, const QmitkDataGenerationJobBase *job) const;
signals:
/*! @brief Signal that is emitted if a data generation job is started to generat outdated/inexistant data.
*/
void DataGenerationStarted(const mitk::DataNode* imageNode, const mitk::DataNode* roiNode, const QmitkDataGenerationJobBase* job) const;
/*! @brief Signal that is emitted if new final data is produced.
*/
void NewDataAvailable(mitk::DataStorage::SetOfObjects::ConstPointer data) const;
/*! @brief Signal that is emitted if all jobs are finished and everything is up to date.
*/
void GenerationFinished() const;
/*! @brief Signal that is emitted in case of job errors.
*/
void JobError(QString error, const QmitkDataGenerationJobBase* failedJob) const;
protected:
/*! @brief Constructor
@param storage the data storage where all produced data should be stored
+ @param parent
*/
QmitkDataGeneratorBase(mitk::DataStorage::Pointer storage, QObject* parent = nullptr);
QmitkDataGeneratorBase(QObject* parent = nullptr);
using InputPairVectorType = std::vector<std::pair<mitk::DataNode::ConstPointer, mitk::DataNode::ConstPointer>>;
/** This method must be implemented by derived to indicate if a changed node is relevant and therefore if an update must be triggered.*/
virtual bool ChangedNodeIsRelevant(const mitk::DataNode* changedNode) const = 0;
/** This method must be impemented by derived classes to return the pairs of images and ROIs
(ROI may be null if no ROI is needed) for which data are needed.*/
virtual InputPairVectorType GetAllImageROICombinations() const = 0;
/** This method should indicate all missing and outdated (interim) results in the data storage, with new placeholder nodes and WIP dummy data
added to the storage. The placeholder nodes will be replaced by the real results as soon as they are ready.
The strategy how to detact which placeholder node is need and how the dummy data should look like must be implemented by derived classes.*/
virtual void IndicateFutureResults(const mitk::DataNode* imageNode, const mitk::DataNode* roiNode) const = 0;
/*! @brief Is called to generate the next job instance that needs to be done and is associated dummy node
in order to progress the data generation workflow.
@remark The method can assume that the caller takes care of the job instance deletion.
@return std::pair of job pointer and placeholder node associated with the job. Following combinations are possible:
- Both are null: nothing to do;
- Both are set: there is something to do for a pending dumme node -> trigger computation;
- Job null and node set: a job for this node is already work in progress -> pass on till its finished.*/
virtual std::pair<QmitkDataGenerationJobBase*,mitk::DataNode::Pointer> GetNextMissingGenerationJob(const mitk::DataNode* imageNode, const mitk::DataNode* roiNode) const =0;
/** Remove all obsolete data nodes for the given image and ROI node from the data storage.
Obsolete nodes are (interim) result nodes that are not the most recent any more.*/
virtual void RemoveObsoleteDataNodes(const mitk::DataNode* imageNode, const mitk::DataNode* roiNode) const = 0;
/** Prepares result to be added to the storage in an appropriate way and returns the data node for that.*/
virtual mitk::DataNode::Pointer PrepareResultForStorage(const std::string& label, mitk::BaseData* result, const QmitkDataGenerationJobBase* job) const = 0;
/*! Creates a data node for WIP place holder results. It can be used by IndicateFutureResults().*/
static mitk::DataNode::Pointer CreateWIPDataNode(mitk::BaseData* dataDummy, const std::string& nodeName);
/** Filters a passed pair vector. The returned pair vector only contains pair of nodes that exist in the data storage.*/
InputPairVectorType FilterImageROICombinations(InputPairVectorType&& imageROICombinations) const;
/** Return a descriptive label of a passed pair. Used e.g. for some debug log messages.*/
std::string GetPairDescription(const InputPairVectorType::value_type& imageAndSeg) const;
/** Internal part of the generation strategy. Here is where the heavy lifting is done.*/
bool DoGenerate() const;
/** Methods either directly calls generation or if its allready onging flags to restart the generation.*/
void EnsureRecheckingAndGeneration() const;
mitk::WeakPointer<mitk::DataStorage> m_Storage;
bool m_AutoUpdate = false;
mutable std::mutex m_DataMutex;
private:
/** Indicates if we are currently in the Generation() verification and generation of pending jobs triggering loop.
Only needed for the internal logic.*/
mutable bool m_InGenerate = false;
/** Internal flag that is set if a generation was requested, while one generation loop was already ongoing.*/
mutable bool m_RestartGeneration = false;
/** Indicates if there are still jobs pending or computing (true) or if everything is valid (false).*/
mutable bool m_WIP = false;
/** Internal flag that indicates that generator is currently in the process of adding results to the storage*/
mutable bool m_AddingToStorage = false;
/**Member is called when a node is added to the storage.*/
void NodeAddedOrModified(const mitk::DataNode* node);
unsigned long m_DataStorageDeletedTag;
};
#endif
diff --git a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsDataGenerator.h b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsDataGenerator.h
index 4d3766e246..2dc85d2f98 100644
--- a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsDataGenerator.h
+++ b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsDataGenerator.h
@@ -1,67 +1,69 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QmitkImageStatisticsDataGenerator_h
#define QmitkImageStatisticsDataGenerator_h
#include "QmitkImageAndRoiDataGeneratorBase.h"
#include <MitkImageStatisticsUIExports.h>
/**
Generates ImageStatisticContainers by using QmitkImageStatisticsCalculationRunnables for each pair if image and ROIs and ensures their
validity.
It also encodes the HistogramNBins and IgnoreZeroValueVoxel as properties to the results as these settings are important criteria for
discreminating statistics results.
For more details of how the generation is done see QmitkDataGenerationBase.
*/
class MITKIMAGESTATISTICSUI_EXPORT QmitkImageStatisticsDataGenerator : public QmitkImageAndRoiDataGeneratorBase
{
public:
QmitkImageStatisticsDataGenerator(mitk::DataStorage::Pointer storage, QObject* parent = nullptr) : QmitkImageAndRoiDataGeneratorBase(storage, parent) {};
QmitkImageStatisticsDataGenerator(QObject* parent = nullptr) : QmitkImageAndRoiDataGeneratorBase(parent) {};
bool IsValidResultAvailable(const mitk::DataNode* imageNode, const mitk::DataNode* roiNode) const;
/** Returns the latest result for a given image and ROI and the current settings of the generator.
+ @param imageNode
+ @param roiNode
@param onlyIfUpToDate Indicates if results should only be returned if the are up to date, thus not older then image and ROI.
@param noWIP If noWIP is true, the function only returns valid final result and not just its placeholder (WIP).
If noWIP equals false it might also return a WIP, thus the valid result is currently processed/ordered but might not be ready yet.*/
mitk::DataNode::Pointer GetLatestResult(const mitk::DataNode* imageNode, const mitk::DataNode* roiNode, bool onlyIfUpToDate = false, bool noWIP = true) const;
std::string GenerateStatisticsNodeName(const mitk::Image* image, const mitk::BaseData* roi) const;
/*! /brief Set flag to ignore zero valued voxels */
void SetIgnoreZeroValueVoxel(bool _arg);
/*! /brief Get status of zero value voxel ignoring. */
bool GetIgnoreZeroValueVoxel() const;
/*! /brief Set bin size for histogram resolution.*/
void SetHistogramNBins(unsigned int nbins);
/*! /brief Get bin size for histogram resolution.*/
unsigned int GetHistogramNBins() const;
protected:
bool ChangedNodeIsRelevant(const mitk::DataNode* changedNode) const;
void IndicateFutureResults(const mitk::DataNode* imageNode, const mitk::DataNode* roiNode) const;
std::pair<QmitkDataGenerationJobBase*, mitk::DataNode::Pointer> GetNextMissingGenerationJob(const mitk::DataNode* imageNode, const mitk::DataNode* roiNode) const;
void RemoveObsoleteDataNodes(const mitk::DataNode* imageNode, const mitk::DataNode* roiNode) const;
mitk::DataNode::Pointer PrepareResultForStorage(const std::string& label, mitk::BaseData* result, const QmitkDataGenerationJobBase* job) const;
QmitkImageStatisticsDataGenerator(const QmitkImageStatisticsDataGenerator&) = delete;
QmitkImageStatisticsDataGenerator& operator = (const QmitkImageStatisticsDataGenerator&) = delete;
bool m_IgnoreZeroValueVoxel = false;
unsigned int m_HistogramNBins = 100;
};
#endif
diff --git a/Modules/MapperExt/doc/Doxygen/Modules.dox b/Modules/MapperExt/doc/Doxygen/Modules.dox
index 0e499ef6ed..c2fe324db0 100644
--- a/Modules/MapperExt/doc/Doxygen/Modules.dox
+++ b/Modules/MapperExt/doc/Doxygen/Modules.dox
@@ -1,10 +1,10 @@
/**
\defgroup MitkMapperExtModule MapperExt
\ingroup MITKModules
\brief MITK mapper classes for data type extensions.
This module provides MITK mapper classes for the data types
- defined in the \ref MitkDataTypesExt module. It is usually
+ defined in the \ref MitkDataTypesExtModule module. It is usually
not used directly.
*/
diff --git a/Modules/MatchPointRegistrationUI/Qmitk/QmitkAlgorithmProfileViewer.h b/Modules/MatchPointRegistrationUI/Qmitk/QmitkAlgorithmProfileViewer.h
index 52f2d5bd68..d9d8333ea2 100644
--- a/Modules/MatchPointRegistrationUI/Qmitk/QmitkAlgorithmProfileViewer.h
+++ b/Modules/MatchPointRegistrationUI/Qmitk/QmitkAlgorithmProfileViewer.h
@@ -1,50 +1,50 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QMITK_ALGORITHM_PROFILE_VIEWER_H
#define QMITK_ALGORITHM_PROFILE_VIEWER_H
#include <mapDeploymentDLLInfo.h>
#include <MitkMatchPointRegistrationUIExports.h>
#include "ui_QmitkAlgorithmProfileViewer.h"
#include <QWidget>
/**
* \class QmitkAlgorithmProfileViewer
* \brief Widget that views the information and profile of an algorithm stored in an DLLInfo object.
*/
class MITKMATCHPOINTREGISTRATIONUI_EXPORT QmitkAlgorithmProfileViewer : public QWidget,
private Ui::QmitkAlgorithmProfileViewer
{
Q_OBJECT
public:
QmitkAlgorithmProfileViewer(QWidget *parent = nullptr);
/**
* \brief Updates the widget according to the new info.
- * \param pointer to the info instance.
+ * \param newInfo pointer to the info instance.
* \remark The DLLInfo is not stored internally or as reference
* to update the widget you must use the updateInfo() method.
*/
void updateInfo(const map::deployment::DLLInfo *newInfo);
public Q_SLOTS:
/**
* \brief Slot that can be used to trigger updateInfo();
*/
void OnInfoChanged(const map::deployment::DLLInfo *newInfo);
};
#endif // QmitkAlgorithmProfileViewer_H
diff --git a/Modules/MatchPointRegistrationUI/Qmitk/QmitkAlgorithmSettingsConfig.h b/Modules/MatchPointRegistrationUI/Qmitk/QmitkAlgorithmSettingsConfig.h
index c576a87283..afaa49bc1e 100644
--- a/Modules/MatchPointRegistrationUI/Qmitk/QmitkAlgorithmSettingsConfig.h
+++ b/Modules/MatchPointRegistrationUI/Qmitk/QmitkAlgorithmSettingsConfig.h
@@ -1,56 +1,56 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QMITK_ALGORITHM_SETTINGS_CONFIG_H
#define QMITK_ALGORITHM_SETTINGS_CONFIG_H
#include <QSortFilterProxyModel>
#include <QWidget>
#include <mapDeploymentDLLInfo.h>
#include <QmitkMAPAlgorithmModel.h>
#include <MitkMatchPointRegistrationUIExports.h>
#include "ui_QmitkAlgorithmSettingsConfig.h"
/**
* \class QmitkAlgorithmSettingsConfig
* \brief Widget that views the information and profile of an algorithm stored in an DLLInfo object.
*/
class MITKMATCHPOINTREGISTRATIONUI_EXPORT QmitkAlgorithmSettingsConfig : public QWidget,
private Ui::QmitkAlgorithmSettingsConfig
{
Q_OBJECT
public:
QmitkAlgorithmSettingsConfig(QWidget *parent = nullptr);
/**
* \brief Changes the current algorithm and updates widget accordingly.
- * \param pointer to the algorithm instance.
+ * \param alg pointer to the algorithm instance.
*/
void setAlgorithm(map::algorithm::RegistrationAlgorithmBase *alg);
map::algorithm::RegistrationAlgorithmBase *getAlgorithm();
protected:
/** Pointer to the algorithm that should be configured */
map::algorithm::RegistrationAlgorithmBase::Pointer m_currentAlg;
// control the properties of the selected algorithm
QmitkMAPAlgorithmModel *m_AlgorithmModel;
QSortFilterProxyModel *m_ProxyModel;
};
#endif // QmitkAlgorithmSettingsConfig_H
diff --git a/Modules/MatchPointRegistrationUI/Qmitk/QmitkMapperSettingsWidget.h b/Modules/MatchPointRegistrationUI/Qmitk/QmitkMapperSettingsWidget.h
index 0dd3e5f0cf..c2e6da6ee5 100644
--- a/Modules/MatchPointRegistrationUI/Qmitk/QmitkMapperSettingsWidget.h
+++ b/Modules/MatchPointRegistrationUI/Qmitk/QmitkMapperSettingsWidget.h
@@ -1,65 +1,65 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QMITK_MAPPER_SETTINGS_WIDGET_H
#define QMITK_MAPPER_SETTINGS_WIDGET_H
#include <MitkMatchPointRegistrationUIExports.h>
#include "ui_QmitkMapperSettingsWidget.h"
#include <QWidget>
struct QmitkMappingJobSettings;
/**
* \class QmitkMapperSettingsWidget
* \brief Widget that views the information and profile of an algorithm stored in an DLLInfo object.
*/
class MITKMATCHPOINTREGISTRATIONUI_EXPORT QmitkMapperSettingsWidget : public QWidget,
private Ui::QmitkMapperSettingsWidget
{
Q_OBJECT
public:
QmitkMapperSettingsWidget(QWidget *parent = nullptr);
/**
* Configures the passed settings according to the current state of the
* widget.
- * \param pointer to a instance based on QmitkMappingJobSettings.
+ * \param settings to a instance based on QmitkMappingJobSettings.
* \pre settings must point to a valid instance..
*/
void ConfigureJobSettings(QmitkMappingJobSettings *settings);
public Q_SLOTS:
/**
* \brief Slot that can be used to set the mode for the mapping settings.
* Mask mode allows only nearest neighbour interpolation. It is needed for exmample
* when mapping segmentations.*/
void SetMaskMode(bool activeMask);
/**
* \brief Slot that can be used to set the widget to a mode where super/sub sampling
* is allowed (true) or not (false).*/
void AllowSampling(bool allow);
protected Q_SLOTS:
void OnLinkSampleFactorChecked();
void OnXFactorChanged(double d);
protected:
bool m_MaskMode;
bool m_allowSampling;
};
#endif // QmitkMapperSettingsWidget_H
diff --git a/Modules/ModelFitUI/Qmitk/QmitkInitialValuesManagerWidget.h b/Modules/ModelFitUI/Qmitk/QmitkInitialValuesManagerWidget.h
index a0bbb3a33c..1592cad2d6 100644
--- a/Modules/ModelFitUI/Qmitk/QmitkInitialValuesManagerWidget.h
+++ b/Modules/ModelFitUI/Qmitk/QmitkInitialValuesManagerWidget.h
@@ -1,84 +1,84 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QMITK_INITIAL_VALUES_MANAGER_WIDGET_H
#define QMITK_INITIAL_VALUES_MANAGER_WIDGET_H
#include "MitkModelFitUIExports.h"
#include "ui_QmitkInitialValuesManagerWidget.h"
#include <QWidget>
#include "mitkModelTraitsInterface.h"
#include "mitkInitialParameterizationDelegateBase.h"
/*forward declarations*/
class QmitkInitialValuesModel;
class QmitkInitialValuesTypeDelegate;
class QmitkInitialValuesDelegate;
namespace mitk
{
class DataStorage;
class BaseGeometry;
}
/**
* \class QmitkInitialValuesManagerWidget
* \brief Widget that allows to edit the initial values of an model.
*/
class MITKMODELFITUI_EXPORT QmitkInitialValuesManagerWidget : public QWidget
{
Q_OBJECT
public:
QmitkInitialValuesManagerWidget(QWidget* parent = nullptr);
~QmitkInitialValuesManagerWidget() override;
/** Returns the current set initial values of the model.*/
mitk::ModelTraitsInterface::ParametersType getInitialValues() const;
mitk::InitialParameterizationDelegateBase::Pointer getInitialParametrizationDelegate() const;
bool hasValidInitialValues() const;
signals:
void initialValuesChanged();
public Q_SLOTS:
/** Sets the names and the values of the initial parameter set for the model.
@param names List of all possible parameter names. It is assumed that the
index of the list equals the parameter index in the respective fitting model and its parameter values.
- @values Default values to start with.*/
+ @param values Default values to start with.*/
void setInitialValues(const mitk::ModelTraitsInterface::ParameterNamesType& names,
const mitk::ModelTraitsInterface::ParametersType values);
void setInitialValues(const mitk::ModelTraitsInterface::ParameterNamesType& names);
void setDataStorage(mitk::DataStorage* storage);
void setReferenceImageGeometry(mitk::BaseGeometry* refgeo);
protected:
QmitkInitialValuesModel* m_InternalModel;
QmitkInitialValuesTypeDelegate* m_TypeDelegate;
QmitkInitialValuesDelegate* m_ValuesDelegate;
Ui::QmitkInitialValuesManagerWidget m_Controls;
protected Q_SLOTS:
void OnModelReset();
};
#endif // QmitkInitialValuesManagerWidget_H
diff --git a/Modules/ModelFitUI/Qmitk/QmitkInitialValuesModel.h b/Modules/ModelFitUI/Qmitk/QmitkInitialValuesModel.h
index bb4bd15456..b3dc1a17e6 100644
--- a/Modules/ModelFitUI/Qmitk/QmitkInitialValuesModel.h
+++ b/Modules/ModelFitUI/Qmitk/QmitkInitialValuesModel.h
@@ -1,94 +1,94 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QmitkInitialValuesModel_h
#define QmitkInitialValuesModel_h
#include <QAbstractTableModel>
#include "mitkSimpleBarrierConstraintChecker.h"
#include "mitkModelTraitsInterface.h"
#include "mitkDataNode.h"
#include "mitkInitialParameterizationDelegateBase.h"
#include "MitkModelFitUIExports.h"
/*!
\class QmitkInitialValuesModel
Model that handles the definition of inital model values.
*/
class MITKMODELFITUI_EXPORT QmitkInitialValuesModel : public QAbstractTableModel
{
Q_OBJECT
public:
QmitkInitialValuesModel(QObject* parent = nullptr);
~QmitkInitialValuesModel() override {};
/** Sets the names and the values of the initial parameter set for the model.
@param names List of all possible parameter names. It is assumed that the
index of the list equals the parameter index in the respective fitting model and its parameter values.
- @values Default values to start with.*/
+ @param values Default values to start with.*/
void setInitialValues(const mitk::ModelTraitsInterface::ParameterNamesType& names,
const mitk::ModelTraitsInterface::ParametersType values);
/**@overload
Convinience method that sets the default initial values always to zero.*/
void setInitialValues(const mitk::ModelTraitsInterface::ParameterNamesType& names);
/** Adds an image as a source for the initial value of a parameter.
* @param node Pointer to the image that is the value source.
* @param paramIndex Indicates which parameter is defined by the source image.
* It equals the position of the vector defined by setInitialValues().
* @remark setting an image for an index overwrites the value for this index set by
* SetInitialParameterization.
* @pre paramIndex must be in bound of the initial parametrization vector.
* @pre node must be a valid image instance*/
void addInitialParameterImage(const mitk::DataNode* node, mitk::ModelTraitsInterface::ParametersType::size_type paramIndex);
bool hasValidInitialValues() const;
void resetInitialParameterImage();
/** Returns a pointer to a delegate instance that represents the parameterization of the model.*/
mitk::InitialParameterizationDelegateBase::Pointer getInitialParametrizationDelegate() const;
/** Returns the current set initial values of the model.
- * @Remark: this are only the simpel scalar initial values. If an source image was set, this is missed here.
+ * @remark this are only the simpel scalar initial values. If an source image was set, this is missed here.
* Use getInitialParametrizationDelegate() to get everything at once.*/
mitk::ModelTraitsInterface::ParametersType getInitialValues() const;
Qt::ItemFlags flags(const QModelIndex& index) const override;
QVariant data(const QModelIndex& index, int role) const override;
QVariant headerData(int section, Qt::Orientation orientation, int role) const override;
int rowCount(const QModelIndex& parent = QModelIndex()) const override;
int columnCount(const QModelIndex& parent = QModelIndex()) const override;
bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole) override;
/**Indicates if the content of the model was modified since the data was set via setInitialValues()*/
bool isModified();
private:
int valueType(const QModelIndex& index) const;
mitk::ModelTraitsInterface::ParametersType m_Values;
mitk::ModelTraitsInterface::ParameterNamesType m_ParameterNames;
typedef std::map<mitk::ModelTraitsInterface::ParametersType::size_type, mitk::DataNode::ConstPointer> ImageMapType;
ImageMapType m_ParameterImageMap;
/** Indicates if the data of the model was modified, since the model was set. */
bool m_modified;
};
#endif // QmitkInitialValuesModel_h
diff --git a/Modules/OpenCL/mitkOclResourceService.h b/Modules/OpenCL/mitkOclResourceService.h
index 47b8cdb0b0..5ce273beaa 100644
--- a/Modules/OpenCL/mitkOclResourceService.h
+++ b/Modules/OpenCL/mitkOclResourceService.h
@@ -1,79 +1,79 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef __mitkOclResourceService_h
#define __mitkOclResourceService_h
#include <mitkServiceInterface.h>
#include <mitkOpenCL.h>
/**
* @brief Declaration of the OpenCL Resources micro-service
*
* The OclResourceService defines an service interface for providing access to the
* essential OpenCL-related variables. In addition the service can also store compiled
* OpenCL Programs in order to avoid multiple compiling of a single program source
*/
class OclResourceService
{
public:
/** @brief Returns a valid OpenCL Context (if applicable) or nullptr if none present */
virtual cl_context GetContext() const = 0;
/** @brief Returns a valid cl_command_queue related to the (one) OpenCL context */
virtual cl_command_queue GetCommandQueue() const = 0;
/** @brief Returns the identifier of an OpenCL device related to the current context */
virtual cl_device_id GetCurrentDevice() const = 0;
/** @brief Checks if an OpenCL image format passed in is supported on current device */
virtual bool GetIsFormatSupported( cl_image_format* format ) = 0;
/** @brief Puts the OpenCL Context info in std::cout */
virtual void PrintContextInfo() const = 0;
/** @brief Insert program into the internal program storage
*
* @param program A cl_program object.
* @param string Text identifier of the inserted program. Used for getting the program.
- * @param todo: what is the flag?
+ * @param flag
*/
virtual void InsertProgram(cl_program program, std::string string, bool flag) = 0;
/** @brief Get the cl_program by name
* @param name Text identifier of the program.
* @throws an mitk::Exception in case the program cannot be found
*/
virtual cl_program GetProgram(const std::string& name) = 0;
/** @brief Remove all invalid (=do not compile) programs from the internal storage */
virtual void InvalidateStorage() = 0;
/** @brief Remove given program from storage
* @param name Text identifier of the program.
*/
virtual void RemoveProgram(const std::string& name) = 0;
/** @brief Get the maximum size of an image
*
* @param dimension (unsigned int) identifier of the image diemsion in {0,1,2}
* @param image object type, either CL_MEM_OBJECT_IMAGE2D, CL_MEM_OBJECT_IMAGE3D
*/
- virtual unsigned int GetMaximumImageSize( unsigned int , cl_mem_object_type) = 0;
+ virtual unsigned int GetMaximumImageSize(unsigned int dimension, cl_mem_object_type image) = 0;
virtual ~OclResourceService() = 0;
};
MITK_DECLARE_SERVICE_INTERFACE(OclResourceService, "OpenCLResourceService/1.0")
#endif // __mitkOclResourceService_h
diff --git a/Modules/Python/documentation/mitkPython.dox b/Modules/Python/documentation/mitkPython.dox
index b25d78554c..ce19e8112b 100644
--- a/Modules/Python/documentation/mitkPython.dox
+++ b/Modules/Python/documentation/mitkPython.dox
@@ -1,47 +1,47 @@
/**
\page mitkPython_Overview Python Module
\section python_sec1 Brief description
The MITK Python Module provides a service class to interactively run python code (passed as C++ strings) and
evaluate the results. Furthermore the service class offers means to convert an MITK Image to an ITK/OpenCV image in their wrapped python environment.
<strong>Thus, one can process MITK images with Python Code from the OpenCV and ITK wrapping system</strong>.
Furthermore one can convert an mitk::Surface to a vtkPolyData in its Python environment.<br />
Under the hood, the MITK build system takes care that the wrapping build process for SimpleITK/VTK/OpenCV is correctly initiated and all paths are correctly set within MITK code.
To use the features of the different toolkits make sure they are enabled during the superbuild process.
\section python_sec2 Build Instructions
-Have a look at \ref python_ssec3 on how to build MITK-Python with Qt5.
+Have a look at \ref python_sec3 on how to build MITK-Python with Qt5.
The following CMake build options are available:
<ul>
<li> MITK_USE_Python3
</ul>
\subsection python_ssec1 MITK_USE_Python3
MITK_USE_Python3 enables the python wrapping in MITK. When the option is activated
the build of the additional dependency SimpleITK is also enabled. The default behaviour is to use the python runtime from the system is used.
Only Python 3.x is supported.
The user can also specify it's own runtime by modifying the variables added by the
FindPythonLib.cmake script. <strong>Note:</strong> A Python runtime with numpy is needed to use the MITK Python wrapping.
When using this options all additional libraries installed in the python runtime will be available within the MITK-Python console.
\section python_sec3 Suported Data Types
The following data types in MITK are supported in the MITK Python Wrapping:
<ul>
<li> Image
<li> Surface
</ul>
\subsection python_ssec4 Image
Mitk Images can be transferred to python. The images are copied in-memory and
transferred as a numpy array to Python and vice versa. The MITK python wrapping creates a SimpleITK image
using the numpy array with the properties of the MITK Image. Two dimensional images
can also be transferred as an OpenCV image to python.
\subsection python_ssec5 Surface
Surfaces within mitk can be transferred as a vtkPolyData Object to Python.
The surfaces are fully memory mapped. When changing a python wrapped surface
the original object is also modified on the C++ side of MITK.
*/
diff --git a/Modules/QtOverlays/QmitkCustomWidgetOverlay.h b/Modules/QtOverlays/QmitkCustomWidgetOverlay.h
index 684accc0ef..97e002d76d 100644
--- a/Modules/QtOverlays/QmitkCustomWidgetOverlay.h
+++ b/Modules/QtOverlays/QmitkCustomWidgetOverlay.h
@@ -1,55 +1,55 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QmitkCustomWidgetOverlay_H_HEADER_INCLUDED_C10DC4EB
#define QmitkCustomWidgetOverlay_H_HEADER_INCLUDED_C10DC4EB
// MITK
#include "QmitkOverlay.h"
#include <MitkQtOverlaysExports.h>
/** \class QmitkCustomWidgetOverlay
* \brief object representing a custom widget that is handled and positioned
* as an overlay.
*
* A QmitkCustomWidgetOverlay is a generic sub-class of QmitkOverlay. It
* offers the possibility to set the internal m_Widget from the outside.
*
* This offers the possibility to position custom widgets 'on top of' other
* widgets using the positioning mechanism of all overlays.
*
-* \warn The custom widgets need to be configured and connected manually.
+* \warning The custom widgets need to be configured and connected manually.
* Properties cannot be set.
*
* \ingroup Overlays
*/
class MITKQTOVERLAYS_EXPORT QmitkCustomWidgetOverlay : public QmitkOverlay
{
public:
/**
* @brief Default Constructor
**/
QmitkCustomWidgetOverlay(const char *id);
/**
* @brief Default Destructor
**/
~QmitkCustomWidgetOverlay() override;
void SetWidget(QWidget *widget);
QSize GetNeededSize() override;
};
#endif /* QmitkCustomWidgetOverlay_H_HEADER_INCLUDED_C10DC4EB */
diff --git a/Modules/QtOverlays/QmitkScalarBarOverlay.h b/Modules/QtOverlays/QmitkScalarBarOverlay.h
index b5502d6de0..6cdb69df66 100644
--- a/Modules/QtOverlays/QmitkScalarBarOverlay.h
+++ b/Modules/QtOverlays/QmitkScalarBarOverlay.h
@@ -1,81 +1,81 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef MITKSCALARBAROVERLAY_H_HEADER_INCLUDED_C10DC4EB
#define MITKSCALARBAROVERLAY_H_HEADER_INCLUDED_C10DC4EB
#include <MitkQtOverlaysExports.h>
// MITK-Stuff
#include "QmitkOverlay.h"
#include "mitkCommon.h"
#include "mitkPropertyList.h"
#include <QmitkScalarBar.h>
/** \class QmitkScalarBarOverlay
* \brief object representing a text that is drawn as an overlay
*
* \ingroup Qmitk
*/
class MITKQTOVERLAYS_EXPORT QmitkScalarBarOverlay : public QmitkOverlay
{
Q_OBJECT
public:
/**
* @brief Default Constructor
**/
QmitkScalarBarOverlay(const char *id);
/**
* @brief Default Destructor
**/
~QmitkScalarBarOverlay() override;
/**
* \brief Setup the QLabel with overlay specific information
*
* First, this method sets text-overlay specific properties as described in the class docu above.
* Secondly, the actual text of the label is set.
*
- * \WARNING No error will be issued if the property containing the text is not found, the TextOverlay
+ * \warning No error will be issued if the property containing the text is not found, the TextOverlay
* will show an empty string!
*/
void GenerateData(mitk::PropertyList::Pointer) override;
QSize GetNeededSize() override;
protected:
/**
* \brief internal helper class to determine text-properties
*
* This method is only used internally to apply the text specific properties that can be set
* using a mitk::PropertyList. If a property cannot be found, a default value is used.
*
* The values of these properties are then attributed to the label using QFont and QPalette.
*/
void GetProperties(mitk::PropertyList::Pointer);
void SetupCallback(mitk::BaseProperty::Pointer prop);
void SetScaleFactor();
/** \brief QWidget internally representing the TextOverlay */
QmitkScalarBar *m_ScalarBar;
mitk::BaseProperty::Pointer m_ObservedProperty;
mitk::PropertyList::Pointer m_PropertyList;
unsigned long m_ObserverTag;
};
#endif /* MITKSCALARBAROVERLAY_H_HEADER_INCLUDED_C10DC4EB */
diff --git a/Modules/QtOverlays/QmitkTextOverlay.h b/Modules/QtOverlays/QmitkTextOverlay.h
index 56d1ce7e55..c11ecb63c6 100644
--- a/Modules/QtOverlays/QmitkTextOverlay.h
+++ b/Modules/QtOverlays/QmitkTextOverlay.h
@@ -1,106 +1,106 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef MITKTEXTOVERLAY_H_HEADER_INCLUDED_C10DC4EB
#define MITKTEXTOVERLAY_H_HEADER_INCLUDED_C10DC4EB
// MITK
#include "QmitkOverlay.h"
#include "mitkCommon.h"
#include "mitkPropertyList.h"
// Qt
#include <QLabel>
#include <MitkQtOverlaysExports.h>
/** \class QmitkTextOverlay
* \brief object representing a text that is drawn as an overlay
*
* A QmitkTextOverlay is a text-specific implementation of QmitkOverlay.
* It can be used whenever a simple text is to be rendered as an overlay in
* a QmitkRenderWindow.
*
* Instead of a QWidget (as in QmitkOverlay) a QmitkTextOverlay is internally
* represented by a QLabel. You can access it via GetWidget().
*
* Calling GenerateData( mitk::PropertyList::Pointer ) will setup the textoverlay.
* This includes setting of the actual text (that must be stored in the property
* with the name that is given the overlay as ID).
*
* e.g. mitk::StringProperty::Pointer nameProp = mitk::StringProperty::New( "overlay.text.patientName", "Max" );
* --
* QmitkTextOverlay* nameOverlay = new QmitkTextOverlay( "overlay.text.patientName" );
*
* In order to customize the look of the textoverlays, a number of additional properties can be set
* (default values in square brackets):
*
* overlay.color : defines the text-color (mitk::ColorProperty)
* overlay.fontSize : defines the fontSize of the text (mitk::IntProperty)
* overlay.kerning : defines if kerning is to be used (mitk::BoolProperty)
* overlay.fontFamily : defines the fon family that is to be used (mitk::StringProperty)
*
* \ingroup Qmitk
*/
class MITKQTOVERLAYS_EXPORT QmitkTextOverlay : public QmitkOverlay
{
public:
/**
* @brief Default Constructor
**/
QmitkTextOverlay(const char *id);
/**
* @brief Default Destructor
**/
~QmitkTextOverlay() override;
/**
* \brief Setup the QLabel with overlay specific information
*
* First, this method sets text-overlay specific properties as described in the class docu above.
* Secondly, the actual text of the label is set.
*
- * \WARNING No error will be issued if the property containing the text is not found, the TextOverlay
+ * \warning No error will be issued if the property containing the text is not found, the TextOverlay
* will show an empty string!
*/
void GenerateData(mitk::PropertyList::Pointer) override;
QSize GetNeededSize() override;
protected:
/**
* \brief internal helper class to determine text-properties
*
* This method is only used internally to apply the font specific properties that can be set
* using a mitk::PropertyList. If a property cannot be found, a default value is used.
*
* The values of these properties are then attributed to the QLabel using QFont and QPalette.
*/
void UpdateFontProperties(mitk::PropertyList::Pointer);
void SetupCallback(mitk::BaseProperty::Pointer prop);
void UpdateDisplayedTextFromProperties();
/** \brief QLabel internally representing the TextOverlay */
QLabel *m_Label;
mitk::PropertyList::Pointer m_PropertyList;
mitk::BaseProperty::Pointer m_ObservedProperty;
unsigned long m_ObserverTag;
};
#endif /* MITKTEXTOVERLAY_H_HEADER_INCLUDED_C10DC4EB */
diff --git a/Modules/QtWidgets/include/QmitkAbstractDataStorageInspector.h b/Modules/QtWidgets/include/QmitkAbstractDataStorageInspector.h
index de4ed08294..7b3bc62517 100644
--- a/Modules/QtWidgets/include/QmitkAbstractDataStorageInspector.h
+++ b/Modules/QtWidgets/include/QmitkAbstractDataStorageInspector.h
@@ -1,129 +1,129 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QMITKABSTRACTDATASTORAGEINSPECTOR_H
#define QMITKABSTRACTDATASTORAGEINSPECTOR_H
#include <QmitkModelViewSelectionConnector.h>
#include <MitkQtWidgetsExports.h>
// mitk core
#include <mitkDataStorage.h>
#include <mitkNodePredicateBase.h>
// qt
#include <QWidget>
class QAbstractItemVew;
/**
* @brief This abstract class is a convenient base class for easy implementation of widgets that
* offer a specific view onto a given DataStorage instance to inspect its contents.
* One may also get the selection in this inspector of the data storage.
*/
class MITKQTWIDGETS_EXPORT QmitkAbstractDataStorageInspector : public QWidget
{
Q_OBJECT
public:
~QmitkAbstractDataStorageInspector() override;
/**
* @brief Sets the data storage that will be used /monitored by the widget.
*
* @param dataStorage A pointer to the data storage to set.
*/
void SetDataStorage(mitk::DataStorage* dataStorage);
/**
* @brief Sets the node predicate and updates the widget, according to the node predicate.
*
* @param nodePredicate A pointer to node predicate.
*/
virtual void SetNodePredicate(const mitk::NodePredicateBase* nodePredicate);
const mitk::NodePredicateBase* GetNodePredicate() const;
using NodeList = QList<mitk::DataNode::Pointer>;
/** Returns the list of currently selected nodes.*/
NodeList GetSelectedNodes() const;
/** Returns an pointer to the view that is used in the inspector to show the content.*/
virtual QAbstractItemView* GetView() = 0;
virtual const QAbstractItemView* GetView() const = 0;
/** Returns the setting of the internal connector. It can be changed by SetSelectOnlyVisibleNodes()*/
bool GetSelectOnlyVisibleNodes() const;
using SelectionMode = QAbstractItemView::SelectionMode;
/** Sets the selection mode of the inspector.*/
virtual void SetSelectionMode(SelectionMode mode) = 0;
virtual SelectionMode GetSelectionMode() const = 0;
Q_SIGNALS:
/**
* @brief A signal that will be emitted if the selected node has changed.
*
* @param nodes A list of data nodes that are newly selected.
*/
void CurrentSelectionChanged(NodeList nodes);
public Q_SLOTS:
/**
* @brief Change the selection modus of the item view's selection model.
*
* If true, an incoming selection will be filtered (reduced) to only those nodes that are visible by the current view.
* An outgoing selection can then at most contain the filtered nodes.
* If false, the incoming non-visible selection will be stored and later added to the outgoing selection,
* to include the original selection that could not be modified.
* The part of the original selection, that is non-visible are the nodes that are not
*
* @param selectOnlyVisibleNodes The bool value to define the selection modus.
*/
void SetSelectOnlyVisibleNodes(bool selectOnlyVisibleNodes);
/**
* @brief Transform a list of data nodes into a model selection and set this as a new selection of the
* selection model of the private member item view.
*
* The function filters the given list of nodes according to the 'm_SelectOnlyVisibleNodes' member variable. If
* necessary, the non-visible nodes are stored. This is done if 'm_SelectOnlyVisibleNodes' is false: In this case
* the selection may be filtered and only a subset of the selected nodes may be visible and therefore (de-)selectable
* in the data storage viewer. By storing the non-visible nodes it is possible to send the new, modified selection
* but also include the selected nodes from the original selection that could not be modified (see 'SetSelectOnlyVisibleNodes').
*
- * @param nodes A list of data nodes that should be newly selected.
+ * @param selectedNodes A list of data nodes that should be newly selected.
*/
void SetCurrentSelection(NodeList selectedNodes);
protected Q_SLOTS:
void OnSelectionChanged(NodeList selectedNodes);
protected:
/** Helper function is called if data storage or predicate is changed to (re) initialize the widget correctly.
Implement the function in derived classes.*/
virtual void Initialize() = 0;
mitk::WeakPointer<mitk::DataStorage> m_DataStorage;
mitk::NodePredicateBase::ConstPointer m_NodePredicate;
std::unique_ptr<QmitkModelViewSelectionConnector> m_Connector;
QmitkAbstractDataStorageInspector(QWidget* parent = nullptr);
};
#endif // QMITKABSTRACTDATASTORAGEMODEL_H
diff --git a/Modules/QtWidgets/include/QmitkDataStorageListModel.h b/Modules/QtWidgets/include/QmitkDataStorageListModel.h
index 6ab6c7796b..333e2ea98a 100755
--- a/Modules/QtWidgets/include/QmitkDataStorageListModel.h
+++ b/Modules/QtWidgets/include/QmitkDataStorageListModel.h
@@ -1,156 +1,156 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QmitkDataStorageListModel_h
#define QmitkDataStorageListModel_h
#include <MitkQtWidgetsExports.h>
// MITK
#include "mitkDataStorage.h"
#include "mitkNodePredicateBase.h"
// Qt
#include <QAbstractListModel>
//! \ingroup QmitkModule
//! Qt list model for the (optionally filtered) nodes in a DataStorage.
//!
//! Given a data storage instance, this model will observe the storage
//! for its list of nodes and keep the provided Qt model up to date.
//! When given a NodePredicateBase instance, the Qt model will only
//! contain nodes that satisfy the predicate. This is useful to
//! display lists of a certain data type only, for example.
//!
//! Developer notes:
//! - class should be reviewed by somebody who knows well Qt models
//! - The OnSomethingModifedAddedRemoved() methods are declared virtual. They are required
//! to be executed on event reception, though! They should not be virtual.
//! - Is there any valid use case for sub-classing? Declare class final?
//! - Is GetDataNodes needed? DataStorage or Qt model would yield the same result.
class MITKQTWIDGETS_EXPORT QmitkDataStorageListModel : public QAbstractListModel
{
public:
//! \param dataStorage the data storage to represent
- //! \param predicate the optional predicate to filter filters
+ //! \param pred the optional predicate to filter filters
//! \param parent the Qt parent of this Qt object
QmitkDataStorageListModel(mitk::DataStorage *dataStorage = nullptr,
mitk::NodePredicateBase::Pointer pred = nullptr,
QObject *parent = nullptr);
~QmitkDataStorageListModel() override;
//! Change the data storage to represent
void SetDataStorage(mitk::DataStorage::Pointer dataStorage);
//! Get the represented data storage
mitk::DataStorage *GetDataStorage() const;
//! Change the filter predicate
void SetPredicate(mitk::NodePredicateBase *pred);
//! Get the filter predicate in use
mitk::NodePredicateBase *GetPredicate() const;
//! Get all current data nodes
std::vector<mitk::DataNode *> GetDataNodes() const;
//! Return the node for given model index
mitk::DataNode::Pointer getNode(const QModelIndex &index) const;
//! Return the model index of the given node
QModelIndex getIndex(const mitk::DataNode *node) const;
//! Implements QAbstractListModel
Qt::ItemFlags flags(const QModelIndex &index) const override;
//! Implements QAbstractListModel
QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
//! Implements QAbstractListModel
QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
//! Implements QAbstractListModel
int rowCount(const QModelIndex &parent = QModelIndex()) const override;
//! Called when a DataStorage Add Event was thrown. May be reimplemented
//! by deriving classes.
//!
//! \warning When sub-classing, call this class' method first! Otherwise the node
//! addition will not be reflected in the Qt model!
virtual void OnDataStorageNodeAdded(const mitk::DataNode *node);
//! Called when a DataStorage Remove Event was thrown. May be reimplemented
//! by deriving classes.
//!
//! \warning When sub-classing, call this class' method first! Otherwise the node
//! removal will not be reflected in the Qt model!
virtual void OnDataStorageNodeRemoved(const mitk::DataNode *node);
//! Callback entry for observed DataNodes' ModifiedEvent().
//!
//! Emits signal dataChanged().
virtual void OnDataNodeModified(const itk::Object *caller, const itk::EventObject &event);
//! Callback entry for observed BaseDatas' ModifiedEvent().
//!
//! Emits signal dataChanged().
virtual void OnDataModified(const itk::Object *caller, const itk::EventObject &event);
//! Callback entry for DataStorage's DeleteEvent().
//!
//! Clears the model.
virtual void OnDataStorageDeleted(const itk::Object *caller, const itk::EventObject &event);
protected:
//! \brief Resets the whole model. Get all nodes matching the predicate from the data storage.
void reset();
//! Internal helper: adds given node to end of list
void AddNodeToInternalList(mitk::DataNode *node);
//! Internal helper: remove given node
void RemoveNodeFromInternalList(mitk::DataNode *node);
//! Internal helper: Clear complete model list
void ClearInternalNodeList();
private:
enum OBSERVER_TUPLE_NAMES
{
NODE = 0,
NODE_OBSERVER = 1,
DATA_OBSERVER = 2,
};
//! Holds the predicate that defines what nodes are part of the model.
mitk::NodePredicateBase::Pointer m_NodePredicate;
//! The DataStorage that is represented in the model.
//! We keep only a weak pointer and observe the storage for deletion.
mitk::DataStorage *m_DataStorage;
//! ITK observer tag for the storage's DeleteEvent()
unsigned long m_DataStorageDeleteObserverTag;
//! List of the current model's DataNodes along with their ModifiedEvent observer tags
//! - element 0 : node
//! - element 1 : node's ModifiedEvent observer.
//! - element 2 : node data's ModifiedEvent observer.
std::vector<std::tuple<mitk::DataNode *, unsigned long, unsigned long>> m_NodesAndObserverTags;
//! Prevents infinite loops.
bool m_BlockEvents;
};
#endif /* QMITKDATASTORAGELISTMODEL_H_ */
diff --git a/Modules/QtWidgets/include/QmitkDataStorageTableModel.h b/Modules/QtWidgets/include/QmitkDataStorageTableModel.h
index e69bf5bece..0abd6382e4 100644
--- a/Modules/QtWidgets/include/QmitkDataStorageTableModel.h
+++ b/Modules/QtWidgets/include/QmitkDataStorageTableModel.h
@@ -1,223 +1,223 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QmitkDataStorageTableModel_h
#define QmitkDataStorageTableModel_h
#include <MitkQtWidgetsExports.h>
/// Own includes.
#include "mitkBaseProperty.h"
#include "mitkDataStorage.h"
#include "mitkNodePredicateBase.h"
#include "mitkWeakPointer.h"
/// Toolkit includes.
#include <QAbstractTableModel>
/// Forward declarations.
///
/// \ingroup QmitkModule
/// \class QmitkDataStorageTableModel
///
/// \brief A table model for a set of DataNodes defined by a predicate.
-/// \TODO make columns interchangeable, select which properties to show as columns
+/// \todo make columns interchangeable, select which properties to show as columns
///
class MITKQTWIDGETS_EXPORT QmitkDataStorageTableModel : public QAbstractTableModel
{
Q_OBJECT
//#Ctors/Dtor
public:
///
/// Constructs a new QmitkDataStorageTableModel and sets a predicate that defines
/// this list.
/// \see setPredicate()
///
QmitkDataStorageTableModel(mitk::DataStorage::Pointer _DataStorage,
mitk::NodePredicateBase *_Predicate = nullptr,
QObject *parent = nullptr);
///
/// Standard dtor. Delete predicate, disconnect from DataStorage.
///
~QmitkDataStorageTableModel() override;
//# Public GETTER
public:
///
/// Get the DataStorage.
///
const mitk::DataStorage::Pointer GetDataStorage() const;
///
/// Get the predicate.
///
mitk::NodePredicateBase::Pointer GetPredicate() const;
///
/// Get node at a specific model index. Another way to implement this, is
/// by introducing a new role like "DateTreeNode" and capture
/// that in the data function.
///
mitk::DataNode::Pointer GetNode(const QModelIndex &index) const;
///
/// Overridden from QAbstractTableModel. Returns the header data at section
/// for given orientation and role.
///
QVariant headerData(int section, Qt::Orientation orientation, int role) const override;
///
/// Overridden from QAbstractTableModel. Returns what can be done
/// with an item.
///
Qt::ItemFlags flags(const QModelIndex &index) const override;
///
/// Overridden from QAbstractTableModel. Returns the node count.
///
int rowCount(const QModelIndex &parent) const override;
///
/// Overridden from QAbstractTableModel. Returns the number of features (columns) to display.
///
int columnCount(const QModelIndex &parent) const override;
///
/// Overridden from QAbstractTableModel. Returns the data at index for given role.
///
QVariant data(const QModelIndex &index, int role) const override;
//# Public SETTERS
public:
///
/// Sets the DataStorage.
///
void SetDataStorage(mitk::DataStorage::Pointer _DataStorage);
///
/// Sets the predicate. <b>QmitkDataStorageTableModel is owner of the predicate!</b>
///
void SetPredicate(mitk::NodePredicateBase *_Predicate);
///
/// Adds a node to this model.
/// There are two constraints for nodes in this model:
/// 1. If a predicate is set (not null) the node will be checked against it.
/// 2. The node has to have a data object (no one wants to see empty nodes).
/// Also adds event listeners to the node.
///
virtual void AddNode(const mitk::DataNode *node);
///
/// Removes a node from this model. Also removes any event listener from the node.
///
virtual void RemoveNode(const mitk::DataNode *node);
///
/// Returns a copy of the node-vector that is shown by this model
///
virtual std::vector<mitk::DataNode *> GetNodeSet() const;
///
/// \brief Called when a single property was changed.
/// The function searches through the list of nodes in this model for the changed
/// property. If the property was found a dataChanged signal is emitted forcing
/// all observing views to request the data again.
///
virtual void PropertyModified(const itk::Object *caller, const itk::EventObject &event);
///
/// Overridden from QAbstractTableModel. Sets data at index for given role.
///
bool setData(const QModelIndex &index, const QVariant &value, int role) override;
///
/// \brief Reimplemented sort function from QAbstractTableModel to enable sorting on the table.
///
void sort(int column, Qt::SortOrder order = Qt::AscendingOrder) override;
//#PROTECTED INNER CLASSES
protected:
///
/// \struct DataNodeCompareFunction
/// \brief A struct that inherits from std::binary_function. You can use it in std::sort algorithm for sorting the
/// node list elements.
///
struct DataNodeCompareFunction : public std::binary_function<mitk::DataNode::Pointer, mitk::DataNode::Pointer, bool>
{
///
/// \brief Specifies field of the property with which it will be sorted.
///
enum CompareCriteria
{
CompareByName = 0,
CompareByClassName,
CompareByVisibility
};
///
/// \brief Specifies Ascending/descending ordering.
///
enum CompareOperator
{
Less = 0,
Greater
};
///
/// \brief Creates a PropertyDataSetCompareFunction. A CompareCriteria and a CompareOperator must be given.
///
DataNodeCompareFunction(CompareCriteria _CompareCriteria = CompareByName, CompareOperator _CompareOperator = Less);
///
/// \brief The reimplemented compare function.
///
bool operator()(const mitk::DataNode::Pointer &_Left, const mitk::DataNode::Pointer &_Right) const;
protected:
CompareCriteria m_CompareCriteria;
CompareOperator m_CompareOperator;
};
//#Protected SETTER
protected:
///
/// Called when DataStorage or Predicate changed. Resets whole model and reads all nodes
/// in again.
///
virtual void Reset();
//#Protected MEMBER VARIABLES
protected:
///
/// Pointer to the DataStorage from which the nodes are selected (remember: in BlueBerry there
/// might be more than one DataStorage).
/// Store it in a weak pointer. This is a GUI class which should not hold a strong reference
/// to any non-GUI Object.
///
mitk::WeakPointer<mitk::DataStorage> m_DataStorage;
///
/// Holds the predicate that defines this SubSet of Nodes. If m_Predicate
/// is nullptr all Nodes will be selected.
///
mitk::NodePredicateBase::Pointer m_Predicate;
///
/// Holds all selected Nodes.
///
std::vector<mitk::DataNode *> m_NodeSet;
///
/// \brief Maps a property to an observer tag.
///
std::map<mitk::BaseProperty *, unsigned long> m_NamePropertyModifiedObserverTags;
///
/// \brief Maps a property to an observer tag.
///
std::map<mitk::BaseProperty *, unsigned long> m_VisiblePropertyModifiedObserverTags;
///
/// Saves if this model is currently working on events to prevent endless event loops.
///
bool m_BlockEvents;
///
/// \brief The property is true when the property list is sorted in descending order.
///
bool m_SortDescending;
};
#endif
diff --git a/Modules/QtWidgets/include/QmitkIOUtil.h b/Modules/QtWidgets/include/QmitkIOUtil.h
index 6d2adf3230..ba015926d7 100644
--- a/Modules/QtWidgets/include/QmitkIOUtil.h
+++ b/Modules/QtWidgets/include/QmitkIOUtil.h
@@ -1,237 +1,238 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef _QmitkIOUtil__h_
#define _QmitkIOUtil__h_
#include "MitkQtWidgetsExports.h"
// std
#include <string>
// mitk includes
#include <mitkBaseData.h>
#include <mitkCommon.h>
#include <mitkDataNode.h>
#include <mitkFileWriterWithInformation.h>
#include <mitkIOUtil.h>
#include <mitkImage.h>
#include <mitkPointSet.h>
#include <mitkSurface.h>
// Qt
#include <QList>
#include <QPair>
#include <QScopedPointer>
#include <QString>
class QWidget;
class QString;
class QStringList;
namespace mitk
{
class DataStorage;
class MimeType;
struct IFileReader;
}
/**
* @brief QmitkIOUtil Provides static helper methods to open and save files with Qt dialogs.
*/
class MITKQTWIDGETS_EXPORT QmitkIOUtil : public mitk::IOUtil
{
public:
class MITKQTWIDGETS_EXPORT SaveFilter
{
public:
static mitk::MimeType ALL_MIMETYPE();
SaveFilter(const SaveFilter &other);
SaveFilter(const SaveInfo &saveInfo);
SaveFilter &operator=(const SaveFilter &other);
std::vector<mitk::MimeType> GetMimeTypes() const;
QString GetFilterForMimeType(const std::string &mimeType) const;
mitk::MimeType GetMimeTypeForFilter(const QString &filter) const;
QString GetDefaultFilter() const;
QString GetDefaultExtension() const;
mitk::MimeType GetDefaultMimeType() const;
QString ToString() const;
int Size() const;
bool IsEmpty() const;
bool ContainsMimeType(const std::string &mimeType);
private:
struct Impl;
QScopedPointer<Impl> d;
};
/**
* @brief GetFilterString
* @return
*/
static QString GetFileOpenFilterString();
/**
* @brief Loads the specified files
*
* This methods tries to load all specified files and pop-ups dialog boxes if further
* user input is required (e.g. ambiguous mime-types or reader options).
*
* If the provided DataStorage is not nullptr, some files will be added to it automatically,
* dependeing on the IFileReader used.
*
- * @param files A list of files to load.
- * @param ds An optional data storage passed to IFileReader instances
+ * @param paths
+ * @param parent
* @return A list of BaseData instances which have not already been added to the data storage.
*/
static QList<mitk::BaseData::Pointer> Load(const QStringList &paths, QWidget *parent = nullptr);
static mitk::DataStorage::SetOfObjects::Pointer Load(const QStringList &paths,
mitk::DataStorage &storage,
QWidget *parent = nullptr);
static QList<mitk::BaseData::Pointer> Load(const QString &path, QWidget *parent = nullptr);
static mitk::DataStorage::SetOfObjects::Pointer Load(const QString &path,
mitk::DataStorage &storage,
QWidget *parent = nullptr);
using mitk::IOUtil::Load;
static QString Save(const mitk::BaseData *data,
const QString &defaultBaseName,
const QString &defaultPath = QString(),
QWidget *parent = nullptr,
bool setPathProperty = false);
/**
* @brief Save a list of BaseData objects using a "File Save Dialog".
*
* For each element in the \c data vector, the following algorithm is
* used to find a IFileWriter instance for writing the BaseData object.
*
* First, the user is prompted to select file names for each BaseData object. This
* is equivalent to choosing a specific mime-type, either by selecting a filter
* in the save dialog or by explicitly providing a file name extension:
* <ol>
* <li>Get a list of registered IFileWriter objects for the current BaseData object.
* If no writers are found, a message box displays a warning and
* the process starts from the beginning for the next BaseData object.</li>
* <li>A QFileDialog for prompting the user to select a file name is opened.
* The mime-type associated with each IFileWriter object is used to create
* a filter for file name extensions.
* The best IFileWriter (see FileWriterSelector) for the current BaseData object
* defines the default file name suffix via its associated mime-type. If the
* file name is empty (the user cancelled the dialog), the remaining
* BaseData objects are skipped.
* <li>The file name is matched against valid mime-types. The first mime-type
* which accepts the file name is associated with the current BaseData object.
* If no mime-type accepts the supplied file name and the file already
* exists, the process starts from the beginning with the next BaseData object.
* Otherwise, if the selected filter is the special "all" filter and the
* file name does not contain periods (which may or may not mark the start of
* a file extension), the current BaseData object is associated with the
* default mime-type. If the selected filter is not the special "all" filter,
* the mime-type for this filter is associated with the current BaseData object.
* The default extension of the associated mime-type is then appended to the
* supplied file name.
* <li>The selected/derived file name and associated mime-type is stored in a list
* and the process starts from the beginning for the next BaseData object.</li>
* </ol>
*
* In the second phase, each BaseData object is saved to disk using the specified
* file name and mime-type, according to the following procedure:
* <ol>
* <li>If multiple IFileWriter objects are compatible with the current base data
* object or if the single compatible IFileWriter provides configuration
* options, a dialog window containing a list of IFileWriter objects and
* configurable options is displayed. If the dialog is cancelled by the user,
* neither the current nor the remaining base data objects are saved to disk.
* If the user previously in this phase enabled the "remember options" checkbox
* of the dialog, then the dialog is not shown for base data objects with the
* same data type and associated mime-type if the file writer instance reports
* a higher or equal confidence level for the current base data object.</li>
* <li>The selected writer (either the only available one or the user selected one)
* is used to write the base data object to disk. On failure, an error is
* reported and the second phase continues with the next base data object.</li>
* </ol>
*
* @param data
* @param defaultBaseNames
* @param defaultPath
* @param parent
+ * @param setPathProperty
* @return
*/
static QStringList Save(const std::vector<const mitk::BaseData *> &data,
const QStringList &defaultBaseNames,
const QString &defaultPath = QString(),
QWidget *parent = nullptr,
bool setPathProperty = false);
using mitk::IOUtil::Save;
/**
* @brief SaveBaseDataWithDialog Convenience method to save any data with a Qt dialog.
* @param data BaseData holding the data you wish to save.
* @param fileName The file name where to save the data (including path and extension).
* @param parent An optional QWidget as parent. If no parent is supplied, the QFileDialog can occur anywhere on the
* screen.
* @deprecatedSince{2014_10} Use Save() instead.
*/
DEPRECATED(static void SaveBaseDataWithDialog(mitk::BaseData *data, std::string fileName, QWidget *parent = nullptr));
/**
* @brief SaveSurfaceWithDialog Convenience method to save a surface with a Qt dialog.
* @param surface The surface to save.
* @param fileName The file name where to save the data (including path and extension).
* @param parent An optional QWidget as parent. If no parent is supplied, the QFileDialog can occur anywhere on the
* screen.
* @deprecatedSince{2014_10} Use Save() instead.
*/
DEPRECATED(static void SaveSurfaceWithDialog(mitk::Surface::Pointer surface,
std::string fileName = "",
QWidget *parent = nullptr));
/**
* @brief SaveImageWithDialog Convenience method to save an image with a Qt dialog.
* @param image The image to save.
* @param fileName The file name where to save the data (including path and extension).
* @param parent An optional QWidget as parent. If no parent is supplied, the QFileDialog can occur anywhere on the
* screen.
* @deprecatedSince{2014_10} Use Save() instead.
*/
DEPRECATED(static void SaveImageWithDialog(mitk::Image::Pointer image,
std::string fileName = "",
QWidget *parent = nullptr));
/**
* @brief SavePointSetWithDialog Convenience method to save a pointset with a Qt dialog.
* @param pointset The pointset to save.
* @param fileName The file name where to save the data (including path and extension).
* @param parent An optional QWidget as parent. If no parent is supplied, the QFileDialog can occur anywhere on the
* screen.
* @deprecatedSince{2014_10} Use Save() instead.
*/
DEPRECATED(static void SavePointSetWithDialog(mitk::PointSet::Pointer pointset,
std::string fileName = "",
QWidget *parent = nullptr));
private:
struct Impl;
};
#endif // _QmitkIOUtil__h_
diff --git a/Modules/QtWidgets/include/QmitkModelViewSelectionConnector.h b/Modules/QtWidgets/include/QmitkModelViewSelectionConnector.h
index 8a502c8f93..70e54878b7 100644
--- a/Modules/QtWidgets/include/QmitkModelViewSelectionConnector.h
+++ b/Modules/QtWidgets/include/QmitkModelViewSelectionConnector.h
@@ -1,152 +1,152 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QMITKMODELVIEWSELECTIONCONNECTOR_H
#define QMITKMODELVIEWSELECTIONCONNECTOR_H
#include <MitkQtWidgetsExports.h>
// qt widgets module
#include <QmitkAbstractDataStorageModel.h>
// qt
#include <QAbstractItemView>
/**
* @brief The 'QmitkModelViewSelectionConnector' is used to handle the selections of a model-view-pair and to synchornize them with external node selections
* (e.g. communicated by the application).
*
* The class accepts a view and its model, which are used to react to selection changes. This class is able to propagate selection changes
* to and receive from its surrounding class.
*
* The model-view-pair can be added as a selection listener to a selection service. This should be done by using 'AddPostSelectionListener'
* with the existing selection service of the surrounding 'QmitkAbstractView'.
* The model-view-pair can be set as a selection provider. This should be done by using 'SetAsSelectionProvider' with the existing
* selection provider of the surrounding 'QmitkAbstractView'.
*
* The 'QmitkModelViewSelectionConnector' offers a public slot and signal that can be used to set / propagate the selected
* nodes in the current view:
* The 'SetCurrentSelection'-slot finds the indices of the given selected nodes in its internal data storage model and
* changes the selection of the internal data storage model accordingly.
* The 'CurrentSelectionChanged'-signal sends a list of selected nodes to its environment.
* The 'CurrentSelectionChanged'-signal is emitted by the 'ChangeModelSelection'-function, which transforms the internal item view's
* selection into a data node list. The 'ChangeModelSelection'-function is called whenever the selection of the item view's
* selection model changes.
*/
class MITKQTWIDGETS_EXPORT QmitkModelViewSelectionConnector : public QObject
{
Q_OBJECT
public:
QmitkModelViewSelectionConnector();
/**
* @brief Set the view whose selection model is used to propagate or receive selection changes. Use the view's data model
* to transform selected nodes into model indexes and vice versa.
*
* @pre The view's data model needs to be a 'QmitkAbstractDataStorageModel'. If so, the data model is received from
* the view and stored as a private member.
* The data model must return 'mitk::DataNode::Pointer' objects for model indexes if the role is 'QmitkDataNodeRole'.
* @throw mitk::Exception, if the view is invalid or the view's data model is not a valid 'QmitkAbstractDataStorageModel'.
*
* @param view The view to set.
*/
void SetView(QAbstractItemView* view);
/**
* @brief Retrieve the currently selected nodes (equals the last CurrentSelectionChanged values).
*/
QList<mitk::DataNode::Pointer> GetSelectedNodes() const;
bool GetSelectOnlyVisibleNodes() const;
Q_SIGNALS:
/**
* @brief A signal that will be emitted by the 'ChangeModelSelection'-function. This happens if the selection model
* of the private member item view has changed.
*
* @param nodes A list of data nodes that are newly selected.
*/
void CurrentSelectionChanged(QList<mitk::DataNode::Pointer> nodes);
public Q_SLOTS:
/**
* @brief Change the selection mode of the item view's selection model.
*
* If true, an incoming selection will be filtered (reduced) to only those nodes that are visible to the current view.
* An outgoing selection can then at most contain the filtered nodes.
* If false, the incoming non-visible selection will be stored and later added to the outgoing selection,
* to include the part of the original selection that was not visible.
* The part of the original selection, that is non-visible are the nodes that do not met the predicate of the
* associated QmitkAbstractDataStorageModel.
*
* @param selectOnlyVisibleNodes The bool value to define the selection modus.
*/
void SetSelectOnlyVisibleNodes(bool selectOnlyVisibleNodes);
/**
* @brief Transform a list of data nodes into a model selection and set this as a new selection of the
* selection model of the private member item view.
*
* The function filters the given list of nodes according to the 'm_SelectOnlyVisibleNodes' member variable. If
* necessary, the non-visible nodes are stored. This is done if 'm_SelectOnlyVisibleNodes' is false: In this case
* the selection may be filtered and only a subset of the selected nodes may be visible and therefore (de-)selectable
* in the data storage viewer. By storing the non-visible nodes it is possible to send the new, modified selection
* but also include the selected nodes from the original selection that could not be modified (see 'SetSelectOnlyVisibleNodes').
*
- * @param nodes A list of data nodes that should be newly selected.
+ * @param selectedNodes A list of data nodes that should be newly selected.
*/
void SetCurrentSelection(QList<mitk::DataNode::Pointer> selectedNodes);
private Q_SLOTS:
/**
* @brief Transform a model selection into a data node list and emit the 'CurrentSelectionChanged'-signal.
*
* The function adds the selected nodes from the original selection that could not be modified, if
* 'm_SelectOnlyVisibleNodes' is false.
* This slot is internally connected to the 'selectionChanged'-signal of the selection model of the private member item view.
*
* @param selected The newly selected items.
* @param deselected The newly deselected items.
*/
void ChangeModelSelection(const QItemSelection& selected, const QItemSelection& deselected);
private:
QmitkAbstractDataStorageModel* m_Model;
QAbstractItemView* m_View;
bool m_SelectOnlyVisibleNodes;
QList<mitk::DataNode::Pointer> m_NonVisibleSelection;
/*
* @brief Retrieve the currently selected nodes from the selection model of the private member item view by
* transforming the selection indexes into a data node list.
*
* In order to transform the indices into data nodes, the private data storage model must return
* 'mitk::DataNode::Pointer' objects for model indexes if the role is QmitkDataNodeRole.
*/
QList<mitk::DataNode::Pointer> GetInternalSelectedNodes() const;
/*
* @brief Filter the list of given nodes such that only those nodes are used that are valid
* when using the data storage model's node predicate.
* If no node predicate was set or the data storage model is invalid, the input list
* of given nodes is returned.
*/
QList<mitk::DataNode::Pointer> FilterNodeList(const QList<mitk::DataNode::Pointer>& nodes) const;
};
/*
* @brief Return true, if the nodes in the list of two given selections are equal (Sorting is ignored. Any permutation is valid.)*/
bool MITKQTWIDGETS_EXPORT EqualNodeSelections(const QList<mitk::DataNode::Pointer>& selection1, const QList<mitk::DataNode::Pointer>& selection2);
#endif // QMITKMODELVIEWSELECTIONCONNECTOR_H
diff --git a/Modules/QtWidgets/include/QmitkProgressBar.h b/Modules/QtWidgets/include/QmitkProgressBar.h
index cab36ed703..bd188526a3 100644
--- a/Modules/QtWidgets/include/QmitkProgressBar.h
+++ b/Modules/QtWidgets/include/QmitkProgressBar.h
@@ -1,77 +1,77 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QMITKPROGRESSBAR_H
#define QMITKPROGRESSBAR_H
#include <MitkQtWidgetsExports.h>
#include <QProgressBar>
#include <mitkProgressBarImplementation.h>
/**
* \ingroup QmitkModule
* \brief QT-Toolkit/GUI dependent class that provides the QT's ProgressBar
*
* All mitk-classes will call this class for output:
* mitk::ProgressBar::GetInstance();
*/
class MITKQTWIDGETS_EXPORT QmitkProgressBar : public QProgressBar, public mitk::ProgressBarImplementation
{
Q_OBJECT
public:
//##Documentation
//##@brief Constructor;
//## holds param instance internally and connects this to the mitkProgressBar
QmitkProgressBar(QWidget *parent = nullptr, const char *name = nullptr);
//##Documentation
//##@brief Destructor
~QmitkProgressBar() override;
//##Documentation
//## @brief Sets whether the current progress value is displayed.
void SetPercentageVisible(bool visible) override;
//##Documentation
//## @brief Adds steps to totalSteps.
void AddStepsToDo(unsigned int steps) override;
//##Documentation
//## @brief Sets the current amount of progress to current progress + steps.
- //## @param: steps the number of steps done since last Progress(int steps) call.
+ //## @param steps the number of steps done since last Progress(int steps) call.
void Progress(unsigned int steps) override;
signals:
void SignalAddStepsToDo(unsigned int steps);
void SignalProgress(unsigned int steps);
void SignalSetPercentageVisible(bool visible);
protected slots:
virtual void SlotAddStepsToDo(unsigned int steps);
virtual void SlotProgress(unsigned int steps);
virtual void SlotSetPercentageVisible(bool visible);
private:
//##Documentation
//## @brief Reset the progress bar. The progress bar "rewinds" and shows no progress.
void Reset() override;
unsigned int m_TotalSteps;
unsigned int m_Progress;
};
#endif /* define QMITKPROGRESSBAR_H */
diff --git a/Modules/QtWidgets/include/QmitkStdMultiWidget.h b/Modules/QtWidgets/include/QmitkStdMultiWidget.h
index 12b41a7b79..fcd57a81b2 100644
--- a/Modules/QtWidgets/include/QmitkStdMultiWidget.h
+++ b/Modules/QtWidgets/include/QmitkStdMultiWidget.h
@@ -1,158 +1,158 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QMITKSTDMULTIWIDGET_H
#define QMITKSTDMULTIWIDGET_H
// qt widgets module
#include "MitkQtWidgetsExports.h"
#include "QmitkAbstractMultiWidget.h"
/**
* @brief The 'QmitkStdMultiWidget' is a 'QmitkAbstractMultiWidget' that is used to display multiple render windows at once.
* Render windows are predefined in a 2x2 design with 3 different 2D view planes and a 3D render window.
*/
class MITKQTWIDGETS_EXPORT QmitkStdMultiWidget : public QmitkAbstractMultiWidget
{
Q_OBJECT
public:
QmitkStdMultiWidget(
QWidget *parent = nullptr,
Qt::WindowFlags f = nullptr,
const QString &name = "stdmulti");
~QmitkStdMultiWidget() override;
virtual void InitializeMultiWidget() override;
virtual QmitkRenderWindow* GetRenderWindow(const QString& widgetName) const override;
virtual QmitkRenderWindow* GetRenderWindow(const mitk::BaseRenderer::ViewDirection& viewDirection) const override;
virtual void SetSelectedPosition(const mitk::Point3D& newPosition, const QString& widgetName) override;
virtual const mitk::Point3D GetSelectedPosition(const QString& widgetName) const override;
virtual void SetCrosshairVisibility(bool) override;
virtual bool GetCrosshairVisibility() const override;
virtual void ResetCrosshair() override;
virtual void SetWidgetPlaneMode(int mode) override;
mitk::SliceNavigationController* GetTimeNavigationController();
void AddPlanesToDataStorage();
void RemovePlanesFromDataStorage();
/** \brief Listener to the CrosshairPositionEvent
Ensures the CrosshairPositionEvent is handled only once and at the end of the Qt-Event loop
*/
void HandleCrosshairPositionEvent();
/**
* @brief Convenience method to get a render window widget.
- * @param Number of the widget (0-3)
+ * @param number of the widget (0-3)
* @return The render window widget
*/
QmitkRenderWindow* GetRenderWindow(unsigned int number) const;
QmitkRenderWindow* GetRenderWindow1() const;
QmitkRenderWindow* GetRenderWindow2() const;
QmitkRenderWindow* GetRenderWindow3() const;
QmitkRenderWindow* GetRenderWindow4() const;
/**
* @brief Convenience method to get a widget plane.
- * @param Number of the widget plane (1-3)
+ * @param number of the widget plane (1-3)
* @return The widget plane as data node
*/
mitk::DataNode::Pointer GetWidgetPlane(unsigned int number) const;
mitk::DataNode::Pointer GetWidgetPlane1() const;
mitk::DataNode::Pointer GetWidgetPlane2() const;
mitk::DataNode::Pointer GetWidgetPlane3() const;
/**
* @brief SetDecorationColor Set the color of the decoration of the 4 widgets.
*
* This is used to color the frame of the renderwindow and the corner annatation.
* For the first 3 widgets, this color is a property of the helper object nodes
* which contain the respective plane geometry. For widget 4, this is a member,
* since there is no data node for this widget.
*/
void SetDecorationColor(unsigned int widgetNumber, mitk::Color color);
/**
* @brief GetDecorationColorForWidget Get the color for annotation, crosshair and rectangle.
* @param widgetNumber Number of the renderwindow (0-3).
* @return Color in mitk format.
*/
mitk::Color GetDecorationColor(unsigned int widgetNumber);
public Q_SLOTS:
// mouse events
virtual void mousePressEvent(QMouseEvent*) override;
virtual void moveEvent(QMoveEvent* e) override;
virtual void wheelEvent(QWheelEvent* e) override;
/// Receives the signal from HandleCrosshairPositionEvent, executes the StatusBar update
void HandleCrosshairPositionEventDelayed();
void Fit();
void AddDisplayPlaneSubTree();
void EnsureDisplayContainsPoint(mitk::BaseRenderer *renderer, const mitk::Point3D &p);
void SetWidgetPlaneVisibility(const char *widgetName, bool visible, mitk::BaseRenderer *renderer = nullptr);
void SetWidgetPlanesVisibility(bool visible, mitk::BaseRenderer *renderer = nullptr);
Q_SIGNALS:
void WheelMoved(QWheelEvent *);
void Moved();
private:
virtual void SetLayoutImpl() override;
virtual void SetInteractionSchemeImpl() override { }
void CreateRenderWindowWidgets();
mitk::SliceNavigationController* m_TimeNavigationController;
/**
* @brief The 3 helper objects which contain the plane geometry.
*/
mitk::DataNode::Pointer m_PlaneNode1;
mitk::DataNode::Pointer m_PlaneNode2;
mitk::DataNode::Pointer m_PlaneNode3;
/**
* @brief m_ParentNodeForGeometryPlanes This helper object is added to the datastorage
* and contains the 3 planes for displaying the image geometry (crosshair and 3D planes).
*/
mitk::DataNode::Pointer m_ParentNodeForGeometryPlanes;
/**
* @brief m_DecorationColorWidget4 color for annotation and rectangle of widget 4.
*
* For other widgets1-3, the color is a property of the respective data node.
* There is no node for widget 4, hence, we need an extra member.
*/
mitk::Color m_DecorationColorWidget4;
bool m_PendingCrosshairPositionEvent;
};
#endif // QMITKSTDMULTIWIDGET_H
diff --git a/Modules/QtWidgetsExt/include/QmitkPlotWidget.h b/Modules/QtWidgetsExt/include/QmitkPlotWidget.h
index 9fc9f6c9c0..d8849416c1 100644
--- a/Modules/QtWidgetsExt/include/QmitkPlotWidget.h
+++ b/Modules/QtWidgetsExt/include/QmitkPlotWidget.h
@@ -1,299 +1,300 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef _QmitkPlotWidget_H_
#define _QmitkPlotWidget_H_
#include "MitkQtWidgetsExtExports.h"
#include "mitkCommon.h"
#include <qwidget.h>
#include <qwt_legend.h>
#include <qwt_plot.h>
#include <qwt_plot_curve.h>
#include <qwt_plot_intervalcurve.h>
#include <qwt_symbol.h>
#include <tuple>
#include <vector>
/**
* Provides a convenient interface for plotting curves using qwt.
* Designed for qwt version 5.2.1.
* Can be used with a QmitkPlotDialog, which provides a "Close" button.
* @see QmitkPlotDialog
*
* To plot data do the following:
* 1. Create two QmitkPlotWidget::DataVector Objects and fill them
* with corresponding x/y values. DataVectors are simple stl-vectors
* of type std::vector<double>. Please note that the xValues
* vector and the yValues vector MUST have the same size.
* 2. Instantiate the widget for example like that:
* QmitkPlotWidget* widget = new QmitkPlotWidget( this, "widget" );
* widget->SetAxisTitle( QwtPlot::xBottom, "My x asis [mm]" );
* widget->SetAxisTitle( QwtPlot::yLeft, "My y axis [mm]" );
* int curveId = widget->InsertCurve( "My sophisticated data" );
* widget->SetCurveData( curveId, xValues, yValues );
* widget->SetCurvePen( curveId, QPen( red ) );
* widget->SetCurveTitle( curveId, "My curve description" );
* widget->Replot();
* 3. You can modify the behavior of the plot by directly referencing
* the QwtPlot instance using the method GetPlot().
* @see QwtPlot
* @deprecatedSince{2018_04} Use QmitkChartWidget instead
*/
class MITKQTWIDGETSEXT_EXPORT QmitkPlotWidget
: public QWidget
{
private:
Q_OBJECT
public:
/**
* represents the data type used for scalar values stored
* in data arrays. This type is provided by qwt and may not
* be changed.
*/
typedef double ScalarType;
/**
* This type may be used to store a set of scalar values
* representing either x or y coordinates of the data
* points that should be rendered.
*/
typedef std::vector<ScalarType> DataVector;
/**
* convenience type used to store pairs representing x/y coordinates
* that should be rendered as a curve by the plot widget
*/
typedef std::vector<std::pair<double, double>> XYDataVector;
/**
* Standard qt constructor
*/
QmitkPlotWidget(QWidget *parent = nullptr,
const char *title = nullptr,
const char *name = nullptr,
Qt::WindowFlags f = nullptr);
/**
* Virtual destructor
*/
~QmitkPlotWidget() override;
/**
* Returns the instance of the plot-widget. This may be used
* to modify any detail of the appearance of the plot.
*/
QwtPlot *GetPlot();
/**
* Set the title using (formatted) QwtText object
*/
void SetPlotTitle(const QwtText &qwt_title);
/**
* Set plain text title, using default formatting
*/
void SetPlotTitle(const char *title);
/**
* Inserts a new curve into the plot-window.
* @param title the name of the curve
+ * @param color
* @returns the id of the curve. Use this id to
* refer to the curve, if you want to modify or add data.
*/
unsigned int InsertCurve(const char *title, QColor color = QColor(Qt::black));
/**
* Sets the title of the given axis. For the set of available axes
* @see QwtPlot::Axis.
* @param axis the axis for which the description should be set.
* @param title the name of the axis.
*/
void SetAxisTitle(int axis, const char *title);
/**
* Sets the data for a previously added curve. Data is provided as two vectors of double.
* The first vector represents the x coordinates, the second vector represents the y coordinates.
* @param curveId the id of the curve for which data should be added.
* @param xValues the x coordinates of the points that define the curve
* @param yValues the y coordinates of the points that define the curve
* @returns whether data was added successfully or not
*/
bool SetCurveData(unsigned int curveId, const DataVector &xValues, const DataVector &yValues);
/**
* @brief Sets the data with errors for a previously added curve.
*
* @param curveId the id of the curve for which data should be added.
* @param xValues the x coordinates of the points that define the curve
* @param yValues the y coordinates of the points that define the curve
* @param yLowerError the magnitude (>0) of the error in the lesser direction of y
* @param yUpperError the magnitude (>0) of the error in the larger direction of y
* @returns whether data was added successfully or not
*/
bool SetCurveData(unsigned int curveId,
const DataVector &xValues,
const DataVector &yValues,
const DataVector &yLowerError,
const DataVector &yUpperError);
/**
* @brief Sets the data with errors for a previously added curve.
*
* @param curveId the id of the curve for which data should be added.
* @param xValues the x coordinates of the points that define the curve
* @param yValues the y coordinates of the points that define the curve
* @param xLowerError the magnitude (>0) of the error in the lesser direction of x
* @param xUpperError the magnitude (>0) of the error in the larger direction of x
* @param yLowerError the magnitude (>0) of the error in the lesser direction of y
* @param yUpperError the magnitude (>0) of the error in the larger direction of y
* @returns whether data was added successfully or not
*/
bool SetCurveData(unsigned int curveId,
const DataVector &xValues,
const DataVector &yValues,
const DataVector &xLowerError,
const DataVector &xUpperError,
const DataVector &yLowerError,
const DataVector &yUpperError);
/**
* Sets the data for a previously added curve. Data is provided as a vectors of pairs.
* The pairs represent x/y coordinates of the points that define the curve.
* @param curveId the id of the curve for which data should be added.
* @param data the coordinates of the points that define the curve
* @returns whether data was added successfully or not
*/
bool SetCurveData(unsigned int curveId, const XYDataVector &data);
/**
* Defines how a curve should be drawn. For drawing a curve, a QPen is used.
* @param curveId the id of the curve for which appearance should be changed
* @param pen a QPen (@see QPen) defining the line style
*/
void SetCurvePen(unsigned int curveId, const QPen &pen);
/**
* Assign a brush, which defines the fill pattern of shapes drawn by a QPainter.
* In case of brush.style() != QBrush::NoBrush and * style() != QwtPlotCurve::Sticks
* the area between the curve and the baseline will be filled.
* In case !brush.color().isValid() the area will be filled by pen.color().
* The fill algorithm simply connects the first and the last curve point to the
* baseline. So the curve data has to be sorted (ascending or descending).
* @param curveId the id of the curve for which appearance should be changed
* @param brush a QBrush (@see QBrush) defining the line style
*/
void SetCurveBrush(unsigned int curveId, const QBrush &brush);
/**
* Sets the style how the line is drawn for the curve; like, plain line,
* or with the data points marked with a symbol;
- * @param: style A QwtPlotCurve::CurveStyle
+ * @param curveId
+ * @param style A QwtPlotCurve::CurveStyle
*/
void SetCurveStyle(unsigned int curveId, const QwtPlotCurve::CurveStyle style);
/**
* Sets the style data points are drawn for the curve; like, a line,
* or dots;
- * @param: symbol A QwtSymbol
+ * @param curveId
+ * @param symbol A QwtSymbol
*/
void SetCurveSymbol(unsigned int curveId, QwtSymbol *symbol);
void SetCurveAntialiasingOn(unsigned int curveId);
void SetCurveAntialiasingOff(unsigned int curveId);
/**
* Sets the title of the given curve. The title will be shown in the legend of
* the QwtPlot.
* @param curveId the id of the curve for which the title should be set
* @param title the description of the curve that will be shown in the legend.
*/
void SetCurveTitle(unsigned int curveId, const char *title);
/**
* Defines how a curves errors should be drawn. For drawing a QPen is used.
* @param curveId the id of the curve for which error appearance should be changed
* @param pen a QPen (@see QPen) defining the line style
*/
void SetErrorPen(unsigned int curveId, const QPen &pen);
/**
* Defines the style of errors, symbols or as a curve.
* @param curveId the id of the curve for which error appearance should be changed
* @param drawSmybols true - draw symbols, false - draw curve
*/
void SetErrorStyleSymbols(unsigned int curveId, bool drawSmybols);
/**
* Sets the legend of the plot
*
*/
void SetLegend(QwtLegend *legend, QwtPlot::LegendPosition pos = QwtPlot::RightLegend, double ratio = -1);
/**
* Set a curve's legend attribute
* @param curveId the id of the curve
* @param attribute the legend attribute to be set
*/
void SetLegendAttribute(unsigned int curveId, const QwtPlotCurve::LegendAttribute &attribute);
/**
* Triggers a replot of the curve. Replot should be called once after
* setting new data.
*/
void Replot();
/**
* Resets the plot into an empty state
*/
void Clear();
protected:
/**
* Converts the given values into a raw double* array.
* A new array is allocated via new and must be deleted[] by the caller.
*/
double *ConvertToRawArray(const DataVector &values);
/**
* Converts the given values into a raw double* array.
* A new array is allocated via new and must be deleted[] by the caller.
* @param values the x/y values to convert to an array
* @param component defines if the x values (0) or the y values(1) should
* be converted. Other values than 0 and 1 will not be accepted.
*/
double *ConvertToRawArray(const XYDataVector &values, unsigned int component);
/**
* Adds an error interval curve.
*
* All errors should be absolutes. The magnitude will be used.
*
* @param curveId Which curve should the error curve be added to
- * @param xValues Vector of x values an error bar belongs to
- * @param values The original data value
* @param lessError Error in the negative direction (value - lessError)
* @param moreError Error in the positive direction (value + lessError)
* @param isXError Should the error bars be drawn horizontally
*/
bool AddErrorIntervalCurve(unsigned int curveId,
const DataVector &lessError,
const DataVector &moreError,
bool isXError);
QwtPlot *m_Plot;
std::vector<std::tuple<QwtPlotCurve *, QwtPlotIntervalCurve *, QwtPlotIntervalCurve *>> m_PlotCurveVector;
};
#endif
diff --git a/Modules/QtWidgetsExt/include/QmitkPointListModel.h b/Modules/QtWidgetsExt/include/QmitkPointListModel.h
index 03b4be5314..7da7c40860 100644
--- a/Modules/QtWidgetsExt/include/QmitkPointListModel.h
+++ b/Modules/QtWidgetsExt/include/QmitkPointListModel.h
@@ -1,125 +1,125 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QMITK_POINTLIST_MODEL_H_INCLUDED
#define QMITK_POINTLIST_MODEL_H_INCLUDED
#include "MitkQtWidgetsExtExports.h"
#include <QAbstractListModel>
#include "mitkDataNode.h"
#include "mitkPointSet.h"
class MITKQTWIDGETSEXT_EXPORT QmitkPointListModel : public QAbstractListModel
{
Q_OBJECT
public:
QmitkPointListModel(mitk::DataNode * = nullptr, int t = 0, QObject *parent = nullptr);
~QmitkPointListModel() override;
Qt::ItemFlags flags(const QModelIndex &) const override;
/// interface of QAbstractListModel
int rowCount(const QModelIndex &parent = QModelIndex()) const override;
/// interface of QAbstractListModel
QVariant data(const QModelIndex &index, int role) const override;
/// interface of QAbstractListModel
QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
/// which point set to work on
void SetPointSetNode(mitk::DataNode *pointSetNode);
/// which point set to work on
mitk::PointSet *GetPointSet() const;
// which point set to work on
mitk::DataNode *GetPointSetNode() const;
/// which time step to display/model
void SetTimeStep(int t);
/// which time step to display/model
int GetTimeStep() const;
/// itk observer for point set "modified" events
void OnPointSetChanged(const itk::EventObject &e);
/// itk observer for point set "delete" events
void OnPointSetDeleted(const itk::EventObject &e);
/**
* \brief get point and point ID that correspond to a given QModelIndex
*
* The mitk::PointSet uses a map to store points in an ID<-->Point relation.
* The IDs are not neccesarily continuously numbered, therefore, we can not
* directly use the QModelIndex as point ID. This method returns the point and
* the corresponding point id for a given QModelIndex. The point and the point ID
* are returned in the outgoing parameters p and id. If a valid point and ID were
* found, the method returns true, otherwise it returns false
- * \param[in] QModelIndex &index the index for which a point is requested.
+ * \param[in] index the index for which a point is requested.
The row() part of the index is used to find a corresponding point
- * \param[out] mitk::Point3D& p If a valid point is found, it will be stored in the p parameter
- * \param[out] mitk::PointSet::PointIdentifier& id If a valid point is found, the corresponding ID will be stored in id
+ * \param[out] p If a valid point is found, it will be stored in the p parameter
+ * \param[out] id If a valid point is found, the corresponding ID will be stored in id
* \return Returns true, if a valid point was found, false otherwise
*/
bool GetPointForModelIndex(const QModelIndex &index,
mitk::PointSet::PointType &p,
mitk::PointSet::PointIdentifier &id) const;
/**Documentation
* \brief returns a QModelIndex for a given point ID
*
* The mitk::PointSet uses a map to store points in an ID<-->Point relation.
* The IDs are not neccesarily continuously numbered, therefore, we can not
* directly use the point ID as a QModelIndex. This method returns a QModelIndex
* for a given point ID in the outgoing parameter index.
- * \param[in] mitk::PointSet::PointIdentifier id The point ID for which the QModelIndex will be created
- * \param[out] QModelIndex& index if a point with the ID id was found, index will contain a corresponding QModelIndex
+ * \param[in] id The point ID for which the QModelIndex will be created
+ * \param[out] index if a point with the ID id was found, index will contain a corresponding QModelIndex
* for that point
* \return returns true, if a valid QModelIndex was created, false otherwise
*/
bool GetModelIndexForPointID(mitk::PointSet::PointIdentifier id, QModelIndex &index) const;
public slots:
void MoveSelectedPointUp();
void MoveSelectedPointDown();
void RemoveSelectedPoint();
signals:
/// emitted, when views should update their selection status
/// (because mouse interactions in render windows can change
/// the selection status of points)
void SignalUpdateSelection();
protected:
/// internally observe different point set
void ObserveNewPointSet(mitk::DataNode *pointSetNode);
// initially checks if there is a PointSet as data in the DataNode.
// returns PointSet if so and nullptr if other data is set to node
mitk::PointSet *CheckForPointSetInNode(mitk::DataNode *node) const;
protected:
mitk::DataNode *m_PointSetNode;
unsigned int m_PointSetModifiedObserverTag;
unsigned int m_PointSetDeletedObserverTag;
int m_TimeStep;
};
#endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkAdaptiveRegionGrowingToolGUI.h b/Modules/SegmentationUI/Qmitk/QmitkAdaptiveRegionGrowingToolGUI.h
index c0d645772d..79f848ea27 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkAdaptiveRegionGrowingToolGUI.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkAdaptiveRegionGrowingToolGUI.h
@@ -1,228 +1,229 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QMITK_QmitkAdaptiveRegionGrowingToolGUI_H
#define QMITK_QmitkAdaptiveRegionGrowingToolGUI_H
#include "itkImage.h"
#include "mitkDataStorage.h"
#include "mitkGeometry3D.h"
#include "mitkPointSet.h"
#include "qwidget.h"
#include "ui_QmitkAdaptiveRegionGrowingToolGUIControls.h"
#include <MitkSegmentationUIExports.h>
#include "QmitkToolGUI.h"
#include "mitkAdaptiveRegionGrowingTool.h"
class DataNode;
class QmitkAdaptiveRegionGrowingToolGUIControls;
/*!
*
* \brief QmitkAdaptiveRegionGrowingToolGUI
*
* Adaptive Region Growing View class of the segmentation.
*
*/
class MITKSEGMENTATIONUI_EXPORT QmitkAdaptiveRegionGrowingToolGUI : public QmitkToolGUI
{
Q_OBJECT
public:
/**
* @brief mitkClassMacro
*/
mitkClassMacro(QmitkAdaptiveRegionGrowingToolGUI, QmitkToolGUI);
itkFactorylessNewMacro(Self);
itkCloneMacro(Self);
QmitkAdaptiveRegionGrowingToolGUI(QWidget *parent = nullptr);
/** \brief Method to create the connections for the component. This Method is obligatory even if no connections is
* needed*/
virtual void CreateConnections();
///** \brief Method to set the default data storage.*/
virtual void SetDataStorage(mitk::DataStorage *dataStorage);
/**
* @brief Method to set the name of a data node.
* @param labledSegmentation Name of the labeled segmentation
* @param binaryImage Name of the binary image
* @param surface Name of the surface
+ * @param maskedSegmentation
*/
void SetDataNodeNames(std::string labledSegmentation,
std::string binaryImage,
/*std::string vesselTree,*/ std::string surface,
std::string maskedSegmentation);
/**
* @brief Method to enable/disable controls for region growing
*
* This method checks if a seed point is set and a segmentation exists.
- * @param enable/disable controls
+ * @param enable enable/disable controls
*/
void EnableControls(bool enable);
/**
* @brief Method to set the input image node
- * @param data node
+ * @param node data node
*/
void SetInputImageNode(mitk::DataNode *node);
void Deactivated();
void Activated();
/**
* @brief The created GUI from the .ui-File. This Attribute is obligatory
*/
Ui::QmitkAdaptiveRegionGrowingToolGUIControls m_Controls;
protected slots:
/**
* @brief Method to start the segmentation
*
* This method is called, when the "Start Segmentation" button is clicked.
*/
void RunSegmentation();
/**
* @brief Method to change the level window
*
* This method is called, when the level window slider is changed via the slider in the control widget
- * @param new value
+ * @param newValue new value
*/
void ChangeLevelWindow(double newValue);
/**
* @brief Method to increase the preview slider
*
* This method is called, when the + button is clicked and increases the value by 1
*/
void IncreaseSlider();
/**
* @brief Method to decrease the preview slider
*
* This method is called, when the - button is clicked and decreases the value by 1
*/
void DecreaseSlider();
/**
* @brief Method to confirm the preview segmentation
*
* This method is called, when the "Confirm Segmentation" button is clicked.
*/
void ConfirmSegmentation();
/**
* @brief Method to switch the volume rendering on/off
- * @param on/off
+ * @param on
*/
void UseVolumeRendering(bool on);
/**
* @brief Method to set the lower threshold
*
* This method is called, when the minimum threshold slider has changed
- * @param lower threshold
+ * @param lowerThreshold lower threshold
*/
void SetLowerThresholdValue(double lowerThreshold);
/**
* @brief Method to set upper threshold
*
* This Method is called, when the maximum threshold slider has changed
- * @param upper threshold
+ * @param upperThreshold upper threshold
*/
void SetUpperThresholdValue(double upperThreshold);
/**
* @brief Method to determine which tool to activate
*
* This method listens to the tool manager and activates this tool if requested otherwise disables this view
*/
void OnNewToolAssociated(mitk::Tool *);
protected:
mitk::AdaptiveRegionGrowingTool::Pointer m_RegionGrow3DTool;
/** \brief Destructor. */
~QmitkAdaptiveRegionGrowingToolGUI() override;
mitk::DataStorage *m_DataStorage;
mitk::DataNode::Pointer m_InputImageNode;
/**
* @brief Method to calculate parameter settings, when a seed point is set
*/
void OnPointAdded();
/**
* @brief Method to extract a 3D image based on a given time point that can be taken from the SliceNavigationController
*
* This ensures that the seed point is taken from the current selected 3D image
*/
mitk::Image::ConstPointer GetImageByTimePoint(const mitk::Image *image,
mitk::TimePointType timePoint) const;
private:
std::string m_NAMEFORORGIMAGE;
std::string m_NAMEFORLABLEDSEGMENTATIONIMAGE;
std::string m_NAMEFORBINARYIMAGE;
std::string m_NAMEFORSURFACE;
std::string m_NAMEFORMASKEDSEGMENTATION;
mitk::ScalarType m_LOWERTHRESHOLD; // Hounsfield value
mitk::ScalarType m_UPPERTHRESHOLD; // Hounsfield value
mitk::ScalarType m_SeedPointValueMean;
void RemoveHelperNodes();
int m_DetectedLeakagePoint;
bool m_CurrentRGDirectionIsUpwards; // defines fixed threshold (true = LOWERTHRESHOLD fixed, false = UPPERTHRESHOLD
// fixed)
int m_SeedpointValue;
bool m_SliderInitialized;
bool m_UseVolumeRendering;
bool m_UpdateSuggestedThreshold;
float m_SuggestedThValue;
long m_PointSetAddObserverTag;
long m_PointSetMoveObserverTag;
template <typename TPixel, unsigned int VImageDimension>
void StartRegionGrowing(const itk::Image<TPixel, VImageDimension> *itkImage,
const mitk::BaseGeometry *imageGeometry,
const mitk::PointSet::PointType seedPoint);
template <typename TPixel, unsigned int VImageDimension>
void ITKThresholding(itk::Image<TPixel, VImageDimension> *inputImage);
void InitializeLevelWindow();
void EnableVolumeRendering(bool enable);
void UpdateVolumeRenderingThreshold(int thValue);
};
#endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkSliceBasedInterpolatorWidget.h b/Modules/SegmentationUI/Qmitk/QmitkSliceBasedInterpolatorWidget.h
index f33ab64114..b447a67e11 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkSliceBasedInterpolatorWidget.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkSliceBasedInterpolatorWidget.h
@@ -1,197 +1,197 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QmitkSliceBasedInterpolatorWidget_h_Included
#define QmitkSliceBasedInterpolatorWidget_h_Included
#include "MitkSegmentationUIExports.h"
#include "mitkDataStorage.h"
#include "mitkSliceBasedInterpolationController.h"
#include <map>
#include <QWidget>
#include "ui_QmitkSliceBasedInterpolatorWidgetGUIControls.h"
namespace mitk
{
class PlaneGeometry;
class SliceNavigationController;
class LabelSetImage;
class ToolManager;
class DiffSliceOperation;
}
/**
\brief GUI for slices interpolation.
\ingroup ToolManagerEtAl
\ingroup Widgets
\sa QmitkInteractiveSegmentation
\sa mitk::SegmentationInterpolation
While mitk::SegmentationInterpolation does the bookkeeping of interpolation
(keeping track of which slices contain how much segmentation) and the algorithmic work,
QmitkSliceBasedInterpolatorWidget is responsible to watch the GUI, to notice, which slice is currently
visible. It triggers generation of interpolation suggestions and also triggers acception of
suggestions.
This class uses the mitk::ToolManagerProvider::MULTILABEL_SEGMENTATION context.
\todo show/hide feedback on demand
Last contributor: $Author: maleike $
*/
class MITKSEGMENTATIONUI_EXPORT QmitkSliceBasedInterpolatorWidget : public QWidget
{
Q_OBJECT
public:
QmitkSliceBasedInterpolatorWidget(QWidget *parent = nullptr, const char *name = nullptr);
~QmitkSliceBasedInterpolatorWidget() override;
void SetDataStorage(mitk::DataStorage &storage);
/**
Sets the slice navigation controllers for getting slice changed events from the views.
*/
void SetSliceNavigationControllers(const QList<mitk::SliceNavigationController *> &controllers);
void OnToolManagerWorkingDataModified();
void OnTimeChanged(itk::Object *sender, const itk::EventObject &);
void OnSliceChanged(itk::Object *sender, const itk::EventObject &);
void OnSliceNavigationControllerDeleted(const itk::Object *sender, const itk::EventObject &);
/**
Just public because it is called by itk::Commands. You should not need to call this.
*/
void OnSliceInterpolationInfoChanged(const itk::EventObject &);
Ui::QmitkSliceBasedInterpolatorWidgetGUIControls m_Controls;
signals:
void signalSliceBasedInterpolationEnabled(bool);
public slots:
/**
\brief Reaction to "Start/Stop" button click
*/
void OnToggleWidgetActivation(bool);
protected slots:
/**
\brief Reaction to "Accept Current Slice" button click.
*/
void OnAcceptInterpolationClicked();
/*
\brief Reaction to "Accept All Slices" button click.
Opens popup to ask about which orientation should be interpolated
*/
void OnAcceptAllInterpolationsClicked();
/*
\brief Called from popup menu of OnAcceptAllInterpolationsClicked()
Will trigger interpolation for all slices in given orientation
*/
void OnAcceptAllPopupActivated(QAction *action);
protected:
typedef std::map<QAction *, mitk::SliceNavigationController *> ActionToSliceDimensionMapType;
const ActionToSliceDimensionMapType CreateActionToSliceDimension();
ActionToSliceDimensionMapType m_ActionToSliceDimensionMap;
void AcceptAllInterpolations(mitk::SliceNavigationController *slicer);
void WaitCursorOn();
void WaitCursorOff();
void RestoreOverrideCursor();
/**
Gets the working slice based on the given plane geometry and last saved interaction
\param planeGeometry a plane geometry
*/
mitk::Image::Pointer GetWorkingSlice(const mitk::PlaneGeometry *planeGeometry);
/**
Retrieves the currently selected PlaneGeometry from a SlicedGeometry3D that is generated by a
SliceNavigationController
and calls Interpolate to further process this PlaneGeometry into an interpolation.
\param e is a actually a mitk::SliceNavigationController::GeometrySliceEvent, sent by a SliceNavigationController
- \param slice the SliceNavigationController
+ \param slicer the SliceNavigationController
*/
void TranslateAndInterpolateChangedSlice(const itk::EventObject &e, mitk::SliceNavigationController *slicer);
/**
Given a PlaneGeometry, this method figures out which slice of the first working image (of the associated
ToolManager)
should be interpolated. The actual work is then done by our SegmentationInterpolation object.
*/
void Interpolate(mitk::PlaneGeometry *plane, mitk::TimePointType timePoint, mitk::SliceNavigationController *slicer);
/**
Called internally to update the interpolation suggestion. Finds out about the focused render window and requests an
interpolation.
*/
void UpdateVisibleSuggestion();
private:
mitk::SliceBasedInterpolationController::Pointer m_SliceInterpolatorController;
mitk::ToolManager *m_ToolManager;
bool m_Activated;
template <typename TPixel, unsigned int VImageDimension>
void WritePreviewOnWorkingImage(itk::Image<TPixel, VImageDimension> *target,
const mitk::Image *source,
int overwritevalue);
QHash<mitk::SliceNavigationController *, int> m_ControllerToTimeObserverTag;
QHash<mitk::SliceNavigationController *, int> m_ControllerToSliceObserverTag;
QHash<mitk::SliceNavigationController *, int> m_ControllerToDeleteObserverTag;
unsigned int m_InterpolationInfoChangedObserverTag;
mitk::DiffSliceOperation *m_doOperation;
mitk::DiffSliceOperation *m_undoOperation;
mitk::DataNode::Pointer m_PreviewNode;
mitk::Image::Pointer m_PreviewImage;
mitk::LabelSetImage::Pointer m_WorkingImage;
QHash<mitk::SliceNavigationController *, mitk::TimePointType> m_TimePoints;
mitk::DataStorage::Pointer m_DataStorage;
mitk::SliceNavigationController *m_LastSNC;
unsigned int m_LastSliceIndex;
};
#endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkSlicesInterpolator.h b/Modules/SegmentationUI/Qmitk/QmitkSlicesInterpolator.h
index 19d55cea0f..a6499b7354 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkSlicesInterpolator.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkSlicesInterpolator.h
@@ -1,291 +1,291 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QmitkSlicesInterpolator_h_Included
#define QmitkSlicesInterpolator_h_Included
#include "mitkDataNode.h"
#include "mitkDataStorage.h"
#include "mitkSegmentationInterpolationController.h"
#include "mitkSliceNavigationController.h"
#include "mitkSurfaceInterpolationController.h"
#include "mitkToolManager.h"
#include <MitkSegmentationUIExports.h>
#include "mitkFeatureBasedEdgeDetectionFilter.h"
#include "mitkPointCloudScoringFilter.h"
#include <QWidget>
#include <map>
#include <QCheckBox>
#include <QComboBox>
#include <QFrame>
#include <QGroupBox>
#include <QRadioButton>
#include "mitkVtkRepresentationProperty.h"
#include "vtkProperty.h"
// For running 3D interpolation in background
#include <QFuture>
#include <QFutureWatcher>
#include <QTimer>
#include <QtConcurrentRun>
namespace mitk
{
class PlaneGeometry;
class SliceNavigationController;
}
class QPushButton;
/**
\brief GUI for slices interpolation.
\ingroup ToolManagerEtAl
\ingroup Widgets
\sa QmitkInteractiveSegmentation
\sa mitk::SegmentationInterpolation
While mitk::SegmentationInterpolation does the bookkeeping of interpolation
(keeping track of which slices contain how much segmentation) and the algorithmic work,
QmitkSlicesInterpolator is responsible to watch the GUI, to notice, which slice is currently
visible. It triggers generation of interpolation suggestions and also triggers acception of
suggestions.
\todo show/hide feedback on demand
Last contributor: $Author: maleike $
*/
class MITKSEGMENTATIONUI_EXPORT QmitkSlicesInterpolator : public QWidget
{
Q_OBJECT
public:
QmitkSlicesInterpolator(QWidget *parent = nullptr, const char *name = nullptr);
/**
To be called once before real use.
*/
void Initialize(mitk::ToolManager *toolManager, const QList<mitk::SliceNavigationController *> &controllers);
void Uninitialize();
~QmitkSlicesInterpolator() override;
void SetDataStorage(mitk::DataStorage::Pointer storage);
mitk::DataStorage *GetDataStorage();
/**
Just public because it is called by itk::Commands. You should not need to call this.
*/
void OnToolManagerWorkingDataModified();
/**
Just public because it is called by itk::Commands. You should not need to call this.
*/
void OnToolManagerReferenceDataModified();
void OnTimeChanged(itk::Object *sender, const itk::EventObject &);
void OnSliceChanged(itk::Object *sender, const itk::EventObject &);
void OnSliceNavigationControllerDeleted(const itk::Object *sender, const itk::EventObject &);
/**
Just public because it is called by itk::Commands. You should not need to call this.
*/
void OnInterpolationInfoChanged(const itk::EventObject &);
/**
Just public because it is called by itk::Commands. You should not need to call this.
*/
void OnSurfaceInterpolationInfoChanged(const itk::EventObject &);
/**
* @brief Set the visibility of the 3d interpolation
*/
void Show3DInterpolationResult(bool);
signals:
void SignalRememberContourPositions(bool);
void SignalShowMarkerNodes(bool);
public slots:
virtual void setEnabled(bool);
/**
Call this from the outside to enable/disable interpolation
*/
void EnableInterpolation(bool);
void Enable3DInterpolation(bool);
/**
Call this from the outside to accept all interpolations
*/
void FinishInterpolation(mitk::SliceNavigationController *slicer = nullptr);
protected slots:
/**
Reaction to button clicks.
*/
void OnAcceptInterpolationClicked();
/*
Opens popup to ask about which orientation should be interpolated
*/
void OnAcceptAllInterpolationsClicked();
/*
Reaction to button clicks
*/
void OnAccept3DInterpolationClicked();
void OnReinit3DInterpolation();
void OnSuggestPlaneClicked();
/*
* Will trigger interpolation for all slices in given orientation (called from popup menu of
* OnAcceptAllInterpolationsClicked)
*/
void OnAcceptAllPopupActivated(QAction *action);
/**
Called on activation/deactivation
*/
void OnInterpolationActivated(bool);
void On3DInterpolationActivated(bool);
void OnInterpolationMethodChanged(int index);
// Enhancement for 3D interpolation
void On2DInterpolationEnabled(bool);
void On3DInterpolationEnabled(bool);
void OnInterpolationDisabled(bool);
void OnShowMarkers(bool);
void Run3DInterpolation();
void RunPlaneSuggestion();
void OnSurfaceInterpolationFinished();
void StartUpdateInterpolationTimer();
void StopUpdateInterpolationTimer();
void ChangeSurfaceColor();
protected:
const std::map<QAction *, mitk::SliceNavigationController *> createActionToSliceDimension();
std::map<QAction *, mitk::SliceNavigationController *> ACTION_TO_SLICEDIMENSION;
void AcceptAllInterpolations(mitk::SliceNavigationController *slicer);
/**
Retrieves the currently selected PlaneGeometry from a SlicedGeometry3D that is generated by a
SliceNavigationController
and calls Interpolate to further process this PlaneGeometry into an interpolation.
\param e is a actually a mitk::SliceNavigationController::GeometrySliceEvent, sent by a SliceNavigationController
- \param slice the SliceNavigationController
+ \param slicer the SliceNavigationController
*/
bool TranslateAndInterpolateChangedSlice(const itk::EventObject &e, mitk::SliceNavigationController *slicer);
/**
Given a PlaneGeometry, this method figures out which slice of the first working image (of the associated
ToolManager)
should be interpolated. The actual work is then done by our SegmentationInterpolation object.
*/
void Interpolate(mitk::PlaneGeometry *plane, mitk::TimePointType timePoint, mitk::SliceNavigationController *slicer);
// void InterpolateSurface();
/**
Called internally to update the interpolation suggestion. Finds out about the focused render window and requests an
interpolation.
*/
void UpdateVisibleSuggestion();
void SetCurrentContourListID();
private:
void HideAllInterpolationControls();
void Show2DInterpolationControls(bool show);
void Show3DInterpolationControls(bool show);
void CheckSupportedImageDimension();
void WaitForFutures();
void NodeRemoved(const mitk::DataNode* node);
mitk::SegmentationInterpolationController::Pointer m_Interpolator;
mitk::SurfaceInterpolationController::Pointer m_SurfaceInterpolator;
mitk::FeatureBasedEdgeDetectionFilter::Pointer m_EdgeDetector;
mitk::PointCloudScoringFilter::Pointer m_PointScorer;
mitk::ToolManager::Pointer m_ToolManager;
bool m_Initialized;
QHash<mitk::SliceNavigationController *, int> m_ControllerToTimeObserverTag;
QHash<mitk::SliceNavigationController *, int> m_ControllerToSliceObserverTag;
QHash<mitk::SliceNavigationController *, int> m_ControllerToDeleteObserverTag;
unsigned int InterpolationInfoChangedObserverTag;
unsigned int SurfaceInterpolationInfoChangedObserverTag;
QGroupBox *m_GroupBoxEnableExclusiveInterpolationMode;
QComboBox *m_CmbInterpolation;
QPushButton *m_BtnApply2D;
QPushButton *m_BtnApplyForAllSlices2D;
QPushButton *m_BtnApply3D;
QPushButton *m_BtnSuggestPlane;
QCheckBox *m_ChkShowPositionNodes;
QPushButton *m_BtnReinit3DInterpolation;
mitk::DataNode::Pointer m_FeedbackNode;
mitk::DataNode::Pointer m_InterpolatedSurfaceNode;
mitk::DataNode::Pointer m_3DContourNode;
mitk::Image *m_Segmentation;
mitk::SliceNavigationController *m_LastSNC;
unsigned int m_LastSliceIndex;
QHash<mitk::SliceNavigationController *, mitk::TimePointType> m_TimePoints;
bool m_2DInterpolationEnabled;
bool m_3DInterpolationEnabled;
// unsigned int m_CurrentListID;
mitk::DataStorage::Pointer m_DataStorage;
QFuture<void> m_Future;
QFutureWatcher<void> m_Watcher;
QTimer *m_Timer;
QFuture<void> m_PlaneFuture;
QFutureWatcher<void> m_PlaneWatcher;
bool m_FirstRun;
};
#endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkToolSelectionBox.h b/Modules/SegmentationUI/Qmitk/QmitkToolSelectionBox.h
index 2afc06ce0f..20d15ed015 100755
--- a/Modules/SegmentationUI/Qmitk/QmitkToolSelectionBox.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkToolSelectionBox.h
@@ -1,148 +1,150 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QmitkToolSelectionBox_h_Included
#define QmitkToolSelectionBox_h_Included
#include "QmitkToolGUIArea.h"
#include <MitkSegmentationUIExports.h>
#include "mitkToolManager.h"
#include <QButtonGroup>
#include <QGridLayout>
#include <QWidget>
#include <map>
class QmitkToolGUI;
/**
\brief Display the tool selection state of a mitk::ToolManager
\sa mitk::ToolManager
\ingroup org_mitk_gui_qt_interactivesegmentation
\ingroup ToolManagerEtAl
This widget graphically displays the active tool of a mitk::ToolManager as a set
of toggle buttons. Each button show the identification of a Tool (icon and name).
When a button's toggle state is "down", the tool is activated. When a different button
is clicked, the active tool is switched. When you click an already active button, the
associated tool is deactivated with no replacement, which means that no tool is active
then.
When this widget is enabled/disabled it (normally) also enables/disables the tools. There
could be cases where two QmitkToolSelectionBox widgets are associated to the same ToolManager,
but if this happens, please look deeply into the code.
Last contributor: $Author: maleike $
*/
class MITKSEGMENTATIONUI_EXPORT QmitkToolSelectionBox : public QWidget
//!
{
Q_OBJECT
public:
enum EnabledMode
{
EnabledWithReferenceAndWorkingDataVisible,
EnabledWithReferenceData,
EnabledWithWorkingData,
AlwaysEnabled
};
QmitkToolSelectionBox(QWidget *parent = nullptr, mitk::DataStorage *storage = nullptr);
~QmitkToolSelectionBox() override;
mitk::ToolManager *GetToolManager();
void SetToolManager(mitk::ToolManager &); // no nullptr pointer allowed here, a manager is required
void setTitle(const QString &title);
/**
You may specify a list of tool "groups" that should be displayed in this widget. Every Tool can report its group
- as a string. This method will try to find the tool's group inside the supplied string \param toolGroups. If there is
+ as a string. This method will try to find the tool's group inside the supplied string \c toolGroups . If there is
a match,
the tool is displayed. Effectively, you can provide a human readable list like "default, lymphnodevolumetry,
oldERISstuff".
+
+ @param toolGroups
*/
void SetDisplayedToolGroups(const std::string &toolGroups = nullptr);
void OnToolManagerToolModified();
void OnToolManagerReferenceDataModified();
void OnToolManagerWorkingDataModified();
void OnToolGUIProcessEventsMessage();
void OnToolErrorMessage(std::string s);
void OnGeneralToolMessage(std::string s);
void RecreateButtons();
signals:
/// Whenever a tool is activated. id is the index of the active tool. Counting starts at 0, -1 indicates "no tool
/// selected"
/// This signal is also emitted, when the whole QmitkToolSelectionBox get disabled. Then it will claim
/// ToolSelected(-1)
/// When it is enabled again, there will be another ToolSelected event with the tool that is currently selected
void ToolSelected(int id);
public slots:
virtual void setEnabled(bool);
virtual void SetEnabledMode(EnabledMode mode);
virtual void SetLayoutColumns(int);
virtual void SetShowNames(bool);
virtual void SetGenerateAccelerators(bool);
virtual void SetToolGUIArea(QWidget *parentWidget);
protected slots:
void toolButtonClicked(int id);
void SetGUIEnabledAccordingToToolManagerState();
void UpdateButtonsEnabledState();
protected:
void showEvent(QShowEvent *) override;
void hideEvent(QHideEvent *) override;
void SetOrUnsetButtonForActiveTool();
mitk::ToolManager::Pointer m_ToolManager;
bool m_SelfCall;
std::string m_DisplayedGroups;
/// stores relationship between button IDs of the Qt widget and tool IDs of ToolManager
std::map<int, int> m_ButtonIDForToolID;
/// stores relationship between button IDs of the Qt widget and tool IDs of ToolManager
std::map<int, int> m_ToolIDForButtonID;
int m_LayoutColumns;
bool m_ShowNames;
bool m_GenerateAccelerators;
QWidget *m_ToolGUIWidget;
QmitkToolGUI *m_LastToolGUI;
// store buttons in this group
QButtonGroup *m_ToolButtonGroup;
QGridLayout *m_ButtonLayout;
EnabledMode m_EnabledMode;
};
#endif
diff --git a/Modules/SemanticRelationsUI/include/QmitkLesionTreeItem.h b/Modules/SemanticRelationsUI/include/QmitkLesionTreeItem.h
index efbc11c930..08d5ccc63b 100644
--- a/Modules/SemanticRelationsUI/include/QmitkLesionTreeItem.h
+++ b/Modules/SemanticRelationsUI/include/QmitkLesionTreeItem.h
@@ -1,120 +1,120 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QMITKLESIONTREEITEM_H
#define QMITKLESIONTREEITEM_H
// mitk semantic relations UI
#include "mitkLesionData.h"
// mitk semantic relations
#include <mitkSemanticTypes.h>
// qt
#include <QVariant>
// c++
#include <memory>
#include <vector>
/*
* @brief This class is used by custom tree models to create their tree items.
* It provides functions to traverse and modify the tree.
* Additionally it holds some 'LesionData' that is used to display lesion properties inside a tree view.
*/
class QmitkLesionTreeItem : public std::enable_shared_from_this<QmitkLesionTreeItem>
{
public:
using ChildPointer = std::shared_ptr<QmitkLesionTreeItem>;
using ChildConstPointer = std::shared_ptr<const QmitkLesionTreeItem>;
using ParentPointer = std::weak_ptr<QmitkLesionTreeItem>;
QmitkLesionTreeItem(mitk::LesionData lesionData = mitk::LesionData());
/**
* @brief Return the child of this item at a specific position.
*
* @param row Determines the position of a child item to return.
*
* @return The child of this item at a specific position.
*/
ChildPointer GetChildInRow(int row) const { return m_Children.at(row); };
/**
* @brief Return the parent item.
*
* @return The parent item as std::weak_ptr.
*/
ParentPointer GetParent() const { return m_ParentItem; };
/**
* @brief Set the parent item of this item.
*
* @param parent The new parent item of this item.
*/
void SetParent(ParentPointer parent);
/**
* @brief Return the item data, which contains ...
*
* see <code>mitk::LesionItemData</code>
*/
mitk::LesionData& GetData() { return m_ItemData; };
/**
* @brief Get the row of this item relative to its parent item using 'GetRowOfChild'.
*
* @return The row of this item relative to its parent item.
*/
int GetRow() const;
/**
* @brief Get the row of the given child item relative to this item.
*
* @param child The child item whose row is to be determined.
*
* @return The row of the child item.
*/
int GetRowOfChild(ChildConstPointer child) const;
/**
* @brief Return the number of child items.
*
* @return Number of child items.
*/
size_t ChildCount() const { return m_Children.size(); };
/**
* @brief Add a new child to the list of children of this item if it is not already a child item.
*
* @param child The child item to add to this item.
*/
void AddChild(ChildPointer child);
/**
* @brief Remove a child from the list of children of this item.
*
* @param child The child item to remove from this item.
*/
void RemoveChild(ChildPointer child);
/**
* @brief Set the item data of this item.
*
- * @param value LesionData that provides information about this item.
+ * @param lesionData LesionData that provides information about this item.
*/
void SetData(const mitk::LesionData& lesionData);
private:
ParentPointer m_ParentItem;
std::vector<ChildPointer> m_Children;
mitk::LesionData m_ItemData;
};
Q_DECLARE_METATYPE(QmitkLesionTreeItem)
Q_DECLARE_METATYPE(QmitkLesionTreeItem*)
#endif // QMITKLESIONTREEITEM_H
diff --git a/Modules/ToFUI/Qmitk/QmitkToFCompositeFilterWidget.h b/Modules/ToFUI/Qmitk/QmitkToFCompositeFilterWidget.h
index 919b7334a0..636b1432e9 100644
--- a/Modules/ToFUI/Qmitk/QmitkToFCompositeFilterWidget.h
+++ b/Modules/ToFUI/Qmitk/QmitkToFCompositeFilterWidget.h
@@ -1,171 +1,171 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef _QMITKTOFCOMPOSITEFILTERWIDGET_H_INCLUDED
#define _QMITKTOFCOMPOSITEFILTERWIDGET_H_INCLUDED
#include <MitkToFUIExports.h>
#include "ui_QmitkToFCompositeFilterWidgetControls.h"
//mitk headers
#include <mitkToFCompositeFilter.h>
/**
* @brief Widget for controlling the ToFCompositeFilter (located in module ToFProcessing)
*
* The widget allows to enable/disable the filters internally used in the ToFCompositeFilter
* and to set the individual filter parameters using GUI elements
*
* @ingroup ToFUI
*/
class MITKTOFUI_EXPORT QmitkToFCompositeFilterWidget :public QWidget
{
//this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
Q_OBJECT
public:
static const std::string VIEW_ID;
QmitkToFCompositeFilterWidget(QWidget* p = nullptr, Qt::WindowFlags f1 = nullptr);
~QmitkToFCompositeFilterWidget() override;
/* @brief This method is part of the widget an needs not to be called seperately. */
virtual void CreateQtPartControl(QWidget *parent);
/* @brief This method is part of the widget an needs not to be called seperately. (Creation of the connections of main and control widget.)*/
virtual void CreateConnections();
/*!
\brief Sets the ToFCompositeFilter used by this widget
- \param tofCompositeFilter pointer to the internally used ToFCompositeFilter
+ \param toFCompositeFilter pointer to the internally used ToFCompositeFilter
*/
void SetToFCompositeFilter(mitk::ToFCompositeFilter* toFCompositeFilter);
/*!
\brief Returns the ToFCompositeFilter used by this widget
\return tofCompositeFilter pointer to the internally used ToFCompositeFilter
*/
mitk::ToFCompositeFilter* GetToFCompositeFilter();
/*!
\brief update parameters of ToFCompositeFilter according to current GUI setting
*/
void UpdateFilterParameter();
/*!
\brief set the configuration of the widget specifying which filter is enabled on start
*/
void SetWidgetConfiguration(bool threshold, bool mask, bool tempMedian, bool tempAverage, bool median, bool bilateral );
/*!
\brief sets the standard parameters used for the bilateral filter to the ComboBoxes used in the GUI
\param domainSigma Parameter controlling the smoothing effect of the bilateral filter. Default value: 2
\param rangeSigma Parameter controlling the edge preserving effect of the bilateral filter. Default value: 60
\param kernelRadius radius of the filter mask of the bilateral filter
*/
void SetStandardParametersBilateralFilter(double domainSigma, double rangeSigma, int kernelRadius=0);
/*!
\brief set the standard parameters for the threshold filter to the combo boxes in the GUI
\param min lower threshold of the threshold filter
\param max upper threshold of the threshold filter
*/
void SetStandardParametersThresholdFilter(int min, int max);
/*!
\brief set the standard value for the number of images to be averaged to the combo box in the GUI
*/
void SetStandardParameterTemporalAveraging(int nImages);
void SetDataStorage(mitk::DataStorage::Pointer dataStorage);
signals:
protected slots:
/**
* @brief OnShowAdvancedOptionsCheckboxChecked Show/hide advanced options.
* @param checked show/hide
*/
void OnShowAdvancedOptionsCheckboxChecked(bool checked);
/*!
\brief slot en-/disabling temporal median filter in internal ToFCompositeFilter
*/
void OnTemporalMedianFilterCheckBoxChecked(bool checked);
/*!
\brief slot en-/disabling average filter in internal ToFCompositeFilter
*/
void OnAverageFilterCheckBoxChecked(bool checked);
/*!
\brief slot en-/disabling threshold filter in internal ToFCompositeFilter
*/
void OnThresholdFilterCheckBoxChecked(bool checked);
/*!
\brief slot en-/disabling the mask segmentation in internal ToFCompositeFilter
*/
void OnMaskSegmentationCheckBoxChecked(bool checked);
/*!
\brief slot en-/disabling median filter in internal ToFCompositeFilter
*/
void OnMedianFilterCheckBoxChecked(bool checked);
/*!
\brief slot en-/disabling bilateral filter in internal ToFCompositeFilter
*/
void OnBilateralFilterCheckBoxChecked(bool checked);
/*!
\brief slot updating threshold spin boxes according to slider position
*/
void OnSpanChanged(int lower, int upper);
/*!
\brief slot resetting threshold range slider to default values (min: 1, max: 7000)
*/
void OnResetThresholdFilterRangeSlider();
/*!
\brief slot updating the parameter "number of frames" of the temporal median filter in the ToFCompositeFilter
*/
void OnTemporalMedianFilterNumOfFramesSpinBoxValueChanged(int value);
/*!
\brief slot updating the parameter "domain sigma" of the bilateral filter in the ToFCompositeFilter
*/
void OnBilateralFilterDomainSigmaSpinBoxValueChanged(double value);
/*!
\brief slot updating the paramter "range sigma" of the bilateral filter in the ToFCompositeFilter
*/
void OnBilateralFilterRangeSigmaSpinBoxValueChanged(double value);
/*!
\brief slot updating the paramter "kernel radius" of the bilateral filter in the ToFCompositeFilter
*/
void OnBilateralFilterKernelRadiusSpinBoxValueChanged(int value);
/*!
\brief slot updating the paramter "minimal threshold" of the threshold filter in the ToFCompositeFilter
*/
void OnThresholdFilterMinValueChanged(int value);
/*!
\brief slot updating the paramter "maximal threshold" of the threshold filter in the ToFCompositeFilter
*/
void OnThresholdFilterMaxValueChanged(int value);
protected:
Ui::QmitkToFCompositeFilterWidgetControls* m_Controls; ///< member holding the UI elements of this widget
mitk::ToFCompositeFilter::Pointer m_ToFCompositeFilter; ///< member holding the internally used ToFCompositeFilter
private:
/*!
\brief method updating the parameters of the bilateral filter in the ToFCompositeFilter
*/
void SetBilateralFilterParameter();
/*!
\brief method updating the parameters of the threshold filter in the ToFCompositeFilter
*/
void SetThresholdFilterParameter();
mitk::DataStorage::Pointer m_DataStorage;
};
#endif // _QMITKTOFCOMPOSITEFILTERWIDGET_H_INCLUDED
diff --git a/Modules/ToFUI/Qmitk/QmitkToFPointSetWidget.h b/Modules/ToFUI/Qmitk/QmitkToFPointSetWidget.h
index 13e4203e74..c07f7fc4c3 100644
--- a/Modules/ToFUI/Qmitk/QmitkToFPointSetWidget.h
+++ b/Modules/ToFUI/Qmitk/QmitkToFPointSetWidget.h
@@ -1,144 +1,144 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef _QmitkToFPointSetWidget_H_INCLUDED
#define _QmitkToFPointSetWidget_H_INCLUDED
#include <MitkToFUIExports.h>
#include "ui_QmitkToFPointSetWidgetControls.h"
//mitk headers
#include <mitkCameraIntrinsics.h>
#include <mitkDataStorage.h>
#include <mitkPointSet.h>
#include <mitkPointSetDataInteractor.h>
#include <mitkPropertyList.h>
#include <mitkTextAnnotation2D.h>
#include <mitkToFDistanceImageToPointSetFilter.h>
//Qmitk headers
#include <QmitkRenderWindow.h>
// vtk includes
#include <vtkSmartPointer.h>
#include <vtkTextActor.h>
#include <vtkRenderer.h>
/**
* @brief Widget allowing interaction with point sets for measurement and PointSet definition
*
* The widget allows to
* 1. Measure the distance between two points in 3D ToF space by clicking the points in the 2D slices
* 2. Defining a ToF PointSet both in 2D and 3D. CameraIntrinsics are used for calculation between 2D and 3D
*
* NOTE:
* You have to make sure that the widget is initialized at a position in the plugin using it, where the distance
* image is available. CleanUp has to be called to make sure that all observers and renderers are removed correctly.
*
* @ingroup ToFUI
*/
class MITKTOFUI_EXPORT QmitkToFPointSetWidget :public QWidget
{
//this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
Q_OBJECT
public:
static const std::string VIEW_ID;
QmitkToFPointSetWidget(QWidget* p = nullptr, Qt::WindowFlags f1 = nullptr);
~QmitkToFPointSetWidget() override;
/* @brief This method is part of the widget an needs not to be called seperately. */
virtual void CreateQtPartControl(QWidget *parent);
/* @brief This method is part of the widget an needs not to be called seperately. (Creation of the connections of main and control widget.)*/
virtual void CreateConnections();
/*!
\brief initializes the widget. Observers to the change events of the point sets are created, text actors are activated
to be rendered into the foreground of the render window.
- \param stdMultiWidget QmitkStdMultiWidget used for painting overlays for measurement
+ \param renderWindowHashMap
\param dataStorage DataStorage to add PointSets
- \param distanceImage range image used to calculate 3D PointSet from 2D index
+ \param cameraIntrinsics
*/
void InitializeWidget(QHash<QString, QmitkRenderWindow*> renderWindowHashMap, mitk::DataStorage::Pointer dataStorage, mitk::CameraIntrinsics::Pointer cameraIntrinsics=nullptr);
/*!
\brief cleans up the widget when it's functionality is not used anymore.
Removes observers and deletes foreground renderer
*/
void CleanUpWidget();
/*!
\brief set the image holding the distance information used for measuring
*/
void SetDistanceImage(mitk::Image::Pointer distanceImage);
/*!
\brief Set intrinsic parameters of the used device
*/
void SetCameraIntrinsics(mitk::CameraIntrinsics::Pointer cameraIntrinsics);
signals:
protected slots:
/*!
\brief Activates the interactor for the measurement point set
*/
void OnMeasurement();
/*!
\brief Activates the interactor for the point set
*/
void OnPointSet();
protected:
/*!
\brief function called when the 2D measurement PointSet has changed
*/
void MeasurementPointSetChanged();
/*!
\brief function called when the 2D PointSet has changed
*/
void PointSetChanged();
Ui::QmitkToFPointSetWidgetControls* m_Controls; ///< member holding the UI elements of this widget
mitk::DataStorage::Pointer m_DataStorage; ///< member holding the set DataStorage
mitk::Image::Pointer m_DistanceImage; ///< image holding the range data of the ToF camera
mitk::CameraIntrinsics::Pointer m_CameraIntrinsics; ///< intrinsic parameters of the camera
mitk::TextAnnotation2D::Pointer m_TextAnnotationAxial; ///< text annotation used to display measurements in axial window
mitk::TextAnnotation2D::Pointer m_TextAnnotationSagittal; ///< text annotation used to display measurement in axial window
mitk::TextAnnotation2D::Pointer m_TextAnnotationCoronal; ///< text annotation used to display measurement in axial window
mitk::TextAnnotation2D::Pointer m_TextAnnotation3D; ///< text annotation used to display measurement in 3d window
mitk::VtkPropRenderer::Pointer m_RendererAxial; ///< renderer of axial render window
mitk::VtkPropRenderer::Pointer m_RendererSagittal; ///< renderer of sagittal render window
mitk::VtkPropRenderer::Pointer m_RendererCoronal; ///< renderer of coronal render window
mitk::VtkPropRenderer::Pointer m_Renderer3D; ///< renderer of 3D render window
mitk::PointSet::Pointer m_MeasurementPointSet2D; ///< PointSet holding the 2D ToF image point selection used for measuring
mitk::DataNode::Pointer m_MeasurementPointSet3DNode; ///< DataNode holding the 3D ToF coordinates used for measuring
mitk::PointSet::Pointer m_PointSet2D; ///< PointSet holding the 2D ToF image points
mitk::DataNode::Pointer m_PointSet3DNode; ///< DataNode holding the 3D ToF coordinates
mitk::PointSetDataInteractor::Pointer m_PointSetInteractor; ///< PointSetInteractor used for PointSet definition
mitk::PointSetDataInteractor::Pointer m_MeasurementPointSetInteractor; ///< PointSetInteractor used for measurement
long m_MeasurementPointSetChangedObserverTag; ///< observer tag for measurement PointSet observer
long m_PointSetChangedObserverTag; ///< observer tag for PointSet observer
// long m_DistanceImageChangedObserverTag; ///< observer tag for distance image observer
int m_WindowHeight; ///< Height of the renderWindow
private:
};
#endif // _QmitkToFPointSetWidget_H_INCLUDED
diff --git a/Modules/ToFUI/Qmitk/QmitkToFRecorderWidget.h b/Modules/ToFUI/Qmitk/QmitkToFRecorderWidget.h
index d3668edb51..e4739df3da 100644
--- a/Modules/ToFUI/Qmitk/QmitkToFRecorderWidget.h
+++ b/Modules/ToFUI/Qmitk/QmitkToFRecorderWidget.h
@@ -1,185 +1,185 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef _QMITKTOFRECORDERWIDGET_H_INCLUDED
#define _QMITKTOFRECORDERWIDGET_H_INCLUDED
#include <MitkToFUIExports.h>
#include <ui_QmitkToFRecorderWidgetControls.h>
//QT headers
#include <QWidget>
#include <QString>
#include <QDialog>
#include <QFileDialog>
//itk headers
#include "itkCommand.h"
//mitk headers
#include <mitkToFImageGrabber.h>
#include <mitkToFImageRecorder.h>
class QmitkStdMultiWidget;
struct QFileDialogArgs;
class QFileIconProvider;
class QFileDialogPrivate;
/**
* @brief Widget allowing to play / record ToF data
*
* @ingroup ToFUI
*/
class MITKTOFUI_EXPORT QmitkToFRecorderWidget :public QWidget
{
//this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
Q_OBJECT
public:
static const std::string VIEW_ID;
QmitkToFRecorderWidget(QWidget* p = nullptr, Qt::WindowFlags f1 = nullptr);
~QmitkToFRecorderWidget() override;
/* @brief This method is part of the widget an needs not to be called seperately. */
virtual void CreateQtPartControl(QWidget *parent);
/* @brief This method is part of the widget an needs not to be called seperately. (Creation of the connections of main and control widget.)*/
virtual void CreateConnections();
/*!
\brief Set the parameters used for this widget
\param ToFImageGrabber image grabber providing images from a ToF device
- \param tofImageRecorder image recorder allowing to record ToF images
+ \param toFImageRecorder image recorder allowing to record ToF images
*/
void SetParameter(mitk::ToFImageGrabber* ToFImageGrabber, mitk::ToFImageRecorder* toFImageRecorder);
/*!
\brief resets the GUI elements to the initial state. Play button: enabled, Stop button: disabled, Recording box: disabled
*/
void ResetGUIToInitial();
signals:
/*!
\brief signal emitted when "Play" button is pressed
*/
void ToFCameraStarted();
/*!
\brief signal emitted when "Stop" button is pressed
*/
void ToFCameraStopped();
/*!
\brief signal emitted when recording is started
*/
void RecordingStarted();
/*!
\brief signal emitted AbortEvent() in ToFImageRecorder is observed
*/
void RecordingStopped();
public slots:
/*!
\brief slot invoking to start the camera.
Calls StartCamera() and emits ToFCameraStarted signal
*/
void OnPlay();
/*!
\brief slot invoking to stop the camera and the recorder.
Calls StopCamera() and StopRecorder and emits ToFCameraStarted signal. Resets GUI to initial state.
*/
void OnStop();
/*!
\brief slot invoking to start the recording
After letting the user chose a file location for the record, m_ImageRecorder->StartRecording() is inoved.
*/
void OnStartRecorder();
/*!
\brief slot resetting the GUI elements of the recording box
*/
void OnRecordingStopped();
/*!
\brief slot activating/deactivating "number of frames" spin box dependent on recording mode (PerFrame / Infinite)
*/
void OnChangeRecordModeComboBox(int index);
protected:
/*!
\brief starts the camera by calling ToFImageGrabber::StartCamera()
*/
void StartCamera();
/*!
\brief stops the camera by calling ToFImageGrabber::StopCamera()
*/
void StopCamera();
/*!
\brief stops the recording by calling ToFImageRecorder::StopRecording()
*/
void StopRecorder();
/*!
\brief emits RecordingStopped signal.
*/
void StopRecordingCallback();
/*!
\brief adapted version of QFileDialog::getSaveFileName()
The user is now asked to choose which images he wants to save
(Distance and/or Intensity and/or Amplitude image) and which type the saved
image should have (3D, 2D+t).
*/
static QString getSaveFileName(mitk::ToFImageWriter::ToFImageType& tofImageType,
bool& distanceImageSelected,
bool& amplitudeImageSelected,
bool& intensityImageSelected,
bool& rgbImageSelected,
bool& rawDataSelected,
QWidget *parent = nullptr,
const QString &caption = QString(),
const QString &dir = QString(),
const QString &filter = QString(),
QString *selectedFilter = nullptr,
QFileDialog::Options options = nullptr
);
/*!
\brief method creating a filename from the given information
\param dir directory to save the file
\param baseFilename base file name entered by the user
\param modulationFreq modulation frequency of the camera
\param integrationTime integration time of the camera
\param numOfFrames number of frames recorded
\param extension file extension
\param imageType type of image (DistanceImage, IntensityImage, AmplitudeImage)
\return dir+"/"+baseFilename+"_MF"+modulationFreq+"_IT"+integrationTime+"_"+numOfFrames+"Images"+imageType+extension
*/
std::string prepareFilename(std::string dir,
std::string baseFilename,
std::string modulationFreq,
std::string integrationTime,
std::string numOfFrames,
std::string extension,
std::string imageType);
Ui::QmitkToFRecorderWidgetControls* m_Controls; ///< member holding the UI elements of this widget
mitk::ToFImageGrabber::Pointer m_ToFImageGrabber; ///< member holding the ToFImageGrabber for acquiring ToF images
mitk::ToFImageRecorder::Pointer m_ToFImageRecorder; ///< member holding the recorder for ToF images
mitk::ToFImageRecorder::RecordMode m_RecordMode; ///< member holding the RecordMode of the recorder (PerFrame / Infinite)
typedef itk::SimpleMemberCommand<QmitkToFRecorderWidget> CommandType;
CommandType::Pointer m_StopRecordingCommand; ///< itkCommand for abort of recording
private:
};
#endif // _QMITKTOFRECORDERWIDGET_H_INCLUDED
diff --git a/Modules/ToFUI/Qmitk/QmitkToFSurfaceGenerationWidget.h b/Modules/ToFUI/Qmitk/QmitkToFSurfaceGenerationWidget.h
index 40b94fe1ad..d5f41cd42b 100644
--- a/Modules/ToFUI/Qmitk/QmitkToFSurfaceGenerationWidget.h
+++ b/Modules/ToFUI/Qmitk/QmitkToFSurfaceGenerationWidget.h
@@ -1,156 +1,157 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef _QMITKTOFSURFACEGENERATIONWIDGET_H_INCLUDED
#define _QMITKTOFSURFACEGENERATIONWIDGET_H_INCLUDED
#include <MitkToFUIExports.h>
#include "ui_QmitkToFSurfaceGenerationWidgetControls.h"
// QT headers
#include <QWidget>
// vtk includes
#include <vtkColorTransferFunction.h>
#include <vtkCamera.h>
#include <vtkSmartPointer.h>
//MITK
#include <mitkDataNode.h>
#include <mitkToFDistanceImageToSurfaceFilter.h>
#include <mitkToFImageGrabber.h>
#include <mitkCameraIntrinsics.h>
#include <mitkSurface.h>
class QmitkStdMultiWidget;
/** Documentation:
*
* This widget provides GUI access for all basic surface generation properties and can
* be reused in any other GUI.
* \ingroup ToFUI
*/
class MITKTOFUI_EXPORT QmitkToFSurfaceGenerationWidget :public QWidget
{
//this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
Q_OBJECT
public:
static const std::string VIEW_ID;
QmitkToFSurfaceGenerationWidget (QWidget* p = nullptr, Qt::WindowFlags f1 = nullptr);
~QmitkToFSurfaceGenerationWidget () override;
/* @brief Automatically called method. */
virtual void CreateQtPartControl(QWidget *parent);
/* @brief Automatically called method. Creation of the connections of main and control widget.)*/
virtual void CreateConnections();
/**
* @brief GetToFDistanceImageToSurfaceFilter Get the internally used surface generation filter.
* @return ToFDistanceImageToSurfaceFilter as filter.
*/
mitk::ToFDistanceImageToSurfaceFilter::Pointer GetToFDistanceImageToSurfaceFilter();
/**
* @brief IsActive Check if the widget was initialized correctly.
* @return True for success.
*/
bool IsActive();
/**
* @brief Initialize Initialize the surface generation widget.
* @param filter ToFDistanceImageToSurfaceFilter for surface computation.
* @param grabber ToFImageGrabber to get/set device properties.
* @param intrinsics Intrincs of the device.
* @param surface Generated Surface.
+ * @param camera
* @param generateSurface Check the generate surface combo box.
* @param showAdvancedOptions Show/Hide advanced options.
*/
void Initialize(mitk::ToFDistanceImageToSurfaceFilter::Pointer filter, mitk::ToFImageGrabber::Pointer grabber, mitk::CameraIntrinsics::Pointer intrinsics,
mitk::DataNode::Pointer surface, vtkSmartPointer<vtkCamera> camera, bool generateSurface = false, bool showAdvancedOptions = true);
/**
* @brief UpdateSurface Generate new surface data according to the device properties
* @return True for success.
*/
bool UpdateSurface();
/**
* @brief GetSurface Get the generated surface.
* @return Surface.
*/
mitk::Surface::Pointer GetSurface();
protected slots:
/**
* @brief OnRepresentationChanged Change the representation of the surface. In other words: disable/enable
* triangulation (Point cloud/surface). If triangulation is enabled, this will also allow for editing a
* threshold for triangulating vertices.
*/
void OnRepresentationChanged(int index);
/**
* @brief OnReconstructionChanged Change the reconstruction mode of the ToFDistanceImageToSurfaceFilter.
*/
void OnReconstructionChanged(int index);
/**
* @brief OnCompute3DDataCheckboxChecked Slot beeing called, if the "surface"-checkbox is clicked. This method initializes the surface once, if it is necessary.
* @param checked Is it checked or not?
*/
void OnCompute3DDataCheckboxChecked(bool checked);
/**
* @brief OnShowAdvancedOptionsCheckboxChecked Show/hide advanced options.
* @param checked show/hide
*/
void OnShowAdvancedOptionsCheckboxChecked(bool checked);
/*!
\brief Slot trigged from the triangulation threshold spin box. Changed the threshold for connecting a vertex during triangulation.
*/
void OnTriangulationThresholdSpinBoxChanged();
/**
* @brief OnDistanceColorMapCheckBoxChecked Show the distance color mapping (vtkColorTransferFunction) on the surface.
* @param checked Show/hide.
*/
void OnDistanceColorMapCheckBoxChecked(bool checked);
/**
* @brief OnRGBTextureCheckBoxChecked Put the RGB image as texture on the generated surface/point cloud.
* @param checked Show/hide texture.
*/
void OnRGBTextureCheckBoxChecked(bool checked);
protected:
Ui::QmitkToFSurfaceGenerationWidgetControls* m_Controls;
private:
void FindReconstructionModeProperty();
mitk::ToFDistanceImageToSurfaceFilter::Pointer m_ToFDistanceImageToSurfaceFilter;
mitk::ToFImageGrabber::Pointer m_ToFImageGrabber;
mitk::CameraIntrinsics::Pointer m_CameraIntrinsics;
mitk::DataNode::Pointer m_SurfaceNode;
mitk::Surface::Pointer m_Surface;
bool m_Active;
vtkSmartPointer<vtkCamera> m_Camera3d;
};
#endif // _QMITKTOFVISUALISATIONSETTINGSWIDGET_H_INCLUDED
diff --git a/Modules/ToFUI/Qmitk/QmitkToFVisualisationSettingsWidget.h b/Modules/ToFUI/Qmitk/QmitkToFVisualisationSettingsWidget.h
index 4cadd03e9a..2e86190d4f 100644
--- a/Modules/ToFUI/Qmitk/QmitkToFVisualisationSettingsWidget.h
+++ b/Modules/ToFUI/Qmitk/QmitkToFVisualisationSettingsWidget.h
@@ -1,171 +1,172 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef _QMITKTOFVISUALISATIONSETTINGSWIDGET_H_INCLUDED
#define _QMITKTOFVISUALISATIONSETTINGSWIDGET_H_INCLUDED
#include <MitkToFUIExports.h>
#include "ui_QmitkToFVisualisationSettingsWidgetControls.h"
#include "mitkDataNode.h"
// QT headers
#include <QWidget>
// vtk includes
#include <vtkColorTransferFunction.h>
class QmitkStdMultiWidget;
/** Documentation:
* Widget controlling the visualization of Time-of-Flight image data. A color transfer function can be configured for
* a given distance, amplitude and intensity image. The pre-configured vtkColorTransferFunctions can be accessed as
* an output of the widget.
*
* \ingroup ToFUI
*/
class MITKTOFUI_EXPORT QmitkToFVisualisationSettingsWidget :public QWidget
{
//this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
Q_OBJECT
public:
static const std::string VIEW_ID;
QmitkToFVisualisationSettingsWidget (QWidget* p = nullptr, Qt::WindowFlags f1 = nullptr);
~QmitkToFVisualisationSettingsWidget () override;
/* @brief This method is part of the widget an needs not to be called seperately. */
virtual void CreateQtPartControl(QWidget *parent);
/* @brief This method is part of the widget an needs not to be called seperately. (Creation of the connections of main and control widget.)*/
virtual void CreateConnections();
/*!
\brief initialize the widget with the images to be shown
\param distanceImageNode image holding the range image of a ToF camera
\param amplitudeImageNode image holding the amplitude image of a ToF camera
\param intensityImageNode image holding the intensity image of a ToF camera
+ \param surfaceNode
*/
void Initialize(mitk::DataNode* distanceImageNode=nullptr, mitk::DataNode* amplitudeImageNode=nullptr,
mitk::DataNode* intensityImageNode=nullptr, mitk::DataNode* surfaceNode=nullptr);
/*!
\brief Access the color transfer function of widget 1 (distance image)
\return vtkColorTransferFunction that can be used to define a TransferFunctionProperty
*/
vtkColorTransferFunction* GetWidget1ColorTransferFunction();
/*!
\brief Access the color transfer function of widget 2 (distance image)
\return vtkColorTransferFunction that can be used to define a TransferFunctionProperty
*/
vtkColorTransferFunction* GetWidget2ColorTransferFunction();
/*!
\brief Access the color transfer function of widget 3 (distance image)
\return vtkColorTransferFunction that can be used to define a TransferFunctionProperty
*/
vtkColorTransferFunction* GetWidget3ColorTransferFunction();
/*!
\brief Access the color transfer of the currently selected widget
\return vtkColorTransferFunction that can be used to define a TransferFunctionProperty
*/
vtkColorTransferFunction* GetSelectedColorTransferFunction();
/*!
\brief Return the index of the selected image: 0 = Distance, 1 = Amplitude, 2 = Intensity
*/
int GetSelectedImageIndex();
protected slots:
void OnShowAdvancedOptionsCheckboxChecked(bool checked);
void OnSetXValueColor();
/*!
\brief Slot invoking a reset of the RangeSlider to the minimal and maximal values of the according image
*/
void OnResetSlider();
/*!
\brief Slot called when the range span has changed.
*/
void OnSpanChanged (int lower, int upper);
/*!
\brief Resets the transfer function according to the currently selected widget / image
*/
void OnTransferFunctionReset();
/*!
\brief Updates the GUI according to the widget / image selection
*/
void OnWidgetSelected(int index);
/*!
\brief Slot called when the line edit of the maximal value of the range slider has changed. Leads to an update of the range slider.
*/
void OnRangeSliderMaxChanged();
/*!
\brief Slot called when the line edit of the minimal value of the range slider has changed. Leads to an update of the range slider.
*/
void OnRangeSliderMinChanged();
/*!
\brief Sets the TransferFunctionType members according to the selection of the widget and the transfer type.
*/
void OnTransferFunctionTypeSelected(int index);
protected:
/*!
\brief Invokes an update of the ColorTransferFunctionCanvas. Called when the ColorTransferFunction has changed
*/
void UpdateCanvas();
/*!
\brief Resets the ColorTransferFunctionCanvas according to the lower and upper value of the RangeSlider
*/
void UpdateRanges();
Ui::QmitkToFVisualisationSettingsWidgetControls* m_Controls;
int m_RangeSliderMin; ///< Minimal value of the transfer function range. Initialized to the minimal value of the corresponding image.
int m_RangeSliderMax; ///< Maximal value of the transfer function range. Initialized to the maximal value of the corresponding image.
mitk::DataNode::Pointer m_MitkDistanceImageNode; ///< DataNode holding the range image of the ToF camera as set by Initialize()
mitk::DataNode::Pointer m_MitkAmplitudeImageNode; ///< DataNode holding the amplitude image of the ToF camera as set by Initialize()
mitk::DataNode::Pointer m_MitkIntensityImageNode; ///< DataNode holding the intensity image of the ToF camera as set by Initialize()
mitk::DataNode::Pointer m_MitkSurfaceNode; ///< DataNode holding the surface
vtkColorTransferFunction* m_Widget1ColorTransferFunction; ///< vtkColorTransferFunction of widget 1 (distance) that can be used to define a TransferFunctionProperty
vtkColorTransferFunction* m_Widget2ColorTransferFunction; ///< vtkColorTransferFunction of widget 2 (amplitude) that can be used to define a TransferFunctionProperty
vtkColorTransferFunction* m_Widget3ColorTransferFunction; ///< vtkColorTransferFunction of widget 3 (intensity) that can be used to define a TransferFunctionProperty
int m_Widget1TransferFunctionType; ///< member holding the type of the transfer function applied to the image shown in widget 1 (distance image): 0 = gray scale, 1 = color
int m_Widget2TransferFunctionType; ///< member holding the type of the transfer function applied to the image shown in widget 2 (amplitude image): 0 = gray scale, 1 = color
int m_Widget3TransferFunctionType; ///< member holding the type of the transfer function applied to the image shown in widget 3 (intensity image): 0 = gray scale, 1 = color
private:
/**
* @brief UpdateSurfaceProperty Private helper method to update the surface property color transfer function.
*/
void UpdateSurfaceProperty();
/*!
\brief Reset the color transfer function to the given type and range
\param colorTransferFunction vtkColorTransferfunction to be resetted
\param type type of the transfer function: 0 = gray scale, 1 = color
\param min minimal value to be set to the transfer function
\param max maximal value to be set to the transfer function
*/
void ResetTransferFunction(vtkColorTransferFunction* colorTransferFunction, int type, double min, double max);
/*!
\brief Reset the color transfer function for the given widget
\param widget 0: axial, 1: coronal, 2: sagittal
\param type: type of the transfer function: 0 = gray scale, 1 = color
*/
void ReinitTransferFunction(int widget, int type);
};
#endif // _QMITKTOFVISUALISATIONSETTINGSWIDGET_H_INCLUDED
diff --git a/Modules/US/Documentation/doxygen/USModule.dox b/Modules/US/Documentation/doxygen/USModule.dox
index 072ae386ae..131870ee63 100644
--- a/Modules/US/Documentation/doxygen/USModule.dox
+++ b/Modules/US/Documentation/doxygen/USModule.dox
@@ -1,93 +1,93 @@
/**
\page USModulePage Ultrasound Module
\tableofcontents
\section USModulePageOverview Overview
The Ultrasound Module provides a <strong>microservice based API for ultrasound devices</strong>.
The main features are:
<ul>
<li> Microservice-enabled life cycle management, allowing other modules to easily consume mitk::USDevice-functionality.
<li> Handling and processing of ultrasound image data.
<ul>
<li> Fast image preprocessing capabilities (gray scale conversion, cropping) via OpenCV.
<li> Advanced image processing functions via mitk filters.
</ul>
<li> The mitk::USVideoDevice class allows to connect any ultrasound device with a video-out via a frame grabber.
<li> Connection of API-Enabled devices (specifically the Telemed LogicScan 128 is implemented).
<ul>
<li> The submodule USHardwareTelemed provides classes for handling a Telemed API device (mitk::USTelemedDevice).
<li> Control of API-enabled Devices via MITK (Widgets for basic B mode controls and probe selection are available).
</ul>
<li> Designed to interact with the \link NavigationGeneralModulePage IGT Module \endlink for tracking functionality.
</ul>
This module requires OpenCV to be enabled in the superbuild options via CMake.
Its functionality is made available to the user via the \link org_mitk_gui_qt_ultrasound UltrasoundSupport plugin \endlink
Documentation on how to use Telemed API devices can be found on \subpage USHardwareTelemedPage.
\section USDeviceHierarchy Ultrasound Device Hierarchy
Ultrasound Devices are managed in a simple hierarchy:
\imageMacro{ClassDiagramUSModuleOverview.png,"",14.92}
<ul>
<li> mitk::USDevice: The common superclass for all ultrasound devices. Deriving from this class will make sure that US-specific GUI-Components will be able to interact with your class.
Especially, the microservice life cycle is modeled in this class.
<li> mitk::USImageSource: Abstract class used by the mitk::USDevice for getting the images from the ultrasound device. The images are filtered by one ore more mitk::AbstractOpenCVImageFilter if they were set to the mitk::USImageSource object.
Each concrete subclass of mitk::USDevice has to subclass mitk::USImageSource to handle the actual receiving of images from the ultrasound device.
<li> Two devices are implemented in the ultrasound module:
<ul>
<li> mitk::USVideoDevice: This class can be used for every ultrasound device that is connected to the PC via a frame grabber or a similar video input device.
The \link org_mitk_gui_qt_ultrasound UltrasoundSupport plugin \endlink enables the user to create instances of mitk::USVideoDevice.
There also is a reusable Widget for this Task in the USUI Module. </li>
<li> mitk::USTelemedDevice: This class can be used for API-enabled ultrasound devices of Telemed (e.g. Telemed LogicScan 128). </li>
- <li> One can add another device by subclassing mitk::USDevice and mitk::USImageSource. Additionally the control interfaces may be implemented (see \link USControlInterfaces). </li>
+ <li> One can add another device by subclassing mitk::USDevice and mitk::USImageSource. Additionally the control interfaces may be implemented (see \link USControlInterfaces \endlink ). </li>
</ul>
</li>
</ul>
\section USDeviceLifeCycle Ultrasound Device Life Cycle
Each mitk::USDevice follows a life cycle handling the availabilty as a micro service and the connection to the hardware:
\imageMacro{MicroServiceLifeCycle.png,"",16.00}
-For changing the states corresponding methods are available in mitk::USDevice: mitk::USDevice::Initialize() for initialization, mitk::USDevice::Connect() for connecting, mitk::USDevice::Disconnect() for disconnecting and so on. For example, once an object of mitk::USDevice is constructed it can be made available as a micro service via a call to mitk::USDevice::Initialize(). The state changes to Initialized then and the device is available to other modules or plugins (\link org_mitk_gui_qt_ultrasound UltrasoundSupport\endlink, QmitkUSDeviceManagerWidget) through the micro service framework.
+For changing the states corresponding methods are available in mitk::USDevice: mitk::USDevice::Initialize() for initialization, mitk::USDevice::Connect() for connecting, mitk::USDevice::Disconnect() for disconnecting and so on. For example, once an object of mitk::USDevice is constructed it can be made available as a micro service via a call to mitk::USDevice::Initialize(). The state changes to Initialized then and the device is available to other modules or plugins (\link org_mitk_gui_qt_ultrasound UltrasoundSupport \endlink, QmitkUSDeviceManagerWidget) through the micro service framework.
The methods for changing the states should not be overwritten by sublcasses. Instead mitk::USDevice::OnInitialization(), mitk::USDevice::OnConnection() and so on can be overwritten for handling everything that has to be done on the corresponding state change.
When the mitk::USDevice object was created at first it is available just locally. An initialized device is available as a micro service, but not connected to the real hardware. A connected device is connected to the hardware, but no acquiring images. Finally, an activated device is acquiring images from the ultrasound hardware.
\section USControlInterfaces Control Interfaces for API Devices
Capabilities of API-based ultrasound devices are available through control interfaces which are shown below:
\imageMacro{USControlInterfaces.png,"",16.00}
The control interfaces mitk::USControlInterfaceProbes and mitk::USControlInterfaceBMode are available, while mitk::USControlInterfaceDoppler is empty at the moment. Every sublcass of mitk::USDevice can use an implementation of each of these interfaces, but this is not necessary. The mitk::USVideoDevice for example uses a custom control interface only (mitk::USVideoDeviceCustomControls), which is a subclass of mitk::USAbstractControlInterface. The mitk::USTelemedDevice uses mitk::USTelemedBModeControls for handling the ultrasound b mode and mitk::USTelemedProbesControls for handling the connected ultrasound probe.
Each custom control interface needs its own Widget (subclassed of QmitkUSAbstractCustomWidget), if it should be possible to control its functionality by using the \link org_mitk_gui_qt_ultrasound UltrasoundSupport\endlink plugin. For the standard interfaces mitk::USControlInterfaceProbes, mitk::USControlInterfaceBMode and mitk::USControlInterfaceDoppler there are Widgets available in the USUI module (QmitkUSControlsProbesWidget, QmitkUSControlsBModeWidget, QmitkUSControlsDopplerWidget) which can be used by plugins. For each Widget an object of the corresponding control interface must be set on its constructor call. A class diagram showing how the Widgets are connected to the control interfaces can be seen below:
\imageMacro{USControlWidgets.png,"",16.00}
A plugin can use the Widgets by creating a new object of the Widget and setting the corresponding interface object of the mitk::USDevice which should be controlled. How to use custom widgets is described in the class documentation of QmitkUSAbstractCustomWidget.
\section USDWidgets Available Widgets
There are some Widgets available in the USUI module that can be used for plugin development: a device management Widget, a Widget for creating new mitk::USVideoDevice objects and widgets for the control interfaces of API device.
The usage of the Widgets is described in more detail in the \link org_mitk_gui_qt_ultrasound UltrasoundSupport Plugin Documentation\endlink.
\subsection USQmitkUSDeviceManagerWidget QmitkUSDeviceManagerWidget
The QmitkUSDeviceManagerWidget can view every connected mitk::USDevice and allows the user to activate and deactivate devices. Additionally mitk::USVideoDevice can be created using the QmitkUSNewVideoDeviceWidget and removed by a corresponding button.
\subsection USQmitkNewVideoDeviceWidget QmitkUSNewVideoDeviceWidget
The QmitkUSNewVideoDeviceWidget allows the user to configure a frame grabber or other video input as a mitk::USVideoDevice.
\subsection USControlInterfaceWidgets Control Interface Widgets
There exists several widgets for controling ultrasound devices: QmitkUSControlsBModeWidget, QmitkUSControlsProbesWidget, QmitkUSControlsCustomVideoDeviceWidget. Own custom control widgets can be added by subclassing the available QmitkUSAbstractCustomWidget.
*/
\ No newline at end of file
diff --git a/Plugins/org.blueberry.core.expressions/schema/definitions.exsd b/Plugins/org.blueberry.core.expressions/schema/definitions.exsd
index ad07cdb214..8fab9b8e4d 100644
--- a/Plugins/org.blueberry.core.expressions/schema/definitions.exsd
+++ b/Plugins/org.blueberry.core.expressions/schema/definitions.exsd
@@ -1,166 +1,101 @@
<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.blueberry.core.expressions">
<annotation>
<appInfo>
<meta.schema plugin="org.blueberry.core.expressions" id="definitions" name="Expression Definitions"/>
</appInfo>
- <documentation>
- <p>
-This extension point allows you to create reusable extensions. They can then be used in other core expression constructs.
-</p>
-<p>
-The reference element in a core expression will evaluated the expression definition with the evaluation context that is active for the reference element.
-</p>
-
- </documentation>
+
</annotation>
<include schemaLocation="expressionLanguage.exsd"/>
<element name="extension">
<complexType>
<sequence>
<element ref="definition" minOccurs="0" maxOccurs="unbounded"/>
</sequence>
<attribute name="point" type="string" use="required">
<annotation>
- <documentation>
- a fully qualified identifier of the target extension point
- </documentation>
+
</annotation>
</attribute>
<attribute name="id" type="string">
<annotation>
- <documentation>
- an optional identifier of the extension instance
- </documentation>
+
</annotation>
</attribute>
<attribute name="name" type="string">
<annotation>
- <documentation>
- an optional name of the extension instance
- </documentation>
+
<appInfo>
<meta.attribute translatable="true"/>
</appInfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="definition">
<annotation>
- <documentation>
- Provides a global definition of an expression to be used with the &lt;reference/&gt; expression element. This helps to reuse common expressions.
- </documentation>
+
</annotation>
<complexType>
<choice>
<element ref="not"/>
<element ref="and"/>
<element ref="or"/>
<element ref="instanceof"/>
<element ref="test"/>
<element ref="systemTest"/>
<element ref="equals"/>
<element ref="count"/>
<element ref="with"/>
<element ref="resolve"/>
<element ref="adapt"/>
<element ref="iterate"/>
</choice>
<attribute name="id" type="string" use="required">
<annotation>
- <documentation>
- A globally unique identifier for the expression definition.
- </documentation>
+
</annotation>
</attribute>
</complexType>
</element>
<annotation>
<appInfo>
<meta.section type="examples"/>
</appInfo>
- <documentation>
- You can define and the use core expressions:
-
-<p>
-<pre>
-&lt;extension point="org.blueberry.core.expressions.definitions"&gt;
- &lt;definition id="com.example.parts.activeProblemsView"&gt;
- &lt;with variable="activePartId"&gt;
- &lt;equals value="org.blueberry.ui.views.ProblemsView"/&gt;
- &lt;/with&gt;
- &lt;/definition&gt;
- &lt;definition id="com.example.markers.markerSelection"&gt;
- &lt;iterate&gt;
- &lt;instanceof value="org.blueberry.core.resources.IMarker"/&gt;
- &lt;/with&gt;
- &lt;/definition&gt;
-&lt;/extension&gt;
-</pre>
-</p>
-<p>
-Then this expression definition can be used when composing other expressions.
-</p>
-<p>
-<pre>
-&lt;enabledWhen&gt;
- &lt;reference definitionId="com.example.parts.activeProblemsView"&gt;
-&lt;/enabledWhen&gt;
-</pre>
-<pre>
-&lt;visibleWhen&gt;
- &lt;and&gt;
- &lt;reference definitionId="com.example.parts.activeProblemsView"/&gt;
- &lt;reference definitionId="com.example.markers.markerSelection"/&gt;
- &lt;/and&gt;
-&lt;/visibleWhen&gt;
-</pre>
-</p>
-
- </documentation>
+
</annotation>
<annotation>
<appInfo>
<meta.section type="since"/>
</appInfo>
- <documentation>
- 3.3
- </documentation>
+
</annotation>
<annotation>
<appInfo>
<meta.section type="apiInfo"/>
</appInfo>
- <documentation>
-
- </documentation>
+
</annotation>
<annotation>
<appInfo>
<meta.section type="implementation"/>
</appInfo>
- <documentation>
-
- </documentation>
+
</annotation>
<annotation>
<appInfo>
<meta.section type="copyright"/>
</appInfo>
- <documentation>
- Copyright (c) 2007 IBM Corporation and others.<br>
-All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>
- </documentation>
+
</annotation>
</schema>
diff --git a/Plugins/org.blueberry.core.expressions/schema/expressionLanguage.exsd b/Plugins/org.blueberry.core.expressions/schema/expressionLanguage.exsd
index 400743a1d2..8aced99155 100644
--- a/Plugins/org.blueberry.core.expressions/schema/expressionLanguage.exsd
+++ b/Plugins/org.blueberry.core.expressions/schema/expressionLanguage.exsd
@@ -1,535 +1,396 @@
<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.blueberry.core.expressions">
<annotation>
<appInfo>
<meta.schema plugin="org.blueberry.core.expressions" id="commonExpression" name="Common Expressions"/>
</appInfo>
- <documentation>
-
- </documentation>
+
</annotation>
<element name="enablement">
<annotation>
- <documentation>
- A generic root element. The element can be used inside an extension point to define its enablement expression.
- The children of an enablement expression are combined using the and operator.
- </documentation>
+
</annotation>
<complexType>
<sequence minOccurs="0" maxOccurs="unbounded">
<element ref="not"/>
<element ref="and"/>
<element ref="or"/>
<element ref="instanceof"/>
<element ref="test"/>
<element ref="systemTest"/>
<element ref="equals"/>
<element ref="count"/>
<element ref="with"/>
<element ref="resolve"/>
<element ref="adapt"/>
<element ref="iterate"/>
<element ref="reference"/>
</sequence>
</complexType>
</element>
<element name="not">
<annotation>
- <documentation>
- This element represent a NOT operation on the result of evaluating it's sub-element expression.
- </documentation>
+
</annotation>
<complexType>
<choice>
<element ref="not"/>
<element ref="and"/>
<element ref="or"/>
<element ref="instanceof"/>
<element ref="test"/>
<element ref="systemTest"/>
<element ref="equals"/>
<element ref="count"/>
<element ref="with"/>
<element ref="resolve"/>
<element ref="adapt"/>
<element ref="iterate"/>
<element ref="reference"/>
</choice>
</complexType>
</element>
<element name="and">
<annotation>
- <documentation>
- This element represent an AND operation on the result of evaluating all it's sub-elements expressions.
- </documentation>
+
</annotation>
<complexType>
<sequence minOccurs="0" maxOccurs="unbounded">
<element ref="not"/>
<element ref="and"/>
<element ref="or"/>
<element ref="instanceof"/>
<element ref="test"/>
<element ref="systemTest"/>
<element ref="equals"/>
<element ref="count"/>
<element ref="with"/>
<element ref="resolve"/>
<element ref="adapt"/>
<element ref="iterate"/>
<element ref="reference"/>
</sequence>
</complexType>
</element>
<element name="or">
<annotation>
- <documentation>
- This element represent an OR operation on the result of evaluating all it's sub-element expressions.
- </documentation>
+
</annotation>
<complexType>
<sequence minOccurs="0" maxOccurs="unbounded">
<element ref="not"/>
<element ref="and"/>
<element ref="or"/>
<element ref="instanceof"/>
<element ref="test"/>
<element ref="systemTest"/>
<element ref="equals"/>
<element ref="count"/>
<element ref="with"/>
<element ref="resolve"/>
<element ref="adapt"/>
<element ref="iterate"/>
<element ref="reference"/>
</sequence>
</complexType>
</element>
<element name="instanceof">
<annotation>
<appInfo>
<meta.element labelAttribute="value"/>
</appInfo>
- <documentation>
- This element is used to perform an instanceof check of the object in focus. The expression returns
- EvaluationResult.TRUE if the object's type is a sub type of the type specified by the attribute value.
- Otherwise EvaluationResult.FALSE is returned.
- </documentation>
+
</annotation>
<complexType>
<attribute name="value" type="string" use="required">
<annotation>
- <documentation>
- a fully qualified name of a class or interface.
- </documentation>
+
<appInfo>
<meta.attribute kind="java" basedOn="java.lang.Object"/>
</appInfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="test">
<annotation>
<appInfo>
<meta.element labelAttribute="property"/>
</appInfo>
- <documentation>
- This element is used to evaluate the property state of the object in focus. The set of
- testable properties can be extended using the propery tester extension point. The test
- expression returns EvaluationResult.NOT_LOADED if the property tester doing the actual
- testing isn't loaded yet and the attribute forcePluginActivation is set to false.
- If forcePluginActivation is set to true and the evaluation context used to evaluate
- this expression support plug-in activation then evaluating the property will result in
- activating the plug-in defining the tester.
- </documentation>
+
</annotation>
<complexType>
<attribute name="property" type="string" use="required">
<annotation>
- <documentation>
- the name of an object's property to test.
- </documentation>
+
</annotation>
</attribute>
<attribute name="args" type="string">
<annotation>
- <documentation>
- additional arguments passed to the property tester. Multiple arguments are seperated
- by commas. Each individual argument is converted into a Java base type using the same
- rules as defined for the value attribute of the test expression.
- </documentation>
+
</annotation>
</attribute>
<attribute name="value" type="string">
<annotation>
- <documentation>
- the expected value of the property. Can be omitted if the property
- is a boolean property. The test expression is supposed to return
-EvaluationResult.TRUE if the property matches the value and EvaluationResult.FALSE
-otherwise. The value attribute is converted into a Java base type using the following
-rules:
-<ul>
- <li>the string &quot;true&quot; is converted into Boolean.TRUE</li>
- <li>the string &quot;false&quot; is converted into Boolean.FALSE</li>
- <li>if the string contains a dot then the interpreter tries to convert
- the value into a Float object. If this fails the string is treated as a
- java.lang.String</li>
- <li>if the string only consists of numbers then the interpreter
- converts the value in an Integer object.</li>
- <li>in all other cases the string is treated as a java.lang.String</li>
- <li>the conversion of the string into a Boolean, Float, or Integer can
- be suppressed by surrounding the string with single quotes. For
- example, the attribute value=&quot;'true'&quot; is converted into the
- string &quot;true&quot;</li>
-</ul>
- </documentation>
+
</annotation>
</attribute>
<attribute name="forcePluginActivation" type="boolean">
<annotation>
- <documentation>
- a flag indicating whether the plug-in contributing the property tester
- should be loaded if necessary. As such, this flag should be used judiciously,
- in order to avoid unnecessary plug-in activations. Most clients should avoid
- setting this flag to true. This flag is only honored if the evaluation context
- used to evaluate this expression allows plug-in activation. Otherwise the flag
- is ignored and no plug-in loading takes place.
- </documentation>
+
</annotation>
</attribute>
</complexType>
</element>
<element name="systemTest">
<annotation>
<appInfo>
<meta.element labelAttribute="value"/>
</appInfo>
- <documentation>
- Tests a system property by calling the System.getProperty method and compares the result
- with the value specified through the value attribute.
- </documentation>
+
</annotation>
<complexType>
<attribute name="property" type="string" use="required">
<annotation>
- <documentation>
- the name of an system property to test.
- </documentation>
+
</annotation>
</attribute>
<attribute name="value" type="string" use="required">
<annotation>
- <documentation>
- the expected value of the property. The value is interpreted as a string value.
- </documentation>
+
</annotation>
</attribute>
</complexType>
</element>
<element name="equals">
<annotation>
<appInfo>
<meta.element labelAttribute="value"/>
</appInfo>
- <documentation>
- This element is used to perform an equals check of the object in focus. The expression returns
- EvaluationResult.TRUE if the object is equal to the value provided by the attribute value. Otherwise
- EvaluationResult.FALSE is returned.
- </documentation>
+
</annotation>
<complexType>
<attribute name="value" type="string" use="required">
<annotation>
- <documentation>
- the expected value. The value provided as a string is converted into
- a Java base type using the same rules as for the value attribute of the test expression.
- </documentation>
+
</annotation>
</attribute>
</complexType>
</element>
<element name="count">
<annotation>
- <documentation>
- This element is used to test the number of elements in a collection.
- </documentation>
+
</annotation>
<complexType>
<attribute name="value" type="string" use="required">
<annotation>
- <documentation>
- an expression to specify the number of elements in a list. Following wildcard
- characters can be used:
- <dl>
- <dt>*</dt> <dd>any number of elements</dd>
- <dt>?</dt> <dd>no elements or one element</dd>
- <dt>+</dt> <dd>one or more elements</dd>
- <dt>!</dt> <dd>no elements</dd>
- <dt>integer value</dt> <dd>the list must contain the exact number of elements</dd>
- </dl>
- </documentation>
+
</annotation>
</attribute>
</complexType>
</element>
<element name="with">
<annotation>
<appInfo>
<meta.element labelAttribute="variable"/>
</appInfo>
- <documentation>
- This element changes the object to be inspected for all its child element to the object
- referenced by the given variable. If the variable can not be resolved then the expression
- will throw a ExpressionException when evaluating it. The children of a with expression
- are combined using the and operator.
- </documentation>
+
</annotation>
<complexType>
<sequence minOccurs="0" maxOccurs="unbounded">
<element ref="not"/>
<element ref="and"/>
<element ref="or"/>
<element ref="instanceof"/>
<element ref="test"/>
<element ref="systemTest"/>
<element ref="equals"/>
<element ref="count"/>
<element ref="with"/>
<element ref="resolve"/>
<element ref="adapt"/>
<element ref="iterate"/>
<element ref="reference"/>
</sequence>
<attribute name="variable" type="string" use="required">
<annotation>
- <documentation>
- the name of the variable to be used for further inspection. It is up to the evaluator
- of an extension point to provide the variable in the variable pool.
- </documentation>
+
</annotation>
</attribute>
</complexType>
</element>
<element name="resolve">
<annotation>
<appInfo>
<meta.element labelAttribute="variable"/>
</appInfo>
- <documentation>
- This element changes the object to be inspected for all its child element to the object
- referenced by the given variable. If the variable can not be resolved then the expression
- will throw a ExpressionException when evaluating it. The children of a with expression
- are combined using the and operator.
- </documentation>
+
</annotation>
<complexType>
<sequence minOccurs="0" maxOccurs="unbounded">
<element ref="not"/>
<element ref="and"/>
<element ref="or"/>
<element ref="instanceof"/>
<element ref="test"/>
<element ref="systemTest"/>
<element ref="equals"/>
<element ref="count"/>
<element ref="with"/>
<element ref="resolve"/>
<element ref="adapt"/>
<element ref="iterate"/>
<element ref="reference"/>
</sequence>
<attribute name="variable" type="string" use="required">
<annotation>
- <documentation>
- the name of the variable to be resolved. This variable is then used as the object in focus
- for child element evaluation. It is up to the evaluator of an extension point to provide a
- corresponding variable resolver (see IVariableResolver) through the evaluation context passed
- to the root expression element when evaluating the expression.
- </documentation>
+
</annotation>
</attribute>
<attribute name="args" type="string">
<annotation>
- <documentation>
- additional arguments passed to the variable resolver. Multiple arguments are seperated
- by commas. Each individual argument is converted into a Java base type using the same
- rules as defined for the value attribute of the test expression.
- </documentation>
+
</annotation>
</attribute>
</complexType>
</element>
<element name="adapt">
<annotation>
<appInfo>
<meta.element labelAttribute="type"/>
</appInfo>
- <documentation>
- This element is used to adapt the object in focus to the type specified by the attribute
- type. The expression returns not loaded if either the adapter or the type referenced isn't
- loaded yet. It throws a ExpressionException during evaluation if the type name doesn't exist
- at all. The children of an adapt expression are combined using the and operator.
- </documentation>
+
</annotation>
<complexType>
<sequence minOccurs="0" maxOccurs="unbounded">
<element ref="not"/>
<element ref="and"/>
<element ref="or"/>
<element ref="instanceof"/>
<element ref="test"/>
<element ref="systemTest"/>
<element ref="equals"/>
<element ref="count"/>
<element ref="with"/>
<element ref="resolve"/>
<element ref="adapt"/>
<element ref="iterate"/>
<element ref="reference"/>
</sequence>
<attribute name="type" type="string" use="required">
<annotation>
- <documentation>
- the type to which the object in focus is to be adapted.
- </documentation>
+
<appInfo>
<meta.attribute kind="java" basedOn="java.lang.Object"/>
</appInfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="iterate">
<annotation>
- <documentation>
- This element is used to iterate over a variable that is of type java.util.Collection. If
- the object in focus is not of type java.util.Collection then an ExpressionException will
- be thrown while evaluating the expression.
- </documentation>
+
</annotation>
<complexType>
<sequence minOccurs="0" maxOccurs="unbounded">
<element ref="not"/>
<element ref="and"/>
<element ref="or"/>
<element ref="instanceof"/>
<element ref="test"/>
<element ref="systemTest"/>
<element ref="equals"/>
<element ref="count"/>
<element ref="with"/>
<element ref="resolve"/>
<element ref="adapt"/>
<element ref="iterate"/>
<element ref="reference"/>
</sequence>
<attribute name="operator">
<annotation>
- <documentation>
- either "and" or "or". The operator defines how the child
- elements will be combined. If not specified, "and" will be used.
- </documentation>
+
</annotation>
<simpleType>
<restriction base="string">
<enumeration value="or">
</enumeration>
<enumeration value="and">
</enumeration>
</restriction>
</simpleType>
</attribute>
<attribute name="ifEmpty" type="boolean">
<annotation>
- <documentation>
- the value return from the iterate expression if the collection is empty. If
- not specified then true is returned when the operator equals "and"
- and false is return if the operator equals "or".
- </documentation>
+
</annotation>
</attribute>
</complexType>
</element>
<element name="reference">
<annotation>
<appInfo>
<meta.element labelAttribute="definitionId"/>
</appInfo>
- <documentation>
- This element is used to reference an expression from the <b>org.blueberry.core.expressions.definitions</b> extension point. The expression definition will be evaluated within the current expression element using the current evaluation context.
- </documentation>
+
</annotation>
<complexType>
<attribute name="definitionId" type="string" use="required">
<annotation>
- <documentation>
- The unique id of an expression from <b>org.blueberry.core.expressions.definitions</b>.
- </documentation>
+
</annotation>
</attribute>
</complexType>
</element>
<annotation>
<appInfo>
<meta.section type="since"/>
</appInfo>
- <documentation>
- Release 3.0
- </documentation>
+
</annotation>
<annotation>
<appInfo>
<meta.section type="examples"/>
</appInfo>
- <documentation>
-
- </documentation>
+
</annotation>
<annotation>
<appInfo>
<meta.section type="apiInfo"/>
</appInfo>
- <documentation>
-
- </documentation>
+
</annotation>
<annotation>
<appInfo>
<meta.section type="implementation"/>
</appInfo>
- <documentation>
-
- </documentation>
+
</annotation>
<annotation>
<appInfo>
<meta.section type="copyright"/>
</appInfo>
- <documentation>
- Copyright (c) 2001, 2004 IBM Corporation and others.<br>
-All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>
- </documentation>
+
</annotation>
</schema>
diff --git a/Plugins/org.blueberry.core.expressions/schema/propertyTesters.exsd b/Plugins/org.blueberry.core.expressions/schema/propertyTesters.exsd
index 30f9b60ca4..94e9448d5b 100644
--- a/Plugins/org.blueberry.core.expressions/schema/propertyTesters.exsd
+++ b/Plugins/org.blueberry.core.expressions/schema/propertyTesters.exsd
@@ -1,146 +1,102 @@
<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.blueberry.core.expressions">
<annotation>
<appInfo>
<meta.schema plugin="org.blueberry.core.expressions" id="propertyTesters" name="Property Testers"/>
</appInfo>
- <documentation>
- This extension point allows to add properties to an already existing type. Those
- properties can then be used inside the expression language's test expression
- element.
- </documentation>
+
</annotation>
<element name="extension">
<complexType>
<sequence>
<element ref="propertyTester" minOccurs="0" maxOccurs="unbounded"/>
</sequence>
<attribute name="point" type="string" use="required">
<annotation>
- <documentation>
- a fully qualified identifier of the target extension point
- </documentation>
+
</annotation>
</attribute>
<attribute name="id" type="string">
<annotation>
- <documentation>
- an optional identifier of the extension instance
- </documentation>
+
</annotation>
</attribute>
<attribute name="name" type="string">
<annotation>
- <documentation>
- an optional name of the extension instance
- </documentation>
+
<appInfo>
<meta.attribute translatable="true"/>
</appInfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="propertyTester">
<complexType>
<attribute name="id" type="string" use="required">
<annotation>
- <documentation>
- unique identifier for the property tester
- </documentation>
+
</annotation>
</attribute>
<attribute name="type" type="string" use="required">
<annotation>
- <documentation>
- the type to be extended by this property tester
- </documentation>
+
<appInfo>
<meta.attribute kind="java"/>
</appInfo>
</annotation>
</attribute>
<attribute name="namespace" type="string" use="required">
<annotation>
- <documentation>
- a unique id determining the name space the properties are added to
- </documentation>
+
</annotation>
</attribute>
<attribute name="properties" type="string" use="required">
<annotation>
- <documentation>
- a comma separated list of properties provided by this property tester
- </documentation>
+
</annotation>
</attribute>
<attribute name="class" type="string" use="required">
<annotation>
- <documentation>
- the name of the class that implements the testing methods. The class must be public and extend
-<samp>org.blueberry.core.expressions.PropertyTester</samp> with a public 0-argument constructor.
- </documentation>
+
<appInfo>
<meta.attribute kind="java" basedOn="org.blueberry.core.expressions.PropertyTester"/>
</appInfo>
</annotation>
</attribute>
</complexType>
</element>
<annotation>
<appInfo>
<meta.section type="since"/>
</appInfo>
- <documentation>
- 3.0
- </documentation>
+
</annotation>
<annotation>
<appInfo>
<meta.section type="examples"/>
</appInfo>
- <documentation>
- The following is an example of a property tester contribution:
-
-<p>
-<pre>
- <extension point="org.eclipse.core.expressions.propertyTesters">
- <propertyTester
- id="org.eclipse.jdt.ui.IResourceTester"
- type="org.eclipse.core.resources.IResource"
- namespace="org.eclipse.jdt.ui"
- properties="canDelete"
- class="org.eclipse.jdt.ui.internal.ResourceTester">
- </propertyTester>
- </extension>
-</pre>
-</p>
- </documentation>
+
</annotation>
<annotation>
<appInfo>
<meta.section type="apiInfo"/>
</appInfo>
- <documentation>
- The contributed class must extend <code>berry::PropertyTester</code>
- </documentation>
+
</annotation>
<annotation>
<appInfo>
<meta.section type="copyright"/>
</appInfo>
- <documentation>
- Copyright (c) 2001, 2004 IBM Corporation and others.<br>
-All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>
- </documentation>
+
</annotation>
</schema>
diff --git a/Plugins/org.blueberry.core.runtime/schema/applications.exsd b/Plugins/org.blueberry.core.runtime/schema/applications.exsd
index 48350bda0e..391416228d 100644
--- a/Plugins/org.blueberry.core.runtime/schema/applications.exsd
+++ b/Plugins/org.blueberry.core.runtime/schema/applications.exsd
@@ -1,113 +1,74 @@
<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.blueberry.osgi" xmlns="http://www.w3.org/2001/XMLSchema">
-<annotation>
+ <annotation>
<appinfo>
<meta.schema plugin="org.blueberry.osgi" id="applications" name="Applications"/>
</appinfo>
- <documentation>
- The applications extension point allows plugins to contribute applications to the BlueBerry Platform.
- </documentation>
</annotation>
<element name="extension">
<annotation>
<appinfo>
<meta.element />
</appinfo>
</annotation>
<complexType>
<sequence minOccurs="1" maxOccurs="unbounded">
<element ref="application"/>
</sequence>
<attribute name="point" type="string" use="required">
<annotation>
- <documentation>
-
- </documentation>
</annotation>
</attribute>
<attribute name="id" type="string">
<annotation>
- <documentation>
-
- </documentation>
</annotation>
</attribute>
<attribute name="name" type="string">
<annotation>
- <documentation>
-
- </documentation>
<appinfo>
<meta.attribute translatable="true"/>
</appinfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="application">
<complexType>
<sequence>
<element ref="run"/>
</sequence>
<attribute name="id" type="string" use="required">
<annotation>
- <documentation>
-
- </documentation>
</annotation>
</attribute>
<attribute name="name" type="string">
<annotation>
- <documentation>
-
- </documentation>
</annotation>
</attribute>
</complexType>
</element>
<element name="run">
<complexType>
<attribute name="class" type="string" use="required">
<annotation>
- <documentation>
-
- </documentation>
</annotation>
</attribute>
</complexType>
</element>
<annotation>
<appinfo>
<meta.section type="examples"/>
</appinfo>
- <documentation>
- Following is an example of an application declaration.
-<p>
- <pre>
- <extension id="sampleApplication" point="org.blueberry.osgi.applications">
- <application id="my.domain.application">
- <run class="xyz::SampleApp"/>
- </application>
- </extension>
- </pre>
-</p>
- </documentation>
</annotation>
<annotation>
<appinfo>
<meta.section type="apiInfo"/>
</appinfo>
- <documentation>
- Application classes must subclass <code>berry::IApplication</code>.
- </documentation>
</annotation>
-
-
-
</schema>
diff --git a/Plugins/org.blueberry.core.runtime/schema/products.exsd b/Plugins/org.blueberry.core.runtime/schema/products.exsd
index 39956abccc..cb173e229f 100644
--- a/Plugins/org.blueberry.core.runtime/schema/products.exsd
+++ b/Plugins/org.blueberry.core.runtime/schema/products.exsd
@@ -1,213 +1,128 @@
<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.blueberry.core.runtime">
-<annotation>
+ <annotation>
<appInfo>
<meta.schema plugin="org.blueberry.core.runtime" id="products" name="Products"/>
</appInfo>
- <documentation>
- Products are the BlueBerry unit of branding. Product extensions are supplied by plug-ins wishing to define one or more products. There must be one product per extension as the extension id is used in processing and identifying the product.
-<p>
-There are two possible forms of product extension, static and dynamic. Static product extensions directly contain all relevant information about the product. Dynamic product extensions identify a class (an <code>IProductProvider</code>) which is capable of defining one or more products when queried.
- </documentation>
</annotation>
<element name="extension">
<complexType>
<sequence>
<choice>
<element ref="product"/>
<element ref="provider"/>
</choice>
</sequence>
<attribute name="point" type="string" use="required">
<annotation>
- <documentation>
-
- </documentation>
</annotation>
</attribute>
<attribute name="id" type="string">
<annotation>
- <documentation>
-
- </documentation>
</annotation>
</attribute>
<attribute name="name" type="string">
<annotation>
- <documentation>
-
- </documentation>
<appInfo>
<meta.attribute translatable="true"/>
</appInfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="product">
<complexType>
<sequence>
<element ref="property" minOccurs="0" maxOccurs="unbounded"/>
</sequence>
<attribute name="application" type="string" use="required">
<annotation>
- <documentation>
- the default application to run when running this product
- </documentation>
</annotation>
</attribute>
<attribute name="name" type="string" use="required">
<annotation>
- <documentation>
- the human-readable name of this product
- </documentation>
<appInfo>
<meta.attribute translatable="true"/>
</appInfo>
</annotation>
</attribute>
<attribute name="description" type="string">
<annotation>
- <documentation>
- the human-readable description of this product
- </documentation>
<appInfo>
<meta.attribute translatable="true"/>
</appInfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="property">
<annotation>
<appInfo>
<meta.element labelAttribute="name"/>
</appInfo>
</annotation>
<complexType>
<attribute name="name" type="string" use="required">
<annotation>
- <documentation>
- the key under which this property is stored
- </documentation>
</annotation>
</attribute>
<attribute name="value" type="string" use="required">
<annotation>
- <documentation>
- the value of this property
- </documentation>
</annotation>
</attribute>
</complexType>
</element>
<element name="provider">
<annotation>
- <documentation>
- details of a product provider
- </documentation>
</annotation>
<complexType>
<sequence>
<element ref="run"/>
</sequence>
</complexType>
</element>
<element name="run">
<complexType>
<attribute name="class" type="string" use="required">
<annotation>
- <documentation>
- the fully-qualified name of a class which implements
-<samp>berry::IProductProvider</samp>.
- </documentation>
</annotation>
</attribute>
</complexType>
</element>
<annotation>
<appInfo>
<meta.section type="since"/>
</appInfo>
- <documentation>
- next_release
- </documentation>
</annotation>
<annotation>
<appInfo>
<meta.section type="examples"/>
</appInfo>
- <documentation>
- Following is an example of static product declaration:
-<p>
-<pre>
- <extension id="coolProduct" point="org.blueberry.core.runtime.products">
- <product name="%coolName" application="coolApplication" description="%coolDescription">
- <property name="windowImages" value="window.gif"/>
- <property name="aboutImage" value="image.gif"/>
- <property name="aboutText" value="%aboutText"/>
- <property name="appName" value="CoolApp"/>
- <property name="welcomePage" value="$nl$/welcome.xml"/>
- <property name="preferenceCustomization" value="plugin_customization.ini"/>
- </product>
- </extension>
-</pre>
-</p>
-
-The following is an example of a dynamic product (product provider) declaration:
-Following is an example of an application declaration:
-<p>
-<pre>
- <extension id="coolProvider" point="org.blueberry.core.runtime.products">
- <provider>
- <run class="me::CoolProvider"/>
- </provider>
- </extension>
-</pre>
-</p>
- </documentation>
</annotation>
<annotation>
<appInfo>
<meta.section type="apiInfo"/>
</appInfo>
- <documentation>
- Static product extensions provided here are represented at runtime by instances of <code>IProduct</code>. Dynamic product extensions must identify an implementor of <code>IProductProvider</code>. See <code>IProductConstants</code>
-for details of the branding related product properties defined by the Eclipse UI.
- </documentation>
</annotation>
<annotation>
<appInfo>
<meta.section type="implementation"/>
</appInfo>
- <documentation>
- No implementations of <code>IProductProvider</code> are supplied.
- </documentation>
</annotation>
<annotation>
<appInfo>
<meta.section type="copyright"/>
</appInfo>
- <documentation>
- Copyright (c) 2004, 2005 IBM Corporation and others.<br>
-All rights reserved. This program and the accompanying materials are made
-available under the terms of the Eclipse Public License v1.0 which
-accompanies
-this distribution, and is available at
-<a
-href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>
- </documentation>
</annotation>
-
</schema>
diff --git a/Plugins/org.blueberry.ui.qt.help/documentation/doxygen/modules.dox b/Plugins/org.blueberry.ui.qt.help/documentation/doxygen/modules.dox
index b2561ea7f5..443086c9a7 100644
--- a/Plugins/org.blueberry.ui.qt.help/documentation/doxygen/modules.dox
+++ b/Plugins/org.blueberry.ui.qt.help/documentation/doxygen/modules.dox
@@ -1,46 +1,36 @@
/**
\defgroup org_blueberry_ui_qt_help org.blueberry.ui.qt.help
\ingroup BlueBerryPlugins
\brief Provides access to Qt Help information from inside the Workbench.
This plug-in collects all Qt QCH files (*.qch) from plug-ins in the RESOLVED
state and registers them internally. The plug-in can be configured using the
CTK Config Admin service and it listens to certain event topics on the CTK
Event Admin.
The following configuration properties for the service PID "org.blueberry.services.help"
are supported:
- \b homePage A <code>QString</code> property containing the a qthelp url pointing
to the applications home page.
The plug-in subscribes to the following event topics:
- \b org/blueberry/help/CONTEXTHELP_REQUESTED signals a request for showing context
sensitive help. If no properties are attached to the event, a qthelp url is constructed
using the currently active part ID from the workbench. If the url is invalid, the
home page is shown instead.
<br><br>
Supported event properties are:
- \e url Show the given url
-
- The example below demonstrates how to provide configuration data for the
- org.blueberry.ui.qt.help plug-in.
-
- \snippet org.blueberry.ui.qt.help-config/main.cpp 0
-
- Requesting context help may look like this:
-
- \snippet org.blueberry.ui.qt.help-config/main.cpp 1
-
*/
/**
\defgroup org_blueberry_ui_qt_help_internal Internal
\ingroup org_blueberry_ui_qt_help
\brief This subcategory includes the internal classes of the org.blueberry.ui.qt.help 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/Plugins/org.blueberry.ui.qt/schema/commands.exsd b/Plugins/org.blueberry.ui.qt/schema/commands.exsd
index 84ddaf81da..997a01d5ce 100644
--- a/Plugins/org.blueberry.ui.qt/schema/commands.exsd
+++ b/Plugins/org.blueberry.ui.qt/schema/commands.exsd
@@ -1,466 +1,341 @@
<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.blueberry.ui" xmlns="http://www.w3.org/2001/XMLSchema">
<annotation>
<appinfo>
<meta.schema plugin="org.blueberry.ui" id="commands" name="Commands"/>
</appinfo>
- <documentation>
- <p>
-The <code>org.blueberry.ui.commands</code> extension point is used to declare commands and command categories, using the <code>command</code> and <code>category</code> elements. A command is an abstract representation of some semantic behaviour, but not it's actual implementation. This allows different developers to contribute specific behaviour for their individual parts. For example, there might be a "paste" command with one implementation in an editor and a different implementation in an explorer widget. These implementations are called handlers. Commands can also be viewed as declarative function pointers, or signal handlers.
-</p>
- </documentation>
+
</annotation>
<element name="extension">
<annotation>
<appinfo>
<meta.element />
</appinfo>
</annotation>
<complexType>
<sequence>
<element ref="category" minOccurs="0" maxOccurs="unbounded"/>
<element ref="command" minOccurs="0" maxOccurs="unbounded"/>
<element ref="commandParameterType" minOccurs="0" maxOccurs="unbounded"/>
</sequence>
<attribute name="id" type="string">
<annotation>
- <documentation>
- An optional identifier of the extension instance.
- </documentation>
+
</annotation>
</attribute>
<attribute name="name" type="string">
<annotation>
- <documentation>
- An optional name of the extension instance.
- </documentation>
+
<appinfo>
<meta.attribute translatable="true"/>
</appinfo>
</annotation>
</attribute>
<attribute name="point" type="string" use="required">
<annotation>
- <documentation>
- A fully qualified identifier of the target extension point.
- </documentation>
+
</annotation>
</attribute>
</complexType>
</element>
<element name="command">
<annotation>
- <documentation>
- <p>
-This element is used to define commands. A command represents an request from the user that can be handled by an action, and should be semantically unique among other commands. Do not define a command if there is already one defined with the same meaning. If more than one of these elements exist with the same <code>id</code> attribute, only the last declared element (in order of reading the plugin registry) is considered valid. See the extension points <a href="org_blueberry_ui_actionSets.html">org.blueberry.ui.actionSets</a> and <a href="org_blueberry_ui_editorActions.html">org.blueberry.ui.editorActions</a> to understand how actions are connected to commands.
-</p>
- </documentation>
+
</annotation>
<complexType>
<sequence>
<element ref="defaultHandler" minOccurs="0" maxOccurs="1"/>
<element ref="state" minOccurs="0" maxOccurs="unbounded"/>
<element ref="commandParameter" minOccurs="0" maxOccurs="unbounded"/>
</sequence>
<attribute name="description" type="string">
<annotation>
- <documentation>
- A translatable short description of this command for display in the UI.
- </documentation>
+
<appinfo>
<meta.attribute translatable="true"/>
</appinfo>
</annotation>
</attribute>
<attribute name="id" type="string" use="required">
<annotation>
- <documentation>
- The unique identifier of this command.
- </documentation>
+
</annotation>
</attribute>
<attribute name="name" type="string" use="required">
<annotation>
- <documentation>
- The translatable name of this command for display in the UI. Commands are typically named in the form of an imperative verb.
- </documentation>
+
<appinfo>
<meta.attribute translatable="true"/>
</appinfo>
</annotation>
</attribute>
<attribute name="categoryId" type="string">
<annotation>
- <documentation>
- The unique id of the category for this command. If this command does not specify a category it will be placed in an global "Uncategorized" category.
- </documentation>
+
</annotation>
</attribute>
<attribute name="defaultHandler" type="string">
<annotation>
- <documentation>
- The default handler for this command (see the <a href="org_blueberry_ui_handlers.html">org.blueberry.ui.handlers</a> extension point). If no other handler is active, this handler will be active. This handler will conflict with other handler definitions that specify no <code>activeWhen</code> conditions. If you are creating an <code>IExecutableExtension</code>, you can use the <code>defaultHandler</code> element instead.
- </documentation>
+
<appinfo>
<meta.attribute kind="java" basedOn="org.eclipse.core.commands.IHandler"/>
</appinfo>
</annotation>
</attribute>
<attribute name="returnTypeId" type="string">
<annotation>
- <documentation>
- The id of a <code>commandParameterType</code> indicating the type of value returned by this command. Specifying a <code>returnTypeId</code> allows clients executing the command to associate the value returned with a type and to convert the value to a QString form that may be stored and/or passed to another command that accepts parameters of the same type.
- </documentation>
+
</annotation>
</attribute>
<attribute name="helpContextId" type="string">
<annotation>
- <documentation>
- The identifier of the help context that relates to this command in general. Handlers can override this context identifier to provide help that is more specific to their particular behaviours.
-<p><em>Not used yet</em></p>
- </documentation>
+
</annotation>
</attribute>
</complexType>
</element>
<element name="category">
<annotation>
- <documentation>
- <p>
-In the UI, commands are often organized by category to make them more manageable. This element is used to define these categories. Commands can add themselves to at most one category. If more than one of these elements exist with the same <code>id</code> attribute, only the last declared element (in order of reading the plugin registry) is considered valid.
-</p>
- </documentation>
+
</annotation>
<complexType>
<attribute name="description" type="string">
<annotation>
- <documentation>
- A translatable short description of this category for display in the UI.
- </documentation>
+
<appinfo>
<meta.attribute translatable="true"/>
</appinfo>
</annotation>
</attribute>
<attribute name="id" type="string" use="required">
<annotation>
- <documentation>
- The unique identifier of this category.
- </documentation>
+
</annotation>
</attribute>
<attribute name="name" type="string" use="required">
<annotation>
- <documentation>
- The translatable name of this category for display in the UI.
- </documentation>
+
<appinfo>
<meta.attribute translatable="true"/>
</appinfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="commandParameter">
<annotation>
<appinfo>
<meta.element labelAttribute="id"/>
</appinfo>
- <documentation>
- <p>
-Defines a parameter that a command should understand. A parameter is a way to provide more information to a handler at execution time. For example, a "show view" command might take a view as a parameter. Handlers should be able to understand these parameters, so they should be treated like API.
-</p>
- </documentation>
+
</annotation>
<complexType>
<sequence>
<element ref="values" minOccurs="0" maxOccurs="1"/>
</sequence>
<attribute name="id" type="string" use="required">
<annotation>
- <documentation>
- The unique identifier for this parameter.
- </documentation>
+
</annotation>
</attribute>
<attribute name="name" type="string" use="required">
<annotation>
- <documentation>
- The name for the parameter. This is the name as it will be displayed to an end-user. As such, it should be translatable. The name should be short -- preferrably one word.
- </documentation>
+
<appinfo>
<meta.attribute translatable="true"/>
</appinfo>
</annotation>
</attribute>
<attribute name="values" type="string">
<annotation>
- <documentation>
- The class providing a list of parameter values for the user to select. This class should implement <code>org.blueberry.core.commands.IParameterValues</code>. If this class is not specified, you must specify the more verbose <code>values</code> element. Please see <code>org.blueberry.osgi.IExecutableExtension</code>.
- </documentation>
+
<appinfo>
<meta.attribute kind="java" basedOn=":org.blueberry.core.commands.IParameterValues"/>
</appinfo>
</annotation>
</attribute>
<attribute name="typeId" type="string">
<annotation>
- <documentation>
- The id of a commandParameterType for this commandParameter. Specifying a typeId allows handlers of a command to convert string parameter values to objects in a consistent way and it allows potential callers of a command to look for commands that take objects of various types for their parameters.
- </documentation>
+
</annotation>
</attribute>
<attribute name="optional" type="boolean" use="default" value="true">
<annotation>
- <documentation>
- Whether this parameter is optional. If a parameter is optional, the handler should be able to handle the absence of the parameter. By default, all parameters are optional.
- </documentation>
+
</annotation>
</attribute>
</complexType>
</element>
<element name="commandParameterType">
<annotation>
- <documentation>
- <p>
-Defines the object type of a commandParameter and may specify an <code>org.blueberry.core.commands.AbstractParameterValueConverter</code> subclass to convert between string parameter values and objects.
-</p>
- </documentation>
+
</annotation>
<complexType>
<attribute name="id" type="string" use="required">
<annotation>
- <documentation>
- The unique identifier for this commandParameterType.
- </documentation>
+
</annotation>
</attribute>
<attribute name="type" type="string">
<annotation>
- <documentation>
- The fully qualified name of a class to use as the type of this command parameter. This attribute is optional, however if omitted, <code>org.blueberry.osgi.Object</code> will be used as the parameter type.
- </documentation>
+
<appinfo>
<meta.attribute kind="java"/>
</appinfo>
</annotation>
</attribute>
<attribute name="converter" type="string">
<annotation>
- <documentation>
- The class for converting between objects and string representations of objects for command parameter values. This class should extend <code>org.blueberry.core.commands.AbstractParameterValueConverter</code>. The converter should produce and consume objects of the type indicated in the <code>type</code> attribute. If this class is not specified, this facility to convert between string and object values for this parameter type will not be available (the <code>GetValueConverter()</code> on class <code>ParameterType</code> will return <code>null</code>).
- </documentation>
+
<appinfo>
<meta.attribute kind="java" basedOn="org.eclipse.core.commands.AbstractParameterValueConverter"/>
</appinfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="values">
<annotation>
<appinfo>
<meta.element labelAttribute="class"/>
</appinfo>
- <documentation>
- <p>
-The more verbose version of the <code>values</code> attribute on the <code>commandParameter</code>.
-</p>
- </documentation>
+
</annotation>
<complexType>
<choice>
<element ref="parameter" minOccurs="0" maxOccurs="unbounded"/>
</choice>
<attribute name="class" type="string" use="required">
<annotation>
- <documentation>
- The class providing a list of parameter values for the user to select. This class should implement <code>org.blueberry.core.commands.IParameterValues</code>. If this class is not specified, you must specify the more verbose <code>values</code> element. Please see <code>org.blueberry.osgi.IExecutableExtension</code>.
- </documentation>
+
<appinfo>
<meta.attribute kind="java" basedOn="org.eclipse.core.commands.IParameterValues"/>
</appinfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="parameter">
<annotation>
<appinfo>
<meta.element labelAttribute="name"/>
</appinfo>
- <documentation>
- <p>
-A possible value for a parameter.
-</p>
- </documentation>
+
</annotation>
<complexType>
<attribute name="name" type="string" use="required">
<annotation>
- <documentation>
- The name of the parameter to pass to the <code>IExecutableExtension</code>.
- </documentation>
+
</annotation>
</attribute>
<attribute name="value" type="string" use="required">
<annotation>
- <documentation>
- The value of the parameter to pass to the <code>IExecutableExtension</code>.
- </documentation>
+
</annotation>
</attribute>
</complexType>
</element>
<element name="defaultHandler">
<annotation>
<appinfo>
<meta.element labelAttribute="class"/>
</appinfo>
- <documentation>
- <p>
-The default handler for this command. If no other handler is active, this handler will be active. This handler will conflict with other handler definitions that specify no <code>activeWhen</code> conditions. If you are not creating an <code>IExecutableExtension</code>, you can use the <code>defaultHandler</code> attribute instead.
-</p>
- </documentation>
+
</annotation>
<complexType>
<sequence>
<element ref="parameter"/>
</sequence>
<attribute name="class" type="string" use="required">
<annotation>
- <documentation>
- The class which implements <code>org.blueberry.core.commands.IHandler</code>.
- </documentation>
+
<appinfo>
<meta.attribute kind="java" basedOn="org.eclipse.core.commands.IHandler"/>
</appinfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="state">
<annotation>
<appinfo>
<meta.element labelAttribute="class"/>
</appinfo>
- <documentation>
- <p>
-State information shared between all handlers, and potentially persisted between sessions.The state is simply a class that is loaded to look after the state. See the API Information for more details. This is not used for UI attributes like a menu contribution check box state or label.
-</p>
- </documentation>
+
</annotation>
<complexType>
<sequence>
<element ref="class" minOccurs="0" maxOccurs="1"/>
</sequence>
<attribute name="class" type="string">
<annotation>
- <documentation>
- The class that can be loaded to store the state of this command. State is shared amongst handlers, and can be persisted between sessions. This class must implement <code>org.blueberry.core.commands.State</code>. Please see API Information.
- </documentation>
+
<appinfo>
<meta.attribute kind="java"/>
</appinfo>
</annotation>
</attribute>
<attribute name="id" type="string" use="required">
<annotation>
- <documentation>
- A unique identifier for this state. This is used for persisting the state between sessions (if the state is an instance of <code>org.blueberry.core.commands.PersistentState</code>). Certain common identifiers (see <code>org.blueberry.ui.menus.IMenuStateIds</code>) are understood when the command is being rendered in the menus or tool bars. The identifier only needs to be unique within the command defining the state.
- </documentation>
+
</annotation>
</attribute>
</complexType>
</element>
<element name="class">
<annotation>
<appinfo>
<meta.element labelAttribute="class"/>
</appinfo>
- <documentation>
- <p>
-The class that can be loaded to store the state of this command. This element is used if you wish to pass multiple parameters to an <code>org.blueberry.osgi.IExecutableExtension</code>.
-</p>
- </documentation>
+
</annotation>
<complexType>
<sequence>
<element ref="parameter" minOccurs="0" maxOccurs="unbounded"/>
</sequence>
<attribute name="class" type="string" use="required">
<annotation>
- <documentation>
- The class that can be loaded to store the state of this command. State is shared amongst handlers, and can be persisted between sessions. This class must implement <code>org.blueberry.core.commands.State</code>. Please see API Information.
- </documentation>
+
<appinfo>
<meta.attribute kind="java"/>
</appinfo>
</annotation>
</attribute>
</complexType>
</element>
<annotation>
<appinfo>
<meta.section type="since"/>
</appinfo>
- <documentation>
- <p>
-1.0
-</p>
- </documentation>
+
</annotation>
<annotation>
<appinfo>
<meta.section type="examples"/>
</appinfo>
- <documentation>
- <p>
-The <code>plugin.xml</code> file in the <code>org.blueberry.ui</code> plugin makes extensive use of the <code>org.blueberry.ui.commands</code> extension point.
-</p>
- </documentation>
+
</annotation>
<annotation>
<appinfo>
<meta.section type="apiInfo"/>
</appinfo>
- <documentation>
- <p>
-Handlers can be registered with commands using the <code>org.blueberry.ui.handlers.IHandlerService</code>. This can be retrieved from various workbench components (e.g., workbench, workbench window, part site, etc.) by calling <code>GetService(IHandlerService::ID)</code>.
-</p>
-<p>
-In general, it is preferrably to declare all commands statically (in <code>plugin.xml</code>). This is so that users can attach key bindings to the commands. However, it is possible to declare commands at run-time. To do this, retrieve the <code>org.blueberry.ui.commands.ICommandService</code> from a workbench component, call <code>GetCommand(yourCommandID)</code> and then call <code>Command::Define(...)</code>.
-Commands defined programmatically must be cleaned up by the plugin if it is unloaded.
-</p>
-<p>
-There are a few default implementations of handler states that may be useful to users of this extension point:
-</p>
-<ul>
-<!--
-<li>org.eclipse.jface.commands.TextState</li>
-<li>org.eclipse.jface.commands.RadioState</li>
-<li>org.eclipse.jface.commands.ToggleState</li>
-<li>org.eclipse.ui.handlers.RegistryRadioState</li>
-<li>org.eclipse.ui.handlers.RegistryToggleState</li>
--->
-</ul>
- </documentation>
+
</annotation>
</schema>
diff --git a/Plugins/org.blueberry.ui.qt/schema/editors.exsd b/Plugins/org.blueberry.ui.qt/schema/editors.exsd
index 93f1db4a0f..424fbb2e00 100644
--- a/Plugins/org.blueberry.ui.qt/schema/editors.exsd
+++ b/Plugins/org.blueberry.ui.qt/schema/editors.exsd
@@ -1,328 +1,168 @@
<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.blueberry.ui">
<annotation>
<appInfo>
<meta.schema plugin="org.blueberry.ui" id="editors" name="Internal and External Editors"/>
</appInfo>
- <documentation>
- This extension point is used to add new editors to the
-workbench. A editor is a visual component within a
-workbench page. It is typically used to edit or browse
-a document or input object. To open an editor, the user
-will typically invoke "Open" on an <samp>IFile</samp>.
-When this action is performed the workbench registry
-is consulted to determine an appropriate editor for
-the file type and then a new instance of the editor
-type is created. The actual result depends on the
-type of the editor. The workbench provides support
-for the creation of internal editors, which are tightly
-integrated into the workbench, and external editors,
-which are launched in a separate frame window.
-There are also various level of integration between
-these extremes.
-<p>
-In the case of an internal editor tight integration can
-be achieved between the workbench window and the editor
-part. The workbench menu and toolbar are pre-loaded
-with a number of common actions, such as cut, copy, and
-paste. The active part, view or editor, is expected to
-provide the implementation for these actions. An internal
-editor may also define new actions which appear in the
-workbench window. These actions only appear when the
-editor is active.
-<p>
-The integration between the workbench and external
-editors is more tenuous. In this case the workbench
-may launch an editor but after has no way of determining
-the state of the external editor or collaborating
-with it by any means except through the file system.
- </documentation>
+
</annotation>
<element name="extension">
<complexType>
<sequence>
<element ref="editor" minOccurs="0" maxOccurs="unbounded"/>
</sequence>
<attribute name="point" type="string" use="required">
<annotation>
- <documentation>
- a fully qualified identifier of the target extension point
- </documentation>
+
</annotation>
</attribute>
<attribute name="id" type="string">
<annotation>
- <documentation>
- an optional identifier of the extension instance
- </documentation>
+
</annotation>
</attribute>
<attribute name="name" type="string">
<annotation>
- <documentation>
- an optional name of the extension instance
- </documentation>
+
<appInfo>
<meta.attribute translatable="true"/>
</appInfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="editor">
<annotation>
<appInfo>
<meta.element labelAttribute="name" icon="icon"/>
</appInfo>
</annotation>
<complexType>
<sequence>
<element ref="contentTypeBinding" minOccurs="0" maxOccurs="unbounded"/>
</sequence>
<attribute name="id" type="string" use="required">
<annotation>
- <documentation>
- a unique name that will be used to identify this editor
- </documentation>
+
</annotation>
</attribute>
<attribute name="name" type="string" use="required">
<annotation>
- <documentation>
- a translatable name that will be used in the UI for this editor
- </documentation>
+
<appInfo>
<meta.attribute translatable="true"/>
</appInfo>
</annotation>
</attribute>
<attribute name="icon" type="string">
<annotation>
- <documentation>
- A relative name of the icon that will be used for all resources that match the specified extensions. Editors should provide an icon to make it easy for users to distinguish between different editor types. If you specify a command rather than a class, an icon is not needed. In that case, the workbench
-will use the icon provided by the operating system.
- </documentation>
+
<appInfo>
<meta.attribute kind="resource"/>
</appInfo>
</annotation>
</attribute>
<attribute name="extensions" type="string">
<annotation>
- <documentation>
- an optional field containing the list of file types understood by the editor. This is a string containing comma separate file extensions. For instance, an editor which understands hypertext documents may register for "htm, html".
- </documentation>
+
</annotation>
</attribute>
<attribute name="class" type="string">
<annotation>
- <documentation>
- the name of a class that implements <samp>berry::IEditorPart</samp>. The attributes <samp>class</samp>, <samp>command</samp>, and <samp>launcher</samp> are mutually exclusive. If this attribute is defined then <samp>contributorClass</samp> should also be defined.
- </documentation>
+
<appInfo>
<meta.attribute kind="java" basedOn="berry::EditorPart"/>
</appInfo>
</annotation>
</attribute>
<attribute name="command" type="string">
<annotation>
- <documentation>
- a command to run in order to launch an external editor. The executable command must be located on the system path or in the plug-in's directory. The attributes <samp>class</samp>, <samp>command</samp>, and <samp>launcher</samp> are mutually exclusive.
- </documentation>
+
</annotation>
</attribute>
<attribute name="launcher" type="string">
<annotation>
- <documentation>
- the name of a class which that implements <samp>berry::IEditorLauncher</samp>.
-A launcher will open an external editor. The attributes <samp>class</samp>, <samp>command</samp>, and <samp>launcher</samp> are mutually exclusive.
- </documentation>
+
<appInfo>
<meta.attribute kind="java" basedOn="berry::IEditorLauncher"/>
</appInfo>
</annotation>
</attribute>
<attribute name="contributorClass" type="string">
<annotation>
- <documentation>
- the name of a class that implements <samp>berry::IEditorActionBarContributor</samp>. This attribute should only be defined if the <samp>class</samp> attribute is defined. This class is used to add new actions to the workbench menu and tool bar which reflect the features of the editor type.
- </documentation>
+
<appInfo>
<meta.attribute kind="java" basedOn="berry::EditorActionBarContributor"/>
</appInfo>
</annotation>
</attribute>
<attribute name="default" type="boolean" use="default" value="false">
<annotation>
- <documentation>
- if true, this editor will be used as the default editor for the
-type. This is only relevant in a case where more than one editor
-is registered for the same type. If an editor is not the default
-for the type, it can still be launched using "Open with..."
-submenu for the selected resource.
-<p>
-Please note that this attribute is only honored for filename and extension associations at this time. It will not be honored for content type bindings. Content type-based resolution will occur on a first come, first serve basis and is not explicitly specified.</p>
- </documentation>
+
</annotation>
</attribute>
<attribute name="filenames" type="string">
<annotation>
- <documentation>
- an optional field containing the list of file names
-understood by the editor. This is a string
-containing comma separate file names. For instance,
-an editor which understands specific hypertext
-documents may register for "ejb.htm, ejb.html".
- </documentation>
+
</annotation>
</attribute>
<attribute name="matchingStrategy" type="string">
<annotation>
- <documentation>
- the name of a class that implements <samp>berry::IEditorMatchingStrategy</samp>. This attribute should only be defined if the <samp>class</samp> attribute is defined. This allows the editor extension to provide its own algorithm for matching the input of one of its editors to a given editor input.
- </documentation>
+
<appInfo>
<meta.attribute kind="java" basedOn="berry::IEditorMatchingStrategy"/>
</appInfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="contentTypeBinding">
<annotation>
<appInfo>
<meta.element labelAttribute="contentTypeId"/>
</appInfo>
- <documentation>
- Advertises that the containing editor understands the given content type and is suitable for editing files of that type.
- </documentation>
+
</annotation>
<complexType>
<attribute name="contentTypeId" type="string" use="required">
<annotation>
- <documentation>
- The content type identifier. This is an ID defined by the 'org.blueberry.core.runtime.contentTypes' extension point.
- </documentation>
+
</annotation>
</attribute>
</complexType>
</element>
<annotation>
<appInfo>
<meta.section type="examples"/>
</appInfo>
- <documentation>
- The following is an example
-of an internal editor extension definition:
-<p>
-<pre>
- <extension point="org.blueberry.ui.editors">
- <editor
- id="com.xyz.XMLEditor"
- name="Fancy XYZ XML editor"
- icon="./icons/XMLEditor.gif"
- extensions="xml"
- class="xyz::XMLEditor"
- contributorClass="xyz::XMLEditorContributor"
- default="false">
- </editor>
- </extension>
-</pre>
-</p>
- </documentation>
+
</annotation>
<annotation>
<appInfo>
<meta.section type="apiInfo"/>
</appInfo>
- <documentation>
- If the command attribute is used, it will be treated
-as an external program command line that will be executed
- in a platform-dependent manner.
-<p>
-If the launcher attribute is used the editor will also
-be treated as an external program. In this case the
-specified class must implement
-<samp>org.eclipse.ui.IEditorLauncher</samp>.
-The launcher will be instantiated and then
-<samp>open(IPath path)</samp> will be invoked to
-launch the editor on the provided local file system path.
-<p>
-If the class attribute is used, the workbench will
-assume that it is an internal editor and the specified
-class must implement <samp>org.eclipse.ui.IEditorPart</samp>.
-It is common practice to
-<samp>subclass org.eclipse.ui.EditorPart</samp> when
-defining a new editor type. It is also necessary to
-define a <samp>contributorClass</samp> attribute.
-The specified class must implement
-<samp>org.eclipse.ui.IEditorActionBarContributor</samp>,
-and is used to add new actions to the workbench
-menu and tool bar which reflect the features of the
-editor type.
-<p>
-Within the workbench there may be more than one open
-editor of a particular type. For instance, there may
-be one or more open Java Editors. To avoid the creation
-of duplicate actions and action images the editor
-concept has been split into two. An
-<samp>IEditorActionBarContributor</samp> is responsible
-for the creation of actions. The editor is responsible
-for action implementation. Furthermore, the contributor
-is shared by each open editor. As a result of this
-design there is only one set of actions for one or
-more open editors.
-<p>
-The contributor will add new actions to the workbench
-menu and toolbar which reflect the editor type. These
-actions are shared and, when invoked, act upon the
-active editor. The active editor is passed to the
-contributor by invoking
-<samp>IEditorActionBarContributor.setActiveEditor</samp>.
-The identifiers for actions and major groups within
-the workbench window are defined in
-<samp>org.eclipse.ui.IWorkbenchActionConstants</samp>.
-These should be used as a reference point for the
-addition of new actions. Top level menus are created
-by using the following values for the path attribute:
-<ul>
-<li>
-additions - represents a group to the left of the Window menu.
-</li>
-</ul>
-Actions and menus added into these paths will only be
-shown while the associated editor is active. When the
-editor is closed, menus and actions will be removed.
- </documentation>
+
</annotation>
<annotation>
<appInfo>
<meta.section type="implementation"/>
</appInfo>
- <documentation>
- The workbench provides a "Default Text Editor". The end user product may contain other editors as part of the shipping bundle. In that case, editors will be registered as extensions using the syntax described above.
- </documentation>
+
</annotation>
<annotation>
<appInfo>
<meta.section type="copyright"/>
</appInfo>
- <documentation>
- Copyright (c) 2002, 2007 IBM Corporation and others.<br>
-All rights reserved. This program and the accompanying materials are made
-available under the terms of the Eclipse Public License v1.0 which accompanies
-this distribution, and is available at <a
-href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>
- </documentation>
+
</annotation>
</schema>
diff --git a/Plugins/org.blueberry.ui.qt/schema/elementFactories.exsd b/Plugins/org.blueberry.ui.qt/schema/elementFactories.exsd
index ac2acf1c37..44c8041d9d 100644
--- a/Plugins/org.blueberry.ui.qt/schema/elementFactories.exsd
+++ b/Plugins/org.blueberry.ui.qt/schema/elementFactories.exsd
@@ -1,167 +1,83 @@
<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.blueberry.ui">
<annotation>
<appInfo>
<meta.schema plugin="org.blueberry.ui" id="elementFactories" name="Element Factories"/>
</appInfo>
- <documentation>
- This extension point is used to add element factories
-to the workbench. An element factory is used to
-recreate <samp>IAdaptable</samp> objects which are
-persisted during workbench shutdown.
-<p>
-As an example, the element factory is used to
-persist editor input. The input for an
-editor must implement
-<samp>berry::EditorInput</samp>.
-The life cycle of an <samp>berry::IEditorInput</samp> within
-an editor has a number of phases.
-<ol>
-<li>
-The initial input for an editor is passed in during
-editor creation.
-</li>
-<li>
-On shutdown the workbench state is captured.
-In this process the workbench will create a memento
-for each open editor and its input. The input is
-saved as a two part memento containing a factory ID
-and any primitive data required to recreate the
-element on startup. For more information see
-the documentation on
-<samp>berry::IPersistableElement</samp>.
-</li>
-<li>
-On startup the workbench state is read and the
-editors from the previous session are recreated.
-In this process the workbench will recreate the input
-element for each open editor. To do this it will
-map the original factory ID for the input element
-to a concrete factory class defined in the registry.
-If a mapping exists, and the factory class is valid,
-an instance of the factory class is created. Then
-the workbench asks the factory to recreate the original
-element from the remaining primitive data within the
-memento. The resulting <samp>berry::IAdaptable</samp> is cast
-to an <samp>berry::IEditorInput</samp> and passed to the
-new editor.
-</li>
-</ol>
- </documentation>
+
</annotation>
<element name="extension">
<complexType>
<sequence>
<element ref="factory" minOccurs="0" maxOccurs="unbounded"/>
</sequence>
<attribute name="point" type="string" use="required">
<annotation>
- <documentation>
- a fully qualified identifier of the target extension point
- </documentation>
+
</annotation>
</attribute>
<attribute name="id" type="string">
<annotation>
- <documentation>
- an optional identifier of the extension instance
- </documentation>
+
</annotation>
</attribute>
<attribute name="name" type="string">
<annotation>
- <documentation>
- an optional name of the extension instance
- </documentation>
+
<appInfo>
<meta.attribute translatable="true"/>
</appInfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="factory">
<complexType>
<attribute name="id" type="string" use="required">
<annotation>
- <documentation>
- a unique name that will be used to identify this factory.
- </documentation>
+
</annotation>
</attribute>
<attribute name="class" type="string" use="required">
<annotation>
- <documentation>
- a fully qualified name of a class that implements
-<samp>berry::IElementFactory</samp>
- </documentation>
+
<appInfo>
<meta.attribute kind="c++" basedOn="berry::IElementFactory"/>
</appInfo>
</annotation>
</attribute>
</complexType>
</element>
<annotation>
<appInfo>
<meta.section type="examples"/>
</appInfo>
- <documentation>
- The following is an example of an element factory extension:
-<p>
-<pre>
- <extension
- point = "org.blueberry.ui.elementFactories">
- <factory
- id ="com.xyz.ElementFactory"
- class="xyz::ElementFactory">
- </factory>
- </extension>
-</pre>
-</p>
- </documentation>
+
</annotation>
<annotation>
<appInfo>
<meta.section type="apiInfo"/>
</appInfo>
- <documentation>
- The value of the <samp>class</samp> attribute must
-be a fully qualified name of a class that implements
-<samp>berry::IElementFactory</samp>. An instance
-of this class must create an <samp>berry::IAdaptable</samp>
-object from a workbench memento.
- </documentation>
+
</annotation>
<annotation>
<appInfo>
<meta.section type="implementation"/>
</appInfo>
- <documentation>
- The workbench provides an <samp>IResource</samp> factory.
-Additional factories should be added to recreate other
-<samp>berry::IAdaptable</samp> types commonly found in other
-object models.
- </documentation>
+
</annotation>
<annotation>
<appInfo>
<meta.section type="copyright"/>
</appInfo>
- <documentation>
- Copyright (c) 2002, 2005 IBM Corporation and others.<br>
-All rights reserved. This program and the accompanying materials are made
-available under the terms of the Eclipse Public License v1.0 which accompanies
-this distribution, and is available at <a
-href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>
- </documentation>
+
</annotation>
</schema>
diff --git a/Plugins/org.blueberry.ui.qt/schema/handlers.exsd b/Plugins/org.blueberry.ui.qt/schema/handlers.exsd
index 1ce19c0c10..e67e0bbaef 100644
--- a/Plugins/org.blueberry.ui.qt/schema/handlers.exsd
+++ b/Plugins/org.blueberry.ui.qt/schema/handlers.exsd
@@ -1,309 +1,185 @@
<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.eclipse.ui">
<annotation>
<appInfo>
<meta.schema plugin="org.eclipse.ui" id="handlers" name="Handlers"/>
</appInfo>
- <documentation>
- <p>
-The handlers extension point is an elaboration of the experimental <code>handlerSubmission</code> element defined in Eclipse 3.0. A handler is the behaviour of a command at a particular point in time. A command can have zero or more handlers associated with it. At any one point in time, however, a command will either have no active handler or one active handler. The active handler is the one which is currently responsible for carrying out the behaviour of the command. This is very similar to the concept of an action handler and a retargettable action.
-</p>
-<p>
-The handlers extension point allows a plug-in developer to specify a handler that should become active and/or enabled under certain conditions. If a handler is inactive, then no command will delegate its behaviour to the handler. If a handler is disabled, then the handler will not be asked to execute; execution of the handler is blocked. The conditions are defined using the expression language facility added during 3.0. They are expressed using <code>activeWhen</code> and <code>enabledWhen</code> clauses.
-</p>
-<p>
-The workbench provides some variables that these expressions can rely on. Variables that are valid in activeWhen and enabledWhen expressions can be found in <code>org.eclipse.ui.ISources</code>. The types of the variables are determined by the <code>org.eclipse.ui.ISourceProvider</code> that provides them.
-</p>
-<p>
-A handler that specifies no conditions is a default handler. A default handler is only active if no other handler has all of its conditions satisfied. If two handlers still have conditions that are satisfied, then the conditions are compared. The idea is to select a handler whose condition is more specific or more local. To do this, the variables referred to by the condition are looked at. The condition that refers to the most specific variable "wins". The order of specificity (from least specific to most specific) is suggested in <code>org.eclipse.ui.ISources</code>.
-</p>
-<p>
-If this still doesn't resolve the conflict, then no handler is active. If a particular tracing option is turned on, then this leads to a message in the log. A conflict can also occur if there are two default handlers. It is the responsibility of the plug-in developers and integration testers to ensure that this does not happen.
-</p>
-<p>
-These conditions are used to avoid unnecessary plug-in loading. These handler definitions are wrapped in a proxy. For a proxy to load its underlying handler, two things must happen: the conditions for the proxy must be met so that it becomes active, and the command must be asked to do something which it must delegate (e.g., execute(), isEnabled()).
-</p>
- </documentation>
+
</annotation>
<include schemaLocation="schema://org.eclipse.core.expressions/schema/expressionLanguage.exsd"/>
<element name="extension">
<complexType>
<sequence>
<element ref="handler" minOccurs="0" maxOccurs="unbounded"/>
</sequence>
<attribute name="point" type="string" use="required">
<annotation>
- <documentation>
- </documentation>
</annotation>
</attribute>
<attribute name="id" type="string">
<annotation>
- <documentation>
- </documentation>
</annotation>
</attribute>
<attribute name="name" type="string">
<annotation>
- <documentation>
- </documentation>
</annotation>
</attribute>
</complexType>
</element>
<element name="handler">
<annotation>
- <documentation>
- <p>Associated a command with a handler implementation.</p>
- </documentation>
+
</annotation>
<complexType>
<sequence>
<element ref="activeWhen" minOccurs="0" maxOccurs="1"/>
<element ref="class" minOccurs="0" maxOccurs="1"/>
<element ref="enabledWhen" minOccurs="0" maxOccurs="1"/>
</sequence>
<attribute name="commandId" type="string" use="required">
<annotation>
- <documentation>
- <p>The id of the command to associate with this handler implementation.</p>
- </documentation>
+
</annotation>
</attribute>
<attribute name="class" type="string">
<annotation>
- <documentation>
- <p>The handler class that imlements <code>org.eclipse.core.commands.IHandler</code> or extends <code>org.eclipse.core.commands.AbstractHandler</code>.</p>
- </documentation>
+
<appInfo>
<meta.attribute kind="java" basedOn="org.eclipse.core.commands.IHandler"/>
</appInfo>
</annotation>
</attribute>
<attribute name="helpContextId" type="string">
<annotation>
- <documentation>
- <p>
-The identifier of the help context that relates to this specific handler. While a command can provide a general description of a command's behaviour, it is sometimes appropriate for a handler to provide help more specific to their implementation.
-</p>
-<p><em>Since: 3.2</em></p>
- </documentation>
+
</annotation>
</attribute>
</complexType>
</element>
<element name="activeWhen">
<annotation>
- <documentation>
- <p>Contains a core expression used by the <code>IHandlerService</code> to determine when this handler is active.</p>
- </documentation>
+
</annotation>
<complexType>
<choice>
<element ref="not"/>
<element ref="and"/>
<element ref="or"/>
<element ref="instanceof"/>
<element ref="test"/>
<element ref="systemTest"/>
<element ref="equals"/>
<element ref="count"/>
<element ref="with"/>
<element ref="resolve"/>
<element ref="adapt"/>
<element ref="iterate"/>
<element ref="reference"/>
</choice>
</complexType>
</element>
<element name="enabledWhen">
<annotation>
- <documentation>
- <p>Contains a core expression used by the workbench handler proxy to determine when this handler is enabled without loading it.</p>
- </documentation>
+
</annotation>
<complexType>
<choice>
<element ref="not"/>
<element ref="and"/>
<element ref="or"/>
<element ref="instanceof"/>
<element ref="test"/>
<element ref="systemTest"/>
<element ref="equals"/>
<element ref="count"/>
<element ref="with"/>
<element ref="resolve"/>
<element ref="adapt"/>
<element ref="iterate"/>
<element ref="reference"/>
</choice>
</complexType>
</element>
<element name="class">
<annotation>
- <documentation>
- <p>Used when creating an <code>IExecutableExtension</code> with a named parameter, or more than one.</p>
- </documentation>
+
</annotation>
<complexType>
<sequence>
<element ref="parameter" minOccurs="0" maxOccurs="unbounded"/>
</sequence>
<attribute name="class" type="string">
<annotation>
- <documentation>
- <p>The handler class that imlements <code>org.eclipse.core.commands.IHandler</code> or extends <code>org.eclipse.core.commands.AbstractHandler</code>.</p>
- </documentation>
+
<appInfo>
<meta.attribute kind="java" basedOn="org.eclipse.core.commands.IHandler"/>
</appInfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="parameter">
<annotation>
- <documentation>
- <p>A parameter for an <code>IExecutableExtension</code>.</p>
- </documentation>
+
</annotation>
<complexType>
<attribute name="name" type="string" use="required">
<annotation>
- <documentation>
- <p>The parameter name.</p>
- </documentation>
+
</annotation>
</attribute>
<attribute name="value" type="string" use="required">
<annotation>
- <documentation>
- <p>The parameter value.</p>
- </documentation>
+
</annotation>
</attribute>
</complexType>
</element>
<annotation>
<appInfo>
<meta.section type="since"/>
</appInfo>
- <documentation>
- 3.1
- </documentation>
+
</annotation>
<annotation>
<appInfo>
<meta.section type="examples"/>
</appInfo>
- <documentation>
- <p>
-Variables that are valid in activeWhen and enabledWhen expressions can be found in <code>org.eclipse.ui.ISources</code>. The types of the variables are determined by the <code>org.eclipse.ui.ISourceProvider</code> that provides them.
-</p>
-<pre>
-<extension
- point="org.eclipse.ui.handlers">
- <handler
- commandId="commandId"
- class="org.eclipse.compare.Command">
- <activeWhen>
- <with variable="selection">
- <count value="1" />
- <iterate operator="and">
- <adapt type="org.eclipse.core.resources.IResource" />
- </iterate>
- </with>
- </activeWhen>
- </handler>
- <handler
- commandId="other.commandId"
- class="org.eclipse.ui.TalkToMe">
- <activeWhen>
- <with variable="activePartId">
- <equals value="org.eclipse.ui.views.SampleView"/>
- </with>
- </activeWhen>
- </handler>
-</extension>
-</pre>
-<p>
-To further avoid plug-in loading, it is possible to specify when the handler is enabled. If the proxy has not yet loaded the handler, then only the expressions syntax is used to decide if the handler is enabled. If the proxy has loaded the handler, then the expressions syntax is consulted first. If the expressions syntax evaluates to true, then the handler is asked if it is enabled. (This is a short-circuit Boolean "and" operation between the expressions syntax and the handler's enabled state.)
-</p>
-<pre>
-<extension
- point="org.eclipse.ui.handlers">
- <handler
- commandId="commandId"
- class="org.eclipse.Handler">
- <enabledWhen>
- <with variable="activeContexts">
- <iterator operator="or">
- <equals value="org.eclipse.ui.contexts.window"/>
- </iterator>
- </with>
- </enabledWhen>
- </handler>
-</extension>
-</pre>
- </documentation>
+
</annotation>
<annotation>
<appInfo>
<meta.section type="apiInfo"/>
</appInfo>
- <documentation>
- <p>
-All handlers implement <code>org.eclipse.core.commands.IHandler</code>, and can use <code>org.eclipse.core.commands.AbstractHandler</code> as a base class. Within the workbench, it is possible to activate and deactivate handlers using the <code>org.eclipse.ui.handlers.IHandlerService</code> interface. This interface can be retrieved from supporting workbench objects, such as <code>IWorkbench</code> itself, a workbench window, or a part site. To retrieve the service, you would make a call like <code>IWorkbench.getService(IHandlerService.class)</code>.
-</p>
-<p>
-It is also possible to activate and deactive handlers using legacy code in the workbench. This can be done through the legacy mechanism shown below. This mechanism is useful to clients who are using actions to contribute to menus or toolbars. This is deprecated and not recommended.
-</p>
-<pre>
- IWorkbenchPartSite mySite;
- IAction myAction;
-
- myAction.setActionDefinitionId(commandId);
- IKeyBindingService service = mySite.getKeyBindingService();
- service.registerAction(myAction);
-</pre>
- </documentation>
+
</annotation>
<annotation>
<appInfo>
<meta.section type="implementation"/>
</appInfo>
- <documentation>
- </documentation>
</annotation>
<annotation>
<appInfo>
<meta.section type="copyright"/>
</appInfo>
- <documentation>
- Copyright (c) 2005, 2007 IBM Corporation and others.<br>
-All rights reserved. This program and the accompanying materials are made
-available under the terms of the Eclipse Public License v1.0 which accompanies
-this distribution, and is available at <a
-href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>
- </documentation>
+
</annotation>
</schema>
diff --git a/Plugins/org.blueberry.ui.qt/schema/intro.exsd b/Plugins/org.blueberry.ui.qt/schema/intro.exsd
index b1badeb3bd..251b000a1e 100644
--- a/Plugins/org.blueberry.ui.qt/schema/intro.exsd
+++ b/Plugins/org.blueberry.ui.qt/schema/intro.exsd
@@ -1,208 +1,141 @@
<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.blueberry.ui" xmlns="http://www.w3.org/2001/XMLSchema">
<annotation>
<appinfo>
<meta.schema plugin="org.blueberry.ui" id="intro" name="Intro Part"/>
</appinfo>
- <documentation>
- <p>This extension point is used to register implementations of special workbench parts, called intro parts, that are responsible for introducing a product to new users. An intro part is typically shown the first time a product is started up. Rules for associating an intro part implementation with particular products are also contributed via this extension point.
-</p>
-The life cycle is as follows:
-<ul>
-<li>The intro area is created on workbench start up. As with editor and view areas, this area is managed by an intro site (implementing <code>IIntroSite</code>).</li>
-<li>The id of the current product (Platform::GetProduct()) is used to choose the relevant intro part implementation.
-</li>
-<li>The intro part class (implementing <code>IIntroPart</code>) is created and initialized with the intro site.
-</li>
-<li>While the intro part is showing to the user, it can transition back and forth between full and standby mode (either programmatically or explicitly by the user).
-</li>
-<li>Eventually the intro part is closed (either programmatically or explicitly by the user). The current perspective takes over the entire workbench window area.
-</li>
-</ul>
- </documentation>
+
</annotation>
<element name="extension">
<annotation>
<appinfo>
<meta.element />
</appinfo>
</annotation>
<complexType>
<sequence>
<element ref="intro" minOccurs="0" maxOccurs="unbounded"/>
<element ref="introProductBinding" minOccurs="0" maxOccurs="unbounded"/>
</sequence>
<attribute name="point" type="string" use="required">
<annotation>
- <documentation>
- a fully qualified identifier of the target extension point
- </documentation>
+
</annotation>
</attribute>
<attribute name="id" type="string">
<annotation>
- <documentation>
- an optional identifier of the extension instance
- </documentation>
+
</annotation>
</attribute>
<attribute name="name" type="string">
<annotation>
- <documentation>
- an optional name of the extension instance
- </documentation>
+
<appinfo>
<meta.attribute translatable="true"/>
</appinfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="intro">
<annotation>
<appinfo>
<meta.element labelAttribute="id" icon="icon"/>
</appinfo>
- <documentation>
- Specifies an introduction. An introduction is a product-specific presentation shown to first-time users on product start up.
- </documentation>
+
</annotation>
<complexType>
<attribute name="id" type="string" use="required">
<annotation>
- <documentation>
- a unique identifier for this introduction
- </documentation>
+
</annotation>
</attribute>
<attribute name="icon" type="string">
<annotation>
- <documentation>
- a plug-in-relative file name of the icon that will be associated with this introduction
- </documentation>
+
<appinfo>
<meta.attribute kind="resource"/>
</appinfo>
</annotation>
</attribute>
<attribute name="class" type="string" use="required">
<annotation>
- <documentation>
- a fully qualified name of the class implementing the <code>berry::IIntroPart</code> interface. A common practice
-is to subclass <samp>berry::IntroPart</samp>
-in order to inherit the default functionality. This class implements the introduction.
- </documentation>
+
<appinfo>
<meta.attribute kind="java" basedOn=":berryIIntroPart"/>
</appinfo>
</annotation>
</attribute>
<attribute name="contentDetector" type="string">
<annotation>
- <documentation>
- a fully qualified name of a class extending <code>berry::IntroContentDetector</code>. This optional class is used to detect newly added introduction content. If new content is available, the view showing the introduction will be opened again.
- </documentation>
+
<appinfo>
<meta.attribute kind="java" basedOn=":berryIntroContentDetector"/>
</appinfo>
</annotation>
</attribute>
<attribute name="label" type="string">
<annotation>
- <documentation>
- an string label for this introduction that will be used in the construction of the open action as well as the part label.
- </documentation>
+
</annotation>
</attribute>
</complexType>
</element>
<element name="introProductBinding">
<annotation>
- <documentation>
- Specifies a binding between a product and an introduction. These bindings determine which introduction is appropriate for the current product (as defined by <code>Platform::GetProduct()</code>).
- </documentation>
+
</annotation>
<complexType>
<attribute name="productId" type="string" use="required">
<annotation>
- <documentation>
- unique id of a product
- </documentation>
+
</annotation>
</attribute>
<attribute name="introId" type="string" use="required">
<annotation>
- <documentation>
- unique id of an introduction
- </documentation>
+
</annotation>
</attribute>
</complexType>
</element>
<annotation>
<appinfo>
<meta.section type="since"/>
</appinfo>
- <documentation>
- 3.0
- </documentation>
+
</annotation>
<annotation>
<appinfo>
<meta.section type="examples"/>
</appinfo>
- <documentation>
- The following is an example of an intro part extension that contributes an particular introduction and associates it with a particular product:
-<p>
-<pre>
- <extension point="org.eclipse.ui.intro">
- <intro
- id="com.example.xyz.intro.custom"
- class="com.example.xyz.intro.IntroPart"/>
- <introProductBinding
- productId="com.example.xyz.Product"
- introId="com.example.xyz.intro.custom"/>
- </extension>
-</pre>
-</p>
- </documentation>
+
</annotation>
<annotation>
<appinfo>
<meta.section type="apiInfo"/>
</appinfo>
- <documentation>
- The value of the <code>class</code> attribute must be the fully qualified name of a class that implements the<code>org.eclipse.ui.intro.IIntroPart</code> interface by subclassing <code>org.eclipse.ui.part.intro.IntroPart</code>.
- </documentation>
+
</annotation>
<annotation>
<appinfo>
<meta.section type="implementation"/>
</appinfo>
- <documentation>
- There are no default implementations of the initial user experience. Each Eclipse-based product is responsible for providing one that is closely matched to its branding and function.
- </documentation>
+
</annotation>
<annotation>
<appinfo>
<meta.section type="copyright"/>
</appinfo>
- <documentation>
- Copyright (c) 2004, 2007 IBM Corporation and others.<br>
-All rights reserved. This program and the accompanying materials are made
-available under the terms of the Eclipse Public License v1.0 which accompanies
-this distribution, and is available at <a
-href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>
- </documentation>
+
</annotation>
</schema>
diff --git a/Plugins/org.blueberry.ui.qt/schema/keywords.exsd b/Plugins/org.blueberry.ui.qt/schema/keywords.exsd
index ac8a532caf..ec4dc4cf50 100644
--- a/Plugins/org.blueberry.ui.qt/schema/keywords.exsd
+++ b/Plugins/org.blueberry.ui.qt/schema/keywords.exsd
@@ -1,127 +1,89 @@
<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.blueberry.ui">
<annotation>
<appInfo>
<meta.schema plugin="org.blueberry.ui" id="keywords" name="Keywords"/>
</appInfo>
- <documentation>
- The keywords extension point defines keywords and a unique id for reference by other schemas.
-See propertyPages and preferencePages.
- </documentation>
</annotation>
<element name="extension">
<annotation>
- <documentation>
- </documentation>
+
</annotation>
<complexType>
<choice>
<element ref="keyword" minOccurs="0" maxOccurs="unbounded"/>
</choice>
<attribute name="point" type="string" use="required">
<annotation>
- <documentation>
- a fully qualified identifier of the target extension point
- </documentation>
+
</annotation>
</attribute>
<attribute name="id" type="string">
<annotation>
- <documentation>
- an optional identifier of the extension instance
- </documentation>
+
</annotation>
</attribute>
<attribute name="name" type="string">
<annotation>
- <documentation>
- an optional name of the extension instance
- </documentation>
+
<appInfo>
<meta.attribute translatable="true"/>
</appInfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="keyword">
<annotation>
- <documentation>
- </documentation>
+
</annotation>
<complexType>
<attribute name="id" type="string" use="required">
<annotation>
- <documentation>
- The id is the unique id used to reference the keyword.
- </documentation>
+
</annotation>
</attribute>
<attribute name="label" type="string" use="required">
<annotation>
- <documentation>
- The human readable label of the keyword
- </documentation>
+
<appInfo>
<meta.attribute translatable="true"/>
</appInfo>
</annotation>
</attribute>
</complexType>
</element>
<annotation>
<appInfo>
<meta.section type="examples"/>
</appInfo>
- <documentation>
- The following is an example of a keyword extension:
-<p>
-<pre>
- <extension
- point="org.blueberry.ui.keywords">
- <keyword
- label="presentation tab themes"
- id="com.xyz.AppearanceKeywords"/>
- </extension>
-</pre>
-</p>
- </documentation>
+
</annotation>
<annotation>
<appInfo>
<meta.section type="apiInfo"/>
</appInfo>
- <documentation>
- There currently is no public API for retrieving or creating keywords other than this extension point.
- </documentation>
+
</annotation>
<annotation>
<appInfo>
<meta.section type="implementation"/>
</appInfo>
- <documentation>
- Keywords are used only with preference and property pages. See the <samp>keywordReference</samp> element of the org.blueberry.ui.propertyPages and org.blueberry.ui.preferencePages extension points.
- </documentation>
+
</annotation>
<annotation>
<appInfo>
<meta.section type="copyright"/>
</appInfo>
- <documentation>
- Copyright (c) 2005,2006 IBM Corporation and others.<br>
-All rights reserved. This program and the accompanying materials are made
-available under the terms of the Eclipse Public License v1.0 which accompanies
-this distribution, and is available at <a
-href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>
- </documentation>
+
</annotation>
</schema>
diff --git a/Plugins/org.blueberry.ui.qt/schema/menus.exsd b/Plugins/org.blueberry.ui.qt/schema/menus.exsd
index ecae8da9b0..ff38e6bcf1 100644
--- a/Plugins/org.blueberry.ui.qt/schema/menus.exsd
+++ b/Plugins/org.blueberry.ui.qt/schema/menus.exsd
@@ -1,646 +1,442 @@
<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.blueberry.ui" xmlns="http://www.w3.org/2001/XMLSchema">
<annotation>
<appInfo>
<meta.schema plugin="org.blueberry.ui" id="menus" name="Menus"/>
</appInfo>
- <documentation>
-<p>
-This extension point allows the plug-in developer to add (contribute) a variety of custom additions to the BlueBerry framework:
-<ul>
- <li>Main Menu</li>
- <li>Main Toolbars</li>
- <li>View Menus/Toolbars:
- <ul>
- <li>View Dropdown Menu</li>
- <li>View Toolbar</li>
- <li>Context Menu(s)</li>
- </ul>
- </li>
- <li>Trim</li>
-</ul>
-</p>
-<p>
-The general strategy for this mechanism is to separate the 'location' where the contributions should be inserted from the visibility and enablement state of the element. Each contribution first defines its insertion location through a Menu 'URI', a string (loosely) formatted according to the jave.net.URI format:
-</p><p>
-<b>"[Scheme]:[ID]?[ArgList]"</b>
-<ul>
-<li><b>Scheme</b> - The 'type' of the UI component into which the contributions will be added. It may be either "menu", "popup" or "toolbar". While 'popup' is indeed a form of menu it is provided to allow a distinction between a view's 'chevron' menu (for which we use the "menu" scheme) and its default context menu which, by convention, should be registered using the "popup" scheme.</li>
-<li><b>ID</b> - This is the id of menu or toolbar into which the contributions should be added. By convention views should use their view id as the id of the root of their chevron and default popup menu. Note that there is no explicit distinction between contributions supporting editors and 'normal' contributions into the Menu Menu or Toolbar; both global contributions and editor contributions would use the "org.blueberry.ui.main.menu" id or "org.blueberry.ui.main.toolbar". A special id used with popup:, "org.blueberry.ui.popup.any", is reserved to handle contributions which are candidates to appear on any (top level) context menu. Note that these contributions are expected to implement a 'visibleWhen' expression sufficient to limit their visibility to appropriate menus</li>
-<li><b>Query</b> - This field allows fine-grained definition of the specific location <i>within</i> a given menu. It has the form "[placement]=[id]" where placement is one of "before", "after", or "endof" and the id is expected to be the id of some IContributionItem in the menu.</li>
-</ul>
-<p>
-This will define the location at which the contributions will appear in the BlueBerry UI. Once the insertion point has been defined the rest of the contributions describe the UI elements that will be added at that location. Each element supports a 'visibleWhen' expression that determines at run time whether a particular item should appear in the menu based on the system's current state (selection, active view/editor, context...). See <code>berry::ISources</code> for a list of currently
-supported variables.
-</p>
- </documentation>
+
</annotation>
<include schemaLocation="schema://org.blueberry.core.expressions/schema/expressionLanguage.exsd"/>
<element name="extension">
<annotation>
<appInfo>
<meta.element />
</appInfo>
</annotation>
<complexType>
<sequence>
<element ref="group" minOccurs="0" maxOccurs="unbounded"/>
<element ref="widget" minOccurs="0" maxOccurs="unbounded"/>
<element ref="menuContribution" minOccurs="0" maxOccurs="unbounded"/>
</sequence>
<attribute name="point" type="string" use="required">
<annotation>
- <documentation>
- org.blueberry.ui.menus
- </documentation>
+
</annotation>
</attribute>
<attribute name="id" type="string">
<annotation>
- <documentation>
- An optional identifier of the extension instance.
- </documentation>
+
</annotation>
</attribute>
<attribute name="name" type="string">
<annotation>
- <documentation>
- An optional name of the extension instance.
- </documentation>
+
<appInfo>
<meta.attribute translatable="true"/>
</appInfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="class">
<annotation>
- <documentation>
- A class element supporting the executable extension parsing syntax for both <code>widget</code> and <code>dynamic</code> elements.
- </documentation>
+
</annotation>
<complexType>
<sequence>
<element ref="parameter" minOccurs="0" maxOccurs="unbounded"/>
</sequence>
<attribute name="class" type="string" use="required">
<annotation>
- <documentation>
- The class to load as an <code>IExecutableExtension</code>.
- </documentation>
+
<appInfo>
<meta.attribute kind="java"/>
</appInfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="visibleWhen">
<annotation>
- <documentation>
- A core Expression that controls the visibility of the given element.
- </documentation>
+
</annotation>
<complexType>
<choice minOccurs="0" maxOccurs="1">
<element ref="not"/>
<element ref="or"/>
<element ref="and"/>
<element ref="instanceof"/>
<element ref="test"/>
<element ref="systemTest"/>
<element ref="equals"/>
<element ref="count"/>
<element ref="with"/>
<element ref="resolve"/>
<element ref="adapt"/>
<element ref="iterate"/>
<element ref="reference"/>
</choice>
<attribute name="checkEnabled" type="boolean" use="default" value="false">
<annotation>
- <documentation>
- If this attribute is set to <code>true</code>, then there should be no sub-elements. This just checks the enabled state of the command, and makes the corresponding element visible if the command is enabled.
- </documentation>
+
</annotation>
</attribute>
</complexType>
</element>
<element name="parameter">
<annotation>
- <documentation>
- A parameter to either an executable extension or a command -- depending on where it appears in the extension.
- </documentation>
+
</annotation>
<complexType>
<attribute name="name" type="string" use="required">
<annotation>
- <documentation>
- The name is either the name of the parameter to pass to the executable extension, or the identifier of the parameter for the command.
- </documentation>
+
<appInfo>
<meta.attribute kind="identifier" basedOn="org.blueberry.ui.commands/command/commandParameter/@id"/>
</appInfo>
</annotation>
</attribute>
<attribute name="value" type="string" use="required">
<annotation>
- <documentation>
- The value to pass for this parameter.
- </documentation>
+
</annotation>
</attribute>
</complexType>
</element>
<element name="menuContribution">
<annotation>
- <documentation>
- <p>Defines an ordered set of additions to the command UI structure. The defined elements will be added into the command UI structure at the location specified by the <code>locationURI</code> element.
-</p><p>
-This should be the starting point for <i>all</i> contributions into menus, toolbars or trim, wherever they occur in the UI.
-</p>
- </documentation>
+
</annotation>
<complexType>
<sequence>
<element ref="menu" minOccurs="0" maxOccurs="unbounded"/>
<element ref="command" minOccurs="0" maxOccurs="unbounded"/>
<element ref="separator" minOccurs="0" maxOccurs="unbounded"/>
<element ref="dynamic" minOccurs="0" maxOccurs="unbounded"/>
<element ref="toolbar" minOccurs="0" maxOccurs="unbounded"/>
<element ref="control" minOccurs="0" maxOccurs="unbounded"/>
</sequence>
<attribute name="locationURI" type="string" use="required">
<annotation>
- <documentation>
- A <code>URI</code> specification that defines the insertion point at which the contained additions will be added.
-
-The format for the URI is comprised of three basic parts:
-Scheme: One of "menu", "popup" or "toolbar. Indicates the type of the manager used to handle the contributions
-Id: This is either the id of an existing menu, a view id or the id of the editor 'type'
-Query: The query format is &lt;placement&gt;=&lt;id&gt; where:
- &lt;placement&gt; is either "before", "after", or "endof" and
- &lt;id&gt; is the id of an existing menu item. The placement modifier is executed when this contribution is processed. Following contributions may change the final shape of the menu when they are processed.
- </documentation>
</annotation>
</attribute>
<attribute name="class" type="string">
<annotation>
- <documentation>
- If this optional attribute is specified the provided class will be instantiated and used to provide menu contributions at this location. If provided, all child elements will be ignored.
- </documentation>
+
<appInfo>
<meta.attribute kind="java" basedOn="org.blueberry.ui.menus.ExtensionContributionFactory:"/>
</appInfo>
</annotation>
</attribute>
<attribute name="allPopups" type="boolean" use="default" value="false">
<annotation>
- <documentation>
- By default popup contributions are not contributed to context menus that do not include an <b>additions</b> marker.
- </documentation>
+
</annotation>
</attribute>
</complexType>
</element>
<element name="menu">
<annotation>
- <documentation>
- Defines a new menu contribution at the given insertion point.
- </documentation>
+
</annotation>
<complexType>
<sequence minOccurs="0" maxOccurs="1">
<element ref="visibleWhen" minOccurs="0" maxOccurs="1"/>
<choice minOccurs="0" maxOccurs="unbounded">
<element ref="menu" minOccurs="0" maxOccurs="1"/>
<element ref="command" minOccurs="0" maxOccurs="1"/>
<element ref="separator" minOccurs="0" maxOccurs="1"/>
<element ref="dynamic" minOccurs="0" maxOccurs="1"/>
</choice>
</sequence>
<attribute name="label" type="string" use="required">
<annotation>
- <documentation>
- The label to be displayed for this element when it is placed in either a menu or a toolbar. This value should be translatable.
- </documentation>
+
<appInfo>
<meta.attribute translatable="true"/>
</appInfo>
</annotation>
</attribute>
<attribute name="id" type="string">
<annotation>
- <documentation>
- The 'id' of this menu contribution. If defined then it can be extended through other 'menuAddition' elements or the id can be used as a reference in the Query part of the location defining whether the additions are to go before or after this element.
- </documentation>
+
</annotation>
</attribute>
<attribute name="mnemonic" type="string">
<annotation>
- <documentation>
- The character of the Label that should be given the mnemonic affordance. This is to allow the menu system to re-define the value during translation without having to understand the various platforms' conventions for menu label definition (i.e. using the '&amp;' character...).
- </documentation>
+
<appInfo>
<meta.attribute translatable="true"/>
</appInfo>
</annotation>
</attribute>
<attribute name="icon" type="string">
<annotation>
- <documentation>
- A plugin relative path to the image to be used as the icon for this menu in either a menu or a toolbar.
- </documentation>
+
<appInfo>
<meta.attribute kind="resource"/>
</appInfo>
</annotation>
</attribute>
<attribute name="tooltip" type="string">
<annotation>
- <documentation>
- The tooltip to be displayed for this element when it is placed in a toolbar. This value should be translatable.
- </documentation>
+
<appInfo>
<meta.attribute translatable="true"/>
</appInfo>
</annotation>
</attribute>
<attribute name="commandId" type="string">
<annotation>
- <documentation>
- Th commandId is used to update the submenu text with a keyboard shortcut. The command should have a handler that can launch a quickmenu version of this menu.
- </documentation>
+
<appInfo>
<meta.attribute kind="identifier" basedOn="org.blueberry.ui.commands/command/@id"/>
</appInfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="command">
<annotation>
- <documentation>
- Defines a new Command Contribution at the defined insertion point.
- </documentation>
+
</annotation>
<complexType>
<sequence>
<element ref="visibleWhen" minOccurs="0" maxOccurs="1"/>
<element ref="parameter" minOccurs="0" maxOccurs="unbounded"/>
</sequence>
<attribute name="label" type="string">
<annotation>
- <documentation>
- The label to be displayed for this element when it is placed in either a menu. This value should be translatable.
- </documentation>
+
<appInfo>
<meta.attribute translatable="true"/>
</appInfo>
</annotation>
</attribute>
<attribute name="commandId" type="string" use="required">
<annotation>
- <documentation>
- This is the id of the Command that is to be bound to this element. This is the hook into the Commands/Handlers/Key binding services that actually do the work should this item be selected. In many cases this command will have been defined in a previous extension declaration.
- </documentation>
+
<appInfo>
<meta.attribute kind="identifier" basedOn="org.blueberry.ui.commands/command/@id"/>
</appInfo>
</annotation>
</attribute>
<attribute name="id" type="string">
<annotation>
- <documentation>
- The 'id' of this contribution. If defined then it can be used as a reference in the Query part of the location defining whether the additions are to go before or after this element.
- </documentation>
+
</annotation>
</attribute>
<attribute name="mnemonic" type="string">
<annotation>
- <documentation>
- The character of the Label that should be given the mnemonic affordance. This is to allow the menu system to re-define the value during translation without having to understand the various platforms' conventions for menu label definition (i.e. using the '&amp;' character...).
- </documentation>
+
<appInfo>
<meta.attribute translatable="true"/>
</appInfo>
</annotation>
</attribute>
<attribute name="icon" type="string">
<annotation>
- <documentation>
- a relative path of an icon used to visually represent the action in its context.
-If omitted and the action appears in the toolbar, the Workbench will use a placeholder icon. The path is relative to the location of the plugin.xml file of the contributing plug-in, or the <code>ISharedImages</code> constant.
- </documentation>
+
<appInfo>
<meta.attribute kind="resource"/>
</appInfo>
</annotation>
</attribute>
<attribute name="disabledIcon" type="string">
<annotation>
- <documentation>
- a relative path of an icon used to visually represent the action in its context when the action is disabled. If omitted, the normal icon will simply appear greyed out. The path is relative to the location of the plugin.xml file of the contributing plug-in. The disabled icon will appear in toolbars but not in menus. Icons for disabled actions in menus will be supplied by the OS.
- </documentation>
+
<appInfo>
<meta.attribute kind="resource"/>
</appInfo>
</annotation>
</attribute>
<attribute name="hoverIcon" type="string">
<annotation>
- <documentation>
- a relative path of an icon used to visually represent the action in its context when the mouse pointer is over the action. If omitted, the normal icon will be used. The path is relative to the location of the plugin.xml file of the contributing plug-in.
- </documentation>
+
<appInfo>
<meta.attribute kind="resource"/>
</appInfo>
</annotation>
</attribute>
<attribute name="tooltip" type="string">
<annotation>
- <documentation>
- The tooltip to be displayed for this element when it is placed in a toolbar. This value should be translatable.
- </documentation>
+
<appInfo>
<meta.attribute translatable="true"/>
</appInfo>
</annotation>
</attribute>
<attribute name="helpContextId" type="string">
<annotation>
- <documentation>
- a unique identifier indicating the help context for this action. If the action appears as a menu item, then pressing F1 while the menu item is highlighted will display help. This overrides the help context id provided by the active handler or command.
- </documentation>
+
</annotation>
</attribute>
<attribute name="style" use="default" value="push">
<annotation>
- <documentation>
- an attribute to define the user interface style type for the action. If omitted, then it is <samp>push</samp> by default. The attribute value will be one of the following:
- <table border="0" width="80%">
- <tr>
- <td valign="top" width="25"></td>
- <td valign="top" nowrap><b>push</b></td>
- <td valign="top">- as a regular menu item or tool item.</td>
- </tr>
- <tr>
- <td valign="top" width="25"></td>
- <td valign="top" nowrap><b>radio</b></td>
- <td valign="top">- as a radio style menu item or tool item. Actions with the radio style within the same menu or toolbar group behave as a radio set. The initial value is specified by the <samp>state</samp> attribute.</td>
- </tr>
- <tr>
- <td valign="top" width="25"></td>
- <td valign="top" nowrap><b>toggle</b></td>
- <td valign="top">- as a checked style menu item or as a toggle tool item. The initial value is specified by the <samp>state</samp> attribute.</td>
- </tr>
- <tr>
- <td valign="top" width="25"></td>
- <td valign="top" nowrap><b>pulldown</b></td>
- <td valign="top">- (ToolBar only) Creates a ToolItem with the <code>SWT.DROP_DOWN</code> affordance. The URI of the menu is "menu:" + this item's ID.</td>
- </tr>
- </table>
- </documentation>
+
</annotation>
<simpleType>
<restriction base="string">
<enumeration value="push">
</enumeration>
<enumeration value="radio">
</enumeration>
<enumeration value="toggle">
</enumeration>
<enumeration value="pulldown">
</enumeration>
</restriction>
</simpleType>
</attribute>
<attribute name="mode">
<annotation>
- <documentation>
- For commands appearing in a toolbar, <code>FORCE_TEXT</code> will show text even if there is an icon. See CommandContributionItem.
- </documentation>
+
</annotation>
<simpleType>
<restriction base="string">
<enumeration value="FORCE_TEXT">
</enumeration>
</restriction>
</simpleType>
</attribute>
</complexType>
</element>
<element name="separator">
<annotation>
- <documentation>
- Inserts a separator at the current insertion point.
- </documentation>
+
</annotation>
<complexType>
<attribute name="name" type="string" use="required">
<annotation>
- <documentation>
- The 'id' of this contribution. If defined then it can be used as a reference in the Query part of the location defining whether the additions are to go before or after this element (or at the end of the logical group containing this element using the 'endof' value).
-<p>
-Separator contributions that have an id define the start of a logical group so the result of using the 'endof' value for placement is to search forward in the current menu to locate the next separator and to place the inserted elements before that element. If no trailing separator is found then the items are placed at the end of the menu.
-</p>
- </documentation>
+
</annotation>
</attribute>
<attribute name="visible" type="boolean">
<annotation>
- <documentation>
- Indicates whether or not the separator should be visible in the UI. <code>false</code> by default.
- </documentation>
+
</annotation>
</attribute>
</complexType>
</element>
<element name="toolbar">
<annotation>
- <documentation>
- Contributes a new ToolBar at the current insertion point. This element is only currently valid for CoolBarManagers, which can contain toolbars. For example, the trim location URIs specified in <code>org.blueberry.ui.menus.MenuUtil</code>.
- </documentation>
+
</annotation>
<complexType>
<sequence minOccurs="0" maxOccurs="1">
<element ref="visibleWhen" minOccurs="0" maxOccurs="1"/>
<choice minOccurs="0" maxOccurs="unbounded">
<element ref="command" minOccurs="0" maxOccurs="1"/>
<element ref="separator" minOccurs="0" maxOccurs="1"/>
<element ref="dynamic" minOccurs="0" maxOccurs="1"/>
<element ref="control" minOccurs="0" maxOccurs="1"/>
</choice>
</sequence>
<attribute name="id" type="string" use="required">
<annotation>
- <documentation>
- The 'id' of this toolbar contribution. If defined then it can be extended through other 'menuAddition' elements or the id can be used as a reference in the Query part of the location defining whether the additions are to go before or after this element.
- </documentation>
+
</annotation>
</attribute>
<attribute name="label" type="string">
<annotation>
- <documentation>
- The label to be displayed for this element when it is displayed in the customize perspective dialog. This value should be translatable.
- </documentation>
+
<appInfo>
<meta.attribute translatable="true"/>
</appInfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="control">
<annotation>
- <documentation>
- Used to contribute controls to ToolBars in the workbench. The 'class' attribute must be a derivative of the
-WorkbenchWindowControlContribution base class.
-<p>
-<b>NOTE:</b> Due to platform restrictions control contributions are only supported for toolbars; Attempts to contribute controls into a menu or popup will be treated as a NO-OP.
-</p>
- </documentation>
+
</annotation>
<complexType>
<sequence>
<element ref="visibleWhen" minOccurs="0" maxOccurs="1"/>
</sequence>
<attribute name="id" type="string">
<annotation>
- <documentation>
- The 'id' of this menu contribution. If defined then it can be used as a reference in the Query part of the location defining whether the additions are to go before or after this element.
- </documentation>
+
</annotation>
</attribute>
<attribute name="class" type="string" use="required">
<annotation>
- <documentation>
- The class which will be used to create the control that is to be hosted in a ToolBar. This must be a subclass of
-WorkbenchWindowControlContribution which provides information as to the control's location (i.e. which workbench window it's being hosted in and the side of the window that it is currently being displayed on.
- </documentation>
+
<appInfo>
<meta.attribute kind="java" basedOn="org.blueberry.ui.menus.WorkbenchWindowControlContribution"/>
</appInfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="dynamic">
<annotation>
- <documentation>
- The element provides a mechanism that will call back into the defined class to provide an IContributionItem to be shown when the menu or toolbar is built. The defined class must be a derivative of the org.blueberry.jface.action.ContributionItem base class. It can also use org.blueberry.ui.action.CompoundContributionItem and provide an implementation for the abstract <code>getContributionItems</code> method to provide a dynamic menu item.
- </documentation>
+
</annotation>
<complexType>
<sequence>
<element ref="class" minOccurs="0" maxOccurs="1"/>
<element ref="visibleWhen" minOccurs="0" maxOccurs="1"/>
</sequence>
<attribute name="id" type="string" use="required">
<annotation>
- <documentation>
- A unique identifier for this contribution. It is recommended that the identifier be prefixed by the plug-in name, to guarantee uniqueness. For example, a widget contributed by <code>org.blueberry.ui</code> might be called <code>org.blueberry.ui.widget1</code>.
-<p>
-If defined then it can be used as a reference in the Query part of the location defining whether the additions are to go before or after this element (or at the end of the logical group containing this element using the 'endof' value).
-</p>
- </documentation>
+
</annotation>
</attribute>
<attribute name="class" type="string" use="required">
<annotation>
- <documentation>
- This class is expected to be a subclass of ContributionItem. The item may implement IWorkbenchContribution to be provided an IServiceLocator.
- </documentation>
+
<appInfo>
<meta.attribute kind="java" basedOn="org.blueberry.jface.action.ContributionItem"/>
</appInfo>
</annotation>
</attribute>
</complexType>
</element>
<annotation>
<appInfo>
<meta.section type="apiInfo"/>
</appInfo>
- <documentation>
- <p>
-It is preferred that menu contributions be added in the <code>plugin.xml</code>. Plugins can
-programmatically add their own menu contributions using <code>org.blueberry.ui.menus.IMenuService</code> and <code>org.blueberry.ui.menus.AbstractContributionFactory</code>, but should be sure to remove them if the plugin is unloaded. The <code>IMenuService</code> can be retrieved through any of the <code>IServiceLocators</code>, the workbench, the workbench window, or the part site.
-</p>
-<p>
-See <a href="org_blueberry_ui_commands.html">org.blueberry.ui.commands</a> to define a command and <a href="org_blueberry_ui_handlers.html">org.blueberry.ui.handlers</a> to define an implementation for the command.
-</p>
-<p>To register a context menu, use the <code>IWorkbenchPartSite.registerContextMenu</code> methods.</p>
- </documentation>
+
</annotation>
<annotation>
<appInfo>
<meta.section type="since"/>
</appInfo>
- <documentation>
- 3.3
- </documentation>
+
</annotation>
<annotation>
<appInfo>
<meta.section type="examples"/>
</appInfo>
- <documentation>
- <p>
-A basic extension looks like this.
-</p>
-<pre>
- <extension
- id="add.item"
- point="org.blueberry.ui.menus">
- <menuContribution
- locationURI="menu:someorg.somemenu.id?after=additions">
- <command
- commandId="someorg.someid.someCommand"
- icon="icons/anything.gif"
- id="someorg.someid.BasicCmdItem"
- label="Simple Item"
- mnemonic="S">
- </command>
- </menuContribution>
- </extension>
-</pre>
-<p>
-This is the simplest example; adding a command contribution after an existing menu's additions group.
-</p>
- </documentation>
+
</annotation>
<annotation>
<appInfo>
<meta.section type="copyright"/>
</appInfo>
- <documentation>
- Copyright (c) 2005,2007 IBM Corporation and others.<br>
-All rights reserved. This program and the accompanying materials are made
-available under the terms of the Eclipse Public License v1.0 which accompanies
-this distribution, and is available at <a
-href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>
- </documentation>
+
</annotation>
</schema>
diff --git a/Plugins/org.blueberry.ui.qt/schema/perspectiveExtensions.exsd b/Plugins/org.blueberry.ui.qt/schema/perspectiveExtensions.exsd
index d908729c13..7abf492647 100644
--- a/Plugins/org.blueberry.ui.qt/schema/perspectiveExtensions.exsd
+++ b/Plugins/org.blueberry.ui.qt/schema/perspectiveExtensions.exsd
@@ -1,373 +1,267 @@
<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.blueberry.ui" xmlns="http://www.w3.org/2001/XMLSchema">
<annotation>
<appInfo>
<meta.schema plugin="org.blueberry.ui" id="perspectiveExtensions" name="Perspective Extensions"/>
</appInfo>
- <documentation>
- This extension point is used to extend perspectives
-registered by other plug-ins. A perspective defines
-the initial contents of the window action bars
-(menu and toolbar) and the initial set of views
-and their layout within a workbench page.
-Other plug-ins may contribute actions or views to
-the perspective which appear when the perspective
-is selected. Optional additions by other plug-ins
-are appended to the initial definition.
- </documentation>
+
</annotation>
<element name="extension">
<annotation>
<appInfo>
<meta.element />
</appInfo>
</annotation>
<complexType>
<sequence>
<element ref="perspectiveExtension" minOccurs="0" maxOccurs="unbounded"/>
</sequence>
<attribute name="point" type="string" use="required">
<annotation>
- <documentation>
- a fully qualified identifier of the target extension point
- </documentation>
+
</annotation>
</attribute>
<attribute name="id" type="string">
<annotation>
- <documentation>
- an optional identifier of the extension instance
- </documentation>
+
</annotation>
</attribute>
<attribute name="name" type="string">
<annotation>
- <documentation>
- an optional name of the extension instance
- </documentation>
+
<appInfo>
<meta.attribute translatable="true"/>
</appInfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="perspectiveExtension">
<annotation>
<appInfo>
<meta.element labelAttribute="targetID"/>
</appInfo>
</annotation>
<complexType>
<choice minOccurs="0" maxOccurs="unbounded">
<element ref="actionSet"/>
<element ref="viewShortcut"/>
<element ref="perspectiveShortcut"/>
<element ref="newWizardShortcut"/>
<element ref="view"/>
<element ref="showInPart"/>
<element ref="hiddenMenuItem"/>
<element ref="hiddenToolBarItem"/>
</choice>
<attribute name="targetID" use="required">
<annotation>
- <documentation>
- the unique identifier of the perspective (as specified in the registry) into which the contribution is made. If the value is set to "*" the extension is applied to all perspectives.
- </documentation>
+
<appInfo>
<meta.attribute kind="identifier" basedOn="org.blueberry.ui.perspectives/perspective/@id"/>
</appInfo>
</annotation>
<simpleType>
<restriction base="string">
<enumeration value="*">
</enumeration>
</restriction>
</simpleType>
</attribute>
</complexType>
</element>
<element name="actionSet">
<complexType>
<attribute name="id" type="string" use="required">
<annotation>
- <documentation>
- the unique identifier of the action set which will be added to the perspective.
- </documentation>
+
<appInfo>
<meta.attribute kind="identifier" basedOn="org.blueberry.ui.actionSets/actionSet/@id"/>
</appInfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="viewShortcut">
<complexType>
<attribute name="id" type="string" use="required">
<annotation>
- <documentation>
- the unique identifier of the view which will be added to the perspective's "Show View" submenu of the "Window" menu.
- </documentation>
+
<appInfo>
<meta.attribute kind="identifier" basedOn="org.blueberry.ui.views/view/@id"/>
</appInfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="perspectiveShortcut">
<complexType>
<attribute name="id" type="string" use="required">
<annotation>
- <documentation>
- the unique identifier of the perspective which will be added to the perspective's "Open Perspective" submenu of the "Window" menu.
- </documentation>
+
<appInfo>
<meta.attribute kind="identifier" basedOn="org.blueberry.ui.perspectives/perspective/@id"/>
</appInfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="newWizardShortcut">
<complexType>
<attribute name="id" type="string" use="required">
<annotation>
- <documentation>
- the unique identifier of the new wizard which will be added to the perspective's "New" submenu of the "File" menu.
- </documentation>
+
<appInfo>
<meta.attribute kind="identifier" basedOn="org.blueberry.ui.newWizards/wizard/@id"/>
</appInfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="showInPart">
<complexType>
<attribute name="id" type="string">
<annotation>
- <documentation>
- the unique identifier of the view which will be added to the perspective's "Show In..." prompter in the Navigate menu.
- </documentation>
+
<appInfo>
<meta.attribute kind="identifier" basedOn="org.blueberry.ui.views/view/@id"/>
</appInfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="view">
<complexType>
<attribute name="id" type="string" use="required">
<annotation>
- <documentation>
- the unique identifier of the view which will be added to the perspective layout.
- </documentation>
+
<appInfo>
<meta.attribute kind="identifier" basedOn="org.blueberry.ui.views/view/@id"/>
</appInfo>
</annotation>
</attribute>
<attribute name="relative">
<annotation>
- <documentation>
- the unique identifier of a view which already exists in the perspective. This will be used as a reference point for placement of the view. The relationship between these two views is defined by <samp>relationship</samp>. Ignored if relationship is "fast".
- </documentation>
+
<appInfo>
<meta.attribute kind="identifier" basedOn="org.blueberry.ui.views/view/@id"/>
</appInfo>
</annotation>
<simpleType>
<restriction base="string">
<enumeration value="org.blueberry.ui.editorss">
</enumeration>
</restriction>
</simpleType>
</attribute>
<attribute name="relationship" use="required">
<annotation>
- <documentation>
- specifies the relationship between <samp>id</samp> and
-<samp>relative</samp>.
-The following values are supported:
-<ul>
-<b>fast</b> - the view extension will be created as a fast view.
-<br><b>stack</b> - the view extension will be stacked with the relative
-view in a folder.
-<br><b>left, right, top, bottom</b> - the view extension will be placed
-beside the relative view. In this case a <samp>ratio</samp> must also
-be defined.</ul>
- </documentation>
+
</annotation>
<simpleType>
<restriction base="string">
<enumeration value="stack">
</enumeration>
<enumeration value="left">
</enumeration>
<enumeration value="right">
</enumeration>
<enumeration value="top">
</enumeration>
<enumeration value="bottom">
</enumeration>
<enumeration value="fast">
</enumeration>
</restriction>
</simpleType>
</attribute>
<attribute name="ratio" type="string">
<annotation>
- <documentation>
- the percentage of area within the relative view which will be donated to the view extension. If the view extension is a fast view, the ratio is the percentage of the workbench the fast view will cover when active. This must be defined as a floating point value and lie between 0.05 and 0.95.
- </documentation>
+
</annotation>
</attribute>
<attribute name="visible" type="boolean">
<annotation>
- <documentation>
- whether the view is initially visible when the perspective is opened. This attribute should have a value of "true" or "false" if used.
-If this attribute is not used, the view will be initially visible by default.
- </documentation>
+
</annotation>
</attribute>
<attribute name="closeable" type="boolean">
<annotation>
- <documentation>
- whether the view is closeable in the target perspective. This attribute should have a value of "true" or "false" if used. If this attribute is not used, the view will be closeable, unless the perspective itself is marked as fixed.
- </documentation>
+
</annotation>
</attribute>
<attribute name="moveable" type="boolean">
<annotation>
- <documentation>
- whether the view is moveable. A non-moveable view cannot be moved either within the same folder, or moved between folders in the perspective. This attribute should have a value of "true" or "false" if used.
-If this attribute is not used, the view will be moveable, unless the perspective itself is marked as fixed.
- </documentation>
+
</annotation>
</attribute>
<attribute name="standalone" type="boolean">
<annotation>
- <documentation>
- whether the view is a standalone view. A standalone view cannot be docked together with others in the same folder. This attribute should have a value of "true" or "false" if used. This attribute is ignored if the relationship attribute is "fast" or "stacked". If this attribute is not used, the view will be a regular view, not a standalone view (default is "false").
- </documentation>
+
</annotation>
</attribute>
<attribute name="showTitle" type="boolean">
<annotation>
- <documentation>
- whether the view's title is shown. This attribute should have a value of "true" or "false" if used. This attribute only applies to standalone views. If this attribute is not used, the view's title will be shown (default is "true").
- </documentation>
+
</annotation>
</attribute>
<attribute name="minimized" type="boolean" use="default" value="false">
<annotation>
- <documentation>
- If the perspective extension will result in a new view stack being created (i.e. the 'relationship' attribute is one of left, right, top or bottom) this field determines the new stack's initial display state.
- </documentation>
+
</annotation>
</attribute>
</complexType>
</element>
<element name="hiddenMenuItem">
<complexType>
<attribute name="id" type="string" use="required">
<annotation>
- <documentation>
- The unique identifier of the Command which is to be removed from the menu.
-<strong>WARNING:</strong> This is considered to be a 'Product level' extension and should not be used in consumable plugins without great care.
- </documentation>
</annotation>
</attribute>
</complexType>
</element>
<element name="hiddenToolBarItem">
<complexType>
<attribute name="id" type="string" use="required">
<annotation>
- <documentation>
- The unique identifier of the Command which is to be removed from thetoolbar.
-<strong>WARNING:</strong> This is considered to be a 'Product level' extension and should not be used in consumable plugins without great care.
- </documentation>
</annotation>
</attribute>
</complexType>
</element>
<annotation>
<appInfo>
<meta.section type="examples"/>
</appInfo>
- <documentation>
- The following is an example of a perspective extension (note the subelements and the way attributes are used):
-<p>
-<pre>
- <extension point="org.blueberry.ui.perspectiveExtensions">
- <perspectiveExtension
- targetID="org.blueberry.ui.resourcePerspective">
- <actionSet id="org.xyz.MyActionSet"/>
- <viewShortcut id="org.xyz.views.PackageExplorer"/>
- <newWizardShortcut id="org.xyz.wizards.NewProjectCreationWizard"/>
- <perspectiveShortcut id="org.xyz.MyPerspective"/>
- <view id="org.xyz.views.PackageExplorer"
- relative="org.blueberry.ui.views.ResourceNavigator"
- relationship="stack"/>
- <view id="org.xyz.views.TypeHierarchy"
- relative="org.blueberry.ui.views.ResourceNavigator"
- relationship="left"
- ratio="0.50"/>
- </perspectiveExtension>
- </extension>
-</pre>
-</p>
-<p>
-In the example above, an action set, view shortcut,
-new wizard shortcut, and perspective shortcut are
-contributed to the initial contents of the
-Resource Perspective. In addition, the
-Package Explorer view is stacked on the
-Resource Navigator and the Type Hierarchy View is
-added beside the Resource Navigator.
-</p>
- </documentation>
+
</annotation>
<annotation>
<appInfo>
<meta.section type="apiInfo"/>
</appInfo>
- <documentation>
- The items defined within the perspective extension are contributed to the initial contents of the target perspective. Following this, the user may remove any contribution or add others to a perspective from within the workbench user interface.
- </documentation>
+
</annotation>
<annotation>
<appInfo>
<meta.section type="copyright"/>
</appInfo>
- <documentation>
- Copyright (c) 2002, 2007 IBM Corporation and others.<br>
-All rights reserved. This program and the accompanying materials are made
-available under the terms of the Eclipse Public License v1.0 which accompanies
-this distribution, and is available at <a
-href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>
- </documentation>
+
</annotation>
</schema>
diff --git a/Plugins/org.blueberry.ui.qt/schema/perspectives.exsd b/Plugins/org.blueberry.ui.qt/schema/perspectives.exsd
index 8e355d8ed3..5b3c237ba7 100644
--- a/Plugins/org.blueberry.ui.qt/schema/perspectives.exsd
+++ b/Plugins/org.blueberry.ui.qt/schema/perspectives.exsd
@@ -1,181 +1,122 @@
<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.blueberry.ui">
<annotation>
<appInfo>
<meta.schema plugin="org.blueberry.ui" id="perspective" name="Perspectives"/>
</appInfo>
- <documentation>
- This extension point is used to add perspective factories to the workbench. A perspective factory is used to define the initial layout and visible action sets for a perspective. The user can select a perspective by invoking the "Open Perspective" submenu of the "Window" menu.
- </documentation>
+
</annotation>
<element name="extension">
<complexType>
<sequence>
<element ref="perspective" minOccurs="0" maxOccurs="unbounded"/>
</sequence>
<attribute name="point" type="string" use="required">
<annotation>
- <documentation>
- a fully qualified identifier of the target extension point
- </documentation>
+
</annotation>
</attribute>
<attribute name="id" type="string">
<annotation>
- <documentation>
- an optional identifier of the extension instance
- </documentation>
+
</annotation>
</attribute>
<attribute name="name" type="string">
<annotation>
- <documentation>
- an optional name of the extension instance
- </documentation>
+
<appInfo>
<meta.attribute translatable="true"/>
</appInfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="perspective">
<annotation>
<appInfo>
<meta.element labelAttribute="name" icon="icon"/>
</appInfo>
</annotation>
<complexType>
<sequence>
<element ref="description" minOccurs="0" maxOccurs="1"/>
<element ref="keywordReference" minOccurs="0" maxOccurs="unbounded"/>
</sequence>
<attribute name="id" type="string" use="required">
<annotation>
- <documentation>
- a unique name that will be used to identify this perspective.
- </documentation>
+
</annotation>
</attribute>
<attribute name="name" type="string" use="required">
<annotation>
- <documentation>
- a translatable name that will be used in the workbench window menu bar to represent this perspective.
- </documentation>
+
<appInfo>
<meta.attribute translatable="true"/>
</appInfo>
</annotation>
</attribute>
<attribute name="class" type="string" use="required">
<annotation>
- <documentation>
- a fully qualified name of the class that implements
-<samp>berry::IPerspectiveFactory</samp> interface.
- </documentation>
+
<appInfo>
<meta.attribute kind="java" basedOn="berry::IPerspectiveFactory"/>
</appInfo>
</annotation>
</attribute>
<attribute name="icon" type="string">
<annotation>
- <documentation>
- a relative name of the icon that will be associated
-with this perspective.
- </documentation>
+
<appInfo>
<meta.attribute kind="resource"/>
</appInfo>
</annotation>
</attribute>
<attribute name="fixed" type="boolean">
<annotation>
- <documentation>
- indicates whether the layout of the perspective is fixed. If true, then views created by the perspective factory are not closeable, and cannot be moved. The default is false.
- </documentation>
+
</annotation>
</attribute>
</complexType>
</element>
<element name="description" type="string">
<annotation>
<appInfo>
<meta.element translatable="true"/>
</appInfo>
- <documentation>
- an optional subelement whose body should contain text providing a short description of the perspective.
- </documentation>
+
</annotation>
</element>
<annotation>
<appInfo>
<meta.section type="examples"/>
</appInfo>
- <documentation>
- The following is an example of a perspective extension:
-<p>
-<pre>
- <extension
- point="org.blueberry.ui.perspectives">
- <perspective
- id="org.blueberry.ui.resourcePerspective"
- name="Resource"
- class="berry::ResourcePerspective"
- icon="resources/MyIcon.gif">
- </perspective>
- </extension>
-</pre>
-</p>
- </documentation>
+
</annotation>
<annotation>
<appInfo>
<meta.section type="apiInfo"/>
</appInfo>
- <documentation>
- The value of the <samp>class</samp> attribute must be the
-fully qualified name of a class that implements
-<samp>berry::IPerspectiveFactory</samp>.
-The class must supply the initial layout for a
-perspective when asked by the workbench.
-<p>
-The <samp>plugin_customization.ini</samp> file is used to define the default perspective. The <i>default perspective</i> is the first perspective which appears when the product is launched after install. It is also used when the user opens a page or window with no specified perspective. The default perspective is defined as a property within the plugin_customization.ini, as shown below. The user may also override this perspective from the workbench perspectives preference page.
-<pre>
- defaultPerspectiveId = org.blueberry.ui.resourcePerspective
-</pre>
-The perspectives which appear in the "Open Perspective" menu are shortcuts for perspective selection. This set is defined by the active perspective itself, and extensions made through the perspectiveExtensions extension point.
- </documentation>
+
</annotation>
<annotation>
<appInfo>
<meta.section type="implementation"/>
</appInfo>
- <documentation>
- The workbench provides a "Resource Perspective".
-Additional perspectives may be added by plug-ins.
-They are selected using the "Open Perspective" submenu of the "Window" menu.
- </documentation>
+
</annotation>
<annotation>
<appInfo>
<meta.section type="copyright"/>
</appInfo>
- <documentation>
- Copyright (c) 2002, 2005 IBM Corporation and others.<br>
-All rights reserved. This program and the accompanying materials are made
-available under the terms of the Eclipse Public License v1.0 which accompanies
-this distribution, and is available at <a
-href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>
- </documentation>
+
</annotation>
</schema>
diff --git a/Plugins/org.blueberry.ui.qt/schema/preferencePages.exsd b/Plugins/org.blueberry.ui.qt/schema/preferencePages.exsd
index 0869da9db8..8ff375baf5 100644
--- a/Plugins/org.blueberry.ui.qt/schema/preferencePages.exsd
+++ b/Plugins/org.blueberry.ui.qt/schema/preferencePages.exsd
@@ -1,195 +1,125 @@
<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.blueberry.ui" xmlns="http://www.w3.org/2001/XMLSchema">
<annotation>
<appinfo>
<meta.schema plugin="org.blueberry.ui" id="preferencePages" name="Preference Pages"/>
</appinfo>
- <documentation>
- The workbench provides one common dialog box for preferences.
-The purpose of this extension point is to allow plug-ins to add
-pages to the preference dialog box. When preference dialog box
-is opened (initiated from the menu bar), pages contributed in
-this way will be added to the dialog box.
-
-<p>
-The preference dialog
-box provides for hierarchical grouping of the pages. For this
-reason, a page can optionally specify a <samp>category</samp> attribute.
-This
-attribute represents a path composed of parent page IDs separated
-by '/'. If this attribute is omitted or if any of the parent
-nodes in the path cannot be found, the page will be added at
-the root level.
-</p>
- </documentation>
+
</annotation>
<element name="extension">
<complexType>
<sequence>
<element ref="page" minOccurs="0" maxOccurs="unbounded"/>
</sequence>
<attribute name="point" type="string" use="required">
<annotation>
- <documentation>
- a fully qualified identifier of the target extension point
- </documentation>
+
</annotation>
</attribute>
<attribute name="id" type="string">
<annotation>
- <documentation>
- an optional identifier of the extension instance
- </documentation>
+
</annotation>
</attribute>
<attribute name="name" type="string">
<annotation>
- <documentation>
- an optional name of the extension instance
- </documentation>
+
<appinfo>
<meta.attribute translatable="true"/>
</appinfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="page">
<annotation>
<appinfo>
<meta.element labelAttribute="name"/>
</appinfo>
</annotation>
<complexType>
<sequence>
<element ref="keywordReference" minOccurs="0" maxOccurs="unbounded"/>
</sequence>
<attribute name="id" type="string" use="required">
<annotation>
- <documentation>
- a unique name that will be used to identify this page.
- </documentation>
+
</annotation>
</attribute>
<attribute name="name" type="string" use="required">
<annotation>
- <documentation>
- a translatable name that will be used in the UI for this page.
- </documentation>
+
<appinfo>
<meta.attribute translatable="true"/>
</appinfo>
</annotation>
</attribute>
<attribute name="class" type="string" use="required">
<annotation>
- <documentation>
- a name of the fully qualified class that implements
-<samp>berry::IWorkbenchPreferencePage</samp>.
- </documentation>
+
<appinfo>
<meta.attribute kind="java" basedOn="org.eclipse.jface.preference.PreferencePage:org.eclipse.ui.IWorkbenchPreferencePage"/>
</appinfo>
</annotation>
</attribute>
<attribute name="category" type="string">
<annotation>
- <documentation>
- a path indicating the location of the page in the preference tree. The path may either be a parent node ID or a sequence
- of IDs separated by '/', representing the full path from the root node.
- </documentation>
+
<appinfo>
<meta.attribute kind="identifier" basedOn="org.eclipse.ui.preferencePages/page/@id"/>
</appinfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="keywordReference">
<annotation>
- <documentation>
- A reference by a preference page to a keyword. See the keywords extension point.
- </documentation>
+
</annotation>
<complexType>
<attribute name="id" type="string" use="required">
<annotation>
- <documentation>
- The id of the keyword being referred to.
- </documentation>
+
<appinfo>
<meta.attribute kind="identifier" basedOn="org.eclipse.ui.keywords/keyword/@id"/>
</appinfo>
</annotation>
</attribute>
</complexType>
</element>
<annotation>
<appinfo>
<meta.section type="examples"/>
</appinfo>
- <documentation>
- The following is an example for the preference extension point:
-<p>
-<pre>
- <extension
- point="org.blueberry.ui.preferencePages">
- <page
- id="com.xyz.prefpage1"
- name="XYZ"
- class="xyz::PrefPage1">
- <keywordReference id="xyz.Keyword"/>
- </page>
- <page
- id="com.xyz.prefpage2"
- name="Keyboard Settings"
- class="xyz::PrefPage2"
- category="com.xyz.prefpage1">
- </page>
- </extension>
-</pre>
-</p>
- </documentation>
+
</annotation>
<annotation>
<appinfo>
<meta.section type="apiInfo"/>
</appinfo>
- <documentation>
- The value of the attribute class must represent a fully qualified name of the class that implements
-<samp>berry::IWorkbenchPreferencePage</samp>.
- </documentation>
+
</annotation>
<annotation>
<appinfo>
<meta.section type="implementation"/>
</appinfo>
- <documentation>
- The workbench adds several pages for setting the preferences of the platform. Pages registered
-through this extension will be added after them according to their category information.
- </documentation>
+
</annotation>
<annotation>
<appinfo>
<meta.section type="copyright"/>
</appinfo>
- <documentation>
- Copyright (c) 2002, 2005 IBM Corporation and others.<br>
-All rights reserved. This program and the accompanying materials are made
-available under the terms of the Eclipse Public License v1.0 which accompanies
-this distribution, and is available at <a
-href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>
- </documentation>
+
</annotation>
</schema>
diff --git a/Plugins/org.blueberry.ui.qt/schema/presentationFactories.exsd b/Plugins/org.blueberry.ui.qt/schema/presentationFactories.exsd
index e7dcb6d72f..615fe36d99 100644
--- a/Plugins/org.blueberry.ui.qt/schema/presentationFactories.exsd
+++ b/Plugins/org.blueberry.ui.qt/schema/presentationFactories.exsd
@@ -1,125 +1,91 @@
<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.blueberry.ui">
<annotation>
<appInfo>
<meta.schema plugin="org.blueberry.ui" id="presentationFactories" name="Presentation Factories"/>
</appInfo>
- <documentation>
- This extension point is used to add presentation factories to the workbench.
- A presentation factory defines the overall look and feel of the workbench,
- including how views and editors are presented.
- </documentation>
+
</annotation>
<element name="extension">
<complexType>
<sequence>
<element ref="factory" minOccurs="0" maxOccurs="unbounded"/>
</sequence>
<attribute name="point" type="string" use="required">
<annotation>
- <documentation>
- </documentation>
</annotation>
</attribute>
<attribute name="id" type="string">
<annotation>
- <documentation>
- </documentation>
</annotation>
</attribute>
<attribute name="name" type="string">
<annotation>
- <documentation>
- </documentation>
<appInfo>
<meta.attribute translatable="true"/>
</appInfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="factory">
<complexType>
<attribute name="class" type="string" use="required">
<annotation>
- <documentation>
- Specify the fully qualified class to be used for the presentation factory. The specified value must implement the interface <code>berry::IPresentationFactory</code>.
- </documentation>
+
<appInfo>
<meta.attribute kind="java" basedOn="org.eclipse.ui.presentations.AbstractPresentationFactory"/>
</appInfo>
</annotation>
</attribute>
<attribute name="id" type="string" use="required">
<annotation>
- <documentation>
- a unique name that will be used to identify this presentation factory
- </documentation>
+
</annotation>
</attribute>
<attribute name="name" type="string" use="required">
<annotation>
- <documentation>
- a translatable name that can be used to show this presentation factory in the UI
- </documentation>
+
<appInfo>
<meta.attribute translatable="true"/>
</appInfo>
</annotation>
</attribute>
</complexType>
</element>
<annotation>
<appInfo>
<meta.section type="examples"/>
</appInfo>
- <documentation>
- The following is an example of a presentationFactory extension:
-<pre>
- <extension point="org.blueberry.ui.presentationFactories">
- <factory
- class="berry::ExampleWorkbenchPresentationFactory"/>
- </extension>
- </pre>
- </documentation>
+
</annotation>
<annotation>
<appInfo>
<meta.section type="apiInfo"/>
</appInfo>
- <documentation>
- The class specified in the factory element must be a concrete subclass of <code>org.eclipse.ui.presentations.AbstractPresentationFactory</code>.
- </documentation>
+
</annotation>
<annotation>
<appInfo>
<meta.section type="implementation"/>
</appInfo>
- <documentation>
- If a presentation factory is not specified or is missing then the implementation in <code>berry::QtWorkbenchPresentationFactory</code> will be used.
- </documentation>
+
</annotation>
<annotation>
<appInfo>
<meta.section type="copyright"/>
</appInfo>
- <documentation>
- Copyright (c) 2004, 2005 IBM Corporation and others.<br>
-All rights reserved. This program and the accompanying materials are made
-available under the terms of the Eclipse Public License v1.0 which accompanies
-this distribution, and is available at <a
-href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>
- </documentation>
+
</annotation>
</schema>
diff --git a/Plugins/org.blueberry.ui.qt/schema/services.exsd b/Plugins/org.blueberry.ui.qt/schema/services.exsd
index b07d5c4c07..e940e68b2c 100644
--- a/Plugins/org.blueberry.ui.qt/schema/services.exsd
+++ b/Plugins/org.blueberry.ui.qt/schema/services.exsd
@@ -1,226 +1,154 @@
<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.blueberry.ui" xmlns="http://www.w3.org/2001/XMLSchema">
<annotation>
<appinfo>
<meta.schema plugin="org.blueberry.ui" id="services" name="Services"/>
</appinfo>
- <documentation>
- Define service factories so that services can be contributed declaratively and will be available through <code>berry::IServiceLocator::GetService(Class)</code>. The implementation of <code>AbstractServiceFactory</code> must be able to return a global service and multiple child services (if applicable).
-<p>
-Services must follow a general contract:
-<ul>
-<li>The top level service has no parent.</li>
-<li>The child service may use the supplied parent, which can be cast to the service interface.</li>
-<li>Any other services needed for initialization should be retrieved from the <code>berry::IServiceLocator</code>.</li>
-<li>If the service needs to clean up any state (like listeners) it should implement <code>berry::IDisposable</code>.</li>
-<li>Services should clearly specify when they perform cleanup for clients, such as removing listeners automatically on disposal.</li>
-</ul>
-</p>
- </documentation>
+
</annotation>
<element name="extension">
<annotation>
- <documentation>
- Contribute services to the workbench.
- </documentation>
+
</annotation>
<complexType>
<sequence minOccurs="1" maxOccurs="unbounded">
<element ref="serviceFactory" minOccurs="0" maxOccurs="1"/>
<element ref="sourceProvider" minOccurs="0" maxOccurs="1"/>
</sequence>
<attribute name="point" type="string" use="required">
<annotation>
- <documentation>
- </documentation>
</annotation>
</attribute>
<attribute name="id" type="string">
<annotation>
- <documentation>
- </documentation>
</annotation>
</attribute>
<attribute name="name" type="string">
<annotation>
- <documentation>
- </documentation>
<appinfo>
<meta.attribute translatable="true"/>
</appinfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="serviceFactory">
<annotation>
- <documentation>
- Match a service interface to a factory that can supply a hierachical implementation of that service.
- </documentation>
+
</annotation>
<complexType>
<sequence>
<element ref="service" minOccurs="1" maxOccurs="unbounded"/>
</sequence>
<attribute name="factoryClass" type="string" use="required">
<annotation>
- <documentation>
- The factory that extends <code>AbstractServiceFactory</code> and can create the implementation for the serviceClass.
- </documentation>
+
<appinfo>
<meta.attribute kind="java" basedOn="org.eclipse.ui.services.AbstractServiceFactory:"/>
</appinfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="service">
<annotation>
- <documentation>
- A service this factory can provide.
- </documentation>
+
</annotation>
<complexType>
<attribute name="serviceClass" type="string">
<annotation>
- <documentation>
- The interface that represents a service contract.
- </documentation>
+
<appinfo>
<meta.attribute kind="java"/>
</appinfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="sourceProvider">
<annotation>
- <documentation>
- A Source Provider supplies source variables to the IEvaluationService. It can also notify the IEvaluationService when one or more of the variables change.
- </documentation>
+
</annotation>
<complexType>
<sequence>
<element ref="variable" minOccurs="1" maxOccurs="unbounded"/>
</sequence>
<attribute name="provider" type="string" use="required">
<annotation>
- <documentation>
- This class must provide variables and call the appropriate fireSourceChanged(*) method when any of the variables change.
- </documentation>
+
<appinfo>
<meta.attribute kind="java" basedOn="org.eclipse.ui.AbstractSourceProvider:"/>
</appinfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="variable">
<annotation>
- <documentation>
- A source variable from this provider. A source provider must declare all variables that it provides.
- </documentation>
+
</annotation>
<complexType>
<attribute name="name" type="string" use="required">
<annotation>
- <documentation>
- The name of a contributed source variable. It is a good practice to prepend the plugin id to the variable name to avoid collisions with other source providers.
- </documentation>
+
</annotation>
</attribute>
<attribute name="priorityLevel" use="required">
<annotation>
- <documentation>
- For conflict resolution used by services like the IHandlerService, contributed source variables must assign a priority. <b>workbench</b> is the global default priority. See <code>ISources</code> for relative priority information.
- </documentation>
+
</annotation>
<simpleType>
<restriction base="string">
<enumeration value="workbench">
</enumeration>
<enumeration value="activeContexts">
</enumeration>
<enumeration value="activeShell">
</enumeration>
<enumeration value="activeWorkbenchWindow">
</enumeration>
<enumeration value="activeEditorId">
</enumeration>
<enumeration value="activePartId">
</enumeration>
<enumeration value="activeSite">
</enumeration>
</restriction>
</simpleType>
</attribute>
</complexType>
</element>
<annotation>
<appinfo>
<meta.section type="examples"/>
</appinfo>
- <documentation>
- <p>
-Here is a basic definition:
-<pre>
- <extension
- point="org.blueberry.ui.services">
- <serviceFactory
- factoryClass="my::LevelServiceFactory">
- <service
- serviceClass="my::ILevelService">
- </service>
- </serviceFactory>
- </extension>
-</pre></p>
-<p>
-The <code>LevelServiceFactory</code> can return an <code>ILevelService</code> when it is requested from the <code>IServiceLocator</code>:
-<pre>
- berry::ILevelService::Pointer s = GetSite()->GetService(my::ILevelService::GetStaticClassName());
- std::cout << s->GetLevel();
-</pre>
-</p>
-<p>
-In this test example, the factory would instantiate three <code>ILevelService</code> implementations during the first call to <code>GetSite()->GetService(*)</code>. The global one in the workbench, one for the workbench window, and one for the site.
-</p>
- </documentation>
+
</annotation>
<annotation>
<appinfo>
<meta.section type="apiInfo"/>
</appinfo>
- <documentation>
- <p>
-Please see <code>org.eclipse.ui.services.AbstractServiceFactory</code>, <code>org.eclipse.ui.services.IDisposable</code>, and <code>org.eclipse.ui.services.IServiceWithSources</code> for more information.
-</p>
- </documentation>
+
</annotation>
<annotation>
<appinfo>
<meta.section type="copyright"/>
</appinfo>
- <documentation>
- Copyright (c) 2007 IBM Corporation and others.<br>
-All rights reserved. This program and the accompanying materials are made
-available under the terms of the Eclipse Public License v1.0 which accompanies
-this distribution, and is available at <a
-href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>
- </documentation>
+
</annotation>
</schema>
diff --git a/Plugins/org.blueberry.ui.qt/schema/tweaklets.exsd b/Plugins/org.blueberry.ui.qt/schema/tweaklets.exsd
index 6d4f0a67d4..445d756415 100644
--- a/Plugins/org.blueberry.ui.qt/schema/tweaklets.exsd
+++ b/Plugins/org.blueberry.ui.qt/schema/tweaklets.exsd
@@ -1,145 +1,106 @@
<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.blueberry.ui" xmlns="http://www.w3.org/2001/XMLSchema">
<annotation>
<appinfo>
<meta.schema plugin="org.blueberry.ui" id="tweaklets" name="Tweaklets"/>
</appinfo>
- <documentation>
- This extension point is used to define tweaklets. A tweaklet is anything that can be used to tweak the look and feel of the Workbench.
- </documentation>
+
</annotation>
<element name="extension">
<annotation>
<appinfo>
<meta.element />
</appinfo>
</annotation>
<complexType>
<choice minOccurs="0" maxOccurs="unbounded">
<element ref="tweaklet"/>
</choice>
<attribute name="point" type="string" use="required">
<annotation>
- <documentation>
- </documentation>
</annotation>
</attribute>
<attribute name="id" type="string">
<annotation>
- <documentation>
- </documentation>
</annotation>
</attribute>
<attribute name="name" type="string">
<annotation>
- <documentation>
- </documentation>
<appinfo>
<meta.attribute translatable="true"/>
</appinfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="tweaklet">
<annotation>
<appinfo>
<meta.element labelAttribute="name" icon="icon"/>
</appinfo>
</annotation>
<complexType>
<attribute name="id" type="string" use="required">
<annotation>
- <documentation>
- a unique name that will be used to identify this tweaklet
- </documentation>
+
</annotation>
</attribute>
<attribute name="name" type="string" use="required">
<annotation>
- <documentation>
- a translatable name that will be used in the UI for this tweaklet
- </documentation>
+
<appinfo>
<meta.attribute translatable="true"/>
</appinfo>
</annotation>
</attribute>
<attribute name="description" type="string">
<annotation>
- <documentation>
- a translatable short description of this tweaklet, to be used in the UI
- </documentation>
+
<appinfo>
<meta.attribute translatable="true"/>
</appinfo>
</annotation>
</attribute>
<attribute name="definition" type="string">
<annotation>
- <documentation>
- an identifier of the tweaklet definition in the workbench, typically a fully qualified type name without colons
- </documentation>
+
</annotation>
</attribute>
<attribute name="implementation" type="string">
<annotation>
- <documentation>
- an identifier of the tweaklet implementation provided by the extender, typically a fully qualified class name
- </documentation>
+
</annotation>
</attribute>
</complexType>
</element>
<annotation>
<appinfo>
<meta.section type="apiInfo"/>
</appinfo>
- <documentation>
- The following is an example tweaklet:
-<p>
-<pre>
- <extension point="org.blueberry.ui.tweaklets">
- <tweaklet
- id="org.blueberry.ui.tweaklets.ConcreteXYZTweaklet"
- name="XYZ Tweaklet"
- description="Short description of the tweak"
- definition="berryAbstractXYZTweaklet"
- implementation="berry::ConcreteXYZTweaklet"/>
- </extension>
-</pre>
-</p>
- </documentation>
+
</annotation>
<annotation>
<appinfo>
<meta.section type="since"/>
</appinfo>
- <documentation>
- Typically, although not required, the value of the <samp>definition</samp> attribute is the
-fully qualified name without colons of an abstract class defined by the
-workbench, and the value of the <samp>implementation</samp> attribute is the
-fully qualified name of a non-abstract class provided by the extending plug-in.
- </documentation>
+
</annotation>
<annotation>
<appinfo>
<meta.section type="implementation"/>
</appinfo>
- <documentation>
- Tweaklets are usually used to specialize the workbench for a specific GUI toolkit.
- </documentation>
+
</annotation>
</schema>
diff --git a/Plugins/org.blueberry.ui.qt/schema/views.exsd b/Plugins/org.blueberry.ui.qt/schema/views.exsd
index 3ebdced734..93aa1b52df 100644
--- a/Plugins/org.blueberry.ui.qt/schema/views.exsd
+++ b/Plugins/org.blueberry.ui.qt/schema/views.exsd
@@ -1,311 +1,212 @@
<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.blueberry.ui" xmlns="http://www.w3.org/2001/XMLSchema">
<annotation>
<appinfo>
<meta.schema plugin="org.blueberry.ui" id="views" name="Views"/>
</appinfo>
- <documentation>
- This extension point is used to define additional views
-for the workbench. A view is a visual component
-within a workbench page. It is typically used to
-navigate a hierarchy of information (like the workspace),
-open an editor, or display properties for
-the active editor. The user can make a view
-visible from the Window > Show View menu or close it from the
-view local title bar.
-<p>
-In order to reduce the visual clutter in the Show View Dialog, views should be grouped using categories.
- </documentation>
+
</annotation>
<element name="extension">
<annotation>
<appinfo>
<meta.element />
</appinfo>
</annotation>
<complexType>
<choice minOccurs="0" maxOccurs="unbounded">
<element ref="category"/>
<element ref="view"/>
<element ref="stickyView"/>
</choice>
<attribute name="point" type="string" use="required">
<annotation>
- <documentation>
- a fully qualified identifier of the target extension point
- </documentation>
+
</annotation>
</attribute>
<attribute name="id" type="string">
<annotation>
- <documentation>
- an optional identifier of the extension instance
- </documentation>
+
</annotation>
</attribute>
<attribute name="name" type="string">
<annotation>
- <documentation>
- an optional name of the extension instance
- </documentation>
+
<appinfo>
<meta.attribute translatable="true"/>
</appinfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="category">
<complexType>
<attribute name="id" type="string" use="required">
<annotation>
- <documentation>
- a unique name that will be used to identify this category
- </documentation>
+
</annotation>
</attribute>
<attribute name="name" type="string" use="required">
<annotation>
- <documentation>
- a translatable name that will be used in the UI for this category
- </documentation>
+
<appinfo>
<meta.attribute translatable="true"/>
</appinfo>
</annotation>
</attribute>
<attribute name="parentCategory" type="string">
<annotation>
- <documentation>
- an optional path composed of category IDs separated by '/'. This
-allows the creation of a hierarchy of categories.
- </documentation>
+
<appinfo>
<meta.attribute kind="identifier" basedOn="org.blueberry.ui.views/category/@id"/>
</appinfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="view">
<complexType>
<sequence>
<element ref="description" minOccurs="0" maxOccurs="1"/>
<element ref="keywordReference" minOccurs="0" maxOccurs="unbounded"/>
</sequence>
<attribute name="id" type="string" use="required">
<annotation>
- <documentation>
- a unique name that will be used to identify this view
- </documentation>
+
</annotation>
</attribute>
<attribute name="name" type="string" use="required">
<annotation>
- <documentation>
- a translatable name that will be used in the UI for this view
- </documentation>
+
<appinfo>
<meta.attribute translatable="true"/>
</appinfo>
</annotation>
</attribute>
<attribute name="category" type="string">
<annotation>
- <documentation>
- an optional attribute that is composed of the category IDs separated
-by '/'. Each referenced category must be declared in a corresponding category element.
- </documentation>
+
<appinfo>
<meta.attribute kind="identifier" basedOn="org.blueberry.ui.views/category/@id"/>
</appinfo>
</annotation>
</attribute>
<attribute name="class" type="string" use="required">
<annotation>
- <documentation>
- a fully qualified name of the class that implements
-<samp>berry::IViewPart</samp>. A common practice
-is to subclass <samp>berry::ViewPart</samp> or <samp>berry::QtViewPart</samp>
-in order to inherit the default functionality.
- </documentation>
+
<appinfo>
<meta.attribute kind="java" basedOn="berryViewPart:"/>
</appinfo>
</annotation>
</attribute>
<attribute name="icon" type="string">
<annotation>
- <documentation>
- a relative name of the icon that will
-be associated with the view.
- </documentation>
+
<appinfo>
<meta.attribute kind="resource"/>
</appinfo>
</annotation>
</attribute>
<attribute name="fastViewWidthRatio" type="string">
<annotation>
- <documentation>
- the percentage of the width of the workbench that the view will take up as an active fast view.
-This must be defined as a floating point value and lie between 0.05 and 0.95.
-If no value is supplied, a default ratio will be used.
- </documentation>
+
</annotation>
</attribute>
<attribute name="allowMultiple" type="boolean">
<annotation>
- <documentation>
- flag indicating whether this view allows multiple instances to be created using IWorkbenchPage::ShowView(QString id, QString secondaryId). The default is false.
- </documentation>
+
</annotation>
</attribute>
<attribute name="restorable" type="boolean" use="default" value="true">
<annotation>
- <documentation>
- flag indicating whether this view allows to be restored upon workbench restart. If set to false, the view will not be open after a workbench restart. The default is true.
- </documentation>
+
</annotation>
</attribute>
</complexType>
</element>
<element name="description" type="string">
<annotation>
<appinfo>
<meta.element translatable="true"/>
</appinfo>
- <documentation>
- an optional subelement whose body should contain text providing a short description of the view.
- </documentation>
+
</annotation>
</element>
<element name="stickyView">
<annotation>
- <documentation>
- A sticky view is a view that will appear by default across all perspectives in a window once it is opened. Its initial placement is governemed by the location attribute, but nothing prevents it from being moved or closed by the user. Use of this element will only cause a placeholder for the view to be created, it will not show the view. Please note that usage of this element should be done with great care and should only be applied to views that truely have a need to live across perspectives.
- </documentation>
+
</annotation>
<complexType>
<attribute name="id" type="string" use="required">
<annotation>
- <documentation>
- the id of the view to be made sticky.
- </documentation>
+
<appinfo>
<meta.attribute kind="identifier" basedOn="org.blueberry.ui.views/view/@id"/>
</appinfo>
</annotation>
</attribute>
<attribute name="location">
<annotation>
- <documentation>
- optional attribute that specifies the location of the sticky view relative to the editor area. If absent, the view will be docked to the right of the editor area.
- </documentation>
+
</annotation>
<simpleType>
<restriction base="string">
<enumeration value="RIGHT">
</enumeration>
<enumeration value="LEFT">
</enumeration>
<enumeration value="TOP">
</enumeration>
<enumeration value="BOTTOM">
</enumeration>
</restriction>
</simpleType>
</attribute>
<attribute name="closeable" type="boolean">
<annotation>
- <documentation>
- optional attribute that specifies wether the view should be closeable. If absent it will be closeable.
- </documentation>
+
</annotation>
</attribute>
<attribute name="moveable" type="boolean">
<annotation>
- <documentation>
- optional attribute that specifies wether the view should be moveable. If absent it will be moveable.
- </documentation>
+
</annotation>
</attribute>
</complexType>
</element>
<annotation>
<appinfo>
<meta.section type="examples"/>
</appinfo>
- <documentation>
- The following is an example of the extension point:
-<p>
-<pre>
- <extension point="org.blueberry.ui.views">
- <category
- id="com.xyz.views.XYZviews"
- name="XYZ"/>
- <view
- id="com.xyz.views.XYZView"
- name="XYZ View"
- category="com.xyz.views.XYZviews"
- class="ns::XYZView"
- icon="icons/XYZ.gif"/>
- </extension>
-</pre>
-</p>
-The following is an example of a sticky view declaration:
-<p>
-<pre>
- <extension point="org.blueberry.ui.views">
- <stickyView
- id="com.xyz.views.XYZView" />
- </extension>
-</pre>
-</p>
- </documentation>
+
</annotation>
<annotation>
<appinfo>
<meta.section type="apiInfo"/>
</appinfo>
- <documentation>
- The value of the <samp>class</samp> attribute must be a
-fully qualified name of the class that implements
-<samp>berry::IViewPart</samp>. It is common
-practice to subclass <samp>berry::ViewPart</samp>
-or <samp>berry::QtViewPart<samp> when developing a new view.
- </documentation>
+
</annotation>
<annotation>
<appinfo>
<meta.section type="implementation"/>
</appinfo>
- <documentation>
- The BlueBerry Platform provides a number of standard views. From the user point of view, these views are no different from any other view provided by the plug-ins. All the views can be shown from the "Show View" submenu of the "Window" menu. The position of a view is persistent: it is saved when the view is closed and restored when the view is reopened in a single session. The position is also persisted between workbench sessions.
- </documentation>
+
</annotation>
<annotation>
<appinfo>
<meta.section type="copyright"/>
</appinfo>
- <documentation>
- Copyright (c) 2002, 2005 IBM Corporation and others.<br>
-All rights reserved. This program and the accompanying materials are made
-available under the terms of the Eclipse Public License v1.0 which accompanies
-this distribution, and is available at <a
-href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>
- </documentation>
+
</annotation>
</schema>
diff --git a/Plugins/org.mitk.core.ext/schema/inputdevice.exsd b/Plugins/org.mitk.core.ext/schema/inputdevice.exsd
index 6fc8bb6533..cc2159a250 100644
--- a/Plugins/org.mitk.core.ext/schema/inputdevice.exsd
+++ b/Plugins/org.mitk.core.ext/schema/inputdevice.exsd
@@ -1,153 +1,113 @@
<?xml version='1.0' encoding='UTF-8'?>
<schema targetNamespace="org.mitk.core.ext" xmlns="http://www.w3.org/2001/XMLSchema">
<annotation>
<appinfo>
<meta.schema plugin="org.mitk.core.ext" id="inputdevices" name="Input Devices"/>
</appinfo>
- <documentation>
- This extension point is used to define additional input devices.
- </documentation>
+
</annotation>
<element name="extension">
<annotation>
<appinfo>
<meta.element />
</appinfo>
</annotation>
<complexType>
<sequence>
<element ref="inputdevice" minOccurs="0" maxOccurs="unbounded"/>
</sequence>
<attribute name="point" type="string" use="required">
<annotation>
- <documentation>
- a fully qualified identifier of the target extension point
- </documentation>
+
</annotation>
</attribute>
<attribute name="id" type="string">
<annotation>
- <documentation>
- an optional identifier of the extension instance
- </documentation>
+
</annotation>
</attribute>
<attribute name="name" type="string">
<annotation>
- <documentation>
- an optional name of the extension instance
- </documentation>
+
<appinfo>
<meta.attribute translatable="true"/>
</appinfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="inputdevice">
<annotation>
<appinfo>
<meta.element />
</appinfo>
</annotation>
<complexType>
<sequence>
<element ref="description" minOccurs="0" maxOccurs="1"/>
</sequence>
<attribute name="id" type="string" use="required">
<annotation>
- <documentation>
- the identifier of the input device
- </documentation>
+
</annotation>
</attribute>
<attribute name="name" type="string">
<annotation>
- <documentation>
- an optional name of the input device
- </documentation>
+
<appinfo>
<meta.attribute translatable="true"/>
</appinfo>
</annotation>
</attribute>
<attribute name="class" type="string" use="required">
<annotation>
- <documentation>
- a fully qualified name of the class that implements
-<samp>mitk::IInputDevice</samp>.
- </documentation>
+
<appinfo>
<meta.attribute kind="java" basedOn="mitk::IInputDevice"/>
</appinfo>
</annotation>
</attribute>
</complexType>
</element>
<element name="description" type="string">
<annotation>
<appinfo>
<meta.element translatable="true"/>
</appinfo>
- <documentation>
- an optional subelement whose body should contain text providing a short description of the input device.
- </documentation>
+
</annotation>
</element>
<annotation>
<appinfo>
<meta.section type="examples"/>
</appinfo>
- <documentation>
- The following is an example of the extension point:
-<p>
-<pre>
- <extension point="org.mitk.core.ext.inputdevices">
- <inputdevice
- id="com.xyz.inputdevice.XYZDevice"
- name="XYZ Device"
- class="ns::XYZDevice" >
- <description>My new 20-dimensional input device</description>
- </inputdevice>
- </extension>
-</pre>
-</p>
- </documentation>
+
</annotation>
<annotation>
<appinfo>
<meta.section type="apiInfo"/>
</appinfo>
- <documentation>
- The value of the <samp>class</samp> attribute must be a
-fully qualified name of the class that implements
-<samp>mitk::IInputDevice</samp>.
- </documentation>
+
</annotation>
<annotation>
<appinfo>
<meta.section type="implementation"/>
</appinfo>
- <documentation>
- The MITK Platform can handle multiple distinct input devices by...
- </documentation>
+
</annotation>
<annotation>
<appinfo>
<meta.section type="copyright"/>
</appinfo>
- <documentation>
- Copyright (c) German Cancer Research Center (DKFZ)<br>
-All rights reserved.
- </documentation>
+
</annotation>
</schema>
diff --git a/Plugins/org.mitk.gui.qt.application/documentation/doxygen/modules.dox b/Plugins/org.mitk.gui.qt.application/documentation/doxygen/modules.dox
index c89ec4876f..fcf22312bd 100755
--- a/Plugins/org.mitk.gui.qt.application/documentation/doxygen/modules.dox
+++ b/Plugins/org.mitk.gui.qt.application/documentation/doxygen/modules.dox
@@ -1,23 +1,23 @@
/**
\defgroup org_mitk_gui_qt_application org.mitk.gui.qt.application
\ingroup MITKPlugins
\brief Provides utility classes for MITK application developers.
This plug-in provides QAction derived classes for common application actions
like opening files and closing the application. It also provides a central
preferences dialog.
The plug-in is usually used as a dependency for plug-ins contributing a
- \ref xp_org_blueberry_osgi_applications extension and providing workbench advisor
+ \ref BlueBerryExtPointsIndex_PlatformRuntime_App extension and providing workbench advisor
classes which customize the main application menu and toolbar.
*/
/**
\defgroup org_mitk_gui_qt_application_internal Internal
\ingroup org_mitk_gui_qt_application
\brief This subcategory includes the internal classes of the org.mitk.gui.qt.application 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/Plugins/org.mitk.gui.qt.common.legacy/src/QmitkFunctionality.h b/Plugins/org.mitk.gui.qt.common.legacy/src/QmitkFunctionality.h
index 0565457e63..fae0b394ce 100755
--- a/Plugins/org.mitk.gui.qt.common.legacy/src/QmitkFunctionality.h
+++ b/Plugins/org.mitk.gui.qt.common.legacy/src/QmitkFunctionality.h
@@ -1,396 +1,397 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QMITKFUNCTIONALITY_H_
#define QMITKFUNCTIONALITY_H_
//# blueberry stuff
#include <berryQtViewPart.h>
#include <berryIPreferencesService.h>
#include <berryISelectionListener.h>
#include <berryIPreferences.h>
//# mitk stuff
#include <org_mitk_gui_qt_common_legacy_Export.h>
#include "mitkDataNodeSelection.h"
#include <mitkDataStorage.h>
#include <mitkIDataStorageService.h>
#include <mitkIDataStorageReference.h>
#include <QmitkAbstractMultiWidget.h>
// CTK Includes
#include <ctkServiceTracker.h>
//# forward declarations
namespace mitk {
class DataNode;
struct IDataStorageService;
}
namespace berry {
struct IBerryPreferences;
}
class QmitkFunctionalitySelectionProvider;
///
/// \ingroup org_mitk_gui_qt_common_legacy
///
/// \class QmitkFunctionality
///
/// \brief The base class of all MITK related blueberry views (~ in the old version of MITK, this was called "Functionality")
///
/// QmitkFunctionality provides several convenience methods that eases the introduction of a new view:
///
/// <ol>
/// <li> Access to the DataStorage (~ the shared data repository)
/// <li> Access to the MultiWidget
/// <li> Access to and update notification for the functionality/view preferences
/// <li> Access to and update notification for the current DataNode selection / to DataNode selection events send through the SelectionService
/// <li> Methods to send DataNode selections through the SelectionService
/// <li> Some events for unproblematic inter-View communication (e.g. when to add/remove interactors)
/// <li> Some minor important convenience methods (like changing the mouse cursor/exception handling)
/// </ol>
///
/// Please use the Activated/Deactivated method to add/remove interactors, disabling multiwidget crosshair or anything which may
/// "affect" other functionalities. For further reading please have a look at QmitkFunctionality::IsExclusiveFunctionality().
///
class MITK_QT_COMMON_LEGACY QmitkFunctionality : public berry::QtViewPart
{
//# public virtual methods which can be overwritten
public:
///
/// Creates smartpointer typedefs
///
berryObjectMacro(QmitkFunctionality);
///
/// Nothing to do in the standard ctor. <b>Initiliaze your GUI in CreateQtPartControl(QWidget*)</b>
/// \see berry::QtViewPart::CreateQtPartControl(QWidget*)
///
QmitkFunctionality();
///
/// Disconnects all standard event listeners
///
~QmitkFunctionality() override;
///
/// Called, when the WorkbenchPart gets closed
/// by the user directly or by closing the whole
/// app (e.g. for removing event listeners)
///
virtual void ClosePart();
///
/// Called when the selection in the workbench changed
///
virtual void OnSelectionChanged(std::vector<mitk::DataNode*> /*nodes*/);
///
/// Called when the preferences object of this view changed.
/// \see GetPreferences()
///
virtual void OnPreferencesChanged(const berry::IBerryPreferences*);
///
/// Make this view manage multiple DataStorage. If set to true GetDataStorage()
/// will return the currently active DataStorage (and not the default one).
/// \see GetDataStorage()
///
void SetHandleMultipleDataStorages(bool multiple);
///
/// \return true if this view handles multiple DataStorages, false otherwise
///
bool HandlesMultipleDataStorages() const;
///
/// Called when a MultiWidget is available. Should not be used anymore, see GetActiveMultiWidget()
/// \see GetActiveMultiWidget()
///
virtual void MultiWidgetAvailable(QmitkAbstractMultiWidget& multiWidget);
///
/// Called when a MultiWidget is available. Should not be used anymore, see GetActiveMultiWidget()
/// \see GetActiveMultiWidget()
///
virtual void MultiWidgetClosed(QmitkAbstractMultiWidget& multiWidget);
///
/// Called when no MultiWidget is available anymore. Should not be used anymore, see GetActiveMultiWidget()
/// \see GetActiveMultiWidget()
///
virtual void MultiWidgetNotAvailable();
///
/// Only called when IsExclusiveFunctionality() returns true.
/// \see IsExclusiveFunctionality()
///
virtual void Activated();
///
/// \return true if this view is currently activated, false otherwise
///
bool IsActivated() const;
///
/// Only called when IsExclusiveFunctionality() returns true.
/// \see IsExclusiveFunctionality()
///
virtual void Deactivated();
///
/// Some functionalities need to add special interactors, removes the crosshair from the multiwidget, etc.
/// In this case the functionality has to tidy up when changing to another functionality
/// which also wants to change the "default configuration". In the old Qt3-based
/// version of MITK, two functionalities could never be opened at the same time so that the
/// methods Activated() and Deactivated() were the right place for the functionalitites to
/// add/remove their interactors, etc. This is still true for the new MITK Workbench,
/// but as there can be several functionalities visible at the same time, the behaviour concerning
/// when Activated() and Deactivated() are called has changed:
///
/// 1. Activated() and Deactivated() are only called if IsExclusiveFunctionality() returns true
///
/// 2. If only one standalone functionality is or becomes visible, Activated() will be called on that functionality
///
/// 3. If two or more standalone functionalities are visible,
/// Activated() will be called on the functionality that receives focus, Deactivated() will be called
/// on the one that looses focus, gets hidden or closed
///
///
/// As a consequence of 1. if you overwrite IsExclusiveFunctionality() and let it return false, you
/// signalize the MITK Workbench that this functionality does nothing to the "default configuration"
/// and can easily be visible while other functionalities are also visible.
///
/// By default the method returns true.
///
/// \return true if this functionality is meant to work as a standalone view, false otherwise
///
virtual bool IsExclusiveFunctionality() const;
///
/// Informs other parts of the workbench that node is selected via the blueberry selection service.
///
void FireNodeSelected(mitk::DataNode* node);
///
/// Informs other parts of the workbench that the nodes are selected via the blueberry selection service.
///
void FireNodesSelected(std::vector<mitk::DataNode*> nodes);
///
/// Called when this functionality becomes visible ( no matter what IsExclusiveFunctionality() returns )
///
virtual void Visible();
///
/// \return true if this view is currently visible, false otherwise
///
bool IsVisible() const;
///
/// Called when this functionality is hidden ( no matter what IsExclusiveFunctionality() returns )
///
virtual void Hidden();
//# protected virtual methods which can be overwritten
protected:
///
/// Called when a DataStorage Add event was thrown. May be reimplemented
/// by deriving classes.
///
virtual void NodeAdded(const mitk::DataNode* node);
///
/// Called when a DataStorage Changed event was thrown. May be reimplemented
/// by deriving classes.
///
virtual void NodeChanged(const mitk::DataNode* /*node*/);
///
/// Called when a DataStorage Remove event was thrown. May be reimplemented
/// by deriving classes.
///
virtual void NodeRemoved(const mitk::DataNode* node);
///
/// Called when a DataStorage add *or* remove *or* change event was thrown. May be reimplemented
/// by deriving classes.
///
virtual void DataStorageChanged();
///
/// \return the selection of the currently active part of the workbench or an empty vector
/// if nothing is selected
///
std::vector<mitk::DataNode*> GetCurrentSelection() const;
///
/// Returns the current selection made in the datamanager bundle or an empty vector
/// if nothing`s selected or if the bundle does not exist
///
std::vector<mitk::DataNode*> GetDataManagerSelection() const;
///
/// Returns the Preferences object for this Functionality.
/// <b>Important</b>: When refering to this preferences, e.g. in a PreferencePage: The ID
/// for this preferences object is "/<VIEW-ID>", e.g. "/org.mitk.views.datamanager"
///
berry::IPreferences::Pointer GetPreferences() const;
///
/// Returns the default <b>or</b> the currently active DataStorage if m_HandlesMultipleDataStorages
/// is set to true
/// \see SetHandleMultipleDataStorages(bool)
/// \see HandlesMultipleDataStorages()
///
mitk::DataStorage::Pointer GetDataStorage() const;
///
/// \return always returns the default DataStorage
///
mitk::DataStorage::Pointer GetDefaultDataStorage() const;
mitk::IDataStorageReference::Pointer GetDataStorageReference() const;
///
/// Returns the default and active MultiWidget.
/// \param reCreateWidget a boolean flag to en-/disable the attempt to re-create the StdWidget
/// <b>If there is not MultiWidget yet a new one is
/// created in this method when called with default parameter!</b>
///
QmitkAbstractMultiWidget* GetActiveMultiWidget( bool reCreateWidget = true);
///
/// Outputs an error message to the console and displays a message box containing
/// the exception description.
/// \param e the exception which should be handled
+ /// \param parent
/// \param showDialog controls, whether additionally a message box should be
/// displayed to inform the user that something went wrong
///
void HandleException( std::exception& e, QWidget* parent = nullptr, bool showDialog = true ) const;
///
/// Calls HandleException ( std::exception&, QWidget*, bool ) internally
/// \see HandleException ( std::exception&, QWidget*, bool )
///
void HandleException( const char* str, QWidget* parent = nullptr, bool showDialog = true ) const;
///
/// Convenient method to set and reset a wait cursor ("hourglass")
///
void WaitCursorOn();
///
/// Convenient method to restore the standard cursor
///
void WaitCursorOff();
///
/// Convenient method to set and reset a busy cursor
///
void BusyCursorOn();
///
/// Convenient method to restore the standard cursor
///
void BusyCursorOff();
///
/// Convenient method to restore the standard cursor
///
void RestoreOverrideCursor();
//# other public methods which should not be overwritten
public:
///
/// Creates a scroll area for this view and calls CreateQtPartControl then
///
void CreatePartControl(QWidget* parent) override;
///
/// Called when this view receives the focus. Same as Activated()
/// \see Activated()
///
void SetFocus() override;
///
/// Called when a DataStorage Add Event was thrown. Sets
/// m_InDataStorageChanged to true and calls NodeAdded afterwards.
/// \see m_InDataStorageChanged
///
void NodeAddedProxy(const mitk::DataNode* node);
///
/// Called when a DataStorage remove event was thrown. Sets
/// m_InDataStorageChanged to true and calls NodeRemoved afterwards.
/// \see m_InDataStorageChanged
///
void NodeRemovedProxy(const mitk::DataNode* node);
///
/// Called when a DataStorage changed event was thrown. Sets
/// m_InDataStorageChanged to true and calls NodeChanged afterwards.
/// \see m_InDataStorageChanged
///
void NodeChangedProxy(const mitk::DataNode* node);
///
/// Toggles the visible flag m_Visible
///
void SetVisible(bool visible);
///
/// Toggles the activated flag m_Activated
///
void SetActivated(bool activated);
///
/// Called, when the WorkbenchPart gets closed for removing event listeners
/// Internally this method calls ClosePart after it removed the listeners registered
/// by QmitkFunctionality. By having this proxy method the user does not have to
/// call QmitkFunctionality::ClosePart() when overwriting ClosePart()
///
void ClosePartProxy();
//# other protected methods which should not be overwritten (or which are deprecated)
protected:
///
/// Called immediately after CreateQtPartControl().
/// Here standard event listeners for a QmitkFunctionality are registered
///
void AfterCreateQtPartControl();
///
/// code to activate the last visible functionality
///
void ActivateLastVisibleFunctionality();
///
/// reactions to selection events from data manager (and potential other senders)
///
void BlueBerrySelectionChanged(const berry::IWorkbenchPart::Pointer& sourcepart, const berry::ISelection::ConstPointer& selection);
///
/// Converts a mitk::DataNodeSelection to a std::vector<mitk::DataNode*> (possibly empty
///
std::vector<mitk::DataNode*> DataNodeSelectionToVector(mitk::DataNodeSelection::ConstPointer currentSelection) const;
//# protected fields
protected:
///
/// helper stuff to observe BlueBerry selections
///
friend struct berry::SelectionChangedAdapter<QmitkFunctionality>;
///
/// Saves the parent of this view (this is the scrollarea created in CreatePartControl(QWidget*)
/// \see CreatePartControl(QWidget*)
///
QWidget* m_Parent;
///
/// Saves if this view is the currently active one.
///
bool m_Active;
///
/// Saves if this view is visible
///
bool m_Visible;
//# private fields:
private:
///
/// Holds the current selection (selection made by this Functionality !!!)
///
QmitkFunctionalitySelectionProvider* m_SelectionProvider;
///
/// object to observe BlueBerry selections
///
QScopedPointer<berry::ISelectionListener> m_BlueBerrySelectionListener;
ctkServiceTracker<mitk::IDataStorageService*> m_DataStorageServiceTracker;
///
/// Saves if this view handles multiple datastorages
///
bool m_HandlesMultipleDataStorages;
///
/// Saves if this class is currently working on DataStorage changes.
/// This is a protector variable to avoid recursive calls on event listener functions.
bool m_InDataStorageChanged;
///
/// saves all visible functionalities
///
std::set<std::string> m_VisibleFunctionalities;
};
#endif /*QMITKFUNCTIONALITY_H_*/
diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractView.h b/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractView.h
index 9cd2453c30..6fb4f65f85 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractView.h
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractView.h
@@ -1,362 +1,363 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QMITKABSTRACTVIEW_H_
#define QMITKABSTRACTVIEW_H_
//# blueberry stuff
#include <berryQtViewPart.h>
#include <berryIPreferencesService.h>
#include <berryISelectionListener.h>
#include <berryIPreferences.h>
//# mitk stuff
#include <org_mitk_gui_qt_common_Export.h>
#include "mitkDataNodeSelection.h"
#include "mitkIRenderWindowPart.h"
#include <mitkWorkbenchUtil.h>
#include <mitkDataStorage.h>
#include <mitkRenderingManager.h>
#include <mitkIDataStorageReference.h>
#include <QItemSelectionModel>
namespace mitk {
class DataNode;
}
namespace berry {
struct IBerryPreferences;
}
class QmitkAbstractViewPrivate;
class QmitkAbstractViewSelectionProvider;
/**
* \ingroup org_mitk_gui_qt_common
*
* \brief A convenient base class for MITK related BlueBerry Views.
*
* QmitkAbstractView provides several convenience methods that ease the introduction of a new view:
*
* <ol>
* <li> Access to the DataStorage (~ the shared data repository)
* <li> Access to the active IRenderWindowPart
* <li> Access to and update notification for the view's preferences
* <li> Access to and update notification for the current DataNode selection / to DataNode selection events send through the SelectionService
* <li> Access to and update notification for DataNode events (added/removed/modified)
* <li> Methods to send DataNode selections through the SelectionService
* <li> Some minor important convenience methods (like changing the mouse cursor/exception handling)
* </ol>
*
* Usually all MITK Views inherit from QmitkAbstractView to achieve a consistent Workbench behavior.
*
* When inheriting from QmitkAbstractView, you must implement the following methods:
* <ul>
* <li>void CreateQtPartControl(QWidget* parent)
* <li>void SetFocus()
* </ul>
*
* You may reimplement the following private virtual methods to customize your View's behavior:
* <ul>
* <li>void SetSelectionProvider()
* <li>QItemSelectionModel* GetDataNodeSelectionModel() const
* </ul>
*
* You may reimplement the following private virtual methods to be notified about certain changes:
* <ul>
* <li>void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer> &nodes)
* <li>void OnNullSelection(berry::IWorkbenchPart::Pointer part)
* <li>void OnPreferencesChanged(const berry::IBerryPreferences*)
* <li>void NodeAdded(const mitk::DataNode* node)
* <li>void NodeChanged(const mitk::DataNode* node)
* <li>void NodeRemoved(const mitk::DataNode* node)
* <li>void DataStorageModified()
* <li>void DataStorageChanged(mitk::IDataStorageReference::Pointer dsRef)
* </ul>
*
* \see mitk::ILifecycleAwarePart
* \see mitk::IZombieViewPart
* \see mitk::IRenderWindowPartListener
*/
class MITK_QT_COMMON QmitkAbstractView : public berry::QtViewPart
{
public:
/**
* Creates smartpointer typedefs
*/
berryObjectMacro(QmitkAbstractView);
/**
* Nothing to do in the standard ctor. <b>Initiliaze your GUI in CreateQtPartControl(QWidget*)</b>
* \see berry::QtViewPart::CreateQtPartControl(QWidget*)
*/
QmitkAbstractView();
/**
* Disconnects all standard event listeners
*/
~QmitkAbstractView() override;
protected:
/**
* Informs other parts of the workbench that node is selected via the blueberry selection service.
*
* \note This method should not be used if you have set your own selection provider via
* SetSelectionProvider() or your own QItemSelectionModel via GetDataNodeSelectionModel().
*/
void FireNodeSelected(mitk::DataNode::Pointer node);
/**
* Informs other parts of the workbench that the nodes are selected via the blueberry selection service.
*
* \note This method should not be used if you have set your own selection provider via
* SetSelectionProvider() or your own QItemSelectionModel via GetDataNodeSelectionModel().
*/
virtual void FireNodesSelected(const QList<mitk::DataNode::Pointer>& nodes);
/**
* \return The selection of the currently active part of the workbench or an empty list
* if there is no selection or if it is empty.
*
* \see IsCurrentSelectionValid
*/
QList<mitk::DataNode::Pointer> GetCurrentSelection() const;
/**
* Queries the state of the current selection.
*
* \return If the current selection is <code>nullptr</code>, this method returns
* <code>false</code> and <code>true</code> otherwise.
*/
bool IsCurrentSelectionValid() const;
/**
* Returns the current selection made in the datamanager bundle or an empty list
* if there is no selection or if it is empty.
*
* \see IsDataManagerSelectionValid
*/
QList<mitk::DataNode::Pointer> GetDataManagerSelection() const;
/**
* Queries the state of the current selection of the data manager view.
*
* \return If the current data manager selection is <code>nullptr</code>, this method returns
* <code>false</code> and <code>true</code> otherwise.
*/
bool IsDataManagerSelectionValid() const;
/**
* Sets the selection of the data manager view if available.
*
* \param selection The new selection for the data manager.
* \param flags The Qt selection flags for controlling the way how the selection is updated.
*/
void SetDataManagerSelection(const berry::ISelection::ConstPointer& selection,
QItemSelectionModel::SelectionFlags flags = QItemSelectionModel::ClearAndSelect) const;
/**
* Takes the current selection and sets it on the data manager. Only matching nodes in the
* data manager view will be selected.
*/
void SynchronizeDataManagerSelection() const;
/**
* Returns the Preferences object for this View.
* <b>Important</b>: When refering to this preferences, e.g. in a PreferencePage: The ID
* for this preferences object is "/<VIEW-ID>", e.g. "/org.mitk.views.datamanager"
*/
berry::IPreferences::Pointer GetPreferences() const;
/**
* Returns a reference to the currently active DataStorage.
*/
mitk::IDataStorageReference::Pointer GetDataStorageReference() const;
/**
* Returns the currently active DataStorage.
*/
mitk::DataStorage::Pointer GetDataStorage() const;
/**
* Returns the currently active mitk::IRenderWindowPart.
*
* \param strategies Strategies for returning a mitk::IRenderWindowPart instance if there
* is currently no active one.
* \return The active mitk::IRenderWindowPart.
*/
mitk::IRenderWindowPart* GetRenderWindowPart(mitk::WorkbenchUtil::IRenderWindowPartStrategies strategies = mitk::WorkbenchUtil::NONE) const;
/**
* Request an update of all render windows of the currently active IRenderWindowPart.
*
* \param requestType Specifies the type of render windows for which an update
* will be requested.
*/
void RequestRenderWindowUpdate(mitk::RenderingManager::RequestType requestType = mitk::RenderingManager::REQUEST_UPDATE_ALL);
/**
* Outputs an error message to the console and displays a message box containing
* the exception description.
* \param e the exception which should be handled
+ * \param parent
* \param showDialog controls, whether additionally a message box should be
* displayed to inform the user that something went wrong
*/
void HandleException( std::exception& e, QWidget* parent = nullptr, bool showDialog = true ) const;
/**
* Calls HandleException ( std::exception&, QWidget*, bool ) internally
* \see HandleException ( std::exception&, QWidget*, bool )
*/
void HandleException( const char* str, QWidget* parent = nullptr, bool showDialog = true ) const;
/**
* Convenient method to set and reset a wait cursor ("hourglass")
*/
void WaitCursorOn();
/**
* Convenient method to restore the standard cursor
*/
void WaitCursorOff();
/**
* Convenient method to set and reset a busy cursor
*/
void BusyCursorOn();
/**
* Convenient method to restore the standard cursor
*/
void BusyCursorOff();
/**
* Convenient method to restore the standard cursor
*/
void RestoreOverrideCursor();
private:
/**
* Reimplement this method to set a custom selection provider. This method is
* called once after CreateQtPartControl().
*
* The default implementation registers a QmitkDataNodeSelectionProvider with
* a QItemSelectionModel returned by GetDataNodeSelectionModel().
*/
virtual void SetSelectionProvider();
/**
* Reimplement this method to supply a custom Qt selection model. The custom
* model will be used with the default selection provider QmitkDataNodeSelectionProvider
* to inform the MITK Workbench about selection changes.
*
* If you reimplement this method, the methods FireNodeSelected() and FireNodesSelected()
* will have no effect. Use your custom selection model to notify the MITK Workbench
* about selection changes.
*
* The Qt item model used with the custom selection model must return mitk::DataNode::Pointer
* objects for model indexes when the role is QmitkDataNodeRole.
*/
virtual QItemSelectionModel* GetDataNodeSelectionModel() const;
/**
* Called when the selection in the workbench changed.
* May be reimplemented by deriving classes.
*
* \param part The source part responsible for the selection change.
* \param nodes A list of selected nodes.
*
* \see OnNullSelection
*/
virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer> &nodes);
/**
* Called when a <code>nullptr</code> selection occurs.
*
* \param part The source part responsible for the selection change.
*/
virtual void OnNullSelection(berry::IWorkbenchPart::Pointer part);
/**
* Called when the preferences object of this view changed.
* May be reimplemented by deriving classes.
*
* \see GetPreferences()
*/
virtual void OnPreferencesChanged(const berry::IBerryPreferences*);
/**
* Called when a DataStorage Add event was thrown. May be reimplemented
* by deriving classes.
*/
virtual void NodeAdded(const mitk::DataNode* node);
/**
* Called when a DataStorage Changed event was thrown. May be reimplemented
* by deriving classes.
*/
virtual void NodeChanged(const mitk::DataNode* node);
/**
* Called when a DataStorage Remove event was thrown. May be reimplemented
* by deriving classes.
*/
virtual void NodeRemoved(const mitk::DataNode* node);
/**
* Called when a DataStorage add *or* remove *or* change event from the currently active
* data storage is thrown.
*
* May be reimplemented by deriving classes.
*/
virtual void DataStorageModified();
/**
* Called when the currently active DataStorage changed.
* May be reimplemented by deriving classes.
*
* \param dsRef A reference to the new active DataStorage.
*/
virtual void DataStorageChanged(mitk::IDataStorageReference::Pointer dsRef);
/**
* Creates a scroll area for this view and calls CreateQtPartControl then
*/
void CreatePartControl(QWidget* parent) override;
/**
* Called immediately after CreateQtPartControl().
* Here standard event listeners for a QmitkAbstractView are registered
*/
void AfterCreateQtPartControl();
private:
friend class QmitkAbstractViewPrivate;
friend class QmitkViewCoordinator;
Q_DISABLE_COPY(QmitkAbstractView)
const QScopedPointer<QmitkAbstractViewPrivate> d;
};
#endif /*QMITKABSTRACTVIEW_H_*/
diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkMultiWidgetDecorationManager.h b/Plugins/org.mitk.gui.qt.common/src/QmitkMultiWidgetDecorationManager.h
index e48319e7bb..7b42bbe25a 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkMultiWidgetDecorationManager.h
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkMultiWidgetDecorationManager.h
@@ -1,140 +1,140 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QMITKMULTIWIDGETDECORATIONMANAGER_H
#define QMITKMULTIWIDGETDECORATIONMANAGER_H
#include <org_mitk_gui_qt_common_Export.h>
// mitk core
#include <mitkColorProperty.h>
// mitk annotation
#include <mitkLogoAnnotation.h>
// mitk qt widgets
#include <QmitkAbstractMultiWidget.h>
// berry
#include <berryIBerryPreferences.h>
// vtk
#include <vtkImageData.h>
#include <vtkSmartPointer.h>
// qt
#include <QString>
#include <QStringList>
/**
* @brief
*
*
*/
class MITK_QT_COMMON QmitkMultiWidgetDecorationManager
{
public:
QmitkMultiWidgetDecorationManager(QmitkAbstractMultiWidget* multiWidget);
enum class Colormap
{
BlackAndWhite = 0 // black background, white decoration
};
void DecorationPreferencesChanged(const berry::IBerryPreferences* preferences);
/**
* @brief Show or hide decorations like like colored borders or background, logos, menu widgets, logos and
* text annotations.
*
* \@par Show the decorations specified in decorations if true. Hide them, if not.
* \@par A list of decoration names. If empty, all supported decorations are affected.
*/
void ShowDecorations(bool show, const QStringList& decorations);
/**
* @brief Return if a specific decoration is visible.
*
* \return True, if the specified decoration is shown, false if not.
*/
bool IsDecorationVisible(const QString &decoration) const;
QStringList GetDecorations() const;
void SetupLogo(const char* path);
void ShowLogo(bool show);
bool IsLogoVisible() const;
void SetColormap(Colormap colormap);
void SetDecorationColor(const QString& widgetID, const mitk::Color& color);
void SetAllDecorationColors(const mitk::Color& color);
mitk::Color GetDecorationColor(const QString& widgetID) const;
void ShowColoredRectangle(const QString& widgetID, bool show);
void ShowAllColoredRectangles(bool show);
bool IsColoredRectangleVisible(const QString& widgetID) const;
bool AreAllColoredRectanglesVisible() const;
/**
* @brief Set a background color gradient for a specific render window.
*
* If two different input colors are used, a gradient background is generated.
*
* @param upper The color of the gradient background.
* @param lower The color of the gradient background.
* @param widgetID The widget identifier.
*/
void SetGradientBackgroundColors(const mitk::Color& upper, const mitk::Color& lower, const QString& widgetID);
/**
* @brief Set a background color gradient for all available render windows.
*
* If two different input colors are used, a gradient background is generated.
*
* @param upper The color of the gradient background.
* @param lower The color of the gradient background.
*/
void SetAllGradientBackgroundColors(const mitk::Color& upper, const mitk::Color& lower);
void FillAllGradientBackgroundColorsWithBlack();
void ShowGradientBackground(const QString& widgetID, bool show);
void ShowAllGradientBackgrounds(bool show);
/**
- * @rief Return a render window (widget) specific background color gradient
+ * @brief Return a render window (widget) specific background color gradient
*
* @param widgetID The widget identifier.
*
* @return A color gradient as a pair of colors.
* First entry: upper color value
* Second entry: lower color value
*/
std::pair<mitk::Color, mitk::Color> GetGradientBackgroundColors(const QString& widgetID) const;
bool IsGradientBackgroundOn(const QString& widgetID) const;
bool AreAllGradientBackgroundsOn() const;
void SetCornerAnnotationText(const QString& widgetID, const std::string& cornerAnnotation);
std::string GetCornerAnnotationText(const QString& widgetID) const;
void ShowCornerAnnotation(const QString& widgetID, bool show);
void ShowAllCornerAnnotations(bool show);
bool IsCornerAnnotationVisible(const QString& widgetID) const;
bool AreAllCornerAnnotationsVisible() const;
private:
vtkSmartPointer<vtkImageData> GetVtkLogo(const char* path);
void SetLogo(vtkSmartPointer<vtkImageData> vtkLogo);
QmitkAbstractMultiWidget* m_MultiWidget;
mitk::LogoAnnotation::Pointer m_LogoAnnotation;
};
#endif // QMITKMULTIWIDGETDECORATIONMANAGER_H
diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionDialog.h b/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionDialog.h
index c40dde3199..217e212b6d 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionDialog.h
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionDialog.h
@@ -1,146 +1,146 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QMITK_NODE_SELECTION_DIALOG_H
#define QMITK_NODE_SELECTION_DIALOG_H
#include "org_mitk_gui_qt_common_Export.h"
#include "ui_QmitkNodeSelectionDialog.h"
#include <mitkDataStorage.h>
#include <mitkWeakPointer.h>
#include <mitkNodePredicateBase.h>
#include "mitkIDataStorageInspectorProvider.h"
#include <QmitkAbstractDataStorageInspector.h>
#include <QDialog>
#include <QPushButton>
/**
* @class QmitkNodeSelectionDialog
* @brief A customized QDialog that displays different data storage inspectors and allows to
* set and get a current selection by selecting data nodes in the data storage inspectors.
*/
class MITK_QT_COMMON QmitkNodeSelectionDialog : public QDialog
{
Q_OBJECT
public:
explicit QmitkNodeSelectionDialog(QWidget* parent = nullptr, QString caption = "", QString hint = "");
/**
* @brief Set the data storage that will be used.
* The function iterates over the dialog's panels and sets the data storage of each panel accordingly.
* Each panel is a specific data storage inspector.
*
* @param dataStorage A pointer to the data storage to set.
*/
void SetDataStorage(mitk::DataStorage* dataStorage);
/**
* @brief Set the node predicate that will be used.
* The function iterates over the dialog's panels and sets the node predicate of each panel accordingly.
* Each panel is a specific data storage inspector.
*
* @param nodePredicate A pointer to node predicate.
*/
virtual void SetNodePredicate(const mitk::NodePredicateBase* nodePredicate);
const mitk::NodePredicateBase* GetNodePredicate() const;
using NodeList = QList<mitk::DataNode::Pointer>;
NodeList GetSelectedNodes() const;
/**
* @brief Helper function that is used to check the given selection for consistency.
* Returning an empty string assumes that everything is alright and the selection is valid.
* If the string is not empty, the content of the string will be used as error message.
*/
using SelectionCheckFunctionType = std::function<std::string(const NodeList &)>;
/**
* @brief A selection check function can be set. If set the dialog uses this function to check the made/set selection.
* If the selection is valid, everything is fine.
* If the selection is indicated as invalid, the dialog will display the selection check function error message.
*/
void SetSelectionCheckFunction(const SelectionCheckFunctionType &checkFunction);
bool GetSelectOnlyVisibleNodes() const;
using SelectionMode = QAbstractItemView::SelectionMode;
/**
* @brief Set the Qt selection mode (e.g. Single selection, multi selection).
* The function iterates over the dialog's panels and sets the Qt selection mode of each panel accordingly.
* Each panel is a concrete data storage inspector.
*
* @param mode The QAbstractItemView::SelectionMode to define the selection mode.
*/
void SetSelectionMode(SelectionMode mode);
SelectionMode GetSelectionMode() const;
Q_SIGNALS:
/**
* @brief A signal that will be emitted if the selected node has changed.
*
* @param nodes A list of data nodes that are newly selected.
*/
void CurrentSelectionChanged(NodeList nodes);
public Q_SLOTS:
/**
* @brief Set the selection modus to (not) include invisible nodes in the selection.
* The function iterates over the dialog's panels and sets the selection modus of each panel accordingly.
* Each panel is a concrete data storage inspector.
*
* @param selectOnlyVisibleNodes The bool value to define the selection modus.
*/
void SetSelectOnlyVisibleNodes(bool selectOnlyVisibleNodes);
/**
* @brief Set the currently selected nodes given a list of data nodes.
* The function iterates over the dialog's panels and sets the current selection of each panel accordingly.
* Each panel is a concrete data storage inspector.
*
- * @param nodes A list of data nodes that should be newly selected.
+ * @param selectedNodes A list of data nodes that should be newly selected.
*/
void SetCurrentSelection(NodeList selectedNodes);
protected Q_SLOTS:
void OnSelectionChanged(NodeList selectedNodes);
void OnFavoriteNodesButtonClicked();
void OnOK();
void OnCancel();
void OnDoubleClicked(const QModelIndex& index);
protected:
void SetErrorText(const std::string& checkResponse);
void AddPanel(const mitk::IDataStorageInspectorProvider* provider, const mitk::IDataStorageInspectorProvider::InspectorIDType &preferredID, bool &preferredFound, int &preferredIndex);
mitk::WeakPointer<mitk::DataStorage> m_DataStorage;
mitk::NodePredicateBase::ConstPointer m_NodePredicate;
bool m_SelectOnlyVisibleNodes;
NodeList m_SelectedNodes;
SelectionCheckFunctionType m_CheckFunction;
SelectionMode m_SelectionMode;
using PanelVectorType = std::vector<QmitkAbstractDataStorageInspector*>;
PanelVectorType m_Panels;
QPushButton* m_FavoriteNodesButton;
Ui_QmitkNodeSelectionDialog m_Controls;
};
#endif // QMITK_NODE_SELECTION_DIALOG_H