Merge branch 'normalized-signals-slots'

* normalized-signals-slots:
  Normalize SIGNALS/SLOTS for performance.

Applications/ctkExampleHost/ctkHostAppExampleWidget.cpp

@@ -45,7 +45,7 @@ ctkHostAppExampleWidget::ctkHostAppExampleWidget(QWidget *parent) :
   connect(&this->Host->getAppProcess(),SIGNAL(error(QProcess::ProcessError)),SLOT(appProcessError(QProcess::ProcessError)));
   connect(&this->Host->getAppProcess(),SIGNAL(stateChanged(QProcess::ProcessState)),SLOT(appProcessStateChanged(QProcess::ProcessState)));
   connect(ui->placeholderFrame,SIGNAL(resized()),SLOT(placeholderResized()));
-  connect(this->Host,SIGNAL( stateChangedReceived(ctkDicomAppHosting::State)),SLOT(appStateChanged(ctkDicomAppHosting::State)));
+  connect(this->Host,SIGNAL(stateChangedReceived(ctkDicomAppHosting::State)),SLOT(appStateChanged(ctkDicomAppHosting::State)));
 
 }
 

Libs/Core/Testing/Cpp/ctkWorkflowTest2.cpp

@@ -145,45 +145,45 @@ int ctkWorkflowTest2(int argc, char * argv [] )
   ctkExampleWorkflowStepUsingSignalsAndSlots* qObject4 = new ctkExampleWorkflowStepUsingSignalsAndSlots(step4);
 
   // use the qObjects for validation
-  QObject::connect(step1->ctkWorkflowStepQObject(), SIGNAL(invokeValidateCommand(const QString&)),
-                   qObject1, SLOT(validate(const QString&)));
-  QObject::connect(step2->ctkWorkflowStepQObject(), SIGNAL(invokeValidateCommand(const QString&)),
-                   qObject2, SLOT(validate(const QString&)));
+  QObject::connect(step1->ctkWorkflowStepQObject(), SIGNAL(invokeValidateCommand(QString)),
+                   qObject1, SLOT(validate(QString)));
+  QObject::connect(step2->ctkWorkflowStepQObject(), SIGNAL(invokeValidateCommand(QString)),
+                   qObject2, SLOT(validate(QString)));
   // step 3's validation will always fail
-  QObject::connect(step3->ctkWorkflowStepQObject(), SIGNAL(invokeValidateCommand(const QString&)),
+  QObject::connect(step3->ctkWorkflowStepQObject(), SIGNAL(invokeValidateCommand(QString)),
                    qObject3, SLOT(validateFails()));
 
-  QObject::connect(step4->ctkWorkflowStepQObject(), SIGNAL(invokeValidateCommand(const QString&)),
-                   qObject4, SLOT(validate(const QString&)));
+  QObject::connect(step4->ctkWorkflowStepQObject(), SIGNAL(invokeValidateCommand(QString)),
+                   qObject4, SLOT(validate(QString)));
 
   // use the qObjects for entry processing
   QObject::connect(
-      step1->ctkWorkflowStepQObject(), SIGNAL(invokeOnEntryCommand(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)),
-      qObject1, SLOT(onEntry(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)));
+      step1->ctkWorkflowStepQObject(), SIGNAL(invokeOnEntryCommand(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)),
+      qObject1, SLOT(onEntry(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)));
   QObject::connect(
-      step2->ctkWorkflowStepQObject(), SIGNAL(invokeOnEntryCommand(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)),
-      qObject2, SLOT(onEntry(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)));
+      step2->ctkWorkflowStepQObject(), SIGNAL(invokeOnEntryCommand(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)),
+      qObject2, SLOT(onEntry(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)));
   QObject::connect(
-      step3->ctkWorkflowStepQObject(), SIGNAL(invokeOnEntryCommand(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)),
-      qObject3, SLOT(onEntry(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)));
+      step3->ctkWorkflowStepQObject(), SIGNAL(invokeOnEntryCommand(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)),
+      qObject3, SLOT(onEntry(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)));
   QObject::connect(
-      step4->ctkWorkflowStepQObject(), SIGNAL(invokeOnEntryCommand(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)),
-      qObject4, SLOT(onEntry(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)));
+      step4->ctkWorkflowStepQObject(), SIGNAL(invokeOnEntryCommand(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)),
+      qObject4, SLOT(onEntry(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)));
 
 
   // use the qObjects for exit processing
   QObject::connect(
-      step1->ctkWorkflowStepQObject(), SIGNAL(invokeOnExitCommand(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)),
-      qObject1, SLOT(onExit(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)));
+      step1->ctkWorkflowStepQObject(), SIGNAL(invokeOnExitCommand(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)),
+      qObject1, SLOT(onExit(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)));
   QObject::connect(
-      step2->ctkWorkflowStepQObject(), SIGNAL(invokeOnExitCommand(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)),
-      qObject2, SLOT(onExit(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)));
+      step2->ctkWorkflowStepQObject(), SIGNAL(invokeOnExitCommand(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)),
+      qObject2, SLOT(onExit(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)));
   QObject::connect(
-      step3->ctkWorkflowStepQObject(), SIGNAL(invokeOnExitCommand(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)),
-      qObject3, SLOT(onExit(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)));
+      step3->ctkWorkflowStepQObject(), SIGNAL(invokeOnExitCommand(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)),
+      qObject3, SLOT(onExit(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)));
   QObject::connect(
-      step4->ctkWorkflowStepQObject(), SIGNAL(invokeOnExitCommand(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)),
-      qObject4, SLOT(onExit(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)));
+      step4->ctkWorkflowStepQObject(), SIGNAL(invokeOnExitCommand(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)),
+      qObject4, SLOT(onExit(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)));
 
   step1->setHasValidateCommand(1);
   step2->setHasValidateCommand(1);

Libs/Core/ctkCheckableModelHelper.cpp

@@ -308,36 +308,36 @@ void ctkCheckableModelHelper::setModel(QAbstractItemModel *newModel)
   if(current)
     {
     this->disconnect(
-      current, SIGNAL(headerDataChanged(Qt::Orientation, int, int)),
-      this, SLOT(onHeaderDataChanged(Qt::Orientation, int, int)));
+      current, SIGNAL(headerDataChanged(Qt::Orientation,int,int)),
+      this, SLOT(onHeaderDataChanged(Qt::Orientation,int,int)));
     this->disconnect(
-      current, SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&)),
-      this, SLOT(onDataChanged(const QModelIndex&, const QModelIndex&)));
+      current, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
+      this, SLOT(onDataChanged(QModelIndex,QModelIndex)));
     this->disconnect(
-      current, SIGNAL(columnsInserted(const QModelIndex &, int, int)), 
-      this, SLOT(onColumnsInserted(const QModelIndex &, int, int)));
+      current, SIGNAL(columnsInserted(QModelIndex,int,int)), 
+      this, SLOT(onColumnsInserted(QModelIndex,int,int)));
     this->disconnect(
-      current, SIGNAL(rowsInserted(const QModelIndex &, int, int)),
-      this, SLOT(onRowsInserted(const QModelIndex &, int, int)));
+      current, SIGNAL(rowsInserted(QModelIndex,int,int)),
+      this, SLOT(onRowsInserted(QModelIndex,int,int)));
     }
   d->Model = newModel;
   if(newModel)
     {
     this->connect(
-      newModel, SIGNAL(headerDataChanged(Qt::Orientation, int, int)),
-      this, SLOT(onHeaderDataChanged(Qt::Orientation, int, int)));
+      newModel, SIGNAL(headerDataChanged(Qt::Orientation,int,int)),
+      this, SLOT(onHeaderDataChanged(Qt::Orientation,int,int)));
     if (d->PropagateDepth != 0)
       {
       this->connect(
-        newModel, SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&)),
-        this, SLOT(onDataChanged(const QModelIndex&, const QModelIndex&)));
+        newModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
+        this, SLOT(onDataChanged(QModelIndex,QModelIndex)));
       }
     this->connect(
-      newModel, SIGNAL(columnsInserted(const QModelIndex &, int, int)),
-      this, SLOT(onColumnsInserted(const QModelIndex &, int, int)));
+      newModel, SIGNAL(columnsInserted(QModelIndex,int,int)),
+      this, SLOT(onColumnsInserted(QModelIndex,int,int)));
     this->connect(
-      newModel, SIGNAL(rowsInserted(const QModelIndex &, int, int)),
-      this, SLOT(onRowsInserted(const QModelIndex &, int, int)));
+      newModel, SIGNAL(rowsInserted(QModelIndex,int,int)),
+      this, SLOT(onRowsInserted(QModelIndex,int,int)));
 
     if (d->ForceCheckability)
       {
@@ -385,15 +385,15 @@ void ctkCheckableModelHelper::setPropagateDepth(int depth)
   if (depth != 0)
     {
     this->connect(
-      this->model(), SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&)),
-      this, SLOT(onDataChanged(const QModelIndex&, const QModelIndex&)), Qt::UniqueConnection);
+      this->model(), SIGNAL(dataChanged(QModelIndex,QModelIndex)),
+      this, SLOT(onDataChanged(QModelIndex,QModelIndex)), Qt::UniqueConnection);
     this->updateHeadersFromItems();
     }
   else
     {
     this->disconnect(
-      this->model(), SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&)),
-      this, SLOT(onDataChanged(const QModelIndex&, const QModelIndex&)));
+      this->model(), SIGNAL(dataChanged(QModelIndex,QModelIndex)),
+      this, SLOT(onDataChanged(QModelIndex,QModelIndex)));
     }
 }
 

