Renamed CLI files and class names to have more descriptive names.

Applications/ctkCommandLineModuleExplorer/ctkCLModuleExplorerMainWindow.cpp

@@ -22,16 +22,16 @@
 #include "ctkCLModuleExplorerMainWindow.h"
 #include "ui_ctkCLModuleExplorerMainWindow.h"
 
-#include <ctkModuleDescriptionValidator.h>
-#include <ctkModuleManager.h>
-#include <ctkModuleProcessFuture.h>
+#include <ctkCmdLineModuleXmlValidator.h>
+#include <ctkCmdLineModuleManager.h>
+#include <ctkCmdLineModuleProcessFuture.h>
 
 #include <QFile>
 #include <QBuffer>
 #include <QUiLoader>
 #include <QDebug>
 
-class ctkModuleDescriptionDefaultFactory : public ctkModuleDescriptionFactory
+class ctkCmdLineModuleDescriptionDefaultFactory : public ctkCmdLineModuleDescriptionFactory
 {
 public:
 
@@ -56,7 +56,7 @@ private:
     input.setData(xmlDescription);
     input.open(QIODevice::ReadOnly);
 
-    ctkModuleDescriptionValidator validator(&input);
+    ctkCmdLineModuleXmlValidator validator(&input);
     if (!validator.validateXSLTOutput())
     {
       qCritical() << validator.errorString();
@@ -82,7 +82,7 @@ private:
 ctkCLModuleExplorerMainWindow::ctkCLModuleExplorerMainWindow(QWidget *parent) :
   QMainWindow(parent),
   ui(new Ui::ctkCLModuleExplorerMainWindow),
-  factory(new ctkModuleDescriptionDefaultFactory),
+  factory(new ctkCmdLineModuleDescriptionDefaultFactory),
   moduleManager(factory)
 {
   ui->setupUi(this);
@@ -94,7 +94,7 @@ ctkCLModuleExplorerMainWindow::~ctkCLModuleExplorerMainWindow()
   delete factory;
 }
 
-void ctkCLModuleExplorerMainWindow::addModuleTab(const ctkModuleReference& moduleRef)
+void ctkCLModuleExplorerMainWindow::addModuleTab(const ctkCmdLineModuleReference& moduleRef)
 {
   if (moduleRef.widgetTree() == 0) return;
 
@@ -105,7 +105,7 @@ void ctkCLModuleExplorerMainWindow::addModuleTab(const ctkModuleReference& modul
 
 void ctkCLModuleExplorerMainWindow::addModule(const QString &location)
 {
-  ctkModuleReference ref = moduleManager.addModule(location);
+  ctkCmdLineModuleReference ref = moduleManager.addModule(location);
   if (ref.isValid())
   {
     addModuleTab(ref);
@@ -127,10 +127,10 @@ void ctkCLModuleExplorerMainWindow::on_actionRun_triggered()
 {
   qDebug() << "Creating module command line...";
 
-  QStringList cmdLineArgs = ctkModuleManager::createCommandLineArgs(ui->mainTabWidget->currentWidget());
+  QStringList cmdLineArgs = ctkCmdLineModuleManager::createCommandLineArgs(ui->mainTabWidget->currentWidget());
   qDebug() << cmdLineArgs;
 
-  ctkModuleReference moduleRef = mapTabToModuleRef[ui->mainTabWidget->currentIndex()];
+  ctkCmdLineModuleReference moduleRef = mapTabToModuleRef[ui->mainTabWidget->currentIndex()];
   if (!moduleRef.isValid())
   {
     qWarning() << "Invalid module reference";
@@ -138,7 +138,7 @@ void ctkCLModuleExplorerMainWindow::on_actionRun_triggered()
   }
 
   connect(&futureWatcher, SIGNAL(finished()), this, SLOT(futureFinished()));
-  ctkModuleProcessFuture future = moduleManager.run(moduleRef);
+  ctkCmdLineModuleProcessFuture future = moduleManager.run(moduleRef);
   futureWatcher.setFuture(future);
 }
 
@@ -149,7 +149,7 @@ void ctkCLModuleExplorerMainWindow::futureFinished()
   qDebug() << "stderr:" << futureWatcher.future().standardError();
 }
 
-ctkModuleReference ctkCLModuleExplorerMainWindow::moduleReference(int tabIndex)
+ctkCmdLineModuleReference ctkCLModuleExplorerMainWindow::moduleReference(int tabIndex)
 {
   return mapTabToModuleRef[tabIndex];
 }

Applications/ctkCommandLineModuleExplorer/ctkCLModuleExplorerMainWindow.h

@@ -24,9 +24,9 @@
 
 #include <QMainWindow>
 
-#include <ctkModuleManager.h>
+#include <ctkCmdLineModuleManager.h>
 
-class ctkModuleDescriptionDefaultFactory;
+class ctkCmdLineModuleDescriptionDefaultFactory;
 
 namespace Ui {
 class ctkCLModuleExplorerMainWindow;
@@ -51,19 +51,19 @@ protected Q_SLOTS:
 
 protected:
 
-  void addModuleTab(const ctkModuleReference& moduleRef);
+  void addModuleTab(const ctkCmdLineModuleReference& moduleRef);
 
-  ctkModuleReference moduleReference(int tabIndex);
+  ctkCmdLineModuleReference moduleReference(int tabIndex);
   
 private:
   Ui::ctkCLModuleExplorerMainWindow *ui;
 
-  ctkModuleDescriptionDefaultFactory* factory;
-  ctkModuleManager moduleManager;
+  ctkCmdLineModuleDescriptionDefaultFactory* factory;
+  ctkCmdLineModuleManager moduleManager;
 
-  QHash<int, ctkModuleReference> mapTabToModuleRef;
+  QHash<int, ctkCmdLineModuleReference> mapTabToModuleRef;
 
-  ctkModuleProcessFutureWatcher futureWatcher;
+  ctkCmdLineModuleProcessFutureWatcher futureWatcher;
 };
 
 #endif // CTKCLIPLUGINEXPLORERMAINWINDOW_H

Applications/ctkCommandLineModuleExplorer/ctkCommandLineModuleExplorerMain.cpp

@@ -31,7 +31,7 @@
 
 // CTK includes
 #include <ctkCommandLineParser.h>
-#include <ctkModuleDescriptionValidator.h>
+#include <ctkCmdLineModuleXmlValidator.h>
 
 #include "ctkCLModuleExplorerMainWindow.h"
 
@@ -79,7 +79,7 @@ int main(int argc, char** argv)
     }
     input.open(QIODevice::ReadOnly);
 
-    ctkModuleDescriptionValidator validator(&input);
+    ctkCmdLineModuleXmlValidator validator(&input);
     if (!validator.validate())
     {
       qCritical() << validator.errorString();
@@ -97,7 +97,7 @@ int main(int argc, char** argv)
   }
 
 
-  //ctkModuleDescription* descr = ctkModuleDescription::parse(&input);
+  //ctkCmdLineModuleDescription* descr = ctkCmdLineModuleDescription::parse(&input);
 
   ctkCLModuleExplorerMainWindow mainWindow;
 

Libs/CommandLineModules/CMakeLists.txt

@@ -14,36 +14,26 @@ set(KIT_export_directive "CTK_CMDLINEMODULE_EXPORT")
 
 # Source files
 set(KIT_SRCS
-  ctkModuleDescription.h
-  ctkModuleDescription.cpp
-  ctkModuleDescriptionParser.cpp
-  ctkModuleDescriptionValidator.h
-  ctkModuleDescriptionValidator.cpp
-  ctkModuleManager.h
-  ctkModuleManager.cpp
-  ctkModuleObjectHierarchyReader.h
-  ctkModuleObjectHierarchyReader.cpp
-  ctkModuleParameter.h
-  ctkModuleParameter.cpp
-  ctkModuleParameterGroup.h
-  ctkModuleParameterGroup.cpp
-  ctkModuleParameterParsers_p.h
-  ctkModuleProcessException.h
-  ctkModuleProcessException.cpp
-  ctkModuleProcessFuture.h
-  ctkModuleProcessFuture.cpp
-  ctkModuleProcessRunner_p.h
-  ctkModuleProcessRunner.cpp
-  ctkModuleReference.h
-  ctkModuleReference.cpp
-  ctkModuleReferencePrivate.h
-  ctkModuleReferencePrivate.cpp
- )
+  ctkCmdLineModuleDescription.cpp
+  ctkCmdLineModuleManager.cpp
+  ctkCmdLineModuleObjectHierarchyReader.cpp
+  ctkCmdLineModuleParameter.cpp
+  ctkCmdLineModuleParameterGroup.cpp
+  ctkCmdLineModuleParameterParsers_p.h
+  ctkCmdLineModuleProcessException.cpp
+  ctkCmdLineModuleProcessFuture.cpp
+  ctkCmdLineModuleProcessRunner.cpp
+  ctkCmdLineModuleProcessRunner_p.h
+  ctkCmdLineModuleReference.cpp
+  ctkCmdLineModuleReferencePrivate.cpp
+  ctkCmdLineModuleXmlParser.cpp
+  ctkCmdLineModuleXmlValidator.cpp
+)
 
 # Headers that should run through moc
 set(KIT_MOC_SRCS
-  ctkModuleProcessRunner_p.h
-  ctkModuleReferencePrivate.h
+  ctkCmdLineModuleProcessRunner_p.h
+  ctkCmdLineModuleReferencePrivate.h
 )
 
 # UI files
@@ -52,7 +42,7 @@ set(KIT_UI_FORMS
 
 # Resources
 set(KIT_resources
-  Resources/ctkModuleDescription.qrc
+  Resources/ctkCmdLineModules.qrc
 )
 
 set(QT_USE_QTXMLPATTERNS 1)

Libs/CommandLineModules/Resources/ctkCmdLineModules.qrc

@@ -0,0 +1,7 @@
+<RCC>
+    <qresource prefix="/">
+        <file>ctkCmdLineModule.xsd</file>
+        <file>ctkCmdLineModuleXmlToQtUi.xsl</file>
+        <file>QtDesigner.xsd</file>
+    </qresource>
+</RCC>

Libs/CommandLineModules/Resources/ctkModuleDescription.qrc

@@ -1,7 +0,0 @@
-<RCC>
-    <qresource prefix="/">
-        <file>ctkModuleDescription.xsd</file>
-        <file>ctkQtModuleDescription.xsl</file>
-        <file>QtDesigner.xsd</file>
-    </qresource>
-</RCC>

Libs/CommandLineModules/ctkModuleDescription.cpp

@@ -18,14 +18,14 @@ limitations under the License.
 
 =============================================================================*/
 
-#include "ctkModuleDescription.h"
+#include "ctkCmdLineModuleDescription.h"
 #include <iostream>
 #include "QFile"
 #include "QTextStream"
 
-struct ctkModuleDescriptionPrivate
+struct ctkCmdLineModuleDescriptionPrivate
 {
-  ~ctkModuleDescriptionPrivate()
+  ~ctkCmdLineModuleDescriptionPrivate()
   {
     qDeleteAll(ParameterGroups);
   }
@@ -47,191 +47,191 @@ struct ctkModuleDescriptionPrivate
 
   QIcon Logo;
 
-  QList<ctkModuleParameterGroup*> ParameterGroups;
+  QList<ctkCmdLineModuleParameterGroup*> ParameterGroups;
 
   //ModuleProcessInformation ProcessInformation;
 };
 
 //----------------------------------------------------------------------------
-ctkModuleDescription::ctkModuleDescription()
-  : d_ptr(new ctkModuleDescriptionPrivate)
+ctkCmdLineModuleDescription::ctkCmdLineModuleDescription()
+  : d_ptr(new ctkCmdLineModuleDescriptionPrivate)
 {
 }
 
 //----------------------------------------------------------------------------
-ctkModuleDescription::~ctkModuleDescription()
+ctkCmdLineModuleDescription::~ctkCmdLineModuleDescription()
 {
   delete d_ptr;
 }
 
 
 //----------------------------------------------------------------------------
-void ctkModuleDescription::setCategory(const QString& cat)
+void ctkCmdLineModuleDescription::setCategory(const QString& cat)
 {
-  Q_D(ctkModuleDescription);
+  Q_D(ctkCmdLineModuleDescription);
   d->Category = cat;
 }
 
 //----------------------------------------------------------------------------
-QString ctkModuleDescription::category() const
+QString ctkCmdLineModuleDescription::category() const
 {
-  Q_D(const ctkModuleDescription);
+  Q_D(const ctkCmdLineModuleDescription);
   return d->Category;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleDescription::setTitle(const QString& title)
+void ctkCmdLineModuleDescription::setTitle(const QString& title)
 {
-  Q_D(ctkModuleDescription);
+  Q_D(ctkCmdLineModuleDescription);
   d->Title = title;
 }
 
 //----------------------------------------------------------------------------
-QString ctkModuleDescription::title() const
+QString ctkCmdLineModuleDescription::title() const
 {
-  Q_D(const ctkModuleDescription);
+  Q_D(const ctkCmdLineModuleDescription);
   return d->Title;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleDescription::setDescription(const QString& description)
+void ctkCmdLineModuleDescription::setDescription(const QString& description)
 {
-  Q_D(ctkModuleDescription);
+  Q_D(ctkCmdLineModuleDescription);
   d->Description = description;
 }
 
 //----------------------------------------------------------------------------
-QString ctkModuleDescription::description() const
+QString ctkCmdLineModuleDescription::description() const
 {
-  Q_D(const ctkModuleDescription);
+  Q_D(const ctkCmdLineModuleDescription);
   return d->Description;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleDescription::setVersion(const QString& version)
+void ctkCmdLineModuleDescription::setVersion(const QString& version)
 {
-  Q_D(ctkModuleDescription);
+  Q_D(ctkCmdLineModuleDescription);
   d->Version = version;
 }
 
 //----------------------------------------------------------------------------
-QString ctkModuleDescription::version() const
+QString ctkCmdLineModuleDescription::version() const
 {
-  Q_D(const ctkModuleDescription);
+  Q_D(const ctkCmdLineModuleDescription);
   return d->Version;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleDescription::setDocumentationURL(const QString& documentationURL)
+void ctkCmdLineModuleDescription::setDocumentationURL(const QString& documentationURL)
 {
-  Q_D(ctkModuleDescription);
+  Q_D(ctkCmdLineModuleDescription);
   d->DocumentationURL = documentationURL;
 }
 
 //----------------------------------------------------------------------------
-QString ctkModuleDescription::documentationURL() const
+QString ctkCmdLineModuleDescription::documentationURL() const
 {
-  Q_D(const ctkModuleDescription);
+  Q_D(const ctkCmdLineModuleDescription);
   return d->DocumentationURL;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleDescription::setLicense(const QString& license)
+void ctkCmdLineModuleDescription::setLicense(const QString& license)
 {
-  Q_D(ctkModuleDescription);
+  Q_D(ctkCmdLineModuleDescription);
   d->License = license;
 }
 
 //----------------------------------------------------------------------------
-QString ctkModuleDescription::license() const
+QString ctkCmdLineModuleDescription::license() const
 {
-  Q_D(const ctkModuleDescription);
+  Q_D(const ctkCmdLineModuleDescription);
   return d->License;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleDescription::setAcknowledgements(const QString& acknowledgements)
+void ctkCmdLineModuleDescription::setAcknowledgements(const QString& acknowledgements)
 {
-  Q_D(ctkModuleDescription);
+  Q_D(ctkCmdLineModuleDescription);
   d->Acknowledgements = acknowledgements;
 }
 
 //----------------------------------------------------------------------------
-QString ctkModuleDescription::acknowledgements() const
+QString ctkCmdLineModuleDescription::acknowledgements() const
 {
-  Q_D(const ctkModuleDescription);
+  Q_D(const ctkCmdLineModuleDescription);
   return d->Acknowledgements;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleDescription::setContributor(const QString& contributor)
+void ctkCmdLineModuleDescription::setContributor(const QString& contributor)
 {
-  Q_D(ctkModuleDescription);
+  Q_D(ctkCmdLineModuleDescription);
   d->Contributor = contributor;
 }
 
 //----------------------------------------------------------------------------
-QString ctkModuleDescription::contributor() const
+QString ctkCmdLineModuleDescription::contributor() const
 {
-  Q_D(const ctkModuleDescription);
+  Q_D(const ctkCmdLineModuleDescription);
   return d->Contributor;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleDescription::setLocation(const QString& target)
+void ctkCmdLineModuleDescription::setLocation(const QString& target)
 {
-  Q_D(ctkModuleDescription);
+  Q_D(ctkCmdLineModuleDescription);
   d->Location = target;
 }
 
 //----------------------------------------------------------------------------
-QString ctkModuleDescription::location() const
+QString ctkCmdLineModuleDescription::location() const
 {
-  Q_D(const ctkModuleDescription);
+  Q_D(const ctkCmdLineModuleDescription);
   return d->Location;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleDescription::setLogo(const QIcon& logo)
+void ctkCmdLineModuleDescription::setLogo(const QIcon& logo)
 {
-  Q_D(ctkModuleDescription);
+  Q_D(ctkCmdLineModuleDescription);
   d->Logo = logo;
 }
 
 //----------------------------------------------------------------------------
-QIcon ctkModuleDescription::logo() const
+QIcon ctkCmdLineModuleDescription::logo() const
 {
-  Q_D(const ctkModuleDescription);
+  Q_D(const ctkCmdLineModuleDescription);
   return d->Logo;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleDescription::addParameterGroup(ctkModuleParameterGroup* group)
+void ctkCmdLineModuleDescription::addParameterGroup(ctkCmdLineModuleParameterGroup* group)
 {
-  Q_D(ctkModuleDescription);
+  Q_D(ctkCmdLineModuleDescription);
   d->ParameterGroups.push_back(group);
 }
 
 //----------------------------------------------------------------------------
-QList<ctkModuleParameterGroup*> ctkModuleDescription::parameterGroups() const
+QList<ctkCmdLineModuleParameterGroup*> ctkCmdLineModuleDescription::parameterGroups() const
 {
-  Q_D(const ctkModuleDescription);
+  Q_D(const ctkCmdLineModuleDescription);
   return d->ParameterGroups;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleDescription::setParameterGroups(const QList<ctkModuleParameterGroup*>& groups)
+void ctkCmdLineModuleDescription::setParameterGroups(const QList<ctkCmdLineModuleParameterGroup*>& groups)
 {
-  Q_D(ctkModuleDescription);
+  Q_D(ctkCmdLineModuleDescription);
   d->ParameterGroups = groups;
 }
 
 //----------------------------------------------------------------------------
-bool ctkModuleDescription::hasParameter(const QString& name) const
+bool ctkCmdLineModuleDescription::hasParameter(const QString& name) const
 {
-  Q_D(const ctkModuleDescription);
+  Q_D(const ctkCmdLineModuleDescription);
   // iterate over each parameter group
-  foreach(const ctkModuleParameterGroup* group, d->ParameterGroups)
+  foreach(const ctkCmdLineModuleParameterGroup* group, d->ParameterGroups)
   {
     if (group->hasParameter(name)) return true;
   }
@@ -239,23 +239,23 @@ bool ctkModuleDescription::hasParameter(const QString& name) const
 }
 
 //----------------------------------------------------------------------------
-ctkModuleParameter* ctkModuleDescription::parameter(const QString& name) const
+ctkCmdLineModuleParameter* ctkCmdLineModuleDescription::parameter(const QString& name) const
 {
-  Q_D(const ctkModuleDescription);
-  foreach(const ctkModuleParameterGroup* group, d->ParameterGroups)
+  Q_D(const ctkCmdLineModuleDescription);
+  foreach(const ctkCmdLineModuleParameterGroup* group, d->ParameterGroups)
   {
-    ctkModuleParameter* param = group->parameter(name);
+    ctkCmdLineModuleParameter* param = group->parameter(name);
     if (param) return param;
   }
   return 0;
 }
 
 //----------------------------------------------------------------------------
-bool ctkModuleDescription::hasReturnParameters() const
+bool ctkCmdLineModuleDescription::hasReturnParameters() const
 {
-  Q_D(const ctkModuleDescription);
+  Q_D(const ctkCmdLineModuleDescription);
   // iterate over each parameter group
-  foreach(const ctkModuleParameterGroup* group, d->ParameterGroups)
+  foreach(const ctkCmdLineModuleParameterGroup* group, d->ParameterGroups)
   {
     if (group->hasReturnParameters()) return true;
   }
@@ -263,10 +263,10 @@ bool ctkModuleDescription::hasReturnParameters() const
 }
 
 //----------------------------------------------------------------------------
-bool ctkModuleDescription::setParameterDefaultValue(const QString& name,
+bool ctkCmdLineModuleDescription::setParameterDefaultValue(const QString& name,
                                                     const QString& value)
 {
-  ctkModuleParameter* param = parameter(name);
+  ctkCmdLineModuleParameter* param = parameter(name);
   if (param)
   {
     param->setDefaultValue(value);
@@ -276,7 +276,7 @@ bool ctkModuleDescription::setParameterDefaultValue(const QString& name,
 }
 
 //----------------------------------------------------------------------------
-bool ctkModuleDescription ::readParameterFile(const QString& filename)
+bool ctkCmdLineModuleDescription ::readParameterFile(const QString& filename)
 {
   bool modified = false;
 
@@ -307,7 +307,7 @@ bool ctkModuleDescription ::readParameterFile(const QString& filename)
     
     // std::cout << "key=" << key << ", value=" << value << "!" << endl;
 
-    ctkModuleParameter* param = this->parameter(key);
+    ctkCmdLineModuleParameter* param = this->parameter(key);
     if (param)
     {
       if (value != param->defaultValue())
@@ -324,10 +324,10 @@ bool ctkModuleDescription ::readParameterFile(const QString& filename)
 }
 
 //----------------------------------------------------------------------------
-bool ctkModuleDescription::
+bool ctkCmdLineModuleDescription::
 writeParameterFile(const QString& filename, bool withHandlesToBulkParameters)const
 {
-  Q_D(const ctkModuleDescription);
+  Q_D(const ctkCmdLineModuleDescription);
 
   QFile rtp(filename);
 
@@ -339,7 +339,7 @@ writeParameterFile(const QString& filename, bool withHandlesToBulkParameters)con
 
   QTextStream in(&rtp);
   // iterate over each parameter group
-  foreach(const ctkModuleParameterGroup* group, d->ParameterGroups)
+  foreach(const ctkCmdLineModuleParameterGroup* group, d->ParameterGroups)
   {
     group->writeParameterFile(in, withHandlesToBulkParameters);
   }
@@ -348,7 +348,7 @@ writeParameterFile(const QString& filename, bool withHandlesToBulkParameters)con
 }
 
 //----------------------------------------------------------------------------
-QTextStream & operator<<(QTextStream &os, const ctkModuleDescription &module)
+QTextStream & operator<<(QTextStream &os, const ctkCmdLineModuleDescription &module)
 {
   os << "Title: " << module.title() << '\n';
   os << "Category: " << module.category() << '\n';
@@ -365,7 +365,7 @@ QTextStream & operator<<(QTextStream &os, const ctkModuleDescription &module)
   //   << *(module.GetProcessInformation());
 
   os << "ParameterGroups: " << '\n';
-  foreach(const ctkModuleParameterGroup* group, module.parameterGroups())
+  foreach(const ctkCmdLineModuleParameterGroup* group, module.parameterGroups())
   {
     os << *group;
   }

Libs/CommandLineModules/ctkModuleDescription.h

@@ -18,14 +18,14 @@
 
 =============================================================================*/
 
-#ifndef __ctkModuleDescription_h
-#define __ctkModuleDescription_h
+#ifndef __ctkCmdLineModuleDescription_h
+#define __ctkCmdLineModuleDescription_h
 
 #include <QIcon>
 
-#include "ctkModuleParameterGroup.h"
+#include "ctkCmdLineModuleParameterGroup.h"
 
-struct ctkModuleDescriptionPrivate;
+struct ctkCmdLineModuleDescriptionPrivate;
 
 /**
 * Description of the parameters of a module
@@ -38,15 +38,15 @@ struct ctkModuleDescriptionPrivate;
 * command (with path) for an executable.
 * - Location: This is path to the executable for the module
 */
-class CTK_CMDLINEMODULE_EXPORT ctkModuleDescription
+class CTK_CMDLINEMODULE_EXPORT ctkCmdLineModuleDescription
 {
-  Q_DECLARE_PRIVATE(ctkModuleDescription)
+  Q_DECLARE_PRIVATE(ctkCmdLineModuleDescription)
 
 public:
 
-  ~ctkModuleDescription();
+  ~ctkCmdLineModuleDescription();
 
-  static ctkModuleDescription* parse(QIODevice* input);
+  static ctkCmdLineModuleDescription* parse(QIODevice* input);
 
   void setCategory(const QString& cat);
   QString category() const;
@@ -80,13 +80,13 @@ public:
   void setLogo(const QIcon& logo);
   QIcon logo() const;
 
-  void addParameterGroup(ctkModuleParameterGroup* group);
-  QList<ctkModuleParameterGroup*> parameterGroups() const;
-  void setParameterGroups(const QList<ctkModuleParameterGroup*>& groups);
+  void addParameterGroup(ctkCmdLineModuleParameterGroup* group);
+  QList<ctkCmdLineModuleParameterGroup*> parameterGroups() const;
+  void setParameterGroups(const QList<ctkCmdLineModuleParameterGroup*>& groups);
 
   bool hasParameter(const QString& name) const;
 
-  ctkModuleParameter* parameter(const QString& name) const;
+  ctkCmdLineModuleParameter* parameter(const QString& name) const;
 
   // Does the module have any simple (primitive) return types?
   bool hasReturnParameters() const;
@@ -115,14 +115,14 @@ public:
 
 private:
 
-  ctkModuleDescription();
+  ctkCmdLineModuleDescription();
 
-  Q_DISABLE_COPY(ctkModuleDescription)
+  Q_DISABLE_COPY(ctkCmdLineModuleDescription)
 
-  ctkModuleDescriptionPrivate * const d_ptr;
+  ctkCmdLineModuleDescriptionPrivate * const d_ptr;
 
 };
 
-CTK_CMDLINEMODULE_EXPORT QTextStream & operator<<(QTextStream& os, const ctkModuleDescription& module);
+CTK_CMDLINEMODULE_EXPORT QTextStream & operator<<(QTextStream& os, const ctkCmdLineModuleDescription& module);
 
 #endif

Libs/CommandLineModules/ctkModuleManager.cpp

@@ -19,12 +19,12 @@
   
 =============================================================================*/
 
-#include "ctkModuleManager.h"
+#include "ctkCmdLineModuleManager.h"
 
-#include "ctkModuleDescriptionValidator.h"
-#include "ctkModuleObjectHierarchyReader.h"
-#include "ctkModuleProcessRunner_p.h"
-#include "ctkModuleReferencePrivate.h"
+#include "ctkCmdLineModuleXmlValidator.h"
+#include "ctkCmdLineModuleObjectHierarchyReader.h"
+#include "ctkCmdLineModuleProcessRunner_p.h"
+#include "ctkCmdLineModuleReferencePrivate.h"
 
 #include <QStringList>
 #include <QBuffer>
@@ -37,14 +37,14 @@ QString normalizeFlag(const QString& flag)
   return flag.trimmed().remove(QRegExp("^-*"));
 }
 
-ctkModuleManager::ctkModuleManager(ctkModuleDescriptionFactory *descriptionFactory)
+ctkCmdLineModuleManager::ctkCmdLineModuleManager(ctkCmdLineModuleDescriptionFactory *descriptionFactory)
   : descriptionFactory(descriptionFactory)
 {
 }
 
-QStringList ctkModuleManager::createCommandLineArgs(QObject *hierarchy)
+QStringList ctkCmdLineModuleManager::createCommandLineArgs(QObject *hierarchy)
 {
-  ctkModuleObjectHierarchyReader reader(hierarchy);
+  ctkCmdLineModuleObjectHierarchyReader reader(hierarchy);
 
   QStringList cmdLineArgs;
   QHash<int, QString> indexedArgs;
@@ -93,13 +93,13 @@ QStringList ctkModuleManager::createCommandLineArgs(QObject *hierarchy)
   return cmdLineArgs;
 }
 
-ctkModuleReference ctkModuleManager::addModule(const QString& location)
+ctkCmdLineModuleReference ctkCmdLineModuleManager::addModule(const QString& location)
 {
   QProcess process;
   process.setReadChannel(QProcess::StandardOutput);
   process.start(location, QStringList("--xml"));
 
-  ctkModuleReference ref;
+  ctkCmdLineModuleReference ref;
   ref.d->loc = location;
   if (!process.waitForFinished() || process.exitStatus() == QProcess::CrashExit ||
       process.error() != QProcess::UnknownError)
@@ -117,7 +117,7 @@ ctkModuleReference ctkModuleManager::addModule(const QString& location)
   QBuffer input(&xml);
   input.open(QIODevice::ReadOnly);
 
-  ctkModuleDescriptionValidator validator(&input);
+  ctkCmdLineModuleXmlValidator validator(&input);
   if (!validator.validateXMLInput())
   {
     qCritical() << validator.errorString();
@@ -132,10 +132,10 @@ ctkModuleReference ctkModuleManager::addModule(const QString& location)
   return ref;
 }
 
-ctkModuleProcessFuture ctkModuleManager::run(const ctkModuleReference& moduleRef)
+ctkCmdLineModuleProcessFuture ctkCmdLineModuleManager::run(const ctkCmdLineModuleReference& moduleRef)
 {
   // TODO: manage memory
   QStringList args = createCommandLineArgs(moduleRef.d->objectRepresentation);
-  ctkModuleProcessRunner* moduleProcess = new ctkModuleProcessRunner(moduleRef.location(), args);
+  ctkCmdLineModuleProcessRunner* moduleProcess = new ctkCmdLineModuleProcessRunner(moduleRef.location(), args);
   return moduleProcess->start();
 }

Libs/CommandLineModules/ctkModuleManager.h

@@ -19,22 +19,22 @@
   
 =============================================================================*/
 
-#ifndef CTKMODULEMANAGER_H
-#define CTKMODULEMANAGER_H
+#ifndef CTKCMDLINEMODULEMANAGER_H
+#define CTKCMDLINEMODULEMANAGER_H
 
 #include <QStringList>
 #include <QString>
 
 #include <ctkCommandLineModulesExport.h>
 
-#include "ctkModuleReference.h"
-#include "ctkModuleProcessFuture.h"
+#include "ctkCmdLineModuleReference.h"
+#include "ctkCmdLineModuleProcessFuture.h"
 
 class QObject;
 
-struct ctkModuleDescriptionFactory
+struct ctkCmdLineModuleDescriptionFactory
 {
-  virtual ~ctkModuleDescriptionFactory() {}
+  virtual ~ctkCmdLineModuleDescriptionFactory() {}
 
   virtual QObject* createGUIFromXML(const QByteArray& xmlDescription)
   {
@@ -46,22 +46,22 @@ struct ctkModuleDescriptionFactory
 };
 
 /// The methods in this class are for playing around... no API design yet
-class CTK_CMDLINEMODULE_EXPORT ctkModuleManager
+class CTK_CMDLINEMODULE_EXPORT ctkCmdLineModuleManager
 {
 public:
-  ctkModuleManager(ctkModuleDescriptionFactory* descriptionFactory);
+  ctkCmdLineModuleManager(ctkCmdLineModuleDescriptionFactory* descriptionFactory);
 
-  ctkModuleReference addModule(const QString& location);
+  ctkCmdLineModuleReference addModule(const QString& location);
 
   static QStringList createCommandLineArgs(QObject* hierarchy);
 
-  static ctkModuleProcessFuture run(const ctkModuleReference& moduleRef);
+  static ctkCmdLineModuleProcessFuture run(const ctkCmdLineModuleReference& moduleRef);
 
 private:
 
-  ctkModuleDescriptionFactory* descriptionFactory;
+  ctkCmdLineModuleDescriptionFactory* descriptionFactory;
 
-  QHash<QString, ctkModuleReference> cache;
+  QHash<QString, ctkCmdLineModuleReference> cache;
 };
 
-#endif // CTKMODULEMANAGER_H
+#endif // CTKCMDLINEMODULEMANAGER_H

Libs/CommandLineModules/ctkModuleObjectHierarchyReader.cpp

@@ -19,7 +19,7 @@
   
 =============================================================================*/
 
-#include "ctkModuleObjectHierarchyReader.h"
+#include "ctkCmdLineModuleObjectHierarchyReader.h"
 
 #include <QObject>
 #include <QStack>
@@ -33,12 +33,12 @@ static QString PREFIX_PARAMETER = "parameter:";
 
 }
 
-class ctkModuleObjectHierarchyReaderPrivate
+class ctkCmdLineModuleObjectHierarchyReaderPrivate
 {
 public:
 
-  ctkModuleObjectHierarchyReaderPrivate(QObject* root)
-    : rootObject(root), currentObject(0), currentToken(ctkModuleObjectHierarchyReader::NoToken),
+  ctkCmdLineModuleObjectHierarchyReaderPrivate(QObject* root)
+    : rootObject(root), currentObject(0), currentToken(ctkCmdLineModuleObjectHierarchyReader::NoToken),
       atEnd(false)
   {
   }
@@ -50,29 +50,29 @@ public:
     QString prefixedName;
     switch(currentToken)
     {
-    case ctkModuleObjectHierarchyReader::Executable: prefixedName = PREFIX_EXECUTABLE + propName;
-    case ctkModuleObjectHierarchyReader::ParameterGroup: prefixedName = PREFIX_PARAMETER_GROUP + propName;
-    case ctkModuleObjectHierarchyReader::Parameter: prefixedName = PREFIX_PARAMETER + propName;
+    case ctkCmdLineModuleObjectHierarchyReader::Executable: prefixedName = PREFIX_EXECUTABLE + propName;
+    case ctkCmdLineModuleObjectHierarchyReader::ParameterGroup: prefixedName = PREFIX_PARAMETER_GROUP + propName;
+    case ctkCmdLineModuleObjectHierarchyReader::Parameter: prefixedName = PREFIX_PARAMETER + propName;
     default: ;
     }
 
     return currentObject->property(qPrintable(prefixedName));
   }
 
-  ctkModuleObjectHierarchyReader::TokenType token(QObject* obj)
+  ctkCmdLineModuleObjectHierarchyReader::TokenType token(QObject* obj)
   {
-    if (obj == 0) return ctkModuleObjectHierarchyReader::NoToken;
+    if (obj == 0) return ctkCmdLineModuleObjectHierarchyReader::NoToken;
     QString name = obj->objectName();
-    if (name.startsWith(PREFIX_EXECUTABLE)) return ctkModuleObjectHierarchyReader::Executable;
-    if (name.startsWith(PREFIX_PARAMETER_GROUP)) return ctkModuleObjectHierarchyReader::ParameterGroup;
-    if (name.startsWith(PREFIX_PARAMETER)) return ctkModuleObjectHierarchyReader::Parameter;
-    return ctkModuleObjectHierarchyReader::NoToken;
+    if (name.startsWith(PREFIX_EXECUTABLE)) return ctkCmdLineModuleObjectHierarchyReader::Executable;
+    if (name.startsWith(PREFIX_PARAMETER_GROUP)) return ctkCmdLineModuleObjectHierarchyReader::ParameterGroup;
+    if (name.startsWith(PREFIX_PARAMETER)) return ctkCmdLineModuleObjectHierarchyReader::Parameter;
+    return ctkCmdLineModuleObjectHierarchyReader::NoToken;
   }
 
   bool setCurrent(QObject* obj)
   {
-    ctkModuleObjectHierarchyReader::TokenType t = token(obj);
-    if (t != ctkModuleObjectHierarchyReader::NoToken)
+    ctkCmdLineModuleObjectHierarchyReader::TokenType t = token(obj);
+    if (t != ctkCmdLineModuleObjectHierarchyReader::NoToken)
     {
       currentObject = obj;
       currentToken = t;
@@ -84,50 +84,50 @@ public:
   QObject* rootObject;
   QObject* currentObject;
 
-  ctkModuleObjectHierarchyReader::TokenType currentToken;
+  ctkCmdLineModuleObjectHierarchyReader::TokenType currentToken;
   bool atEnd;
 
   QStack<QObject*> objectStack;
 };
 
-ctkModuleObjectHierarchyReader::ctkModuleObjectHierarchyReader(QObject *root)
-  : d(new ctkModuleObjectHierarchyReaderPrivate(root))
+ctkCmdLineModuleObjectHierarchyReader::ctkCmdLineModuleObjectHierarchyReader(QObject *root)
+  : d(new ctkCmdLineModuleObjectHierarchyReaderPrivate(root))
 {
 }
 
-ctkModuleObjectHierarchyReader::~ctkModuleObjectHierarchyReader()
+ctkCmdLineModuleObjectHierarchyReader::~ctkCmdLineModuleObjectHierarchyReader()
 {
 }
 
-void ctkModuleObjectHierarchyReader::setRootObject(QObject* root)
+void ctkCmdLineModuleObjectHierarchyReader::setRootObject(QObject* root)
 {
   d->rootObject = root;
   clear();
 }
 
-void ctkModuleObjectHierarchyReader::clear()
+void ctkCmdLineModuleObjectHierarchyReader::clear()
 {
   d->currentToken = NoToken;
   d->currentObject = 0;
   d->objectStack.clear();
 }
 
-bool ctkModuleObjectHierarchyReader::atEnd() const
+bool ctkCmdLineModuleObjectHierarchyReader::atEnd() const
 {
   return d->atEnd || d->rootObject == 0;
 }
 
-bool ctkModuleObjectHierarchyReader::isParameterGroup() const
+bool ctkCmdLineModuleObjectHierarchyReader::isParameterGroup() const
 {
   return d->currentToken == ParameterGroup;
 }
 
-bool ctkModuleObjectHierarchyReader::isParameter() const
+bool ctkCmdLineModuleObjectHierarchyReader::isParameter() const
 {
   return d->currentToken == Parameter;
 }
 
-QString ctkModuleObjectHierarchyReader::name() const
+QString ctkCmdLineModuleObjectHierarchyReader::name() const
 {
   if (d->currentObject == 0) return QString();
   switch(d->currentToken)
@@ -139,7 +139,7 @@ QString ctkModuleObjectHierarchyReader::name() const
   }
 }
 
-QString ctkModuleObjectHierarchyReader::label() const
+QString ctkCmdLineModuleObjectHierarchyReader::label() const
 {
   if (d->currentObject == 0) return QString();
   switch(d->currentToken)
@@ -151,37 +151,37 @@ QString ctkModuleObjectHierarchyReader::label() const
   }
 }
 
-QString ctkModuleObjectHierarchyReader::value() const
+QString ctkCmdLineModuleObjectHierarchyReader::value() const
 {
   QString valProp = property("valueProperty").toString();
   return property(valProp).toString();
 }
 
-QString ctkModuleObjectHierarchyReader::flag() const
+QString ctkCmdLineModuleObjectHierarchyReader::flag() const
 {
   QVariant v = property("flag");
   return v.isValid() ? v.toString() : QString();
 }
 
-QString ctkModuleObjectHierarchyReader::longFlag() const
+QString ctkCmdLineModuleObjectHierarchyReader::longFlag() const
 {
   QVariant v = property("longflag");
   return v.isValid() ? v.toString() : QString();
 }
 
-int ctkModuleObjectHierarchyReader::index() const
+int ctkCmdLineModuleObjectHierarchyReader::index() const
 {
   QVariant v = property("index");
   return v.isValid() ? v.toInt() : -1;
 }
 
-bool ctkModuleObjectHierarchyReader::isMultiple() const
+bool ctkCmdLineModuleObjectHierarchyReader::isMultiple() const
 {
   QVariant v = property("multiple");
   return v.isValid() ? v.toBool() : false;
 }
 
-QVariant ctkModuleObjectHierarchyReader::property(const QString &propName) const
+QVariant ctkCmdLineModuleObjectHierarchyReader::property(const QString &propName) const
 {
   if (d->currentObject == 0) return QVariant();
 
@@ -192,7 +192,7 @@ QVariant ctkModuleObjectHierarchyReader::property(const QString &propName) const
   return res;
 }
 
-ctkModuleObjectHierarchyReader::TokenType ctkModuleObjectHierarchyReader::readNext() const
+ctkCmdLineModuleObjectHierarchyReader::TokenType ctkCmdLineModuleObjectHierarchyReader::readNext() const
 {
   if (d->atEnd) return NoToken;
 
@@ -242,25 +242,25 @@ ctkModuleObjectHierarchyReader::TokenType ctkModuleObjectHierarchyReader::readNe
   return NoToken;
 }
 
-bool ctkModuleObjectHierarchyReader::readNextExecutable() const
+bool ctkCmdLineModuleObjectHierarchyReader::readNextExecutable() const
 {
   while (!(readNext() == Executable || d->atEnd));
   return !d->atEnd;
 }
 
-bool ctkModuleObjectHierarchyReader::readNextParameterGroup() const
+bool ctkCmdLineModuleObjectHierarchyReader::readNextParameterGroup() const
 {
   while (!(readNext() == ParameterGroup || d->atEnd));
   return !d->atEnd;
 }
 
-bool ctkModuleObjectHierarchyReader::readNextParameter() const
+bool ctkCmdLineModuleObjectHierarchyReader::readNextParameter() const
 {
   while (!(readNext() == Parameter || d->atEnd));
   return !d->atEnd;
 }
 
-ctkModuleObjectHierarchyReader::TokenType ctkModuleObjectHierarchyReader::tokenType() const
+ctkCmdLineModuleObjectHierarchyReader::TokenType ctkCmdLineModuleObjectHierarchyReader::tokenType() const
 {
   return d->currentToken;
 }

Libs/CommandLineModules/ctkModuleObjectHierarchyReader.h

@@ -19,8 +19,8 @@
   
 =============================================================================*/
 
-#ifndef CTKMODULEOBJECTHIERARCHYREADER_H
-#define CTKMODULEOBJECTHIERARCHYREADER_H
+#ifndef CTKCMDLINEMODULEOBJECTHIERARCHYREADER_H
+#define CTKCMDLINEMODULEOBJECTHIERARCHYREADER_H
 
 #include <QString>
 #include <QScopedPointer>
@@ -30,9 +30,9 @@
 
 class QObject;
 
-class ctkModuleObjectHierarchyReaderPrivate;
+class ctkCmdLineModuleObjectHierarchyReaderPrivate;
 
-class CTK_CMDLINEMODULE_EXPORT ctkModuleObjectHierarchyReader
+class CTK_CMDLINEMODULE_EXPORT ctkCmdLineModuleObjectHierarchyReader
 {
 
 public:
@@ -44,8 +44,8 @@ public:
     Parameter
   };
 
-  ctkModuleObjectHierarchyReader(QObject* root = 0);
-  ~ctkModuleObjectHierarchyReader();
+  ctkCmdLineModuleObjectHierarchyReader(QObject* root = 0);
+  ~ctkCmdLineModuleObjectHierarchyReader();
 
   void setRootObject(QObject* root);
   void clear();
@@ -77,8 +77,8 @@ public:
 
 private:
 
-  QScopedPointer<ctkModuleObjectHierarchyReaderPrivate> d;
+  QScopedPointer<ctkCmdLineModuleObjectHierarchyReaderPrivate> d;
 
 };
 
-#endif // CTKMODULEOBJECTHIERARCHYREADER_H
+#endif // CTKCMDLINEMODULEOBJECTHIERARCHYREADER_H

Libs/CommandLineModules/ctkModuleParameter.cpp

@@ -18,12 +18,12 @@ limitations under the License.
 
 =============================================================================*/
 
-#include "ctkModuleParameter.h"
+#include "ctkCmdLineModuleParameter.h"
 #include <QStringList>
 
-struct ctkModuleParameterPrivate
+struct ctkCmdLineModuleParameterPrivate
 {
-  ctkModuleParameterPrivate()
+  ctkCmdLineModuleParameterPrivate()
     : Hidden(false), Constraints(false), Index(-1), Multiple(false), Aggregate("false")
   {}
 
@@ -77,90 +77,90 @@ struct ctkModuleParameterPrivate
 };
 
 //----------------------------------------------------------------------------
-ctkModuleParameter::ctkModuleParameter()
-  : d_ptr(new ctkModuleParameterPrivate)
+ctkCmdLineModuleParameter::ctkCmdLineModuleParameter()
+  : d_ptr(new ctkCmdLineModuleParameterPrivate)
 { }
 
 //----------------------------------------------------------------------------
-ctkModuleParameter::~ctkModuleParameter()
+ctkCmdLineModuleParameter::~ctkCmdLineModuleParameter()
 {
   delete d_ptr;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleParameter::setTag(const QString& tag)
+void ctkCmdLineModuleParameter::setTag(const QString& tag)
 {
-  Q_D(ctkModuleParameter);
+  Q_D(ctkCmdLineModuleParameter);
   d->Tag = tag;
 }
 
 //----------------------------------------------------------------------------
-QString ctkModuleParameter::tag() const
+QString ctkCmdLineModuleParameter::tag() const
 {
-  Q_D(const ctkModuleParameter);
+  Q_D(const ctkCmdLineModuleParameter);
   return d->Tag;
 }
 
 ////----------------------------------------------------------------------------
-//void ctkModuleParameter::setCPPType(const QString& type)
+//void ctkCmdLineModuleParameter::setCPPType(const QString& type)
 //{
-//  Q_D(ctkModuleParameter);
+//  Q_D(ctkCmdLineModuleParameter);
 //  d->CPPType = type;
 //}
 
 ////----------------------------------------------------------------------------
-//QString ctkModuleParameter::cppType() const
+//QString ctkCmdLineModuleParameter::cppType() const
 //{
-//  Q_D(const ctkModuleParameter);
+//  Q_D(const ctkCmdLineModuleParameter);
 //  return d->CPPType;
 //}
 
 //----------------------------------------------------------------------------
-void ctkModuleParameter::setType(const QString& type)
+void ctkCmdLineModuleParameter::setType(const QString& type)
 {
-  Q_D(ctkModuleParameter);
+  Q_D(ctkCmdLineModuleParameter);
   d->Type = type;
 }
 
 //----------------------------------------------------------------------------
-QString ctkModuleParameter::type() const
+QString ctkCmdLineModuleParameter::type() const
 {
-  Q_D(const ctkModuleParameter);
+  Q_D(const ctkCmdLineModuleParameter);
   return d->Type;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleParameter::setReference(const QString& ref)
+void ctkCmdLineModuleParameter::setReference(const QString& ref)
 {
-  Q_D(ctkModuleParameter);
+  Q_D(ctkCmdLineModuleParameter);
   d->Reference = ref;
 }
 
 //----------------------------------------------------------------------------
-QString ctkModuleParameter::reference() const
+QString ctkCmdLineModuleParameter::reference() const
 {
-  Q_D(const ctkModuleParameter);
+  Q_D(const ctkCmdLineModuleParameter);
   return d->Reference;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleParameter::setHidden(bool hidden)
+void ctkCmdLineModuleParameter::setHidden(bool hidden)
 {
-  Q_D(ctkModuleParameter);
+  Q_D(ctkCmdLineModuleParameter);
   d->Hidden = hidden;
 }
 
 //----------------------------------------------------------------------------
-bool ctkModuleParameter::hidden() const
+bool ctkCmdLineModuleParameter::hidden() const
 {
-  Q_D(const ctkModuleParameter);
+  Q_D(const ctkCmdLineModuleParameter);
   return d->Hidden;
 }
 
 //----------------------------------------------------------------------------
-bool ctkModuleParameter::isReturnParameter() const
+bool ctkCmdLineModuleParameter::isReturnParameter() const
 {
-  Q_D(const ctkModuleParameter);
+  Q_D(const ctkCmdLineModuleParameter);
   // could check for tag == float, int, float-vector, ...
   if (d->Channel == "output"
       && !this->isFlagParameter() && !this->isIndexParameter())
@@ -171,396 +171,396 @@ bool ctkModuleParameter::isReturnParameter() const
 }
 
 //----------------------------------------------------------------------------
-bool ctkModuleParameter::isFlagParameter() const
+bool ctkCmdLineModuleParameter::isFlagParameter() const
 {
-  Q_D(const ctkModuleParameter);
+  Q_D(const ctkCmdLineModuleParameter);
   return (d->Flag != "" || d->LongFlag != "");
 }
 
 //----------------------------------------------------------------------------
-bool ctkModuleParameter::isIndexParameter() const
+bool ctkCmdLineModuleParameter::isIndexParameter() const
 {
-  Q_D(const ctkModuleParameter);
+  Q_D(const ctkCmdLineModuleParameter);
   return (d->Index > -1);
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleParameter::setArgType(const QString& argType)
+void ctkCmdLineModuleParameter::setArgType(const QString& argType)
 {
-  Q_D(ctkModuleParameter);
+  Q_D(ctkCmdLineModuleParameter);
   d->ArgType = argType;
 }
 
 //----------------------------------------------------------------------------
-QString ctkModuleParameter::argType() const
+QString ctkCmdLineModuleParameter::argType() const
 {
-  Q_D(const ctkModuleParameter);
+  Q_D(const ctkCmdLineModuleParameter);
   return d->ArgType;
 }
 
 ////----------------------------------------------------------------------------
-//void ctkModuleParameter::setStringToType(const QString& stringToType)
+//void ctkCmdLineModuleParameter::setStringToType(const QString& stringToType)
 //{
-//  Q_D(ctkModuleParameter);
+//  Q_D(ctkCmdLineModuleParameter);
 //  d->StringToType = stringToType;
 //}
 
 ////----------------------------------------------------------------------------
-//QString ctkModuleParameter::stringToType() const
+//QString ctkCmdLineModuleParameter::stringToType() const
 //{
-//  Q_D(const ctkModuleParameter);
+//  Q_D(const ctkCmdLineModuleParameter);
 //  return d->StringToType;
 //}
 
 //----------------------------------------------------------------------------
-void ctkModuleParameter::setName(const QString& name)
+void ctkCmdLineModuleParameter::setName(const QString& name)
 {
-  Q_D(ctkModuleParameter);
+  Q_D(ctkCmdLineModuleParameter);
   d->Name = name;
 }
 
 //----------------------------------------------------------------------------
-QString ctkModuleParameter::name() const
+QString ctkCmdLineModuleParameter::name() const
 {
-  Q_D(const ctkModuleParameter);
+  Q_D(const ctkCmdLineModuleParameter);
   return d->Name;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleParameter::setLongFlag(const QString& longFlag)
+void ctkCmdLineModuleParameter::setLongFlag(const QString& longFlag)
 {
-  Q_D(ctkModuleParameter);
+  Q_D(ctkCmdLineModuleParameter);
   d->LongFlag = longFlag;
 }
 
 //----------------------------------------------------------------------------
-QString ctkModuleParameter::longFlag() const
+QString ctkCmdLineModuleParameter::longFlag() const
 {
-  Q_D(const ctkModuleParameter);
+  Q_D(const ctkCmdLineModuleParameter);
   return d->LongFlag;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleParameter::setLongFlagAliasesAsString(const QString& aliases)
+void ctkCmdLineModuleParameter::setLongFlagAliasesAsString(const QString& aliases)
 {
-  Q_D(ctkModuleParameter);
+  Q_D(ctkCmdLineModuleParameter);
   d->LongFlagAliases = d->splitAndTrim(aliases, ",");
   d->LongFlagAliasesAsString = d->LongFlagAliases.join(", ");
 }
 
 //----------------------------------------------------------------------------
-QString ctkModuleParameter::longFlagAliasesAsString() const
+QString ctkCmdLineModuleParameter::longFlagAliasesAsString() const
 {
-  Q_D(const ctkModuleParameter);
+  Q_D(const ctkCmdLineModuleParameter);
   return d->LongFlagAliasesAsString;
 }
 
 //----------------------------------------------------------------------------
-QStringList ctkModuleParameter::longFlagAliases() const
+QStringList ctkCmdLineModuleParameter::longFlagAliases() const
 {
-  Q_D(const ctkModuleParameter);
+  Q_D(const ctkCmdLineModuleParameter);
   return d->LongFlagAliases;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleParameter::setDeprecatedLongFlagAliasesAsString(const QString& aliases)
+void ctkCmdLineModuleParameter::setDeprecatedLongFlagAliasesAsString(const QString& aliases)
 {
-  Q_D(ctkModuleParameter);
+  Q_D(ctkCmdLineModuleParameter);
   d->DeprecatedLongFlagAliases = d->splitAndTrim(aliases, ",");
   d->DeprecatedLongFlagAliasesAsString = d->DeprecatedLongFlagAliases.join(", ");
 }
 
 //----------------------------------------------------------------------------
-QString ctkModuleParameter::deprecatedLongFlagAliasesAsString() const
+QString ctkCmdLineModuleParameter::deprecatedLongFlagAliasesAsString() const
 {
-  Q_D(const ctkModuleParameter);
+  Q_D(const ctkCmdLineModuleParameter);
   return d->DeprecatedLongFlagAliasesAsString;
 }
 
 //----------------------------------------------------------------------------
-QStringList ctkModuleParameter::deprecatedLongFlagAliases() const
+QStringList ctkCmdLineModuleParameter::deprecatedLongFlagAliases() const
 {
-  Q_D(const ctkModuleParameter);
+  Q_D(const ctkCmdLineModuleParameter);
   return d->DeprecatedLongFlagAliases;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleParameter::setLabel(const QString& label)
+void ctkCmdLineModuleParameter::setLabel(const QString& label)
 {
-  Q_D(ctkModuleParameter);
+  Q_D(ctkCmdLineModuleParameter);
   d->Label = label;
 }
 
 //----------------------------------------------------------------------------
-QString ctkModuleParameter::label() const
+QString ctkCmdLineModuleParameter::label() const
 {
-  Q_D(const ctkModuleParameter);
+  Q_D(const ctkCmdLineModuleParameter);
   return d->Label;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleParameter::setConstraints(bool constraints)
+void ctkCmdLineModuleParameter::setConstraints(bool constraints)
 {
-  Q_D(ctkModuleParameter);
+  Q_D(ctkCmdLineModuleParameter);
   d->Constraints = constraints;
 }
 
 //----------------------------------------------------------------------------
-bool ctkModuleParameter::constraints() const
+bool ctkCmdLineModuleParameter::constraints() const
 {
-  Q_D(const ctkModuleParameter);
+  Q_D(const ctkCmdLineModuleParameter);
   return d->Constraints;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleParameter::setMaximum(const QString& maximum)
+void ctkCmdLineModuleParameter::setMaximum(const QString& maximum)
 {
-  Q_D(ctkModuleParameter);
+  Q_D(ctkCmdLineModuleParameter);
   d->Maximum = maximum;
 }
 
 //----------------------------------------------------------------------------
-QString ctkModuleParameter::maximum() const
+QString ctkCmdLineModuleParameter::maximum() const
 {
-  Q_D(const ctkModuleParameter);
+  Q_D(const ctkCmdLineModuleParameter);
   return d->Maximum;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleParameter::setMinimum(const QString& minimum)
+void ctkCmdLineModuleParameter::setMinimum(const QString& minimum)
 {
-  Q_D(ctkModuleParameter);
+  Q_D(ctkCmdLineModuleParameter);
   d->Minimum = minimum;
 }
 
 //----------------------------------------------------------------------------
-QString ctkModuleParameter::minimum() const
+QString ctkCmdLineModuleParameter::minimum() const
 {
-  Q_D(const ctkModuleParameter);
+  Q_D(const ctkCmdLineModuleParameter);
   return d->Minimum;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleParameter::setStep(const QString& step)
+void ctkCmdLineModuleParameter::setStep(const QString& step)
 {
-  Q_D(ctkModuleParameter);
+  Q_D(ctkCmdLineModuleParameter);
   d->Step = step;
 }
 
 //----------------------------------------------------------------------------
-QString ctkModuleParameter::step() const
+QString ctkCmdLineModuleParameter::step() const
 {
-  Q_D(const ctkModuleParameter);
+  Q_D(const ctkCmdLineModuleParameter);
   return d->Step;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleParameter::setDescription(const QString& description)
+void ctkCmdLineModuleParameter::setDescription(const QString& description)
 {
-  Q_D(ctkModuleParameter);
+  Q_D(ctkCmdLineModuleParameter);
   d->Description = description;
 }
 
 //----------------------------------------------------------------------------
-QString ctkModuleParameter::description() const
+QString ctkCmdLineModuleParameter::description() const
 {
-  Q_D(const ctkModuleParameter);
+  Q_D(const ctkCmdLineModuleParameter);
   return d->Description;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleParameter::setChannel(const QString& channel)
+void ctkCmdLineModuleParameter::setChannel(const QString& channel)
 {
-  Q_D(ctkModuleParameter);
+  Q_D(ctkCmdLineModuleParameter);
   d->Channel = channel;
 }
 
 //----------------------------------------------------------------------------
-QString ctkModuleParameter::channel() const
+QString ctkCmdLineModuleParameter::channel() const
 {
-  Q_D(const ctkModuleParameter);
+  Q_D(const ctkCmdLineModuleParameter);
   return d->Channel;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleParameter::setIndex(int index)
+void ctkCmdLineModuleParameter::setIndex(int index)
 {
-  Q_D(ctkModuleParameter);
+  Q_D(ctkCmdLineModuleParameter);
   d->Index = index;
 }
 
 //----------------------------------------------------------------------------
-int ctkModuleParameter::index() const
+int ctkCmdLineModuleParameter::index() const
 {
-  Q_D(const ctkModuleParameter);
+  Q_D(const ctkCmdLineModuleParameter);
   return d->Index;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleParameter::setDefaultValue(const QString& def)
+void ctkCmdLineModuleParameter::setDefaultValue(const QString& def)
 {
-  Q_D(ctkModuleParameter);
+  Q_D(ctkCmdLineModuleParameter);
   d->Default = def;
 }
 
 //----------------------------------------------------------------------------
-QString ctkModuleParameter::defaultValue() const
+QString ctkCmdLineModuleParameter::defaultValue() const
 {
-  Q_D(const ctkModuleParameter);
+  Q_D(const ctkCmdLineModuleParameter);
   return d->Default;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleParameter::setFlag(const QString& flag)
+void ctkCmdLineModuleParameter::setFlag(const QString& flag)
 {
-  Q_D(ctkModuleParameter);
+  Q_D(ctkCmdLineModuleParameter);
   d->Flag = flag;
 }
 
 //----------------------------------------------------------------------------
-QString ctkModuleParameter::flag() const
+QString ctkCmdLineModuleParameter::flag() const
 {
-  Q_D(const ctkModuleParameter);
+  Q_D(const ctkCmdLineModuleParameter);
   return d->Flag;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleParameter::setFlagAliasesAsString(const QString& aliases)
+void ctkCmdLineModuleParameter::setFlagAliasesAsString(const QString& aliases)
 {
-  Q_D(ctkModuleParameter);
+  Q_D(ctkCmdLineModuleParameter);
   d->FlagAliases = d->splitAndTrim(aliases, ",");
   d->FlagAliasesAsString = d->FlagAliases.join(", ");
 }
 
 //----------------------------------------------------------------------------
-QString ctkModuleParameter::flagAliasesAsString() const
+QString ctkCmdLineModuleParameter::flagAliasesAsString() const
 {
-  Q_D(const ctkModuleParameter);
+  Q_D(const ctkCmdLineModuleParameter);
   return d->FlagAliasesAsString;
 }
 
 //----------------------------------------------------------------------------
-QStringList ctkModuleParameter::flagAliases() const
+QStringList ctkCmdLineModuleParameter::flagAliases() const
 {
-  Q_D(const ctkModuleParameter);
+  Q_D(const ctkCmdLineModuleParameter);
   return d->FlagAliases;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleParameter::setDeprecatedFlagAliasesAsString(const QString& aliases)
+void ctkCmdLineModuleParameter::setDeprecatedFlagAliasesAsString(const QString& aliases)
 {
-  Q_D(ctkModuleParameter);
+  Q_D(ctkCmdLineModuleParameter);
   d->DeprecatedFlagAliases = d->splitAndTrim(aliases, ",");
   d->DeprecatedFlagAliasesAsString = d->DeprecatedFlagAliases.join(", ");
 }
 
 //----------------------------------------------------------------------------
-QString ctkModuleParameter::deprecatedFlagAliasesAsString() const
+QString ctkCmdLineModuleParameter::deprecatedFlagAliasesAsString() const
 {
-  Q_D(const ctkModuleParameter);
+  Q_D(const ctkCmdLineModuleParameter);
   return d->DeprecatedFlagAliasesAsString;
 }
 
 //----------------------------------------------------------------------------
-QStringList ctkModuleParameter::deprecatedFlagAliases() const
+QStringList ctkCmdLineModuleParameter::deprecatedFlagAliases() const
 {
-  Q_D(const ctkModuleParameter);
+  Q_D(const ctkCmdLineModuleParameter);
   return d->DeprecatedFlagAliases;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleParameter::setMultiple(bool multiple)
+void ctkCmdLineModuleParameter::setMultiple(bool multiple)
 {
-  Q_D(ctkModuleParameter);
+  Q_D(ctkCmdLineModuleParameter);
   d->Multiple = multiple;
 }
 
 //----------------------------------------------------------------------------
-bool ctkModuleParameter::multiple() const
+bool ctkCmdLineModuleParameter::multiple() const
 {
-  Q_D(const ctkModuleParameter);
+  Q_D(const ctkCmdLineModuleParameter);
   return d->Multiple;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleParameter::setAggregate(const QString& aggregate)
+void ctkCmdLineModuleParameter::setAggregate(const QString& aggregate)
 {
-  Q_D(ctkModuleParameter);
+  Q_D(ctkCmdLineModuleParameter);
   d->Aggregate = aggregate;
 }
 
 //----------------------------------------------------------------------------
-QString ctkModuleParameter::aggregate() const
+QString ctkCmdLineModuleParameter::aggregate() const
 {
-  Q_D(const ctkModuleParameter);
+  Q_D(const ctkCmdLineModuleParameter);
   return d->Aggregate;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleParameter::setFileExtensionsAsString(const QString& extensions)
+void ctkCmdLineModuleParameter::setFileExtensionsAsString(const QString& extensions)
 {
-  Q_D(ctkModuleParameter);
+  Q_D(ctkCmdLineModuleParameter);
   d->FileExtensions = d->splitAndTrim(extensions, ",");
   d->FileExtensionsAsString = d->FileExtensions.join(",");
 }
 
 //----------------------------------------------------------------------------
-QString ctkModuleParameter::fileExtensionsAsString() const
+QString ctkCmdLineModuleParameter::fileExtensionsAsString() const
 {
-  Q_D(const ctkModuleParameter);
+  Q_D(const ctkCmdLineModuleParameter);
   return d->FileExtensionsAsString;
 }
 
 //----------------------------------------------------------------------------
-QStringList ctkModuleParameter::fileExtensions() const
+QStringList ctkCmdLineModuleParameter::fileExtensions() const
 {
-  Q_D(const ctkModuleParameter);
+  Q_D(const ctkCmdLineModuleParameter);
   return d->FileExtensions;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleParameter::setCoordinateSystem(const QString& coordinateSystem)
+void ctkCmdLineModuleParameter::setCoordinateSystem(const QString& coordinateSystem)
 {
-  Q_D(ctkModuleParameter);
+  Q_D(ctkCmdLineModuleParameter);
   d->CoordinateSystem = coordinateSystem;
 }
 
 //----------------------------------------------------------------------------
-QString ctkModuleParameter::coordinateSystem() const
+QString ctkCmdLineModuleParameter::coordinateSystem() const
 {
-  Q_D(const ctkModuleParameter);
+  Q_D(const ctkCmdLineModuleParameter);
   return d->CoordinateSystem;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleParameter::addElement(const QString &elem)
+void ctkCmdLineModuleParameter::addElement(const QString &elem)
 {
-  Q_D(ctkModuleParameter);
+  Q_D(ctkCmdLineModuleParameter);
   d->Elements.push_back(elem);
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleParameter::setElements(const QStringList& elems)
+void ctkCmdLineModuleParameter::setElements(const QStringList& elems)
 {
-  Q_D(ctkModuleParameter);
+  Q_D(ctkCmdLineModuleParameter);
   d->Elements = elems;
 }
 
 //----------------------------------------------------------------------------
-QStringList ctkModuleParameter::elements() const
+QStringList ctkCmdLineModuleParameter::elements() const
 {
-  Q_D(const ctkModuleParameter);
+  Q_D(const ctkCmdLineModuleParameter);
   return d->Elements;
 }
 
 //----------------------------------------------------------------------------
-//QStringList& ctkModuleParameter::elements()
+//QStringList& ctkCmdLineModuleParameter::elements()
 //{
 //  return d->Elements;
 //}
 
 //----------------------------------------------------------------------------
-QTextStream& operator<<(QTextStream& os, const ctkModuleParameter& parameter)
+QTextStream& operator<<(QTextStream& os, const ctkCmdLineModuleParameter& parameter)
 {
   os << "    Parameter" << '\n';
   os << "      " << "Tag: " << parameter.tag() << '\n';

Libs/CommandLineModules/ctkModuleParameter.h

@@ -18,32 +18,32 @@
 
 =============================================================================*/
 
-#ifndef __ctkModuleParameter_h
-#define __ctkModuleParameter_h
+#ifndef __ctkCmdLineModuleParameter_h
+#define __ctkCmdLineModuleParameter_h
 
 #include "ctkCommandLineModulesExport.h"
 
 #include <QTextStream>
 
-class ctkModuleParameterPrivate;
+class ctkCmdLineModuleParameterPrivate;
 
 /** 
  *  \brief Single parameter to a module, like a threshold of a filter.
  *
- * ctkModuleParameter describes a single parameters to a
+ * ctkCmdLineModuleParameter describes a single parameters to a
  * module. Information on the parameter type, name, flag, label,
  * description, channel, index, default, and constraints can be
  * stored.
  *
  */
-class CTK_CMDLINEMODULE_EXPORT ctkModuleParameter
+class CTK_CMDLINEMODULE_EXPORT ctkCmdLineModuleParameter
 {
-  Q_DECLARE_PRIVATE(ctkModuleParameter)
+  Q_DECLARE_PRIVATE(ctkCmdLineModuleParameter)
 
 public:
 
-  ctkModuleParameter();
-  ~ctkModuleParameter();
+  ctkCmdLineModuleParameter();
+  ~ctkCmdLineModuleParameter();
 
   void setTag(const QString& tag);
   QString tag() const;
@@ -147,11 +147,11 @@ public:
 
 private:
 
-  Q_DISABLE_COPY(ctkModuleParameter)
+  Q_DISABLE_COPY(ctkCmdLineModuleParameter)
 
-  ctkModuleParameterPrivate * const d_ptr;
+  ctkCmdLineModuleParameterPrivate * const d_ptr;
 };
 
-CTK_CMDLINEMODULE_EXPORT QTextStream& operator<<(QTextStream& os, const ctkModuleParameter& parameter);
+CTK_CMDLINEMODULE_EXPORT QTextStream& operator<<(QTextStream& os, const ctkCmdLineModuleParameter& parameter);
 
 #endif

Libs/CommandLineModules/ctkModuleParameterGroup.cpp

@@ -18,11 +18,11 @@ limitations under the License.
 
 =============================================================================*/
 
-#include "ctkModuleParameterGroup.h"
+#include "ctkCmdLineModuleParameterGroup.h"
 
-struct ctkModuleParameterGroupPrivate
+struct ctkCmdLineModuleParameterGroupPrivate
 {
-  ~ctkModuleParameterGroupPrivate()
+  ~ctkCmdLineModuleParameterGroupPrivate()
   {
     qDeleteAll(Parameters);
   }
@@ -30,82 +30,82 @@ struct ctkModuleParameterGroupPrivate
   QString Label;
   QString Description;
   bool Advanced;
-  QList<ctkModuleParameter*> Parameters;
+  QList<ctkCmdLineModuleParameter*> Parameters;
 };
 
 //----------------------------------------------------------------------------
-ctkModuleParameterGroup::ctkModuleParameterGroup()
-  : d_ptr(new ctkModuleParameterGroupPrivate())
+ctkCmdLineModuleParameterGroup::ctkCmdLineModuleParameterGroup()
+  : d_ptr(new ctkCmdLineModuleParameterGroupPrivate())
 {
 }
 
 //----------------------------------------------------------------------------
-ctkModuleParameterGroup::~ctkModuleParameterGroup()
+ctkCmdLineModuleParameterGroup::~ctkCmdLineModuleParameterGroup()
 {
   delete d_ptr;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleParameterGroup::setLabel(const QString& label)
+void ctkCmdLineModuleParameterGroup::setLabel(const QString& label)
 {
-  Q_D(ctkModuleParameterGroup);
+  Q_D(ctkCmdLineModuleParameterGroup);
   d->Label = label;
 }
 
 //----------------------------------------------------------------------------
-QString ctkModuleParameterGroup::label() const
+QString ctkCmdLineModuleParameterGroup::label() const
 {
-  Q_D(const ctkModuleParameterGroup);
+  Q_D(const ctkCmdLineModuleParameterGroup);
   return d->Label;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleParameterGroup::setDescription(const QString& description)
+void ctkCmdLineModuleParameterGroup::setDescription(const QString& description)
 {
-  Q_D(ctkModuleParameterGroup);
+  Q_D(ctkCmdLineModuleParameterGroup);
   d->Description = description;
 }
 
 //----------------------------------------------------------------------------
-QString ctkModuleParameterGroup::description() const
+QString ctkCmdLineModuleParameterGroup::description() const
 {
-  Q_D(const ctkModuleParameterGroup);
+  Q_D(const ctkCmdLineModuleParameterGroup);
   return d->Description;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleParameterGroup::setAdvanced(bool advanced)
+void ctkCmdLineModuleParameterGroup::setAdvanced(bool advanced)
 {
-  Q_D(ctkModuleParameterGroup);
+  Q_D(ctkCmdLineModuleParameterGroup);
   d->Advanced = advanced;
 }
 
 //----------------------------------------------------------------------------
-bool ctkModuleParameterGroup::advanced() const
+bool ctkCmdLineModuleParameterGroup::advanced() const
 {
-  Q_D(const ctkModuleParameterGroup);
+  Q_D(const ctkCmdLineModuleParameterGroup);
   return d->Advanced;
 }
 
 //----------------------------------------------------------------------------
-void ctkModuleParameterGroup::addParameter(ctkModuleParameter* parameter)
+void ctkCmdLineModuleParameterGroup::addParameter(ctkCmdLineModuleParameter* parameter)
 {
-  Q_D(ctkModuleParameterGroup);
+  Q_D(ctkCmdLineModuleParameterGroup);
   d->Parameters.push_back(parameter);
 }
 
 //----------------------------------------------------------------------------
-QList<ctkModuleParameter*> ctkModuleParameterGroup::parameters() const
+QList<ctkCmdLineModuleParameter*> ctkCmdLineModuleParameterGroup::parameters() const
 {
-  Q_D(const ctkModuleParameterGroup);
+  Q_D(const ctkCmdLineModuleParameterGroup);
   return d->Parameters;
 }
 
 //----------------------------------------------------------------------------
-bool ctkModuleParameterGroup::hasParameter(const QString& name) const
+bool ctkCmdLineModuleParameterGroup::hasParameter(const QString& name) const
 {
-  Q_D(const ctkModuleParameterGroup);
-  foreach(const ctkModuleParameter* param, d->Parameters)
+  Q_D(const ctkCmdLineModuleParameterGroup);
+  foreach(const ctkCmdLineModuleParameter* param, d->Parameters)
   {
     if (param->name() == name) return true;
   }
@@ -113,10 +113,10 @@ bool ctkModuleParameterGroup::hasParameter(const QString& name) const
 }
 
 //----------------------------------------------------------------------------
-ctkModuleParameter* ctkModuleParameterGroup::parameter(const QString& name) const
+ctkCmdLineModuleParameter* ctkCmdLineModuleParameterGroup::parameter(const QString& name) const
 {
-  Q_D(const ctkModuleParameterGroup);
-  foreach(ctkModuleParameter* param, d->Parameters)
+  Q_D(const ctkCmdLineModuleParameterGroup);
+  foreach(ctkCmdLineModuleParameter* param, d->Parameters)
   {
     if (param->name() == name) return param;
   }
@@ -124,11 +124,11 @@ ctkModuleParameter* ctkModuleParameterGroup::parameter(const QString& name) cons
 }
 
 //----------------------------------------------------------------------------
-bool ctkModuleParameterGroup::hasReturnParameters() const
+bool ctkCmdLineModuleParameterGroup::hasReturnParameters() const
 {
-  Q_D(const ctkModuleParameterGroup);
+  Q_D(const ctkCmdLineModuleParameterGroup);
   // iterate over each parameter in d group
-  foreach(const ctkModuleParameter* param, d->Parameters)
+  foreach(const ctkCmdLineModuleParameter* param, d->Parameters)
   {
     if (param->isReturnParameter())
     {
@@ -139,11 +139,11 @@ bool ctkModuleParameterGroup::hasReturnParameters() const
 }
 
 //----------------------------------------------------------------------------
-bool ctkModuleParameterGroup::writeParameterFile(QTextStream& in, bool withHandlesToBulkParameters) const
+bool ctkCmdLineModuleParameterGroup::writeParameterFile(QTextStream& in, bool withHandlesToBulkParameters) const
 {
-  Q_D(const ctkModuleParameterGroup);
+  Q_D(const ctkCmdLineModuleParameterGroup);
   // iterate over each parameter in d group
-  foreach(const ctkModuleParameter* param, d->Parameters)
+  foreach(const ctkCmdLineModuleParameter* param, d->Parameters)
   {
     // write out all parameters or just the ones that are not bulk parameters
     QString tag = param->tag();
@@ -160,13 +160,13 @@ bool ctkModuleParameterGroup::writeParameterFile(QTextStream& in, bool withHandl
 }
 
 //----------------------------------------------------------------------------
-QTextStream & operator<<(QTextStream &os, const ctkModuleParameterGroup &group)
+QTextStream & operator<<(QTextStream &os, const ctkCmdLineModuleParameterGroup &group)
 { 
   os << "  Advanced: " << (group.advanced() ? "true" : "false") << '\n';
   os << "  Label: " << group.label() << '\n';
   os << "  Description: " << group.description() << '\n';
   os << "  Parameters: " << '\n';
-  foreach(ctkModuleParameter* param, group.parameters())
+  foreach(ctkCmdLineModuleParameter* param, group.parameters())
   {
     os << *param;
   }

Libs/CommandLineModules/ctkModuleParameterGroup.h

@@ -18,25 +18,25 @@
 
 =============================================================================*/
 
-#ifndef __ctkModuleParameterGroup_h
-#define __ctkModuleParameterGroup_h
+#ifndef __ctkCmdLineModuleParameterGroup_h
+#define __ctkCmdLineModuleParameterGroup_h
 
-#include "ctkModuleParameter.h"
+#include "ctkCmdLineModuleParameter.h"
 
-class ctkModuleParameterGroupPrivate;
+class ctkCmdLineModuleParameterGroupPrivate;
 
 /** 
 *  \brief Group of parameters
 *
 */
-class CTK_CMDLINEMODULE_EXPORT ctkModuleParameterGroup
+class CTK_CMDLINEMODULE_EXPORT ctkCmdLineModuleParameterGroup
 {
-  Q_DECLARE_PRIVATE(ctkModuleParameterGroup)
+  Q_DECLARE_PRIVATE(ctkCmdLineModuleParameterGroup)
 
 public:
 
-  ctkModuleParameterGroup();
-  ~ctkModuleParameterGroup();
+  ctkCmdLineModuleParameterGroup();
+  ~ctkCmdLineModuleParameterGroup();
   
   void setLabel(const QString& label);
   QString label() const;
@@ -47,12 +47,12 @@ public:
   void setAdvanced(bool advanced);
   bool advanced() const;
 
-  void addParameter(ctkModuleParameter* parameter);
-  QList<ctkModuleParameter*> parameters() const;
+  void addParameter(ctkCmdLineModuleParameter* parameter);
+  QList<ctkCmdLineModuleParameter*> parameters() const;
 
   bool hasParameter(const QString& name) const;
 
-  ctkModuleParameter* parameter(const QString& name) const;
+  ctkCmdLineModuleParameter* parameter(const QString& name) const;
 
   bool hasReturnParameters() const;
 
@@ -60,11 +60,11 @@ public:
   
 private:
 
-  Q_DISABLE_COPY(ctkModuleParameterGroup)
+  Q_DISABLE_COPY(ctkCmdLineModuleParameterGroup)
 
-  ctkModuleParameterGroupPrivate * const d_ptr;
+  ctkCmdLineModuleParameterGroupPrivate * const d_ptr;
 };
 
-CTK_CMDLINEMODULE_EXPORT QTextStream & operator<<(QTextStream &os, const ctkModuleParameterGroup& group);
+CTK_CMDLINEMODULE_EXPORT QTextStream & operator<<(QTextStream &os, const ctkCmdLineModuleParameterGroup& group);
 
 #endif

Libs/CommandLineModules/ctkModuleParameterParsers_p.h

@@ -19,12 +19,12 @@
   
 =============================================================================*/
 
-#ifndef CTKMODULEPARAMETERPARSERS_P_H
-#define CTKMODULEPARAMETERPARSERS_P_H
+#ifndef CTKCMDLINEMODULEPARAMETERPARSERS_P_H
+#define CTKCMDLINEMODULEPARAMETERPARSERS_P_H
 
 #include <QXmlStreamReader>
 
-#include "ctkModuleParameter.h"
+#include "ctkCmdLineModuleParameter.h"
 
 namespace {
 
@@ -40,15 +40,15 @@ static bool parseBooleanAttribute(const QStringRef& attrValue)
 
 }
 
-struct ctkModuleParameterParser
+struct ctkCmdLineModuleParameterParser
 {
 public:
 
-  virtual ~ctkModuleParameterParser() {}
+  virtual ~ctkCmdLineModuleParameterParser() {}
 
-  virtual ctkModuleParameter* parse(QXmlStreamReader &xmlReader)
+  virtual ctkCmdLineModuleParameter* parse(QXmlStreamReader &xmlReader)
   {
-    ctkModuleParameter* moduleParam = this->createModuleParameter();
+    ctkCmdLineModuleParameter* moduleParam = this->createModuleParameter();
 
     this->handleAttributes(moduleParam, xmlReader);
 
@@ -62,18 +62,18 @@ public:
 
 protected:
 
-  virtual ctkModuleParameter* createModuleParameter()
+  virtual ctkCmdLineModuleParameter* createModuleParameter()
   {
-    return new ctkModuleParameter;
+    return new ctkCmdLineModuleParameter;
   }
 
-  virtual void handleAttributes(ctkModuleParameter* moduleParam, QXmlStreamReader& xmlReader)
+  virtual void handleAttributes(ctkCmdLineModuleParameter* moduleParam, QXmlStreamReader& xmlReader)
   {
     // handle common attributes
     moduleParam->setHidden(parseBooleanAttribute(xmlReader.attributes().value("hidden")));
   }
 
-  virtual bool handleSubElement(ctkModuleParameter* moduleParam, QXmlStreamReader& xmlReader)
+  virtual bool handleSubElement(ctkCmdLineModuleParameter* moduleParam, QXmlStreamReader& xmlReader)
   {
     // handle common sub-elements
 
@@ -124,7 +124,7 @@ protected:
     return true;
   }
 
-  bool handleConstraintsElement(ctkModuleParameter* moduleParam, QXmlStreamReader& xmlReader)
+  bool handleConstraintsElement(ctkCmdLineModuleParameter* moduleParam, QXmlStreamReader& xmlReader)
   {
     moduleParam->setConstraints(true);
     while(xmlReader.readNextStartElement())
@@ -152,24 +152,24 @@ protected:
   }
 };
 
-class ctkModuleMultipleParameterParser : public ctkModuleParameterParser
+class ctkCmdLineModuleMultipleParameterParser : public ctkCmdLineModuleParameterParser
 {
 
 protected:
 
-  void handleAttributes(ctkModuleParameter* moduleParam, QXmlStreamReader& xmlReader)
+  void handleAttributes(ctkCmdLineModuleParameter* moduleParam, QXmlStreamReader& xmlReader)
   {
-    ctkModuleParameterParser::handleAttributes(moduleParam, xmlReader);
+    ctkCmdLineModuleParameterParser::handleAttributes(moduleParam, xmlReader);
     moduleParam->setHidden(parseBooleanAttribute(xmlReader.attributes().value("multiple")));
   }
 };
 
-class ctkModuleScalarVectorParameterParser : public ctkModuleParameterParser
+class ctkCmdLineModuleScalarVectorParameterParser : public ctkCmdLineModuleParameterParser
 {
 
 protected:
 
-  bool handleSubElement(ctkModuleParameter* moduleParam, QXmlStreamReader& xmlReader)
+  bool handleSubElement(ctkCmdLineModuleParameter* moduleParam, QXmlStreamReader& xmlReader)
   {
     QStringRef name = xmlReader.name();
 
@@ -179,17 +179,17 @@ protected:
     }
     else
     {
-      return ctkModuleParameterParser::handleSubElement(moduleParam, xmlReader);
+      return ctkCmdLineModuleParameterParser::handleSubElement(moduleParam, xmlReader);
     }
   }
 };
 
-class ctkModuleScalarParameterParser : public ctkModuleMultipleParameterParser
+class ctkCmdLineModuleScalarParameterParser : public ctkCmdLineModuleMultipleParameterParser
 {
 
 protected:
 
-  bool handleSubElement(ctkModuleParameter* moduleParam, QXmlStreamReader& xmlReader)
+  bool handleSubElement(ctkCmdLineModuleParameter* moduleParam, QXmlStreamReader& xmlReader)
   {
     QStringRef name = xmlReader.name();
 
@@ -199,17 +199,17 @@ protected:
     }
     else
     {
-      return ctkModuleMultipleParameterParser::handleSubElement(moduleParam, xmlReader);
+      return ctkCmdLineModuleMultipleParameterParser::handleSubElement(moduleParam, xmlReader);
     }
   }
 };
 
-class ctkModuleEnumerationParameterParser : public ctkModuleParameterParser
+class ctkCmdLineModuleEnumerationParameterParser : public ctkCmdLineModuleParameterParser
 {
 
 protected:
 
-  bool handleSubElement(ctkModuleParameter* moduleParam, QXmlStreamReader& xmlReader)
+  bool handleSubElement(ctkCmdLineModuleParameter* moduleParam, QXmlStreamReader& xmlReader)
   {
     QStringRef name = xmlReader.name();
 
@@ -220,29 +220,29 @@ protected:
     }
     else
     {
-      return ctkModuleParameterParser::handleSubElement(moduleParam, xmlReader);
+      return ctkCmdLineModuleParameterParser::handleSubElement(moduleParam, xmlReader);
     }
   }
 };
 
-class ctkModulePointParameterParser : public ctkModuleMultipleParameterParser
+class ctkCmdLineModulePointParameterParser : public ctkCmdLineModuleMultipleParameterParser
 {
 
 protected:
 
-  void handleAttributes(ctkModuleParameter* moduleParam, QXmlStreamReader& xmlReader)
+  void handleAttributes(ctkCmdLineModuleParameter* moduleParam, QXmlStreamReader& xmlReader)
   {
-    ctkModuleMultipleParameterParser::handleAttributes(moduleParam, xmlReader);
+    ctkCmdLineModuleMultipleParameterParser::handleAttributes(moduleParam, xmlReader);
     moduleParam->setCoordinateSystem(xmlReader.attributes().value("coordinateSystem").toString().trimmed());
   }
 };
 
-class ctkModuleChannelParameterParser : public ctkModuleMultipleParameterParser
+class ctkCmdLineModuleChannelParameterParser : public ctkCmdLineModuleMultipleParameterParser
 {
 
 protected:
 
-  bool handleSubElement(ctkModuleParameter* moduleParam, QXmlStreamReader& xmlReader)
+  bool handleSubElement(ctkCmdLineModuleParameter* moduleParam, QXmlStreamReader& xmlReader)
   {
     QStringRef name = xmlReader.name();
 
@@ -253,48 +253,48 @@ protected:
     }
     else
     {
-      return ctkModuleMultipleParameterParser::handleSubElement(moduleParam, xmlReader);
+      return ctkCmdLineModuleMultipleParameterParser::handleSubElement(moduleParam, xmlReader);
     }
   }
 };
 
-class ctkModuleFileParameterParser : public ctkModuleChannelParameterParser
+class ctkCmdLineModuleFileParameterParser : public ctkCmdLineModuleChannelParameterParser
 {
 
 protected:
 
-  void handleAttributes(ctkModuleParameter* moduleParam, QXmlStreamReader& xmlReader)
+  void handleAttributes(ctkCmdLineModuleParameter* moduleParam, QXmlStreamReader& xmlReader)
   {
-    ctkModuleChannelParameterParser::handleAttributes(moduleParam, xmlReader);
+    ctkCmdLineModuleChannelParameterParser::handleAttributes(moduleParam, xmlReader);
     moduleParam->setFileExtensionsAsString(xmlReader.attributes().value("fileExtensions").toString().trimmed());
   }
 };
 
-class ctkModuleGeometryParameterParser : public ctkModuleMultipleParameterParser
+class ctkCmdLineModuleGeometryParameterParser : public ctkCmdLineModuleMultipleParameterParser
 {
 
 protected:
 
-  void handleAttributes(ctkModuleParameter* moduleParam, QXmlStreamReader& xmlReader)
+  void handleAttributes(ctkCmdLineModuleParameter* moduleParam, QXmlStreamReader& xmlReader)
   {
-    ctkModuleMultipleParameterParser::handleAttributes(moduleParam, xmlReader);
+    ctkCmdLineModuleMultipleParameterParser::handleAttributes(moduleParam, xmlReader);
     moduleParam->setFileExtensionsAsString(xmlReader.attributes().value("fileExtensions").toString().trimmed());
     moduleParam->setType(xmlReader.attributes().value("type").toString().trimmed());
   }
 };
 
-class ctkModuleImageParameterParser : public ctkModuleChannelParameterParser
+class ctkCmdLineModuleImageParameterParser : public ctkCmdLineModuleChannelParameterParser
 {
 
 protected:
 
-  void handleAttributes(ctkModuleParameter* moduleParam, QXmlStreamReader& xmlReader)
+  void handleAttributes(ctkCmdLineModuleParameter* moduleParam, QXmlStreamReader& xmlReader)
   {
-    ctkModuleChannelParameterParser::handleAttributes(moduleParam, xmlReader);
+    ctkCmdLineModuleChannelParameterParser::handleAttributes(moduleParam, xmlReader);
     moduleParam->setFileExtensionsAsString(xmlReader.attributes().value("fileExtensions").toString().trimmed());
     moduleParam->setType(xmlReader.attributes().value("type").toString().trimmed());
   }
 };
 
 
-#endif // CTKMODULEPARAMETERPARSERS_P_H
+#endif // CTKCMDLINEMODULEPARAMETERPARSERS_P_H

Libs/CommandLineModules/ctkModuleProcessException.cpp

@@ -19,41 +19,41 @@
   
 =============================================================================*/
 
-#include "ctkModuleProcessException.h"
+#include "ctkCmdLineModuleProcessException.h"
 
-ctkModuleProcessException::ctkModuleProcessException(const QString& msg, int code,
+ctkCmdLineModuleProcessException::ctkCmdLineModuleProcessException(const QString& msg, int code,
                                                      QProcess::ExitStatus status)
   : msg(msg), code(code), status(status)
 {}
 
-int ctkModuleProcessException::exitCode() const
+int ctkCmdLineModuleProcessException::exitCode() const
 {
   return code;
 }
 
-QProcess::ExitStatus ctkModuleProcessException::exitStatus() const
+QProcess::ExitStatus ctkCmdLineModuleProcessException::exitStatus() const
 {
   return status;
 }
 
-QString ctkModuleProcessException::message() const
+QString ctkCmdLineModuleProcessException::message() const
 {
   return msg;
 }
 
-const char* ctkModuleProcessException::what() const throw()
+const char* ctkCmdLineModuleProcessException::what() const throw()
 {
   static std::string strMsg;
   strMsg = msg.toStdString();
   return strMsg.c_str();
 }
 
-void ctkModuleProcessException::raise() const
+void ctkCmdLineModuleProcessException::raise() const
 {
   throw *this;
 }
 
-ctkModuleProcessException* ctkModuleProcessException::clone() const
+ctkCmdLineModuleProcessException* ctkCmdLineModuleProcessException::clone() const
 {
-  return new ctkModuleProcessException(*this);
+  return new ctkCmdLineModuleProcessException(*this);
 }

Libs/CommandLineModules/ctkModuleProcessException.h

@@ -19,21 +19,21 @@
   
 =============================================================================*/
 
-#ifndef CTKMODULEPROCESSEXCEPTION_H
-#define CTKMODULEPROCESSEXCEPTION_H
+#ifndef CTKCMDLINEMODULEPROCESSEXCEPTION_H
+#define CTKCMDLINEMODULEPROCESSEXCEPTION_H
 
 #include <qtconcurrentexception.h>
 
 #include <QProcess>
 
-class ctkModuleProcessException : public QtConcurrent::Exception
+class ctkCmdLineModuleProcessException : public QtConcurrent::Exception
 {
 public:
 
-  ctkModuleProcessException(const QString& msg, int code = 0,
+  ctkCmdLineModuleProcessException(const QString& msg, int code = 0,
                             QProcess::ExitStatus status = QProcess::NormalExit);
 
-  ~ctkModuleProcessException() throw() {}
+  ~ctkCmdLineModuleProcessException() throw() {}
 
   int exitCode() const;
 
@@ -44,7 +44,7 @@ public:
   const char* what() const throw();
 
   void raise() const;
-  ctkModuleProcessException* clone() const;
+  ctkCmdLineModuleProcessException* clone() const;
 
 private:
 
@@ -53,4 +53,4 @@ private:
   QProcess::ExitStatus status;
 };
 
-#endif // CTKMODULEPROCESSEXCEPTION_H
+#endif // CTKCMDLINEMODULEPROCESSEXCEPTION_H

Libs/CommandLineModules/ctkModuleProcessFuture.cpp

@@ -19,11 +19,11 @@
   
 =============================================================================*/
 
-#include "ctkModuleProcessFuture.h"
+#include "ctkCmdLineModuleProcessFuture.h"
 
-struct ctkModuleProcessFutureInterfacePrivate
+struct ctkCmdLineModuleProcessFutureInterfacePrivate
 {
-  ctkModuleProcessFutureInterfacePrivate()
+  ctkCmdLineModuleProcessFutureInterfacePrivate()
     : refCount(1), _exitCode(0), _exitStatus(QProcess::NormalExit),
       _processError(QProcess::UnknownError)
   {}
@@ -38,20 +38,20 @@ struct ctkModuleProcessFutureInterfacePrivate
   QString _stdErr;
 };
 
-ctkModuleProcessFutureInterface::QFutureInterface(State initialState)
-  : QFutureInterfaceBase(initialState), d(new ctkModuleProcessFutureInterfacePrivate)
+ctkCmdLineModuleProcessFutureInterface::QFutureInterface(State initialState)
+  : QFutureInterfaceBase(initialState), d(new ctkCmdLineModuleProcessFutureInterfacePrivate)
 { }
 
-ctkModuleProcessFutureInterface::QFutureInterface(const ctkModuleProcessFutureInterface& other)
+ctkCmdLineModuleProcessFutureInterface::QFutureInterface(const ctkCmdLineModuleProcessFutureInterface& other)
   : QFutureInterfaceBase(other), d(other.d)
 {
   d->refCount.ref();
 }
 
-ctkModuleProcessFutureInterface ctkModuleProcessFutureInterface::canceledResult()
-{ return ctkModuleProcessFutureInterface(State(Started | Finished | Canceled)); }
+ctkCmdLineModuleProcessFutureInterface ctkCmdLineModuleProcessFutureInterface::canceledResult()
+{ return ctkCmdLineModuleProcessFutureInterface(State(Started | Finished | Canceled)); }
 
-ctkModuleProcessFutureInterface& ctkModuleProcessFutureInterface::operator=(const ctkModuleProcessFutureInterface& other)
+ctkCmdLineModuleProcessFutureInterface& ctkCmdLineModuleProcessFutureInterface::operator=(const ctkCmdLineModuleProcessFutureInterface& other)
 {
   QFutureInterfaceBase::operator=(other);
   other.d->refCount.ref();
@@ -60,38 +60,38 @@ ctkModuleProcessFutureInterface& ctkModuleProcessFutureInterface::operator=(cons
   return *this;
 }
 
-int ctkModuleProcessFutureInterface::exitCode() const
+int ctkCmdLineModuleProcessFutureInterface::exitCode() const
 { QMutexLocker lock(this->mutex()); return d->_exitCode; }
 
-void ctkModuleProcessFutureInterface::reportExitCode(int code)
+void ctkCmdLineModuleProcessFutureInterface::reportExitCode(int code)
 { QMutexLocker lock(this->mutex()); d->_exitCode = code; }
 
-QProcess::ExitStatus ctkModuleProcessFutureInterface::exitStatus() const
+QProcess::ExitStatus ctkCmdLineModuleProcessFutureInterface::exitStatus() const
 { QMutexLocker lock(this->mutex()); return d->_exitStatus; }
 
-void ctkModuleProcessFutureInterface::reportExitStatus(QProcess::ExitStatus status)
+void ctkCmdLineModuleProcessFutureInterface::reportExitStatus(QProcess::ExitStatus status)
 { QMutexLocker lock(this->mutex()); d->_exitStatus = status; }
 
-QProcess::ProcessError ctkModuleProcessFutureInterface::error() const
+QProcess::ProcessError ctkCmdLineModuleProcessFutureInterface::error() const
 { QMutexLocker lock(this->mutex()); return d->_processError; }
 
-void ctkModuleProcessFutureInterface::reportProcessError(QProcess::ProcessError procErr)
+void ctkCmdLineModuleProcessFutureInterface::reportProcessError(QProcess::ProcessError procErr)
 { QMutexLocker lock(this->mutex()); d->_processError = procErr; }
 
-QString ctkModuleProcessFutureInterface::errorString() const
+QString ctkCmdLineModuleProcessFutureInterface::errorString() const
 { QMutexLocker lock(this->mutex()); return d->_errorString; }
 
-void ctkModuleProcessFutureInterface::reportErrorString(const QString& errorStr)
+void ctkCmdLineModuleProcessFutureInterface::reportErrorString(const QString& errorStr)
 { QMutexLocker lock(this->mutex()); d->_errorString = errorStr; }
 
-QString ctkModuleProcessFutureInterface::standardOutput() const
+QString ctkCmdLineModuleProcessFutureInterface::standardOutput() const
 { QMutexLocker lock(this->mutex()); return d->_stdOut; }
 
-void ctkModuleProcessFutureInterface::reportStandardOutput(const QString& stdOut)
+void ctkCmdLineModuleProcessFutureInterface::reportStandardOutput(const QString& stdOut)
 { QMutexLocker lock(this->mutex()); d->_stdOut = stdOut; }
 
-QString ctkModuleProcessFutureInterface::standardError() const
+QString ctkCmdLineModuleProcessFutureInterface::standardError() const
 { QMutexLocker lock(this->mutex()); return d->_stdErr; }
 
-void ctkModuleProcessFutureInterface::reportStandardError(const QString& stdErr)
+void ctkCmdLineModuleProcessFutureInterface::reportStandardError(const QString& stdErr)
 { QMutexLocker lock(this->mutex()); d->_stdErr = stdErr; }

Libs/CommandLineModules/ctkModuleProcessFuture.h

@@ -19,8 +19,8 @@
   
 =============================================================================*/
 
-#ifndef CTKMODULEPROCESSFUTURE_H
-#define CTKMODULEPROCESSFUTURE_H
+#ifndef CTKCMDLINEMODULEPROCESSFUTURE_H
+#define CTKCMDLINEMODULEPROCESSFUTURE_H
 
 #include <ctkCommandLineModulesExport.h>
 
@@ -28,14 +28,14 @@
 #include <QFutureWatcher>
 #include <QProcess>
 
-class ctkModuleProcessFutureInterfacePrivate;
+class ctkCmdLineModuleProcessFutureInterfacePrivate;
 
-struct ctkModuleProcessDummy {};
-typedef QFutureWatcher<ctkModuleProcessDummy> ctkModuleProcessFutureWatcher;
+struct ctkCmdLineModuleProcessDummy {};
+typedef QFutureWatcher<ctkCmdLineModuleProcessDummy> ctkCmdLineModuleProcessFutureWatcher;
 
 
 template<>
-class CTK_CMDLINEMODULE_EXPORT QFutureInterface<ctkModuleProcessDummy> : public QFutureInterfaceBase
+class CTK_CMDLINEMODULE_EXPORT QFutureInterface<ctkCmdLineModuleProcessDummy> : public QFutureInterfaceBase
 {
 
 public:
@@ -67,23 +67,23 @@ public:
 
 private:
 
-  ctkModuleProcessFutureInterfacePrivate* d;
+  ctkCmdLineModuleProcessFutureInterfacePrivate* d;
 };
 
-typedef QFutureInterface<ctkModuleProcessDummy> ctkModuleProcessFutureInterface;
+typedef QFutureInterface<ctkCmdLineModuleProcessDummy> ctkCmdLineModuleProcessFutureInterface;
 
 
 template<>
-class QFuture<ctkModuleProcessDummy>
+class QFuture<ctkCmdLineModuleProcessDummy>
 {
 
 public:
 
   QFuture()
-    : d(ctkModuleProcessFutureInterface::canceledResult())
+    : d(ctkCmdLineModuleProcessFutureInterface::canceledResult())
   { }
 
-  explicit QFuture(ctkModuleProcessFutureInterface *p) // internal
+  explicit QFuture(ctkCmdLineModuleProcessFutureInterface *p) // internal
     : d(*p)
   { }
 
@@ -121,18 +121,18 @@ public:
 
 private:
 
-  friend class QFutureWatcher<ctkModuleProcessDummy>;
+  friend class QFutureWatcher<ctkCmdLineModuleProcessDummy>;
 
-  mutable ctkModuleProcessFutureInterface d;
+  mutable ctkCmdLineModuleProcessFutureInterface d;
 };
 
-typedef QFuture<ctkModuleProcessDummy> ctkModuleProcessFuture;
+typedef QFuture<ctkCmdLineModuleProcessDummy> ctkCmdLineModuleProcessFuture;
 
 
-inline ctkModuleProcessFuture& ctkModuleProcessFuture::operator=(const ctkModuleProcessFuture& other)
+inline ctkCmdLineModuleProcessFuture& ctkCmdLineModuleProcessFuture::operator=(const ctkCmdLineModuleProcessFuture& other)
 {
   d = other.d;
   return *this;
 }
 
-#endif // CTKMODULEPROCESSFUTURE_H
+#endif // CTKCMDLINEMODULEPROCESSFUTURE_H

Libs/CommandLineModules/ctkModuleProcessRunner.cpp

@@ -19,25 +19,25 @@
   
 =============================================================================*/
 
-#include "ctkModuleProcessRunner_p.h"
+#include "ctkCmdLineModuleProcessRunner_p.h"
 
-#include "ctkModuleProcessException.h"
+#include "ctkCmdLineModuleProcessException.h"
 
 
-ctkModuleProcessRunner::ctkModuleProcessRunner(const QString& location, const QStringList& args)
+ctkCmdLineModuleProcessRunner::ctkCmdLineModuleProcessRunner(const QString& location, const QStringList& args)
   : process(), location(location), args(args)
 {
 }
 
-ctkModuleProcessFuture ctkModuleProcessRunner::start()
+ctkCmdLineModuleProcessFuture ctkCmdLineModuleProcessRunner::start()
 {
   this->reportStarted();
-  ctkModuleProcessFuture future(this);
+  ctkCmdLineModuleProcessFuture future(this);
   run();
   return future;
 }
 
-void ctkModuleProcessRunner::run()
+void ctkCmdLineModuleProcessRunner::run()
 {
   connect(&process, SIGNAL(started()), this, SLOT(processStarted()));
   connect(&process, SIGNAL(error(QProcess::ProcessError)), this, SLOT(processError(QProcess::ProcessError)));
@@ -46,13 +46,13 @@ void ctkModuleProcessRunner::run()
   process.start(location, args);
 }
 
-void ctkModuleProcessRunner::processStarted()
+void ctkCmdLineModuleProcessRunner::processStarted()
 {
   qDebug() << "Reporting process started";
   this->reportStarted();
 }
 
-void ctkModuleProcessRunner::processFinished(int exitCode, QProcess::ExitStatus status)
+void ctkCmdLineModuleProcessRunner::processFinished(int exitCode, QProcess::ExitStatus status)
 {
   Q_UNUSED(exitCode)
   Q_UNUSED(status)
@@ -66,9 +66,9 @@ void ctkModuleProcessRunner::processFinished(int exitCode, QProcess::ExitStatus
   this->reportFinished();
 }
 
-void ctkModuleProcessRunner::processError(QProcess::ProcessError)
+void ctkCmdLineModuleProcessRunner::processError(QProcess::ProcessError)
 {
   qDebug() << "Reporting process error";
-  this->reportException(ctkModuleProcessException(process.errorString(), process.exitCode(),
+  this->reportException(ctkCmdLineModuleProcessException(process.errorString(), process.exitCode(),
                                                   process.exitStatus()));
 }

Libs/CommandLineModules/ctkModuleProcessRunner_p.h

@@ -19,23 +19,23 @@
   
 =============================================================================*/
 
-#ifndef CTKMODULEPROCESSRUNNER_P_H
-#define CTKMODULEPROCESSRUNNER_P_H
+#ifndef CTKCMDLINEMODULEPROCESSRUNNER_P_H
+#define CTKCMDLINEMODULEPROCESSRUNNER_P_H
 
 #include <QObject>
 #include <QProcess>
 
-#include "ctkModuleProcessFuture.h"
+#include "ctkCmdLineModuleProcessFuture.h"
 
-class ctkModuleProcessRunner : public QObject, public QRunnable, public ctkModuleProcessFutureInterface
+class ctkCmdLineModuleProcessRunner : public QObject, public QRunnable, public ctkCmdLineModuleProcessFutureInterface
 {
   Q_OBJECT
 
 public:
 
-  ctkModuleProcessRunner(const QString& location, const QStringList& args);
+  ctkCmdLineModuleProcessRunner(const QString& location, const QStringList& args);
 
-  ctkModuleProcessFuture start();
+  ctkCmdLineModuleProcessFuture start();
 
   void run();
 
@@ -54,4 +54,4 @@ private:
   const QStringList args;
 };
 
-#endif // CTKMODULEPROCESSRUNNER_P_H
+#endif // CTKCMDLINEMODULEPROCESSRUNNER_P_H

Libs/CommandLineModules/ctkModuleReference.cpp

@@ -19,27 +19,27 @@
   
 =============================================================================*/
 
-#include "ctkModuleReference.h"
-#include "ctkModuleReferencePrivate.h"
+#include "ctkCmdLineModuleReference.h"
+#include "ctkCmdLineModuleReferencePrivate.h"
 
-ctkModuleReference::ctkModuleReference()
-  : d(new ctkModuleReferencePrivate)
+ctkCmdLineModuleReference::ctkCmdLineModuleReference()
+  : d(new ctkCmdLineModuleReferencePrivate)
 {}
 
-ctkModuleReference::~ctkModuleReference()
+ctkCmdLineModuleReference::~ctkCmdLineModuleReference()
 {
   if (!d->ref.deref()) delete d;
 }
 
-ctkModuleReference::ctkModuleReference(const ctkModuleReference &ref)
+ctkCmdLineModuleReference::ctkCmdLineModuleReference(const ctkCmdLineModuleReference &ref)
   : d(ref.d)
 {
   d->ref.ref();
 }
 
-ctkModuleReference &ctkModuleReference::operator =(const ctkModuleReference &ref)
+ctkCmdLineModuleReference &ctkCmdLineModuleReference::operator =(const ctkCmdLineModuleReference &ref)
 {
-  ctkModuleReferencePrivate* curr = d;
+  ctkCmdLineModuleReferencePrivate* curr = d;
   d = ref.d;
   d->ref.ref();
 
@@ -48,27 +48,27 @@ ctkModuleReference &ctkModuleReference::operator =(const ctkModuleReference &ref
   return *this;
 }
 
-ctkModuleReference::operator bool()
+ctkCmdLineModuleReference::operator bool()
 {
   return isValid();
 }
 
-bool ctkModuleReference::isValid()
+bool ctkCmdLineModuleReference::isValid()
 {
   return !(d->xml.isEmpty() || d->objectRepresentation == 0);
 }
 
-QByteArray ctkModuleReference::xmlDescription() const
+QByteArray ctkCmdLineModuleReference::xmlDescription() const
 {
   return d->xml;
 }
 
-QString ctkModuleReference::location() const
+QString ctkCmdLineModuleReference::location() const
 {
   return d->loc;
 }
 
-QObject* ctkModuleReference::widgetTree() const
+QObject* ctkCmdLineModuleReference::widgetTree() const
 {
   return d->gui;
 }

Libs/CommandLineModules/ctkModuleReference.h

@@ -19,8 +19,8 @@
   
 =============================================================================*/
 
-#ifndef CTKMODULEREFERENCE_H
-#define CTKMODULEREFERENCE_H
+#ifndef CTKCMDLINEMODULEREFERENCE_H
+#define CTKCMDLINEMODULEREFERENCE_H
 
 #include <ctkCommandLineModulesExport.h>
 
@@ -29,17 +29,17 @@
 
 class QObject;
 
-class ctkModuleReferencePrivate;
+class ctkCmdLineModuleReferencePrivate;
 
-class CTK_CMDLINEMODULE_EXPORT ctkModuleReference
+class CTK_CMDLINEMODULE_EXPORT ctkCmdLineModuleReference
 {
 public:
 
-  ctkModuleReference();
-  ~ctkModuleReference();
+  ctkCmdLineModuleReference();
+  ~ctkCmdLineModuleReference();
 
-  ctkModuleReference(const ctkModuleReference& ref);
-  ctkModuleReference& operator=(const ctkModuleReference& ref);
+  ctkCmdLineModuleReference(const ctkCmdLineModuleReference& ref);
+  ctkCmdLineModuleReference& operator=(const ctkCmdLineModuleReference& ref);
 
   operator bool();
 
@@ -53,10 +53,10 @@ public:
 
 private:
 
-  friend class ctkModuleManager;
+  friend class ctkCmdLineModuleManager;
 
-  ctkModuleReferencePrivate* d;
+  ctkCmdLineModuleReferencePrivate* d;
 
 };
 
-#endif // CTKMODULEREFERENCE_H
+#endif // CTKCMDLINEMODULEREFERENCE_H

Libs/CommandLineModules/ctkModuleReferencePrivate.cpp

@@ -19,26 +19,26 @@
   
 =============================================================================*/
 
-#include "ctkModuleReferencePrivate.h"
+#include "ctkCmdLineModuleReferencePrivate.h"
 
-ctkModuleReferencePrivate::ctkModuleReferencePrivate()
+ctkCmdLineModuleReferencePrivate::ctkCmdLineModuleReferencePrivate()
   : objectRepresentation(0), ref(1), gui(0)
 {}
 
-ctkModuleReferencePrivate::~ctkModuleReferencePrivate()
+ctkCmdLineModuleReferencePrivate::~ctkCmdLineModuleReferencePrivate()
 {
   objectRepresentation->deleteLater();
   if (gui) gui->deleteLater();
 }
 
-void ctkModuleReferencePrivate::setGUI(QObject* gui)
+void ctkCmdLineModuleReferencePrivate::setGUI(QObject* gui)
 {
   if (this->gui) disconnect(gui);
   this->gui = gui;
   connect(this->gui, SIGNAL(destroyed()), this, SLOT(guiDestroyed()));
 }
 
-void ctkModuleReferencePrivate::guiDestroyed()
+void ctkCmdLineModuleReferencePrivate::guiDestroyed()
 {
   gui = 0;
 }

Libs/CommandLineModules/ctkModuleReferencePrivate.h

@@ -19,21 +19,21 @@
   
 =============================================================================*/
 
-#ifndef CTKMODULEREFERENCEPRIVATE_H
-#define CTKMODULEREFERENCEPRIVATE_H
+#ifndef CTKCMDLINEMODULEREFERENCEPRIVATE_H
+#define CTKCMDLINEMODULEREFERENCEPRIVATE_H
 
 #include <QByteArray>
 #include <QObject>
 
-class ctkModuleReferencePrivate : public QObject
+class ctkCmdLineModuleReferencePrivate : public QObject
 {
   Q_OBJECT
 
 public:
 
-  ctkModuleReferencePrivate();
+  ctkCmdLineModuleReferencePrivate();
 
-  ~ctkModuleReferencePrivate();
+  ~ctkCmdLineModuleReferencePrivate();
 
   void setGUI(QObject* gui);
 
@@ -45,7 +45,7 @@ public:
 
 private:
 
-  friend class ctkModuleReference;
+  friend class ctkCmdLineModuleReference;
 
   QObject* gui;
 
@@ -54,4 +54,4 @@ private Q_SLOTS:
   void guiDestroyed();
 };
 
-#endif // CTKMODULEREFERENCEPRIVATE_H
+#endif // CTKCMDLINEMODULEREFERENCEPRIVATE_H

Libs/CommandLineModules/ctkModuleDescriptionParser.cpp

@@ -26,32 +26,32 @@ limitations under the License.
 #include <QXmlStreamReader>
 
 // CTK includes
-#include "ctkModuleDescription.h"
-#include "ctkModuleParameterParsers_p.h"
+#include "ctkCmdLineModuleDescription.h"
+#include "ctkCmdLineModuleParameterParsers_p.h"
 
 // STD includes
 #include <stdexcept>
 
-class ctkModuleDescriptionParser
+class ctkCmdLineModuleXmlParser
 {
 public:
 
-  ctkModuleDescriptionParser(QIODevice* device, ctkModuleDescription* md);
-  ~ctkModuleDescriptionParser();
+  ctkCmdLineModuleXmlParser(QIODevice* device, ctkCmdLineModuleDescription* md);
+  ~ctkCmdLineModuleXmlParser();
 
   void validate();
   void doParse();
 
   void handleExecutableElement();
   void handleParametersElement();
-  ctkModuleParameter* handleParameterElement();
+  ctkCmdLineModuleParameter* handleParameterElement();
 
 private:
 
   QIODevice* const _device;
-  ctkModuleDescription* _md;
+  ctkCmdLineModuleDescription* _md;
   QXmlStreamReader _xmlReader;
-  QHash<QString, ctkModuleParameterParser*> _paramParsers;
+  QHash<QString, ctkCmdLineModuleParameterParser*> _paramParsers;
 };
 
 namespace {
@@ -62,39 +62,39 @@ static const QString DESCRIPTION = "description";
 
 
 // ----------------------------------------------------------------------------
-ctkModuleDescriptionParser::ctkModuleDescriptionParser(QIODevice* device,
-                                                       ctkModuleDescription* md)
+ctkCmdLineModuleXmlParser::ctkCmdLineModuleXmlParser(QIODevice* device,
+                                                       ctkCmdLineModuleDescription* md)
   : _device(device), _md(md)
 {
-  _paramParsers["integer"] = new ctkModuleScalarParameterParser; // type="scalarType"/>
-  _paramParsers["integer-vector"] = new ctkModuleScalarVectorParameterParser; // type="scalarVectorType"/>
-  _paramParsers["boolean"] = new ctkModuleParameterParser; // type="paramType"/>
-  _paramParsers["float"] = new ctkModuleScalarParameterParser; // type="scalarType"/>
-  _paramParsers["float-vector"] = new ctkModuleScalarVectorParameterParser; // type="scalarVectorType"/>
-  _paramParsers["double"] = new ctkModuleScalarParameterParser; // type="scalarType"/>
-  _paramParsers["double-vector"] = new ctkModuleScalarVectorParameterParser; // type="scalarVectorType"/>
-  _paramParsers["string"] = new ctkModuleMultipleParameterParser; // type="multipleType"/>
-  _paramParsers["string-vector"] = new ctkModuleParameterParser; // type="paramType"/>
-  _paramParsers["point"] = new ctkModulePointParameterParser; // type="pointType"/>
-  _paramParsers["region"] = new ctkModulePointParameterParser; // type="pointType"/>
-  _paramParsers["string-enumeration"] = new ctkModuleEnumerationParameterParser; // type="enumerationType"/>
-  _paramParsers["integer-enumeration"] = new ctkModuleEnumerationParameterParser; // type="enumerationType"/>
-  _paramParsers["float-enumeration"] = new ctkModuleEnumerationParameterParser; // type="enumerationType"/>
-  _paramParsers["double-enumeration"] = new ctkModuleEnumerationParameterParser; // type="enumerationType"/>
-  _paramParsers["file"] = new ctkModuleFileParameterParser; // type="fileType"/>
-  _paramParsers["directory"] = new ctkModuleChannelParameterParser; // type="channelType"/>
-  _paramParsers["image"] = new ctkModuleImageParameterParser; // type="imageType"/>
-  _paramParsers["geometry"] = new ctkModuleGeometryParameterParser; // type="geometryType"/>
+  _paramParsers["integer"] = new ctkCmdLineModuleScalarParameterParser; // type="scalarType"/>
+  _paramParsers["integer-vector"] = new ctkCmdLineModuleScalarVectorParameterParser; // type="scalarVectorType"/>
+  _paramParsers["boolean"] = new ctkCmdLineModuleParameterParser; // type="paramType"/>
+  _paramParsers["float"] = new ctkCmdLineModuleScalarParameterParser; // type="scalarType"/>
+  _paramParsers["float-vector"] = new ctkCmdLineModuleScalarVectorParameterParser; // type="scalarVectorType"/>
+  _paramParsers["double"] = new ctkCmdLineModuleScalarParameterParser; // type="scalarType"/>
+  _paramParsers["double-vector"] = new ctkCmdLineModuleScalarVectorParameterParser; // type="scalarVectorType"/>
+  _paramParsers["string"] = new ctkCmdLineModuleMultipleParameterParser; // type="multipleType"/>
+  _paramParsers["string-vector"] = new ctkCmdLineModuleParameterParser; // type="paramType"/>
+  _paramParsers["point"] = new ctkCmdLineModulePointParameterParser; // type="pointType"/>
+  _paramParsers["region"] = new ctkCmdLineModulePointParameterParser; // type="pointType"/>
+  _paramParsers["string-enumeration"] = new ctkCmdLineModuleEnumerationParameterParser; // type="enumerationType"/>
+  _paramParsers["integer-enumeration"] = new ctkCmdLineModuleEnumerationParameterParser; // type="enumerationType"/>
+  _paramParsers["float-enumeration"] = new ctkCmdLineModuleEnumerationParameterParser; // type="enumerationType"/>
+  _paramParsers["double-enumeration"] = new ctkCmdLineModuleEnumerationParameterParser; // type="enumerationType"/>
+  _paramParsers["file"] = new ctkCmdLineModuleFileParameterParser; // type="fileType"/>
+  _paramParsers["directory"] = new ctkCmdLineModuleChannelParameterParser; // type="channelType"/>
+  _paramParsers["image"] = new ctkCmdLineModuleImageParameterParser; // type="imageType"/>
+  _paramParsers["geometry"] = new ctkCmdLineModuleGeometryParameterParser; // type="geometryType"/>
 }
 
 // ----------------------------------------------------------------------------
-ctkModuleDescriptionParser::~ctkModuleDescriptionParser()
+ctkCmdLineModuleXmlParser::~ctkCmdLineModuleXmlParser()
 {
   qDeleteAll(_paramParsers.values());
 }
 
 // ----------------------------------------------------------------------------
-void ctkModuleDescriptionParser::validate()
+void ctkCmdLineModuleXmlParser::validate()
 {
   class _MessageHandler : public QAbstractMessageHandler
   {
@@ -151,7 +151,7 @@ void ctkModuleDescriptionParser::validate()
 
   QXmlSchema schema;
   schema.setMessageHandler(&errorHandler);
-  schema.load(QUrl::fromLocalFile(":/ctkModuleDescription.xsd"));
+  schema.load(QUrl::fromLocalFile(":/ctkCmdLineModuleDescription.xsd"));
 
   bool res = schema.isValid();
   if (!res)
@@ -177,7 +177,7 @@ void ctkModuleDescriptionParser::validate()
 }
 
 // ----------------------------------------------------------------------------
-void ctkModuleDescriptionParser::doParse()
+void ctkCmdLineModuleXmlParser::doParse()
 {
   _xmlReader.clear();
   _xmlReader.setDevice(_device);
@@ -195,7 +195,7 @@ void ctkModuleDescriptionParser::doParse()
 }
 
 // ----------------------------------------------------------------------------
-void ctkModuleDescriptionParser::handleExecutableElement()
+void ctkCmdLineModuleXmlParser::handleExecutableElement()
 {
   while(_xmlReader.readNextStartElement())
   {
@@ -247,9 +247,9 @@ void ctkModuleDescriptionParser::handleExecutableElement()
 }
 
 // ----------------------------------------------------------------------------
-void ctkModuleDescriptionParser::handleParametersElement()
+void ctkCmdLineModuleXmlParser::handleParametersElement()
 {
-  ctkModuleParameterGroup* group = new ctkModuleParameterGroup();
+  ctkCmdLineModuleParameterGroup* group = new ctkCmdLineModuleParameterGroup();
 
   group->setAdvanced(parseBooleanAttribute(_xmlReader.attributes().value("advanced")));
 
@@ -267,7 +267,7 @@ void ctkModuleDescriptionParser::handleParametersElement()
     }
     else
     {
-      ctkModuleParameter* parameter = this->handleParameterElement();
+      ctkCmdLineModuleParameter* parameter = this->handleParameterElement();
       if (parameter)
       {
         group->addParameter(parameter);
@@ -279,10 +279,10 @@ void ctkModuleDescriptionParser::handleParametersElement()
 }
 
 // ----------------------------------------------------------------------------
-ctkModuleParameter* ctkModuleDescriptionParser::handleParameterElement()
+ctkCmdLineModuleParameter* ctkCmdLineModuleXmlParser::handleParameterElement()
 {
   QString paramTag = _xmlReader.name().toString().toLower();
-  ctkModuleParameterParser* paramParser = _paramParsers[paramTag];
+  ctkCmdLineModuleParameterParser* paramParser = _paramParsers[paramTag];
   if (paramParser == 0)
   {
     _xmlReader.skipCurrentElement();
@@ -292,17 +292,17 @@ ctkModuleParameter* ctkModuleDescriptionParser::handleParameterElement()
   }
   else
   {
-    ctkModuleParameter* moduleParam = paramParser->parse(_xmlReader);
+    ctkCmdLineModuleParameter* moduleParam = paramParser->parse(_xmlReader);
     moduleParam->setTag(paramTag);
     return moduleParam;
   }
 }
 
 // ----------------------------------------------------------------------------
-ctkModuleDescription* ctkModuleDescription::parse(QIODevice* device)
+ctkCmdLineModuleDescription* ctkCmdLineModuleDescription::parse(QIODevice* device)
 {
-  ctkModuleDescription* moduleDescription = new ctkModuleDescription();
-  ctkModuleDescriptionParser parser(device, moduleDescription);
+  ctkCmdLineModuleDescription* moduleDescription = new ctkCmdLineModuleDescription();
+  ctkCmdLineModuleXmlParser parser(device, moduleDescription);
 
   try
   {

Libs/CommandLineModules/ctkModuleDescriptionValidator.cpp

@@ -19,7 +19,7 @@
   
 =============================================================================*/
 
-#include "ctkModuleDescriptionValidator.h"
+#include "ctkCmdLineModuleXmlValidator.h"
 
 #include <QFile>
 #include <QBuffer>
@@ -83,42 +83,42 @@ private:
   QSourceLocation m_sourceLocation;
 };
 
-ctkModuleDescriptionValidator::ctkModuleDescriptionValidator(QIODevice *input)
+ctkCmdLineModuleXmlValidator::ctkCmdLineModuleXmlValidator(QIODevice *input)
   : _input(input), _inputSchema(0), _outputSchema(0), _transformation(0)
 {
 }
 
-void ctkModuleDescriptionValidator::setInput(QIODevice *input)
+void ctkCmdLineModuleXmlValidator::setInput(QIODevice *input)
 {
   _input = input;
 }
 
-QString ctkModuleDescriptionValidator::output()
+QString ctkCmdLineModuleXmlValidator::output()
 {
   return _output;
 }
 
-void ctkModuleDescriptionValidator::setInputSchema(QIODevice *input)
+void ctkCmdLineModuleXmlValidator::setInputSchema(QIODevice *input)
 {
   _inputSchema = input;
 }
 
-void ctkModuleDescriptionValidator::setOutputSchema(QIODevice *output)
+void ctkCmdLineModuleXmlValidator::setOutputSchema(QIODevice *output)
 {
   _outputSchema = output;
 }
 
-void ctkModuleDescriptionValidator::setXSLTransformation(QIODevice *transformation)
+void ctkCmdLineModuleXmlValidator::setXSLTransformation(QIODevice *transformation)
 {
   _transformation = transformation;
 }
 
-bool ctkModuleDescriptionValidator::validate()
+bool ctkCmdLineModuleXmlValidator::validate()
 {
   return validateXMLInput() && validateXSLTOutput();
 }
 
-bool ctkModuleDescriptionValidator::validateXMLInput()
+bool ctkCmdLineModuleXmlValidator::validateXMLInput()
 {
   _errorStr.clear();
 
@@ -129,7 +129,7 @@ bool ctkModuleDescriptionValidator::validateXMLInput()
   }
 
   QIODevice* inputSchema = _inputSchema;
-  QScopedPointer<QIODevice> defaultInputSchema(new QFile(":/ctkModuleDescription.xsd"));
+  QScopedPointer<QIODevice> defaultInputSchema(new QFile(":/ctkCmdLineModule.xsd"));
   if (!inputSchema)
   {
     inputSchema = defaultInputSchema.data();
@@ -161,7 +161,7 @@ bool ctkModuleDescriptionValidator::validateXMLInput()
   return true;
 }
 
-bool ctkModuleDescriptionValidator::validateXSLTOutput()
+bool ctkCmdLineModuleXmlValidator::validateXSLTOutput()
 {
   _errorStr.clear();
   _output.clear();
@@ -189,7 +189,7 @@ bool ctkModuleDescriptionValidator::validateXSLTOutput()
   }
 
   QIODevice* transformation = _transformation;
-  QScopedPointer<QIODevice> defaultTransform(new QFile(":/ctkQtModuleDescription.xsl"));
+  QScopedPointer<QIODevice> defaultTransform(new QFile(":/ctkCmdLineModuleXmlToQtUi.xsl"));
   if (!transformation)
   {
     transformation = defaultTransform.data();
@@ -248,12 +248,12 @@ bool ctkModuleDescriptionValidator::validateXSLTOutput()
   return true;
 }
 
-bool ctkModuleDescriptionValidator::error() const
+bool ctkCmdLineModuleXmlValidator::error() const
 {
   return !_errorStr.isEmpty();
 }
 
-QString ctkModuleDescriptionValidator::errorString() const
+QString ctkCmdLineModuleXmlValidator::errorString() const
 {
   return _errorStr;
 }

Libs/CommandLineModules/ctkModuleDescriptionValidator.h

@@ -19,8 +19,8 @@
   
 =============================================================================*/
 
-#ifndef CTKMODULEDESCRIPTIONVALIDATOR_H
-#define CTKMODULEDESCRIPTIONVALIDATOR_H
+#ifndef CTKCMDLINEMODULEXMLVALIDATOR_H
+#define CTKCMDLINEMODULEXMLVALIDATOR_H
 
 #include <ctkCommandLineModulesExport.h>
 
@@ -28,12 +28,12 @@
 
 class QIODevice;
 
-class CTK_CMDLINEMODULE_EXPORT ctkModuleDescriptionValidator
+class CTK_CMDLINEMODULE_EXPORT ctkCmdLineModuleXmlValidator
 {
 
 public:
 
-  ctkModuleDescriptionValidator(QIODevice* input = 0);
+  ctkCmdLineModuleXmlValidator(QIODevice* input = 0);
 
   void setInput(QIODevice* input);
   QString output();
@@ -61,4 +61,4 @@ private:
   QString _errorStr;
 };
 
-#endif // CTKMODULEDESCRIPTIONVALIDATOR_H
+#endif // CTKCMDLINEMODULEXMLVALIDATOR_H