ENH: Rename ctkSliderSpinBoxWidget into ctkSliderWidget

ctkSliderWidget is an advanced QSlider widget: it's a double slider with a
 double spinbox (ctkDoubleSlider + QDoubleSpinBox)

Libs/Widgets/CMakeLists.txt

@@ -56,8 +56,8 @@ SET(KIT_SRCS
   ctkRangeWidget.h
   ctkSettings.cpp
   ctkSettings.h
-  ctkSliderSpinBoxWidget.cpp
-  ctkSliderSpinBoxWidget.h
+  ctkSliderWidget.cpp
+  ctkSliderWidget.h
   ctkTestApplication.cpp
   ctkTestApplication.h
   ctkTransferFunctionBarsItem.cpp
@@ -100,7 +100,7 @@ SET(KIT_MOC_SRCS
   ctkRangeSlider.h
   ctkRangeWidget.h
   ctkSettings.h
-  ctkSliderSpinBoxWidget.h
+  ctkSliderWidget.h
   ctkTestApplication.h
   ctkTransferFunctionBarsItem.h
   ctkTransferFunctionControlPointsItem.h
@@ -115,7 +115,7 @@ SET(KIT_MOC_SRCS
 SET(KIT_UI_FORMS
   Resources/UI/ctkAddRemoveComboBox.ui
   Resources/UI/ctkRangeWidget.ui
-  Resources/UI/ctkSliderSpinBoxWidget.ui
+  Resources/UI/ctkSliderWidget.ui
   )
 
 # Resources

Libs/Widgets/Plugins/CMakeLists.txt

@@ -49,8 +49,8 @@ SET(PLUGIN_SRCS
   ctkTransferFunctionViewPlugin.h
   ctkTreeComboBoxPlugin.cpp
   ctkTreeComboBoxPlugin.h
-  ctkSliderSpinBoxWidgetPlugin.cpp
-  ctkSliderSpinBoxWidgetPlugin.h
+  ctkSliderWidgetPlugin.cpp
+  ctkSliderWidgetPlugin.h
   )
 
 # Headers that should run through moc
@@ -75,7 +75,7 @@ SET(PLUGIN_MOC_SRCS
   ctkRangeWidgetPlugin.h
   ctkTransferFunctionViewPlugin.h
   ctkTreeComboBoxPlugin.h
-  ctkSliderSpinBoxWidgetPlugin.h
+  ctkSliderWidgetPlugin.h
   )
 
 # Resources

Libs/Widgets/Plugins/ctkSliderSpinBoxWidgetPlugin.cpp

@@ -19,51 +19,51 @@
 =========================================================================*/
 
 // CTK includes
-#include "ctkSliderSpinBoxWidgetPlugin.h"
-#include "ctkSliderSpinBoxWidget.h"
+#include "ctkSliderWidgetPlugin.h"
+#include "ctkSliderWidget.h"
 
 //-----------------------------------------------------------------------------
-ctkSliderSpinBoxWidgetPlugin::ctkSliderSpinBoxWidgetPlugin(QObject *_parent)
+ctkSliderWidgetPlugin::ctkSliderWidgetPlugin(QObject *_parent)
         : QObject(_parent)
 {
 
 }
 
 //-----------------------------------------------------------------------------
-QWidget *ctkSliderSpinBoxWidgetPlugin::createWidget(QWidget *_parent)
+QWidget *ctkSliderWidgetPlugin::createWidget(QWidget *_parent)
 {
-  ctkSliderSpinBoxWidget* _widget = new ctkSliderSpinBoxWidget(_parent);
+  ctkSliderWidget* _widget = new ctkSliderWidget(_parent);
   return _widget;
 }
 
 //-----------------------------------------------------------------------------
-QString ctkSliderSpinBoxWidgetPlugin::domXml() const
+QString ctkSliderWidgetPlugin::domXml() const
 {
-  return "<widget class=\"ctkSliderSpinBoxWidget\" \
+  return "<widget class=\"ctkSliderWidget\" \
           name=\"SliderSpinBoxWidget\">\n"
           "</widget>\n";
 }
 
 // --------------------------------------------------------------------------
-QIcon ctkSliderSpinBoxWidgetPlugin::icon() const
+QIcon ctkSliderWidgetPlugin::icon() const
 {
   return QIcon(":/Icons/sliderspinbox.png");
 }
 
 //-----------------------------------------------------------------------------
-QString ctkSliderSpinBoxWidgetPlugin::includeFile() const
+QString ctkSliderWidgetPlugin::includeFile() const
 {
-  return "ctkSliderSpinBoxWidget.h";
+  return "ctkSliderWidget.h";
 }
 
 //-----------------------------------------------------------------------------
-bool ctkSliderSpinBoxWidgetPlugin::isContainer() const
+bool ctkSliderWidgetPlugin::isContainer() const
 {
   return false;
 }
 
 //-----------------------------------------------------------------------------
-QString ctkSliderSpinBoxWidgetPlugin::name() const
+QString ctkSliderWidgetPlugin::name() const
 {
-  return "ctkSliderSpinBoxWidget";
+  return "ctkSliderWidget";
 }

Libs/Widgets/Plugins/ctkSliderSpinBoxWidgetPlugin.h

@@ -18,20 +18,20 @@
  
 =========================================================================*/
 
-#ifndef __ctkSliderSpinBoxWidgetPlugin_h
-#define __ctkSliderSpinBoxWidgetPlugin_h
+#ifndef __ctkSliderWidgetPlugin_h
+#define __ctkSliderWidgetPlugin_h
 
 // CTK includes
 #include "ctkWidgetsAbstractPlugin.h"
 
-class CTK_WIDGETS_PLUGINS_EXPORT ctkSliderSpinBoxWidgetPlugin :
+class CTK_WIDGETS_PLUGINS_EXPORT ctkSliderWidgetPlugin :
   public QObject,
   public ctkWidgetsAbstractPlugin
 {
   Q_OBJECT
 
 public:
-  ctkSliderSpinBoxWidgetPlugin(QObject *_parent = 0);
+  ctkSliderWidgetPlugin(QObject *_parent = 0);
 
   QWidget *createWidget(QWidget *_parent);
   QString  domXml() const;

Libs/Widgets/Plugins/ctkWidgetsPlugins.h

@@ -43,7 +43,7 @@
 #include "ctkRangeWidgetPlugin.h"
 #include "ctkTransferFunctionViewPlugin.h"
 #include "ctkTreeComboBoxPlugin.h"
-#include "ctkSliderSpinBoxWidgetPlugin.h"
+#include "ctkSliderWidgetPlugin.h"
 
 /// \class Group the plugins in one library
 class CTK_WIDGETS_PLUGINS_EXPORT ctkWidgetsPlugins : public QObject,
@@ -71,7 +71,7 @@ public:
             << new ctkMenuButtonPlugin
             << new ctkRangeSliderPlugin
             << new ctkRangeWidgetPlugin
-            << new ctkSliderSpinBoxWidgetPlugin
+            << new ctkSliderWidgetPlugin
             << new ctkTransferFunctionViewPlugin
             << new ctkTreeComboBoxPlugin;
     return plugins;

Libs/Widgets/Resources/UI/ctkSliderSpinBoxWidget.ui

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
- <class>ctkSliderSpinBoxWidget</class>
- <widget class="QWidget" name="ctkSliderSpinBoxWidget">
+ <class>ctkSliderWidget</class>
+ <widget class="QWidget" name="ctkSliderWidget">
   <property name="geometry">
    <rect>
     <x>0</x>
@@ -17,7 +17,7 @@
    </sizepolicy>
   </property>
   <property name="windowTitle">
-   <string>ctkSliderSpinBoxWidget</string>
+   <string>ctkSliderWidget</string>
   </property>
   <layout class="QHBoxLayout" name="horizontalLayout">
    <property name="spacing">

Libs/Widgets/Testing/Cpp/CMakeLists.txt

@@ -19,7 +19,7 @@ CREATE_TEST_SOURCELIST(Tests ${KIT}CppTests.cxx
   ctkMatrixWidgetTest1.cpp
   ctkRangeSliderTest1.cpp
   ctkRangeWidgetTest1.cpp
-  ctkSliderSpinBoxWidgetTest1.cpp
+  ctkSliderWidgetTest1.cpp
   ctkTreeComboBoxTest1.cpp
   )
 
@@ -63,5 +63,5 @@ SIMPLE_TEST( ctkFittedTextBrowserTest1 )
 SIMPLE_TEST( ctkMatrixWidgetTest1 )
 SIMPLE_TEST( ctkRangeSliderTest1 )
 SIMPLE_TEST( ctkRangeWidgetTest1 )
-SIMPLE_TEST( ctkSliderSpinBoxWidgetTest1 )
+SIMPLE_TEST( ctkSliderWidgetTest1 )
 SIMPLE_TEST( ctkTreeComboBoxTest1 )

Libs/Widgets/Testing/Cpp/ctkSliderSpinBoxWidgetTest1.cpp

@@ -22,23 +22,23 @@
 #include <QApplication>
 
 // CTK includes
-#include "ctkSliderSpinBoxWidget.h"
+#include "ctkSliderWidget.h"
 
 // STD includes
 #include <cstdlib>
 #include <iostream>
 
 //-----------------------------------------------------------------------------
-int ctkSliderSpinBoxWidgetTest1(int argc, char * argv [] )
+int ctkSliderWidgetTest1(int argc, char * argv [] )
 {
   QApplication app(argc, argv);
 
-  ctkSliderSpinBoxWidget sliderSpinBox;
+  ctkSliderWidget sliderSpinBox;
 
   // the first part of the tests infer 2 decimals
   if (sliderSpinBox.decimals() != 2)
     {
-    std::cerr << "ctkSliderSpinBoxWidget::decimals default value failed."
+    std::cerr << "ctkSliderWidget::decimals default value failed."
               << sliderSpinBox.decimals() << std::endl;
     return EXIT_FAILURE;
     }
@@ -47,7 +47,7 @@ int ctkSliderSpinBoxWidgetTest1(int argc, char * argv [] )
 
   if (!qFuzzyCompare(sliderSpinBox.value(), 32.12))
     {
-    std::cerr << "ctkSliderSpinBoxWidget::setValue failed."
+    std::cerr << "ctkSliderWidget::setValue failed."
               << sliderSpinBox.value() << std::endl;
     return EXIT_FAILURE;
     }
@@ -57,7 +57,7 @@ int ctkSliderSpinBoxWidgetTest1(int argc, char * argv [] )
   if (!qFuzzyCompare(sliderSpinBox.minimum(), 10.01) || 
       !qFuzzyCompare(sliderSpinBox.value(), 32.12))
     {
-    std::cerr << "ctkSliderSpinBoxWidget::setMinimum failed."
+    std::cerr << "ctkSliderWidget::setMinimum failed."
               << sliderSpinBox.minimum() << " "
               << sliderSpinBox.value() << std::endl;
     return EXIT_FAILURE;
@@ -68,7 +68,7 @@ int ctkSliderSpinBoxWidgetTest1(int argc, char * argv [] )
   if (!qFuzzyCompare(sliderSpinBox.maximum(), 2050.99) || 
       !qFuzzyCompare(sliderSpinBox.value(), 32.12))
     {
-    std::cerr << "ctkSliderSpinBoxWidget::setMaximum failed."
+    std::cerr << "ctkSliderWidget::setMaximum failed."
               << sliderSpinBox.maximum() << " "
               << sliderSpinBox.value() << std::endl;
     return EXIT_FAILURE;
@@ -79,7 +79,7 @@ int ctkSliderSpinBoxWidgetTest1(int argc, char * argv [] )
   if (!qFuzzyCompare(sliderSpinBox.singleStep(), 0.1) || 
       !qFuzzyCompare(sliderSpinBox.value(), 32.12))
     {
-    std::cerr << "ctkSliderSpinBoxWidget::setSingleStep failed."
+    std::cerr << "ctkSliderWidget::setSingleStep failed."
               << sliderSpinBox.singleStep() << " "
               << sliderSpinBox.value() << std::endl;
     return EXIT_FAILURE;
@@ -92,7 +92,7 @@ int ctkSliderSpinBoxWidgetTest1(int argc, char * argv [] )
       !qFuzzyCompare(sliderSpinBox.minimum(), 10.0) ||
       !qFuzzyCompare(sliderSpinBox.maximum(), 2051.0))
     {
-    std::cerr << "ctkSliderSpinBoxWidget::setDecimals failed."
+    std::cerr << "ctkSliderWidget::setDecimals failed."
               << sliderSpinBox.decimals() << " "
               << sliderSpinBox.value() << " " 
               << sliderSpinBox.minimum() << " " 
@@ -104,7 +104,7 @@ int ctkSliderSpinBoxWidgetTest1(int argc, char * argv [] )
 
   if (!qFuzzyCompare(sliderSpinBox.value(), 77.8))
     {
-    std::cerr << "ctkSliderSpinBoxWidget::setValue failed."
+    std::cerr << "ctkSliderWidget::setValue failed."
               << sliderSpinBox.value() << std::endl;
     return EXIT_FAILURE;
     }  
@@ -114,7 +114,7 @@ int ctkSliderSpinBoxWidgetTest1(int argc, char * argv [] )
   if (!qFuzzyCompare(sliderSpinBox.tickInterval(), 0.1) || 
       !qFuzzyCompare(sliderSpinBox.value(), 77.8))
     {
-    std::cerr << "ctkSliderSpinBoxWidget::setTickInterval failed."
+    std::cerr << "ctkSliderWidget::setTickInterval failed."
               << sliderSpinBox.tickInterval() << " "
               << sliderSpinBox.value() << std::endl;
     return EXIT_FAILURE;
@@ -125,7 +125,7 @@ int ctkSliderSpinBoxWidgetTest1(int argc, char * argv [] )
   if (!qFuzzyCompare(sliderSpinBox.minimum(), 80.6) || 
       !qFuzzyCompare(sliderSpinBox.value(), 80.6))
     {
-    std::cerr << "ctkSliderSpinBoxWidget::setMinimum failed."
+    std::cerr << "ctkSliderWidget::setMinimum failed."
               << sliderSpinBox.minimum() << " "
               << sliderSpinBox.value() << std::endl;
     return EXIT_FAILURE;
@@ -135,7 +135,7 @@ int ctkSliderSpinBoxWidgetTest1(int argc, char * argv [] )
 
   if (!qFuzzyCompare(sliderSpinBox.value(), 80.6))
     {
-    std::cerr << "ctkSliderSpinBoxWidget::reset failed."
+    std::cerr << "ctkSliderWidget::reset failed."
               << sliderSpinBox.value() << std::endl;
     return EXIT_FAILURE;
     }
@@ -145,7 +145,7 @@ int ctkSliderSpinBoxWidgetTest1(int argc, char * argv [] )
   if (sliderSpinBox.spinBoxAlignment() != Qt::AlignRight || 
       !qFuzzyCompare(sliderSpinBox.value(), 80.6))
     {
-    std::cerr << "ctkSliderSpinBoxWidget::setSpinBoxAlignment failed."
+    std::cerr << "ctkSliderWidget::setSpinBoxAlignment failed."
               << sliderSpinBox.spinBoxAlignment() << " "
               << sliderSpinBox.value() << std::endl;
     return EXIT_FAILURE;
@@ -156,7 +156,7 @@ int ctkSliderSpinBoxWidgetTest1(int argc, char * argv [] )
   if (sliderSpinBox.isAutoSpinBoxWidth() != false || 
       !qFuzzyCompare(sliderSpinBox.value(), 80.6))
     {
-    std::cerr << "ctkSliderSpinBoxWidget::setAutoSpinBoxWidth failed."
+    std::cerr << "ctkSliderWidget::setAutoSpinBoxWidth failed."
               << sliderSpinBox.isAutoSpinBoxWidth() << " "
               << sliderSpinBox.value() << std::endl;
     return EXIT_FAILURE;
@@ -167,7 +167,7 @@ int ctkSliderSpinBoxWidgetTest1(int argc, char * argv [] )
   if (sliderSpinBox.prefix() != "$" || 
       !qFuzzyCompare(sliderSpinBox.value(), 80.6))
     {
-    std::cerr << "ctkSliderSpinBoxWidget::setPrefix failed."
+    std::cerr << "ctkSliderWidget::setPrefix failed."
               << sliderSpinBox.prefix().toLatin1().data() << " "
               << sliderSpinBox.value() << std::endl;
     return EXIT_FAILURE;
@@ -178,7 +178,7 @@ int ctkSliderSpinBoxWidgetTest1(int argc, char * argv [] )
   if (sliderSpinBox.suffix() != "mm" || 
       !qFuzzyCompare(sliderSpinBox.value(), 80.6))
     {
-    std::cerr << "ctkSliderSpinBoxWidget::setSuffix failed."
+    std::cerr << "ctkSliderWidget::setSuffix failed."
               << sliderSpinBox.suffix().toLatin1().data() << " "
               << sliderSpinBox.value() << std::endl;
     return EXIT_FAILURE;
@@ -190,7 +190,7 @@ int ctkSliderSpinBoxWidgetTest1(int argc, char * argv [] )
       !qFuzzyCompare(sliderSpinBox.minimum(), 81) ||
       !qFuzzyCompare(sliderSpinBox.maximum(), 2051))
     {
-    std::cerr << "ctkSliderSpinBoxWidget::setDecimals failed."
+    std::cerr << "ctkSliderWidget::setDecimals failed."
               << sliderSpinBox.value() << " " 
               << sliderSpinBox.minimum() << " " 
               << sliderSpinBox.maximum() << std::endl;

Libs/Widgets/ctkSliderSpinBoxWidget.cpp

@@ -23,8 +23,8 @@
 #include <QMouseEvent>
 
 // CTK includes
-#include "ctkSliderSpinBoxWidget.h"
-#include "ui_ctkSliderSpinBoxWidget.h"
+#include "ctkSliderWidget.h"
+#include "ui_ctkSliderWidget.h"
 
 //-----------------------------------------------------------------------------
 namespace
@@ -36,11 +36,11 @@ bool equal(double v1, double v2)
 }
 
 //-----------------------------------------------------------------------------
-class ctkSliderSpinBoxWidgetPrivate: public ctkPrivate<ctkSliderSpinBoxWidget>,
-                                     public Ui_ctkSliderSpinBoxWidget
+class ctkSliderWidgetPrivate: public ctkPrivate<ctkSliderWidget>,
+                                     public Ui_ctkSliderWidget
 {
 public:
-  ctkSliderSpinBoxWidgetPrivate();
+  ctkSliderWidgetPrivate();
   void updateSpinBoxWidth();
   int synchronizedSpinBoxWidth()const;
   void synchronizeSiblingSpinBox(int newWidth);
@@ -52,7 +52,7 @@ public:
 };
 
 // --------------------------------------------------------------------------
-ctkSliderSpinBoxWidgetPrivate::ctkSliderSpinBoxWidgetPrivate()
+ctkSliderWidgetPrivate::ctkSliderWidgetPrivate()
 {
   this->Tracking = true;
   this->Changing = false;
@@ -61,7 +61,7 @@ ctkSliderSpinBoxWidgetPrivate::ctkSliderSpinBoxWidgetPrivate()
 }
 
 // --------------------------------------------------------------------------
-void ctkSliderSpinBoxWidgetPrivate::updateSpinBoxWidth()
+void ctkSliderWidgetPrivate::updateSpinBoxWidth()
 {
   int spinBoxWidth = this->synchronizedSpinBoxWidth();
   if (this->AutoSpinBoxWidth)
@@ -76,17 +76,17 @@ void ctkSliderSpinBoxWidgetPrivate::updateSpinBoxWidth()
 }
 
 // --------------------------------------------------------------------------
-int ctkSliderSpinBoxWidgetPrivate::synchronizedSpinBoxWidth()const
+int ctkSliderWidgetPrivate::synchronizedSpinBoxWidth()const
 {
-  CTK_P(const ctkSliderSpinBoxWidget);
+  CTK_P(const ctkSliderWidget);
   int maxWidth = this->SpinBox->sizeHint().width();
   if (!p->parent())
     {
     return maxWidth;
     }
-  QList<ctkSliderSpinBoxWidget*> siblings =
-    p->parent()->findChildren<ctkSliderSpinBoxWidget*>();
-  foreach(ctkSliderSpinBoxWidget* sibling, siblings)
+  QList<ctkSliderWidget*> siblings =
+    p->parent()->findChildren<ctkSliderWidget*>();
+  foreach(ctkSliderWidget* sibling, siblings)
     {
     maxWidth = qMax(maxWidth, sibling->ctk_d()->SpinBox->sizeHint().width());
     }
@@ -94,12 +94,12 @@ int ctkSliderSpinBoxWidgetPrivate::synchronizedSpinBoxWidth()const
 }
 
 // --------------------------------------------------------------------------
-void ctkSliderSpinBoxWidgetPrivate::synchronizeSiblingSpinBox(int width)
+void ctkSliderWidgetPrivate::synchronizeSiblingSpinBox(int width)
 {
-  CTK_P(const ctkSliderSpinBoxWidget);
-  QList<ctkSliderSpinBoxWidget*> siblings =
-    p->parent()->findChildren<ctkSliderSpinBoxWidget*>();
-  foreach(ctkSliderSpinBoxWidget* sibling, siblings)
+  CTK_P(const ctkSliderWidget);
+  QList<ctkSliderWidget*> siblings =
+    p->parent()->findChildren<ctkSliderWidget*>();
+  foreach(ctkSliderWidget* sibling, siblings)
     {
     if (sibling != p && sibling->isAutoSpinBoxWidth())
       {
@@ -109,10 +109,10 @@ void ctkSliderSpinBoxWidgetPrivate::synchronizeSiblingSpinBox(int width)
 }
 
 // --------------------------------------------------------------------------
-ctkSliderSpinBoxWidget::ctkSliderSpinBoxWidget(QWidget* _parent) : Superclass(_parent)
+ctkSliderWidget::ctkSliderWidget(QWidget* _parent) : Superclass(_parent)
 {
-  CTK_INIT_PRIVATE(ctkSliderSpinBoxWidget);
-  CTK_D(ctkSliderSpinBoxWidget);
+  CTK_INIT_PRIVATE(ctkSliderWidget);
+  CTK_D(ctkSliderWidget);
   
   d->setupUi(this);
 
@@ -130,25 +130,25 @@ ctkSliderSpinBoxWidget::ctkSliderSpinBoxWidget(QWidget* _parent) : Superclass(_p
 }
 
 // --------------------------------------------------------------------------
-double ctkSliderSpinBoxWidget::minimum()const
+double ctkSliderWidget::minimum()const
 {
-  CTK_D(const ctkSliderSpinBoxWidget);
+  CTK_D(const ctkSliderWidget);
   Q_ASSERT(equal(d->SpinBox->minimum(),d->Slider->minimum()));
   return d->Slider->minimum();
 }
 
 // --------------------------------------------------------------------------
-double ctkSliderSpinBoxWidget::maximum()const
+double ctkSliderWidget::maximum()const
 {
-  CTK_D(const ctkSliderSpinBoxWidget);
+  CTK_D(const ctkSliderWidget);
   Q_ASSERT(equal(d->SpinBox->maximum(),d->Slider->maximum()));
   return d->Slider->maximum();
 }
 
 // --------------------------------------------------------------------------
-void ctkSliderSpinBoxWidget::setMinimum(double min)
+void ctkSliderWidget::setMinimum(double min)
 {
-  CTK_D(ctkSliderSpinBoxWidget);
+  CTK_D(ctkSliderWidget);
   d->SpinBox->setMinimum(min);
   // SpinBox can truncate min (depending on decimals).
   // use Spinbox's min to set Slider's min
@@ -158,9 +158,9 @@ void ctkSliderSpinBoxWidget::setMinimum(double min)
 }
 
 // --------------------------------------------------------------------------
-void ctkSliderSpinBoxWidget::setMaximum(double max)
+void ctkSliderWidget::setMaximum(double max)
 {
-  CTK_D(ctkSliderSpinBoxWidget);
+  CTK_D(ctkSliderWidget);
   d->SpinBox->setMaximum(max);
   // SpinBox can truncate max (depending on decimals).
   // use Spinbox's max to set Slider's max
@@ -170,9 +170,9 @@ void ctkSliderSpinBoxWidget::setMaximum(double max)
 }
 
 // --------------------------------------------------------------------------
-void ctkSliderSpinBoxWidget::setRange(double min, double max)
+void ctkSliderWidget::setRange(double min, double max)
 {
-  CTK_D(ctkSliderSpinBoxWidget);
+  CTK_D(ctkSliderWidget);
   
   d->SpinBox->setRange(min, max);
   // SpinBox can truncate the range (depending on decimals).
@@ -184,37 +184,37 @@ void ctkSliderSpinBoxWidget::setRange(double min, double max)
 }
 /*
 // --------------------------------------------------------------------------
-double ctkSliderSpinBoxWidget::sliderPosition()const
+double ctkSliderWidget::sliderPosition()const
 {
   return ctk_d()->Slider->sliderPosition();
 }
 
 // --------------------------------------------------------------------------
-void ctkSliderSpinBoxWidget::setSliderPosition(double position)
+void ctkSliderWidget::setSliderPosition(double position)
 {
   ctk_d()->Slider->setSliderPosition(position);
 }
 */
 /*
 // --------------------------------------------------------------------------
-double ctkSliderSpinBoxWidget::previousSliderPosition()
+double ctkSliderWidget::previousSliderPosition()
 {
   return ctk_d()->Slider->previousSliderPosition();
 }
 */
 
 // --------------------------------------------------------------------------
-double ctkSliderSpinBoxWidget::value()const
+double ctkSliderWidget::value()const
 {
-  CTK_D(const ctkSliderSpinBoxWidget);
+  CTK_D(const ctkSliderWidget);
   Q_ASSERT(equal(d->Slider->value(), d->SpinBox->value()));
   return d->Changing ? d->ValueBeforeChange : d->Slider->value();
 }
 
 // --------------------------------------------------------------------------
-void ctkSliderSpinBoxWidget::setValue(double _value)
+void ctkSliderWidget::setValue(double _value)
 {
-  CTK_D(ctkSliderSpinBoxWidget);
+  CTK_D(ctkSliderWidget);
   // disable the tracking temporally to emit the
   // signal valueChanged if changeValue() is called
   bool isChanging = d->Changing;
@@ -228,9 +228,9 @@ void ctkSliderSpinBoxWidget::setValue(double _value)
 }
 
 // --------------------------------------------------------------------------
-void ctkSliderSpinBoxWidget::startChanging()
+void ctkSliderWidget::startChanging()
 {
-  CTK_D(ctkSliderSpinBoxWidget);
+  CTK_D(ctkSliderWidget);
   if (d->Tracking)
     {
     return;
@@ -240,9 +240,9 @@ void ctkSliderSpinBoxWidget::startChanging()
 }
 
 // --------------------------------------------------------------------------
-void ctkSliderSpinBoxWidget::stopChanging()
+void ctkSliderWidget::stopChanging()
 {
-  CTK_D(ctkSliderSpinBoxWidget);
+  CTK_D(ctkSliderWidget);
   if (d->Tracking)
     {
     return;
@@ -255,9 +255,9 @@ void ctkSliderSpinBoxWidget::stopChanging()
 }
 
 // --------------------------------------------------------------------------
-void ctkSliderSpinBoxWidget::changeValue(double newValue)
+void ctkSliderWidget::changeValue(double newValue)
 {
-  CTK_D(ctkSliderSpinBoxWidget);
+  CTK_D(ctkSliderWidget);
   //if (d->Tracking)
     {
     emit this->valueIsChanging(newValue);
@@ -269,7 +269,7 @@ void ctkSliderSpinBoxWidget::changeValue(double newValue)
 }
 
 // --------------------------------------------------------------------------
-bool ctkSliderSpinBoxWidget::eventFilter(QObject *obj, QEvent *event)
+bool ctkSliderWidget::eventFilter(QObject *obj, QEvent *event)
  {
    if (event->type() == QEvent::MouseButtonPress)
      {
@@ -284,7 +284,7 @@ bool ctkSliderSpinBoxWidget::eventFilter(QObject *obj, QEvent *event)
      QMouseEvent *mouseEvent = static_cast<QMouseEvent *>(event);
      if (mouseEvent->button() & Qt::LeftButton)
        {
-       // here we might prevent ctkSliderSpinBoxWidget::stopChanging
+       // here we might prevent ctkSliderWidget::stopChanging
        // from sending a valueChanged() event as the spinbox might
        // send a valueChanged() after eventFilter() is done.
        this->stopChanging();
@@ -295,33 +295,33 @@ bool ctkSliderSpinBoxWidget::eventFilter(QObject *obj, QEvent *event)
  }
 
 // --------------------------------------------------------------------------
-double ctkSliderSpinBoxWidget::singleStep()const
+double ctkSliderWidget::singleStep()const
 {
-  CTK_D(const ctkSliderSpinBoxWidget);
+  CTK_D(const ctkSliderWidget);
   Q_ASSERT(equal(d->Slider->singleStep(), d->SpinBox->singleStep()));
   return d->Slider->singleStep();
 }
 
 // --------------------------------------------------------------------------
-void ctkSliderSpinBoxWidget::setSingleStep(double step)
+void ctkSliderWidget::setSingleStep(double step)
 {
-  CTK_D(ctkSliderSpinBoxWidget);
+  CTK_D(ctkSliderWidget);
   d->SpinBox->setSingleStep(step);
   d->Slider->setSingleStep(d->SpinBox->singleStep());
   Q_ASSERT(equal(d->Slider->singleStep(), d->SpinBox->singleStep()));
 }
 
 // --------------------------------------------------------------------------
-int ctkSliderSpinBoxWidget::decimals()const
+int ctkSliderWidget::decimals()const
 {
-  CTK_D(const ctkSliderSpinBoxWidget);
+  CTK_D(const ctkSliderWidget);
   return d->SpinBox->decimals();
 }
 
 // --------------------------------------------------------------------------
-void ctkSliderSpinBoxWidget::setDecimals(int newDecimals)
+void ctkSliderWidget::setDecimals(int newDecimals)
 {
-  CTK_D(ctkSliderSpinBoxWidget);
+  CTK_D(ctkSliderWidget);
   d->SpinBox->setDecimals(newDecimals);
   // The number of decimals can change the range values
   // i.e. 50.55 with 2 decimals -> 51 with 0 decimals
@@ -332,16 +332,16 @@ void ctkSliderSpinBoxWidget::setDecimals(int newDecimals)
 }
 
 // --------------------------------------------------------------------------
-QString ctkSliderSpinBoxWidget::prefix()const
+QString ctkSliderWidget::prefix()const
 {
-  CTK_D(const ctkSliderSpinBoxWidget);
+  CTK_D(const ctkSliderWidget);
   return d->SpinBox->prefix();
 }
 
 // --------------------------------------------------------------------------
-void ctkSliderSpinBoxWidget::setPrefix(const QString& newPrefix)
+void ctkSliderWidget::setPrefix(const QString& newPrefix)
 {
-  CTK_D(ctkSliderSpinBoxWidget);
+  CTK_D(ctkSliderWidget);
   d->SpinBox->setPrefix(newPrefix);
 #if QT_VERSION < 0x040800
   /// Setting the prefix doesn't recompute the sizehint, do it manually here:
@@ -352,16 +352,16 @@ void ctkSliderSpinBoxWidget::setPrefix(const QString& newPrefix)
 }
 
 // --------------------------------------------------------------------------
-QString ctkSliderSpinBoxWidget::suffix()const
+QString ctkSliderWidget::suffix()const
 {
-  CTK_D(const ctkSliderSpinBoxWidget);
+  CTK_D(const ctkSliderWidget);
   return d->SpinBox->suffix();
 }
 
 // --------------------------------------------------------------------------
-void ctkSliderSpinBoxWidget::setSuffix(const QString& newSuffix)
+void ctkSliderWidget::setSuffix(const QString& newSuffix)
 {
-  CTK_D(ctkSliderSpinBoxWidget);
+  CTK_D(ctkSliderWidget);
   d->SpinBox->setSuffix(newSuffix);
 #if QT_VERSION < 0x040800
   /// Setting the suffix doesn't recompute the sizehint, do it manually here:
@@ -372,62 +372,62 @@ void ctkSliderSpinBoxWidget::setSuffix(const QString& newSuffix)
 }
 
 // --------------------------------------------------------------------------
-double ctkSliderSpinBoxWidget::tickInterval()const
+double ctkSliderWidget::tickInterval()const
 {
-  CTK_D(const ctkSliderSpinBoxWidget);
+  CTK_D(const ctkSliderWidget);
   return d->Slider->tickInterval();
 }
 
 // --------------------------------------------------------------------------
-void ctkSliderSpinBoxWidget::setTickInterval(double ti)
+void ctkSliderWidget::setTickInterval(double ti)
 { 
-  CTK_D(ctkSliderSpinBoxWidget);
+  CTK_D(ctkSliderWidget);
   d->Slider->setTickInterval(ti);
 }
 
 // -------------------------------------------------------------------------
-void ctkSliderSpinBoxWidget::reset()
+void ctkSliderWidget::reset()
 {
   this->setValue(0.);
 }
 
 // -------------------------------------------------------------------------
-void ctkSliderSpinBoxWidget::setSpinBoxAlignment(Qt::Alignment alignment)
+void ctkSliderWidget::setSpinBoxAlignment(Qt::Alignment alignment)
 {
   return ctk_d()->SpinBox->setAlignment(alignment);
 }
 
 // -------------------------------------------------------------------------
-Qt::Alignment ctkSliderSpinBoxWidget::spinBoxAlignment()const
+Qt::Alignment ctkSliderWidget::spinBoxAlignment()const
 {
   return ctk_d()->SpinBox->alignment();
 }
 
 // -------------------------------------------------------------------------
-void ctkSliderSpinBoxWidget::setTracking(bool enable)
+void ctkSliderWidget::setTracking(bool enable)
 {
-  CTK_D(ctkSliderSpinBoxWidget);
+  CTK_D(ctkSliderWidget);
   d->Tracking = enable;
 }
 
 // -------------------------------------------------------------------------
-bool ctkSliderSpinBoxWidget::hasTracking()const
+bool ctkSliderWidget::hasTracking()const
 {
-  CTK_D(const ctkSliderSpinBoxWidget);
+  CTK_D(const ctkSliderWidget);
   return d->Tracking;
 }
 
 // -------------------------------------------------------------------------
-bool ctkSliderSpinBoxWidget::isAutoSpinBoxWidth()const
+bool ctkSliderWidget::isAutoSpinBoxWidth()const
 {
-  CTK_D(const ctkSliderSpinBoxWidget);
+  CTK_D(const ctkSliderWidget);
   return d->AutoSpinBoxWidth;
 }
 
 // -------------------------------------------------------------------------
-void ctkSliderSpinBoxWidget::setAutoSpinBoxWidth(bool autoWidth)
+void ctkSliderWidget::setAutoSpinBoxWidth(bool autoWidth)
 {
-  CTK_D(ctkSliderSpinBoxWidget);
+  CTK_D(ctkSliderWidget);
   d->AutoSpinBoxWidth = autoWidth;
   d->updateSpinBoxWidth();
 }

Libs/Widgets/ctkSliderSpinBoxWidget.h

@@ -18,8 +18,8 @@
  
 =========================================================================*/
 
-#ifndef __ctkSliderSpinBoxWidget_h
-#define __ctkSliderSpinBoxWidget_h
+#ifndef __ctkSliderWidget_h
+#define __ctkSliderWidget_h
 
 // Qt includes
 #include <QSlider>
@@ -29,14 +29,13 @@
 
 #include "CTKWidgetsExport.h"
 
-class ctkSliderSpinBoxWidgetPrivate;
+class ctkSliderWidgetPrivate;
 
 ///
-/// ctkSliderSpinBoxWidget is a wrapper around a ctkDoubleSlider and a
-/// synchronized QDoubleSpinBox.
-/// TODO: rename ctkSliderSpinBoxWidget into ctkSliderWidget
+/// ctkSliderWidget is a wrapper around a ctkDoubleSlider and a QDoubleSpinBox
+/// where the slider value and the spinbox value are synchronized.
 /// \sa ctkRangeWidget, ctkDoubleRangeSlider, QSpinBox
-class CTK_WIDGETS_EXPORT ctkSliderSpinBoxWidget : public QWidget
+class CTK_WIDGETS_EXPORT ctkSliderWidget : public QWidget
 {
   Q_OBJECT
   Q_PROPERTY(double minimum READ minimum WRITE setMinimum)
@@ -56,8 +55,8 @@ public:
   typedef QWidget Superclass;
 
   /// Constructors
-  explicit ctkSliderSpinBoxWidget(QWidget* parent = 0);
-  virtual ~ctkSliderSpinBoxWidget(){}
+  explicit ctkSliderWidget(QWidget* parent = 0);
+  virtual ~ctkSliderWidget(){}
 
   /// 
   /// This property holds the sliders and spinbox minimum value.
@@ -88,7 +87,7 @@ public:
 
   /// 
   /// This property holds the slider and spinbox current value.
-  /// ctkSliderSpinBoxWidget forces the value to be within the
+  /// ctkSliderWidget forces the value to be within the
   /// legal range: minimum <= value <= maximum.
   double value()const;
 
@@ -148,7 +147,7 @@ public:
   /// Set/Get the auto spinbox width
   /// When the autoSpinBoxWidth property is on, the width of the SpinBox is
   /// set to the same width of the largest QSpinBox of its
-  // ctkSliderSpinBoxWidget siblings.
+  // ctkSliderWidget siblings.
   bool isAutoSpinBoxWidth()const;
   void setAutoSpinBoxWidth(bool autoWidth);
 
@@ -175,7 +174,7 @@ protected:
   virtual bool eventFilter(QObject *obj, QEvent *event);
   
 private:
-  CTK_DECLARE_PRIVATE(ctkSliderSpinBoxWidget);
+  CTK_DECLARE_PRIVATE(ctkSliderWidget);
 
 };