Libs/Core/ctkErrorLogFDMessageHandler.cpp

@@ -54,8 +54,8 @@ ctkFDHandler::ctkFDHandler(ctkErrorLogFDMessageHandler* messageHandler,
     + QDir::separator () + "ctkFDHandler-%1.XXXXXX.txt";
   this->OutputFile.setFileTemplate(outputFileTemplateName.arg(this->FDNumber));
 
-  connect(&this->OutputFileWatcher, SIGNAL(fileChanged(const QString&)),
-          SLOT(outputFileChanged(const QString&)));
+  connect(&this->OutputFileWatcher, SIGNAL(fileChanged(QString)),
+          SLOT(outputFileChanged(QString)));
 }
 
 // --------------------------------------------------------------------------

Libs/Core/ctkModelTester.cpp

@@ -102,30 +102,30 @@ void ctkModelTester::setModel(QAbstractItemModel *_model)
     }
   if (_model)
     {
-    connect(_model, SIGNAL(columnsAboutToBeInserted(const QModelIndex &, int, int)),
-            this, SLOT(onColumnsAboutToBeInserted(const QModelIndex& , int, int)));
-    connect(_model, SIGNAL(columnsAboutToBeRemoved(const QModelIndex &, int, int)),
-            this, SLOT(onColumnsAboutToBeRemoved(const QModelIndex& , int, int)));
-    connect(_model, SIGNAL(columnsInserted(const QModelIndex &, int, int)),
-            this, SLOT(onColumnsInserted(const QModelIndex& , int, int)));
-    connect(_model, SIGNAL(columnsRemoved(const QModelIndex &, int, int)),
-            this, SLOT(onColumnsRemoved(const QModelIndex& , int, int)));
-    connect(_model, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)),
-            this, SLOT(onDataChanged(const QModelIndex& , const QModelIndex &)));
+    connect(_model, SIGNAL(columnsAboutToBeInserted(QModelIndex,int,int)),
+            this, SLOT(onColumnsAboutToBeInserted(QModelIndex,int,int)));
+    connect(_model, SIGNAL(columnsAboutToBeRemoved(QModelIndex,int,int)),
+            this, SLOT(onColumnsAboutToBeRemoved(QModelIndex,int,int)));
+    connect(_model, SIGNAL(columnsInserted(QModelIndex,int,int)),
+            this, SLOT(onColumnsInserted(QModelIndex,int,int)));
+    connect(_model, SIGNAL(columnsRemoved(QModelIndex,int,int)),
+            this, SLOT(onColumnsRemoved(QModelIndex,int,int)));
+    connect(_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
+            this, SLOT(onDataChanged(QModelIndex,QModelIndex)));
     connect(_model, SIGNAL(headerDataChanged(Qt::Orientation,int,int)),
             this, SLOT(onHeaderDataChanged(Qt::Orientation,int,int)));
     connect(_model, SIGNAL(layoutAboutToBeChanged()), this, SLOT(onLayoutAboutToBeChanged()));
     connect(_model, SIGNAL(layoutChanged()), this, SLOT(onLayoutChanged()));
     connect(_model, SIGNAL(modelAboutToBeReset()), this, SLOT(onModelAboutToBeReset()));
     connect(_model, SIGNAL(modelReset()), this, SLOT(onModelReset()));
-    connect(_model, SIGNAL(rowsAboutToBeInserted(const QModelIndex &, int, int)),
-            this, SLOT(onRowsAboutToBeInserted(const QModelIndex& , int, int)));
-    connect(_model, SIGNAL(rowsAboutToBeRemoved(const QModelIndex &, int, int)),
-            this, SLOT(onRowsAboutToBeRemoved(const QModelIndex& , int, int)));
-    connect(_model, SIGNAL(rowsInserted(const QModelIndex &, int, int)),
-            this, SLOT(onRowsInserted(const QModelIndex& , int, int)));
-    connect(_model, SIGNAL(rowsRemoved(const QModelIndex &, int, int)),
-            this, SLOT(onRowsRemoved(const QModelIndex& , int, int)));
+    connect(_model, SIGNAL(rowsAboutToBeInserted(QModelIndex,int,int)),
+            this, SLOT(onRowsAboutToBeInserted(QModelIndex,int,int)));
+    connect(_model, SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),
+            this, SLOT(onRowsAboutToBeRemoved(QModelIndex,int,int)));
+    connect(_model, SIGNAL(rowsInserted(QModelIndex,int,int)),
+            this, SLOT(onRowsInserted(QModelIndex,int,int)));
+    connect(_model, SIGNAL(rowsRemoved(QModelIndex,int,int)),
+            this, SLOT(onRowsRemoved(QModelIndex,int,int)));
     }
   d->Model = _model;
   this->testModel();

Libs/Core/ctkWorkflow.cpp

@@ -90,8 +90,8 @@ void ctkWorkflowPrivate::addStep(ctkWorkflowStep* step)
   // Setup the signal/slot that triggers the evaluation of the validation results
   // after validate(const QString&) is called
   this->connect(
-      step->ctkWorkflowStepQObject(), SIGNAL(validationComplete(bool, const QString&)),
-      q, SLOT(evaluateValidationResults(bool, const QString&)));
+      step->ctkWorkflowStepQObject(), SIGNAL(validationComplete(bool,QString)),
+      q, SLOT(evaluateValidationResults(bool,QString)));
 
   this->connect(
       step->ctkWorkflowStepQObject(), SIGNAL(onEntryComplete()),

Libs/DICOM/Core/ctkDICOMDatabase.cpp

@@ -143,7 +143,7 @@ void ctkDICOMDatabase::openDatabase(const QString databaseFile, const QString& c
   if (!isInMemory())
     {
     QFileSystemWatcher* watcher = new QFileSystemWatcher(QStringList(databaseFile),this);
-    connect(watcher, SIGNAL( fileChanged(const QString&)),this, SIGNAL ( databaseChanged() ) );
+    connect(watcher, SIGNAL(fileChanged(QString)),this, SIGNAL (databaseChanged()) );
     }
 }
 

Libs/DICOM/Widgets/ctkDICOMAppWidget.cpp

@@ -148,7 +148,7 @@ ctkDICOMAppWidget::ctkDICOMAppWidget(QWidget* _parent):Superclass(_parent),
   this->setDatabaseDirectory(databaseDirectory);
   d->DirectoryButton->setDirectory(databaseDirectory);
 
-  connect(d->DirectoryButton, SIGNAL(directoryChanged(const QString&)), this, SLOT(setDatabaseDirectory(const QString&)));
+  connect(d->DirectoryButton, SIGNAL(directoryChanged(QString)), this, SLOT(setDatabaseDirectory(QString)));
 
   //Initialize import widget
   d->ImportDialog = new ctkFileDialog();
@@ -160,19 +160,19 @@ ctkDICOMAppWidget::ctkDICOMAppWidget(QWidget* _parent):Superclass(_parent),
   d->ImportDialog->setWindowModality(Qt::ApplicationModal);
 
   //connect signal and slots
-  connect(d->TreeView, SIGNAL(clicked(const QModelIndex&)), d->ThumbnailsWidget, SLOT(onModelSelected(const QModelIndex &)));
-  connect(d->TreeView, SIGNAL(clicked(const QModelIndex&)), d->ImagePreview, SLOT(onModelSelected(const QModelIndex &)));
-  connect(d->TreeView, SIGNAL(clicked(const QModelIndex&)), this, SLOT(onModelSelected(const QModelIndex &)));
+  connect(d->TreeView, SIGNAL(clicked(QModelIndex)), d->ThumbnailsWidget, SLOT(onModelSelected(QModelIndex)));
+  connect(d->TreeView, SIGNAL(clicked(QModelIndex)), d->ImagePreview, SLOT(onModelSelected(QModelIndex)));
+  connect(d->TreeView, SIGNAL(clicked(QModelIndex)), this, SLOT(onModelSelected(QModelIndex)));
 
-  connect(d->ThumbnailsWidget, SIGNAL(selected(const ctkThumbnailWidget&)), this, SLOT(onThumbnailSelected(const ctkThumbnailWidget&)));
-  connect(d->ThumbnailsWidget, SIGNAL(doubleClicked(const ctkThumbnailWidget&)), this, SLOT(onThumbnailDoubleClicked(const ctkThumbnailWidget&)));
+  connect(d->ThumbnailsWidget, SIGNAL(selected(ctkThumbnailWidget)), this, SLOT(onThumbnailSelected(ctkThumbnailWidget)));
+  connect(d->ThumbnailsWidget, SIGNAL(doubleClicked(ctkThumbnailWidget)), this, SLOT(onThumbnailDoubleClicked(ctkThumbnailWidget)));
   connect(d->ImportDialog, SIGNAL(fileSelected(QString)),this,SLOT(onImportDirectory(QString)));
 
-  connect(d->QueryRetrieveWidget, SIGNAL( canceled() ), d->QueryRetrieveWidget, SLOT( hide() ) );
+  connect(d->QueryRetrieveWidget, SIGNAL(canceled()), d->QueryRetrieveWidget, SLOT(hide()) );
 
   connect(d->ImagePreview, SIGNAL(requestNextImage()), this, SLOT(onNextImage()));
   connect(d->ImagePreview, SIGNAL(requestPreviousImage()), this, SLOT(onPreviousImage()));
-  connect(d->ImagePreview, SIGNAL(imageDisplayed(int, int)), this, SLOT(onImagePreviewDisplayed(int,int)));
+  connect(d->ImagePreview, SIGNAL(imageDisplayed(int,int)), this, SLOT(onImagePreviewDisplayed(int,int)));
 
   connect(d->SearchOption, SIGNAL(parameterChanged()), this, SLOT(onSearchParameterChanged()));
 

Libs/DICOM/Widgets/ctkDICOMDirectoryListWidget.cpp

@@ -130,7 +130,7 @@ void ctkDICOMDirectoryListWidget::setDICOMDatabase(ctkDICOMDatabase* dicomDataba
   d->directoryListView->setModel(d->directoryListModel);
 
   connect ( d->directoryListView->selectionModel(),
-            SIGNAL(selectionChanged(const QItemSelection&,const QItemSelection&)),
+            SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
             this,
             SLOT(directorySelectionChanged(const QItemSelection & ,
                                            const QItemSelection &  )));

Libs/DICOM/Widgets/ctkDICOMImportWidget.cpp

@@ -65,8 +65,8 @@ ctkDICOMImportWidget::ctkDICOMImportWidget(QWidget* parentWidget)
   d->directoryList->setModel(d->FileSystemModel);
 
   //connect signals and slots
-  connect(d->DirectoryWidget, SIGNAL(directoryChanged(const QString&)),
-          this, SLOT(onTopDirectoryChanged(const QString&)));
+  connect(d->DirectoryWidget, SIGNAL(directoryChanged(QString)),
+          this, SLOT(onTopDirectoryChanged(QString)));
   this->onTopDirectoryChanged(d->DirectoryWidget->directory());
 }
 

Libs/DICOM/Widgets/ctkDICOMServerNodeWidget.cpp

@@ -73,11 +73,11 @@ ctkDICOMServerNodeWidget::ctkDICOMServerNodeWidget(QWidget* parentWidget)
 
   this->readSettings();
 
-  connect(d->CallingAETitle, SIGNAL(textChanged(const QString&)),
+  connect(d->CallingAETitle, SIGNAL(textChanged(QString)),
     this, SLOT(saveSettings()));
-  connect(d->StorageAETitle, SIGNAL(textChanged(const QString&)),
+  connect(d->StorageAETitle, SIGNAL(textChanged(QString)),
     this, SLOT(saveSettings()));
-  connect(d->StoragePort, SIGNAL(textChanged(const QString&)),
+  connect(d->StoragePort, SIGNAL(textChanged(QString)),
     this, SLOT(saveSettings()));
 
   connect(d->AddButton, SIGNAL(clicked()),
@@ -87,7 +87,7 @@ ctkDICOMServerNodeWidget::ctkDICOMServerNodeWidget(QWidget* parentWidget)
 
   connect(d->NodeTable, SIGNAL(cellChanged(int,int)),
     this, SLOT(saveSettings()));
-  connect(d->NodeTable, SIGNAL(currentItemChanged(QTableWidgetItem*, QTableWidgetItem*)),
+  connect(d->NodeTable, SIGNAL(currentItemChanged(QTableWidgetItem*,QTableWidgetItem*)),
     this, SLOT(updateRemoveButtonEnableState()));
 }
 

Libs/Scripting/Python/Core/ctkAbstractPythonManager.cpp

@@ -84,10 +84,10 @@ void ctkAbstractPythonManager::initPythonQt()
 
   PythonQtObjectPtr _mainContext = PythonQt::self()->getMainModule();
 
-  this->connect(PythonQt::self(), SIGNAL(pythonStdOut(const QString&)),
-                SLOT(printStdout(const QString&)));
-  this->connect(PythonQt::self(), SIGNAL(pythonStdErr(const QString&)),
-                SLOT(printStderr(const QString&)));
+  this->connect(PythonQt::self(), SIGNAL(pythonStdOut(QString)),
+                SLOT(printStdout(QString)));
+  this->connect(PythonQt::self(), SIGNAL(pythonStdErr(QString)),
+                SLOT(printStderr(QString)));
   
   PythonQt_init_QtBindings();
   

Libs/Scripting/Python/Widgets/ctkPythonConsole.cpp

@@ -349,10 +349,10 @@ void ctkPythonConsole::initialize(ctkAbstractPythonManager* newPythonManager)
 
   d->initializeInteractiveConsole();
 
-  this->connect(PythonQt::self(), SIGNAL(pythonStdOut(const QString&)),
-                d, SLOT(printOutputMessage(const QString&)));
-  this->connect(PythonQt::self(), SIGNAL(pythonStdErr(const QString&)),
-                d, SLOT(printErrorMessage(const QString&)));
+  this->connect(PythonQt::self(), SIGNAL(pythonStdOut(QString)),
+                d, SLOT(printOutputMessage(QString)));
+  this->connect(PythonQt::self(), SIGNAL(pythonStdErr(QString)),
+                d, SLOT(printErrorMessage(QString)));
 
   PythonQt::self()->setRedirectStdInCallBack(
         ctkConsole::stdInRedirectCallBack, reinterpret_cast<void*>(this));

Libs/Visualization/VTK/Core/Testing/Cpp/ctkVTKObjectTestHelper.cpp

@@ -145,7 +145,7 @@ bool ctkVTKObjectTest::test()
   
   // Set a new connection (protected)
   connection = this->qvtkConnect(object, vtkCommand::ModifiedEvent, 
-                                 this, SLOT( onVTKObjectModifiedProtected ( ) ));
+                                 this, SLOT(onVTKObjectModifiedProtected()));
   if (connection.isEmpty())
     {
     qDebug() << __LINE__ << "ctkVTKObject::qvtkConnect() failed: "<< connection;
@@ -202,11 +202,11 @@ bool ctkVTKObjectTest::test()
 
   // Set new connections
   this->qvtkConnect(object, vtkCommand::ModifiedEvent, 
-                    this, SLOT(onVTKObjectModifiedPublic ()));
+                    this, SLOT(onVTKObjectModifiedPublic()));
   this->qvtkConnect(object, vtkCommand::WarningEvent, 
-                    this, SLOT(onVTKObjectModifiedPublic( )));
+                    this, SLOT(onVTKObjectModifiedPublic()));
   int disconnected = this->qvtkDisconnect(object, vtkCommand::NoEvent, 
-                                          this, SLOT(onVTKObjectModifiedPublic() ));
+                                          this, SLOT(onVTKObjectModifiedPublic()));
   if (disconnected != 2)
     {
     qDebug() << __LINE__ << "qvtkDisconnect failed" << disconnected;

Libs/Visualization/VTK/Core/ctkVTKConnection.cpp

@@ -84,11 +84,11 @@ void ctkVTKConnectionPrivate::connect()
   switch (this->SlotType)
     {
     case ctkVTKConnectionPrivate::ARG_VTKOBJECT_AND_VTKOBJECT:
-      QObject::connect(q, SIGNAL(emitExecute(vtkObject*, vtkObject*)),
+      QObject::connect(q, SIGNAL(emitExecute(vtkObject*,vtkObject*)),
         this->QtObject, this->QtSlot.toLatin1(), this->ConnectionType);
       break;
     case ctkVTKConnectionPrivate::ARG_VTKOBJECT_VOID_ULONG_VOID:
-      QObject::connect(q, SIGNAL(emitExecute(vtkObject*, void*, unsigned long, void*)),
+      QObject::connect(q, SIGNAL(emitExecute(vtkObject*,void*,ulong,void*)),
                        this->QtObject, this->QtSlot.toLatin1(), this->ConnectionType);
       break;
     default:
@@ -133,11 +133,11 @@ void ctkVTKConnectionPrivate::disconnect()
     switch (this->SlotType)
       {
       case ctkVTKConnectionPrivate::ARG_VTKOBJECT_AND_VTKOBJECT:
-        QObject::disconnect(q, SIGNAL(emitExecute(vtkObject*, vtkObject*)),
+        QObject::disconnect(q, SIGNAL(emitExecute(vtkObject*,vtkObject*)),
                             this->QtObject,this->QtSlot.toLatin1().data());
         break;
       case ctkVTKConnectionPrivate::ARG_VTKOBJECT_VOID_ULONG_VOID:
-        QObject::disconnect(q, SIGNAL(emitExecute(vtkObject*, void*, unsigned long, void*)),
+        QObject::disconnect(q, SIGNAL(emitExecute(vtkObject*,void*,ulong,void*)),
                             this->QtObject, this->QtSlot.toLatin1().data());
         break;
       default:

Libs/Visualization/VTK/Widgets/ctkVTKScalarBarWidget.cpp

@@ -61,10 +61,10 @@ void ctkVTKScalarBarWidgetPrivate::init()
                    q, SLOT(setMaxNumberOfColors(int)));
   QObject::connect(this->NumberOfLabelsSpinBox, SIGNAL(valueChanged(int)),
                    q, SLOT(setNumberOfLabels(int)));
-  QObject::connect(this->TitleTextPropertyWidget, SIGNAL(textChanged(const QString&)),
-                   q, SLOT(setTitle(const QString&)));
-  QObject::connect(this->LabelsTextPropertyWidget, SIGNAL(textChanged(const QString&)),
-                   q, SLOT(setLabelsFormat(const QString&)));
+  QObject::connect(this->TitleTextPropertyWidget, SIGNAL(textChanged(QString)),
+                   q, SLOT(setTitle(QString)));
+  QObject::connect(this->LabelsTextPropertyWidget, SIGNAL(textChanged(QString)),
+                   q, SLOT(setLabelsFormat(QString)));
 }
 
 //-----------------------------------------------------------------------------

Libs/Visualization/VTK/Widgets/ctkVTKScalarsToColorsView.cpp

@@ -101,7 +101,7 @@ void ctkVTKScalarsToColorsView::addPlot(vtkPlot* plot)
   if (vtkColorTransferControlPointsItem::SafeDownCast(plot))
     {
     this->qvtkConnect(plot, vtkControlPointsItem::CurrentPointEditEvent,
-                      this, SLOT(editPoint(vtkObject*, void*)));
+                      this, SLOT(editPoint(vtkObject*,void*)));
     }
   this->Superclass::addPlot(plot);
 }

Libs/Visualization/VTK/Widgets/ctkVTKScalarsToColorsWidget.cpp

@@ -88,8 +88,8 @@ void ctkVTKScalarsToColorsWidgetPrivate::setupUi(QWidget* widget)
   QObject::connect(this->PointIdSpinBox, SIGNAL(valueChanged(int)),
                    q, SLOT(onCurrentPointChanged(int)));
   this->PointIdSpinBox->setValue(-1);
-  QObject::connect(this->ColorPickerButton, SIGNAL(colorChanged(const QColor&)),
-                   q, SLOT(onColorChanged(const QColor&)));
+  QObject::connect(this->ColorPickerButton, SIGNAL(colorChanged(QColor)),
+                   q, SLOT(onColorChanged(QColor)));
   QObject::connect(this->OpacitySpinBox, SIGNAL(valueChanged(double)),
                    q, SLOT(onOpacityChanged(double)));
   QObject::connect(this->MidPointSpinBox, SIGNAL(valueChanged(double)),
@@ -99,13 +99,13 @@ void ctkVTKScalarsToColorsWidgetPrivate::setupUi(QWidget* widget)
   this->ColorPickerButton->setVisible(false);
   this->OpacityLabel->setVisible(false);
   this->OpacitySpinBox->setVisible(false);
-  QObject::connect(this->XRangeSlider, SIGNAL(valuesChanged(double, double)),
-                   q, SLOT(setXRange(double, double)));
-  QObject::connect(this->YRangeSlider, SIGNAL(valuesChanged(double, double)),
-                   q, SLOT(setYRange(double, double)));
-  QObject::connect(this->XRangeSlider, SIGNAL(valuesChanged(double, double)),
+  QObject::connect(this->XRangeSlider, SIGNAL(valuesChanged(double,double)),
+                   q, SLOT(setXRange(double,double)));
+  QObject::connect(this->YRangeSlider, SIGNAL(valuesChanged(double,double)),
+                   q, SLOT(setYRange(double,double)));
+  QObject::connect(this->XRangeSlider, SIGNAL(valuesChanged(double,double)),
                    q, SIGNAL(axesModified()));
-  QObject::connect(this->YRangeSlider, SIGNAL(valuesChanged(double, double)),
+  QObject::connect(this->YRangeSlider, SIGNAL(valuesChanged(double,double)),
                    q, SIGNAL(axesModified()));
 
   q->qvtkConnect(this->View->chart()->GetAxis(0),vtkCommand::ModifiedEvent,
@@ -198,7 +198,7 @@ void ctkVTKScalarsToColorsWidget::onPlotAdded(vtkPlot* plot)
   if (vtkControlPointsItem::SafeDownCast(plot))
     {
     this->qvtkConnect(plot, vtkControlPointsItem::CurrentPointChangedEvent,
-                      this, SLOT(setCurrentPoint(vtkObject*, void*)));
+                      this, SLOT(setCurrentPoint(vtkObject*,void*)));
     }
 }
 

Libs/Visualization/VTK/Widgets/ctkVTKTextPropertyWidget.cpp

@@ -58,14 +58,14 @@ void ctkVTKTextPropertyWidgetPrivate::init()
   Q_Q(ctkVTKTextPropertyWidget);
   this->setupUi(q);
   q->updateFromTextProperty();
-  QObject::connect(this->TextLineEdit, SIGNAL(textChanged(const QString&)),
-                   q, SIGNAL(textChanged(const QString&)));
+  QObject::connect(this->TextLineEdit, SIGNAL(textChanged(QString)),
+                   q, SIGNAL(textChanged(QString)));
   QObject::connect(this->ColorPickerButton, SIGNAL(colorChanged(QColor)),
-                   q, SLOT(setColor(const QColor&)));
+                   q, SLOT(setColor(QColor)));
   QObject::connect(this->OpacitySlider, SIGNAL(valueChanged(double)),
                    q, SLOT(setOpacity(double)));
-  QObject::connect(this->FontComboBox, SIGNAL(currentIndexChanged(const QString&)),
-                   q, SLOT(setFont(const QString&)));
+  QObject::connect(this->FontComboBox, SIGNAL(currentIndexChanged(QString)),
+                   q, SLOT(setFont(QString)));
   QObject::connect(this->BoldCheckBox, SIGNAL(toggled(bool)),
                    q, SLOT(setBold(bool)));
   QObject::connect(this->ItalicCheckBox, SIGNAL(toggled(bool)),

Libs/Visualization/VTK/Widgets/ctkVTKThresholdWidget.cpp

@@ -71,8 +71,8 @@ void ctkVTKThresholdWidgetPrivate::setupUi(QWidget* widget)
   Q_ASSERT(q == widget);
   this->Ui_ctkVTKThresholdWidget::setupUi(widget);
 
-  QObject::connect(this->ThresholdSliderWidget, SIGNAL(valuesChanged(double, double)),
-                   q, SLOT(setThresholdValues(double, double)));
+  QObject::connect(this->ThresholdSliderWidget, SIGNAL(valuesChanged(double,double)),
+                   q, SLOT(setThresholdValues(double,double)));
   QObject::connect(this->OpacitySliderWidget, SIGNAL(valueChanged(double)),
                    q, SLOT(setOpacity(double)));
 }

Libs/Widgets/Testing/Cpp/ctkDateRangeWidgetTest1.cpp

@@ -156,8 +156,8 @@ int ctkDateRangeWidgetTest1(int argc, char * argv [] )
     return EXIT_FAILURE;
     }
 
-  QSignalSpy startSpy(&dateRange, SIGNAL(startDateTimeChanged(const QDateTime&)));
-  QSignalSpy endSpy(&dateRange, SIGNAL(endDateTimeChanged(const QDateTime&)));
+  QSignalSpy startSpy(&dateRange, SIGNAL(startDateTimeChanged(QDateTime)));
+  QSignalSpy endSpy(&dateRange, SIGNAL(endDateTimeChanged(QDateTime)));
 
   dateRange.setLastWeek();  
   if (startSpy.count() != 1 || endSpy.count() != 1)

Libs/Widgets/Testing/Cpp/ctkDirectoryButtonTest1.cpp

@@ -91,8 +91,8 @@ int ctkDirectoryButtonTest1(int argc, char * argv [] )
     return EXIT_FAILURE;
     }
 
-  QSignalSpy spyDirectoryChanged(&button, SIGNAL(directoryChanged(const QString&)));
-  QSignalSpy spyDirectorySelected(&button, SIGNAL(directorySelected(const QString&)));
+  QSignalSpy spyDirectoryChanged(&button, SIGNAL(directoryChanged(QString)));
+  QSignalSpy spyDirectorySelected(&button, SIGNAL(directorySelected(QString)));
 
   button.setDirectory(QDir::home().absolutePath());
   if ( QDir(button.directory()) != QDir::home() ||

Libs/Widgets/Testing/Cpp/ctkDoubleRangeSliderTest2.cpp

@@ -38,7 +38,7 @@ int ctkDoubleRangeSliderTest2(int argc, char * argv [] )
 
   ctkDoubleRangeSlider slider(Qt::Horizontal);
 
-  QSignalSpy spyRange(&slider, SIGNAL(rangeChanged(double, double)));
+  QSignalSpy spyRange(&slider, SIGNAL(rangeChanged(double,double)));
 
   slider.setRange(200., 499.01);
   

Libs/Widgets/Testing/Cpp/ctkExampleUseOfWorkflowWidgetUsingSignalsAndSlots.cpp

@@ -105,19 +105,19 @@ int ctkExampleUseOfWorkflowWidgetUsingSignalsAndSlots(int argc, char * argv [] )
   qObject3->setWidget(testStep3->stepArea());
 
   // use the qObjects for validation
-  QObject::connect(testStep1->ctkWorkflowStepQObject(), SIGNAL(invokeValidateCommand(const QString&)), qObject1, SLOT(validate(const QString&)));
-  QObject::connect(testStep2->ctkWorkflowStepQObject(), SIGNAL(invokeValidateCommand(const QString&)), qObject2, SLOT(validate(const QString&)));
-  QObject::connect(testStep3->ctkWorkflowStepQObject(), SIGNAL(invokeValidateCommand(const QString&)), qObject3, SLOT(validate(const QString&)));
+  QObject::connect(testStep1->ctkWorkflowStepQObject(), SIGNAL(invokeValidateCommand(QString)), qObject1, SLOT(validate(QString)));
+  QObject::connect(testStep2->ctkWorkflowStepQObject(), SIGNAL(invokeValidateCommand(QString)), qObject2, SLOT(validate(QString)));
+  QObject::connect(testStep3->ctkWorkflowStepQObject(), SIGNAL(invokeValidateCommand(QString)), qObject3, SLOT(validate(QString)));
 
   // use the qObjects for entry processing
-  QObject::connect(testStep1->ctkWorkflowStepQObject(), SIGNAL(invokeOnEntryCommand(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)), qObject1, SLOT(onEntry(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)));
-  QObject::connect(testStep2->ctkWorkflowStepQObject(), SIGNAL(invokeOnEntryCommand(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)), qObject2, SLOT(onEntry(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)));
-  QObject::connect(testStep3->ctkWorkflowStepQObject(), SIGNAL(invokeOnEntryCommand(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)), qObject3, SLOT(onEntry(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)));
+  QObject::connect(testStep1->ctkWorkflowStepQObject(), SIGNAL(invokeOnEntryCommand(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)), qObject1, SLOT(onEntry(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)));
+  QObject::connect(testStep2->ctkWorkflowStepQObject(), SIGNAL(invokeOnEntryCommand(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)), qObject2, SLOT(onEntry(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)));
+  QObject::connect(testStep3->ctkWorkflowStepQObject(), SIGNAL(invokeOnEntryCommand(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)), qObject3, SLOT(onEntry(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)));
 
   // use the qObjects for exit processing
-  QObject::connect(testStep1->ctkWorkflowStepQObject(), SIGNAL(invokeOnExitCommand(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)), qObject1, SLOT(onExit(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)));
-  QObject::connect(testStep2->ctkWorkflowStepQObject(), SIGNAL(invokeOnExitCommand(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)), qObject2, SLOT(onExit(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)));
-  QObject::connect(testStep3->ctkWorkflowStepQObject(), SIGNAL(invokeOnExitCommand(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)), qObject3, SLOT(onExit(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)));
+  QObject::connect(testStep1->ctkWorkflowStepQObject(), SIGNAL(invokeOnExitCommand(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)), qObject1, SLOT(onExit(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)));
+  QObject::connect(testStep2->ctkWorkflowStepQObject(), SIGNAL(invokeOnExitCommand(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)), qObject2, SLOT(onExit(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)));
+  QObject::connect(testStep3->ctkWorkflowStepQObject(), SIGNAL(invokeOnExitCommand(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)), qObject3, SLOT(onExit(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)));
 
   // use the qObjects for populating the stepWidgetsList
   QObject::connect(testStep1->ctkWorkflowStepQObject(), SIGNAL(invokeCreateUserInterfaceCommand()), qObject1, SLOT(createUserInterface()));

Libs/Widgets/Testing/Cpp/ctkFontButtonTest1.cpp

@@ -54,7 +54,7 @@ int ctkFontButtonTest1(int argc, char * argv [] )
     return EXIT_FAILURE;
     }
 
-  QSignalSpy spyFontChanged(&button, SIGNAL(currentFontChanged(const QFont&)));
+  QSignalSpy spyFontChanged(&button, SIGNAL(currentFontChanged(QFont)));
 
   button.setCurrentFont(customFont2);
   if ( button.currentFont() != customFont2 ||

Libs/Widgets/Testing/Cpp/ctkModalityWidgetTest1.cpp

@@ -36,7 +36,7 @@ int ctkModalityWidgetTest1(int argc, char * argv [] )
 
   ctkModalityWidget modalityWidget;
   
-  QSignalSpy spy(&modalityWidget, SIGNAL(selectedModalitiesChanged(const QStringList&)));
+  QSignalSpy spy(&modalityWidget, SIGNAL(selectedModalitiesChanged(QStringList)));
   modalityWidget.unselectAll();
 
   if (spy.count() != 1)

Libs/Widgets/Testing/Cpp/ctkSettingsPanelTest1.cpp

@@ -112,7 +112,7 @@ int ctkSettingsPanelTest1(int argc, char * argv [] )
 
   QLineEdit* lineEdit = new QLineEdit("default", &settingsPanel);
   settingsPanel.registerProperty("key 2", lineEdit, "text",
-                                  SIGNAL(textChanged(const QString&)));
+                                  SIGNAL(textChanged(QString)));
 
   // Check value after a property is registered
   QVariant lineEditVal = settings.value("key 2");

Libs/Widgets/Testing/Cpp/ctkWorkflowWidgetTest2.cpp

@@ -596,27 +596,27 @@ int ctkWorkflowWidgetTest2(int argc, char * argv [] )
 
   // use the qObjects for validation
   QObject::connect(step1->ctkWorkflowStepQObject(),
-                   SIGNAL(invokeValidateCommand(const QString&)),
-                   qObject1, SLOT(validate(const QString&)));
+                   SIGNAL(invokeValidateCommand(QString)),
+                   qObject1, SLOT(validate(QString)));
   QObject::connect(step2->ctkWorkflowStepQObject(),
-                   SIGNAL(invokeValidateCommand(const QString&)),
-                   qObject2, SLOT(validate(const QString&)));
+                   SIGNAL(invokeValidateCommand(QString)),
+                   qObject2, SLOT(validate(QString)));
 
   // use the qObjects for entry processing
   QObject::connect(step1->ctkWorkflowStepQObject(),
-                   SIGNAL(invokeOnEntryCommand(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)),
-                   qObject1, SLOT(onEntry(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)));
+                   SIGNAL(invokeOnEntryCommand(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)),
+                   qObject1, SLOT(onEntry(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)));
   QObject::connect(step2->ctkWorkflowStepQObject(),
-                   SIGNAL(invokeOnEntryCommand(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)),
-                   qObject2, SLOT(onEntry(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)));
+                   SIGNAL(invokeOnEntryCommand(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)),
+                   qObject2, SLOT(onEntry(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)));
 
   // use the qObjects for exit processing
   QObject::connect(step1->ctkWorkflowStepQObject(),
-                   SIGNAL(invokeOnExitCommand(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)),
-                   qObject1, SLOT(onExit(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)));
+                   SIGNAL(invokeOnExitCommand(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)),
+                   qObject1, SLOT(onExit(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)));
   QObject::connect(step2->ctkWorkflowStepQObject(),
-                   SIGNAL(invokeOnExitCommand(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)),
-                   qObject2, SLOT(onExit(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)));
+                   SIGNAL(invokeOnExitCommand(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)),
+                   qObject2, SLOT(onExit(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)));
 
   // use the qObjects for populating the stepWidgetsList
   QObject::connect(step1->ctkWorkflowStepQObject(),
@@ -681,16 +681,16 @@ int ctkWorkflowWidgetTest2(int argc, char * argv [] )
   qObject3->setWidget(step3->stepArea());
 
   // use the qObjects for validation
-  QObject::connect(step3->ctkWorkflowStepQObject(), SIGNAL(invokeValidateCommand(const QString&)),
-                   qObject3, SLOT(validate(const QString&)));
+  QObject::connect(step3->ctkWorkflowStepQObject(), SIGNAL(invokeValidateCommand(QString)),
+                   qObject3, SLOT(validate(QString)));
 
   // use the qObjects for entry processing
-  QObject::connect(step3->ctkWorkflowStepQObject(), SIGNAL(invokeOnEntryCommand(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)),
-                   qObject3, SLOT(onEntry(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)));
+  QObject::connect(step3->ctkWorkflowStepQObject(), SIGNAL(invokeOnEntryCommand(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)),
+                   qObject3, SLOT(onEntry(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)));
 
   // use the qObjects for exit processing
-  QObject::connect(step3->ctkWorkflowStepQObject(), SIGNAL(invokeOnExitCommand(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)),
-                   qObject3, SLOT(onExit(const ctkWorkflowStep*, const ctkWorkflowInterstepTransition::InterstepTransitionType)));
+  QObject::connect(step3->ctkWorkflowStepQObject(), SIGNAL(invokeOnExitCommand(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)),
+                   qObject3, SLOT(onExit(const ctkWorkflowStep*,ctkWorkflowInterstepTransition::InterstepTransitionType)));
 
   // use the qObjects for populating the stepWidgetsList
   QObject::connect(step3->ctkWorkflowStepQObject(), SIGNAL(invokeCreateUserInterfaceCommand()), qObject3, SLOT(createUserInterface()));

Libs/Widgets/ctkAddRemoveComboBox.cpp

@@ -105,19 +105,19 @@ void ctkAddRemoveComboBoxPrivate::connectComboBox(QComboBox* comboBox)
                 q, SIGNAL(currentIndexChanged(int)));
   /*
   this->connect(d->ComboBox->model(),
-  SIGNAL(rowsAboutToBeInserted(const QModelIndex & _parent, int start, int end )),
-  SLOT(onRowsAboutToBeInserted(const QModelIndex & _parent, int start, int end )));
+  SIGNAL(rowsAboutToBeInserted(QModelIndex&_parent,int start,int end)),
+  SLOT(onRowsAboutToBeInserted(QModelIndex&_parent,int start,int end)));
   */
   QObject::connect(comboBox->model(),
-                SIGNAL(rowsAboutToBeRemoved(const QModelIndex &, int, int)),
-                q, SLOT(onRowsAboutToBeRemoved(const QModelIndex & , int , int  )));
+                SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),
+                q, SLOT(onRowsAboutToBeRemoved(QModelIndex,int,int)));
 
   QObject::connect(comboBox->model(),
-                SIGNAL(rowsInserted(const QModelIndex &, int, int )),
-                q, SLOT(onRowsInserted(const QModelIndex &, int, int)));
+                SIGNAL(rowsInserted(QModelIndex,int,int)),
+                q, SLOT(onRowsInserted(QModelIndex,int,int)));
   QObject::connect(comboBox->model(),
-                SIGNAL(rowsRemoved(const QModelIndex &, int, int)),
-                q, SLOT(onRowsRemoved(const QModelIndex &, int, int )));
+                SIGNAL(rowsRemoved(QModelIndex,int,int)),
+                q, SLOT(onRowsRemoved(QModelIndex,int,int)));
 }
 
 // --------------------------------------------------------------------------

Libs/Widgets/ctkCheckableComboBox.cpp

@@ -240,14 +240,14 @@ bool ctkCheckableComboBox::eventFilter(QObject *o, QEvent *e)
 void ctkCheckableComboBox::setCheckableModel(QAbstractItemModel* newModel)
 {
   Q_D(ctkCheckableComboBox);
-  this->disconnect(this->model(), SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&)),
-                   this, SLOT(onDataChanged(const QModelIndex&, const QModelIndex&)));
+  this->disconnect(this->model(), SIGNAL(dataChanged(QModelIndex,QModelIndex)),
+                   this, SLOT(onDataChanged(QModelIndex,QModelIndex)));
   if (newModel != this->model())
     {
     this->setModel(newModel);
     }
-  this->connect(this->model(), SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&)),
-                this, SLOT(onDataChanged(const QModelIndex&, const QModelIndex&)));
+  this->connect(this->model(), SIGNAL(dataChanged(QModelIndex,QModelIndex)),
+                this, SLOT(onDataChanged(QModelIndex,QModelIndex)));
   d->CheckableModelHelper->setModel(newModel);
   d->updateCheckedList();
 }

Libs/Widgets/ctkCheckableHeaderView.cpp

@@ -185,16 +185,16 @@ void ctkCheckableHeaderView::setModel(QAbstractItemModel *newModel)
   if (current)
     {
     this->disconnect(
-      current, SIGNAL(headerDataChanged(Qt::Orientation, int, int)),
-      this, SLOT(onHeaderDataChanged(Qt::Orientation, int, int)));
+      current, SIGNAL(headerDataChanged(Qt::Orientation,int,int)),
+      this, SLOT(onHeaderDataChanged(Qt::Orientation,int,int)));
     this->disconnect(
       current, SIGNAL(modelReset()),
       this, SLOT(updateHeaderPixmaps()));
     this->disconnect(
-      current, SIGNAL(columnsInserted(const QModelIndex &, int, int)), 
+      current, SIGNAL(columnsInserted(QModelIndex,int,int)), 
       this, SLOT(onHeaderSectionInserted()));
     this->disconnect(
-      current, SIGNAL(rowsInserted(const QModelIndex &, int, int)),
+      current, SIGNAL(rowsInserted(QModelIndex,int,int)),
       this, SLOT(onHeaderSectionInserted()));
     }
   this->QHeaderView::setModel(newModel);
@@ -202,21 +202,21 @@ void ctkCheckableHeaderView::setModel(QAbstractItemModel *newModel)
   if(newModel)
     {
     this->connect(
-      newModel, SIGNAL(headerDataChanged(Qt::Orientation, int, int)),
-      this, SLOT(onHeaderDataChanged(Qt::Orientation, int, int)));
+      newModel, SIGNAL(headerDataChanged(Qt::Orientation,int,int)),
+      this, SLOT(onHeaderDataChanged(Qt::Orientation,int,int)));
     this->connect(
       newModel, SIGNAL(modelReset()),
       this, SLOT(updateHeaderPixmaps()));
     if(this->orientation() == Qt::Horizontal)
       {
       this->connect(
-        newModel, SIGNAL(columnsInserted(const QModelIndex &, int, int)),
+        newModel, SIGNAL(columnsInserted(QModelIndex,int,int)),
         this, SLOT(onHeaderSectionInserted()));
       }
     else
       {
       this->connect(
-        newModel, SIGNAL(rowsInserted(const QModelIndex &, int, int)),
+        newModel, SIGNAL(rowsInserted(QModelIndex,int,int)),
         this, SLOT(onHeaderSectionInserted()));
       }
     }

Libs/Widgets/ctkConsole.cpp

@@ -402,16 +402,16 @@ void ctkConsolePrivate::setCompleter(ctkConsoleCompleter* completer)
   if (this->Completer)
     {
     this->Completer->setWidget(0);
-    disconnect(this->Completer, SIGNAL(activated(const QString&)),
-               this, SLOT(insertCompletion(const QString&)));
+    disconnect(this->Completer, SIGNAL(activated(QString)),
+               this, SLOT(insertCompletion(QString)));
 
     }
   this->Completer = completer;
   if (this->Completer)
     {
     this->Completer->setWidget(this);
-    connect(this->Completer, SIGNAL(activated(const QString&)),
-            this, SLOT(insertCompletion(const QString&)));
+    connect(this->Completer, SIGNAL(activated(QString)),
+            this, SLOT(insertCompletion(QString)));
     }
 }
 

Libs/Widgets/ctkDateRangeWidget.cpp

@@ -133,13 +133,13 @@ ctkDateRangeWidget::ctkDateRangeWidget(QWidget* _parent) : Superclass(_parent)
   QObject::connect(d->SelectRangeRadioButton, SIGNAL(clicked()),
                    this, SLOT(setSelectRange()));
 
-  QObject::connect(d->StartDate, SIGNAL(dateTimeChanged(const QDateTime&)),
-                   this, SIGNAL(startDateTimeChanged(const QDateTime&)));
-  QObject::connect(d->EndDate, SIGNAL(dateTimeChanged(const QDateTime&)),
-                   this, SIGNAL(endDateTimeChanged(const QDateTime&)));
-  QObject::connect(d->StartDate, SIGNAL(dateTimeChanged(const QDateTime&)),
+  QObject::connect(d->StartDate, SIGNAL(dateTimeChanged(QDateTime)),
+                   this, SIGNAL(startDateTimeChanged(QDateTime)));
+  QObject::connect(d->EndDate, SIGNAL(dateTimeChanged(QDateTime)),
+                   this, SIGNAL(endDateTimeChanged(QDateTime)));
+  QObject::connect(d->StartDate, SIGNAL(dateTimeChanged(QDateTime)),
                    this, SLOT(onDateTimeChanged()));
-  QObject::connect(d->EndDate, SIGNAL(dateTimeChanged(const QDateTime&)),
+  QObject::connect(d->EndDate, SIGNAL(dateTimeChanged(QDateTime)),
                    this, SLOT(onDateTimeChanged()));
 }
 

Libs/Widgets/ctkDoubleRangeSlider.cpp

@@ -117,8 +117,8 @@ void ctkDoubleRangeSliderPrivate::connectSlider()
              q, SIGNAL(sliderPressed()));
   q->connect(this->Slider, SIGNAL(sliderReleased()),
              q, SIGNAL(sliderReleased()));
-  q->connect(this->Slider, SIGNAL(rangeChanged(int, int)),
-             q, SLOT(onRangeChanged(int, int)));
+  q->connect(this->Slider, SIGNAL(rangeChanged(int,int)),
+             q, SLOT(onRangeChanged(int,int)));
 }
 
 // --------------------------------------------------------------------------

Libs/Widgets/ctkDoubleSlider.cpp

@@ -87,8 +87,8 @@ void ctkDoubleSliderPrivate::init()
   q->connect(this->Slider, SIGNAL(sliderMoved(int)), q, SLOT(onSliderMoved(int)));
   q->connect(this->Slider, SIGNAL(sliderPressed()), q, SIGNAL(sliderPressed()));
   q->connect(this->Slider, SIGNAL(sliderReleased()), q, SIGNAL(sliderReleased()));
-  q->connect(this->Slider, SIGNAL(rangeChanged(int, int)),
-             q, SLOT(onRangeChanged(int, int)));
+  q->connect(this->Slider, SIGNAL(rangeChanged(int,int)),
+             q, SLOT(onRangeChanged(int,int)));
 
   q->setSizePolicy(this->Slider->sizePolicy());
   q->setAttribute(Qt::WA_WState_OwnSizePolicy, false);

Libs/Widgets/ctkErrorLogWidget.cpp

@@ -128,14 +128,14 @@ void ctkErrorLogWidget::setErrorLogModel(ctkErrorLogModel * newErrorLogModel)
 
   if (this->errorLogModel())
     {
-    disconnect(this->errorLogModel(), SIGNAL(rowsInserted(const QModelIndex&, int, int)),
-               this, SLOT(onRowsInserted(const QModelIndex&, int, int)));
+    disconnect(this->errorLogModel(), SIGNAL(rowsInserted(QModelIndex,int,int)),
+               this, SLOT(onRowsInserted(QModelIndex,int,int)));
 
     disconnect(this->errorLogModel(), SIGNAL(logLevelFilterChanged()),
                this, SLOT(onLogLevelFilterChanged()));
 
-    disconnect(d->SelectionModel.data(), SIGNAL(selectionChanged(const QItemSelection&, const QItemSelection&)),
-               this, SLOT(onSelectionChanged(const QItemSelection &, const QItemSelection &)));
+    disconnect(d->SelectionModel.data(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
+               this, SLOT(onSelectionChanged(QItemSelection,QItemSelection)));
 
     d->SelectionModel.clear();
     }
@@ -144,8 +144,8 @@ void ctkErrorLogWidget::setErrorLogModel(ctkErrorLogModel * newErrorLogModel)
 
   if (newErrorLogModel)
     {
-    connect(this->errorLogModel(), SIGNAL(rowsInserted(const QModelIndex&, int, int)),
-            this, SLOT(onRowsInserted(const QModelIndex&, int, int)));
+    connect(this->errorLogModel(), SIGNAL(rowsInserted(QModelIndex,int,int)),
+            this, SLOT(onRowsInserted(QModelIndex,int,int)));
 
     connect(this->errorLogModel(), SIGNAL(logLevelFilterChanged()),
             this, SLOT(onLogLevelFilterChanged()));
@@ -160,8 +160,8 @@ void ctkErrorLogWidget::setErrorLogModel(ctkErrorLogModel * newErrorLogModel)
     d->SelectionModel = QSharedPointer<QItemSelectionModel>(new QItemSelectionModel(this->errorLogModel()));
     d->SelectionModel->reset();
 
-    connect(d->SelectionModel.data(), SIGNAL(selectionChanged(const QItemSelection&, const QItemSelection&)),
-            this, SLOT(onSelectionChanged(const QItemSelection &, const QItemSelection &)));
+    connect(d->SelectionModel.data(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
+            this, SLOT(onSelectionChanged(QItemSelection,QItemSelection)));
 
     d->ErrorLogTableView->setSelectionModel(d->SelectionModel.data());
 

Libs/Widgets/ctkFileDialog.cpp

@@ -71,7 +71,7 @@ void ctkFileDialogPrivate::init()
   button->installEventFilter(q);
 
   QObject::connect(this->listView()->selectionModel(),
-                   SIGNAL(selectionChanged(QItemSelection, QItemSelection)),
+                   SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
                    q, SLOT(onSelectionChanged()));
 }
 

Libs/Widgets/ctkMaterialPropertyWidget.cpp

@@ -258,8 +258,8 @@ void ctkMaterialPropertyWidget::addPreset(
     new ctkMaterialPropertyPreviewLabel(color, opacity, ambient, diffuse, specular, power);
   if (!color.isValid())
     {
-    connect(this, SIGNAL(colorChanged(const QColor&)),
-            preset, SLOT(setColor(const QColor&)));
+    connect(this, SIGNAL(colorChanged(QColor)),
+            preset, SLOT(setColor(QColor)));
     preset->setColor(this->color());
     }
   preset->setGridOpacity(d->MaterialPropertyPreviewLabel->gridOpacity());

Libs/Widgets/ctkMatrixWidget.cpp

@@ -142,7 +142,7 @@ void ctkMatrixWidgetPrivate::init()
   // The table takes ownership of the prototype.
   this->Table->setItemPrototype(_item);
 
-  QObject::connect(this->Table, SIGNAL(cellChanged(int, int)),
+  QObject::connect(this->Table, SIGNAL(cellChanged(int,int)),
                    q, SIGNAL(matrixChanged()));
   /// \todo Wrap model signals to emit signals when the matrix is changed.
 /// Right now you can connect to the signal:

Libs/Widgets/ctkMenuComboBox.cpp

@@ -95,7 +95,7 @@ void ctkMenuComboBoxPrivate::init()
   this->SearchCompleter = new ctkCompleter(QStringList(), q);
   this->SearchCompleter->setCaseSensitivity(Qt::CaseInsensitive);
   this->SearchCompleter->setModelFiltering(ctkCompleter::FilterWordStartsWith);
-  q->connect(this->SearchCompleter, SIGNAL(activated(const QString&)),
+  q->connect(this->SearchCompleter, SIGNAL(activated(QString)),
              q, SLOT(onEditingFinished()));
 
   // Automatically set the minimumSizeHint of the layout to the widget

Libs/Widgets/ctkPathLineEdit.cpp

@@ -90,9 +90,9 @@ void ctkPathLineEditPrivate::init()
                      QSizePolicy::Expanding, QSizePolicy::Fixed,
                      QSizePolicy::LineEdit));
 
-  QObject::connect(this->ComboBox,SIGNAL(editTextChanged(const QString&)),
-                   q, SLOT(setCurrentDirectory(const QString&)));
-  QObject::connect(this->ComboBox,SIGNAL(editTextChanged(const QString&)),
+  QObject::connect(this->ComboBox,SIGNAL(editTextChanged(QString)),
+                   q, SLOT(setCurrentDirectory(QString)));
+  QObject::connect(this->ComboBox,SIGNAL(editTextChanged(QString)),
                    q, SLOT(updateHasValidInput()));
 }
 

Libs/Widgets/ctkRangeSlider.cpp

@@ -117,7 +117,7 @@ void ctkRangeSliderPrivate::init()
   this->m_MaximumValue = q->maximum();
   this->m_MinimumPosition = q->minimum();
   this->m_MaximumPosition = q->maximum();
-  q->connect(q, SIGNAL(rangeChanged(int, int)), q, SLOT(onRangeChanged(int, int)));
+  q->connect(q, SIGNAL(rangeChanged(int,int)), q, SLOT(onRangeChanged(int,int)));
 }
 
 // --------------------------------------------------------------------------

Libs/Widgets/ctkRangeWidget.cpp

@@ -77,7 +77,7 @@ ctkRangeWidgetPrivate::ctkRangeWidgetPrivate(ctkRangeWidget& object)
 void ctkRangeWidgetPrivate::connectSlider()
 {
   Q_Q(ctkRangeWidget);
-  QObject::connect(this->Slider, SIGNAL(valuesChanged(double, double)),
+  QObject::connect(this->Slider, SIGNAL(valuesChanged(double,double)),
                    q, SLOT(changeValues(double,double)));
   QObject::connect(this->Slider, SIGNAL(minimumValueChanged(double)),
                    q, SLOT(changeMinimumValue(double)));
@@ -97,8 +97,8 @@ void ctkRangeWidgetPrivate::connectSlider()
                    q, SLOT(startChanging()));
   QObject::connect(this->Slider, SIGNAL(sliderReleased()),
                    q, SLOT(stopChanging()));
-  QObject::connect(this->Slider, SIGNAL(rangeChanged(double, double)),
-                   q, SLOT(onSliderRangeChanged(double, double)));
+  QObject::connect(this->Slider, SIGNAL(rangeChanged(double,double)),
+                   q, SLOT(onSliderRangeChanged(double,double)));
 }
 
 // --------------------------------------------------------------------------

Libs/Widgets/ctkSearchBox.cpp

@@ -77,7 +77,7 @@ void ctkSearchBoxPrivate::init()
   // Set a text by default on the QLineEdit
   q->setPlaceholderText(q->tr("Search..."));
 
-  QObject::connect(q, SIGNAL(textChanged(const QString&)),
+  QObject::connect(q, SIGNAL(textChanged(QString)),
                    q, SLOT(updateClearButtonState()));
 }
 

Libs/Widgets/ctkSettingsDialog.cpp

@@ -72,8 +72,8 @@ void ctkSettingsDialogPrivate::init()
   q->setSettings(new QSettings(q));
 
   QObject::connect(this->SettingsTreeWidget,
-    SIGNAL(currentItemChanged(QTreeWidgetItem*, QTreeWidgetItem*)),
-    q, SLOT(onCurrentItemChanged(QTreeWidgetItem*, QTreeWidgetItem*)));
+    SIGNAL(currentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)),
+    q, SLOT(onCurrentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)));
   QObject::connect(this->SettingsButtonBox, SIGNAL(clicked(QAbstractButton*)),
                    q, SLOT(onDialogButtonClicked(QAbstractButton*)));
 }
@@ -153,8 +153,8 @@ void ctkSettingsDialog
   parentItem->addChild(newPanelItem);
   d->SettingsStackedWidget->addWidget(panel);
 
-  connect(panel, SIGNAL(settingChanged(const QString&, const QVariant&)),
-          this, SLOT(onSettingChanged(const QString&, const QVariant&)));
+  connect(panel, SIGNAL(settingChanged(QString,QVariant)),
+          this, SLOT(onSettingChanged(QString,QVariant)));
   panel->setSettings(this->settings());
 }
 

Libs/Widgets/ctkSettingsPanel.cpp

@@ -133,8 +133,8 @@ void ctkSettingsPanelPrivate::init()
   Q_Q(ctkSettingsPanel);
   
   this->SignalMapper = new QSignalMapper(q);
-  QObject::connect(this->SignalMapper, SIGNAL(mapped(const QString&)),
-                   q, SLOT(updateSetting(const QString&)));
+  QObject::connect(this->SignalMapper, SIGNAL(mapped(QString)),
+                   q, SLOT(updateSetting(QString)));
 }
 
 // --------------------------------------------------------------------------

Libs/Widgets/ctkTreeComboBox.cpp

@@ -80,9 +80,9 @@ ctkTreeComboBox::ctkTreeComboBox(QWidget* _parent):Superclass(_parent)
   // we install the filter AFTER the QComboBox installed it.
   // so that our eventFilter will be called first
   this->view()->viewport()->installEventFilter(this);
-  connect(treeView, SIGNAL(collapsed(const QModelIndex&)),
+  connect(treeView, SIGNAL(collapsed(QModelIndex)),
           this, SLOT(resizePopup()));
-  connect(treeView, SIGNAL(expanded(const QModelIndex&)),
+  connect(treeView, SIGNAL(expanded(QModelIndex)),
           this, SLOT(resizePopup()));
 }
 

Plugins/org.commontk.configadmin/ctkConfigurationAdminActivator.cpp

@@ -51,7 +51,7 @@ void ctkConfigurationAdminActivator::start(ctkPluginContext* context)
   eventAdapter->start();
   factory = new ctkConfigurationAdminFactory(context, logTracker);
   factory->start();
-  context->connectPluginListener(factory, SLOT(pluginChanged(const ctkPluginEvent&)));
+  context->connectPluginListener(factory, SLOT(pluginChanged(ctkPluginEvent)));
   registration = context->registerService<ctkConfigurationAdmin>(factory);
 }
 

Plugins/org.commontk.dah.core/ctkSimpleSoapServer.cpp

@@ -38,11 +38,11 @@ void ctkSimpleSoapServer::incomingConnection(int socketDescriptor)
   ctkSoapConnectionRunnable* runnable = new ctkSoapConnectionRunnable(socketDescriptor);
 
   connect(runnable, SIGNAL(incomingSoapMessage(QtSoapMessage,QtSoapMessage*)),
-          this, SIGNAL(incomingSoapMessage(QtSoapMessage, QtSoapMessage*)),
+          this, SIGNAL(incomingSoapMessage(QtSoapMessage,QtSoapMessage*)),
           Qt::BlockingQueuedConnection);
 
   connect(runnable, SIGNAL(incomingWSDLMessage(QString,QString*)),
-          this, SIGNAL(incomingWSDLMessage(QString, QString*)),
+          this, SIGNAL(incomingWSDLMessage(QString,QString*)),
           Qt::BlockingQueuedConnection);
 
   QThreadPool::globalInstance()->start(runnable);