ENH: Can update ctkVTKMagnifyView on vtkRenderWindow renders, and can specify fastest update interval.

- Note renaming: ctkCursorPixmapWidget -> ctkCrosshairLabel, and ctkVTKMagnifyWidget -> ctkVTKMagnifyView

This is a combination of 18 commits.
ENH: ctkVTKMagnifyWidgetPrivate is QVTKObject

ENH: Optionally update magnify widget on vtkRenderWindow EndEvents

ENH: On errors updating pixmap, freeze widget at current state instead of blanking it

STYLE: Number of characters per line

STYLE: Call update() within updatePixmap() and removePixmap()

STYLE: RemovePixmap() is a slot

- Symmetrical with updatePixmap()

ENH: Add test for setting ObserveRenderWindowEvents property

BUG: Fix incorrect logic when toggling observeRenderWindowEvents

ENH: Add testing of observing render window events when mouse is stationary

ENH: Add maximum update interval

- Updates at update interval, to prevent fast mouse events from flooding the updating
- Maintains the most recent event, and updates at a fixed interval

ENH: Add test for changing update interval

STYLE: Use QApplication::processEvents() instead of a timer connecting to application::quit()

STYLE: Rename ctkCursorPixmapWidget -> ctkCrosshairLabel

STYLE: Naming change from cursor -> crosshair

STYLE: Rename ctkVTKMagnifyWidget -> ctkVTKMagnifyView

STYLE: Rename CrossHairCrosshair -> SimpleCrosshair

ENH: In test, trigger more obvious change when not observing render window events

STYLE: Use std::floor and std::ceil.

Libs/Visualization/VTK/Widgets/CMakeLists.txt

@@ -19,8 +19,9 @@ SET(KIT_SRCS
   ctkVTKDataSetModel.h
   ctkVTKDataSetArrayComboBox.cpp
   ctkVTKDataSetArrayComboBox.h
-  ctkVTKMagnifyWidget.cpp
-  ctkVTKMagnifyWidget.h
+  ctkVTKMagnifyView.cpp
+  ctkVTKMagnifyView.h
+  ctkVTKMagnifyView_p.h
   ctkVTKMatrixWidget.cpp
   ctkVTKMatrixWidget.h
   ctkVTKRenderView.cpp
@@ -46,7 +47,8 @@ SET(KIT_MOC_SRCS
   ctkVTKAbstractView_p.h
   ctkVTKDataSetArrayComboBox.h
   ctkVTKDataSetModel.h
-  ctkVTKMagnifyWidget.h
+  ctkVTKMagnifyView.h
+  ctkVTKMagnifyView_p.h
   ctkVTKMatrixWidget.h
   ctkVTKRenderView.h
   ctkVTKRenderView_p.h

Libs/Visualization/VTK/Widgets/Plugins/CMakeLists.txt

@@ -15,8 +15,8 @@ SET(PLUGIN_SRCS
 
   ctkVTKDataSetArrayComboBoxPlugin.cpp
   ctkVTKDataSetArrayComboBoxPlugin.h
-  ctkVTKMagnifyWidgetPlugin.cpp
-  ctkVTKMagnifyWidgetPlugin.h
+  ctkVTKMagnifyViewPlugin.cpp
+  ctkVTKMagnifyViewPlugin.h
   ctkVTKRenderViewPlugin.cpp
   ctkVTKRenderViewPlugin.h
   ctkVTKScalarBarWidgetPlugin.cpp
@@ -34,7 +34,7 @@ SET(PLUGIN_MOC_SRCS
   ctkVTKWidgetsPlugins.h
 
   ctkVTKDataSetArrayComboBoxPlugin.h
-  ctkVTKMagnifyWidgetPlugin.h
+  ctkVTKMagnifyViewPlugin.h
   ctkVTKRenderViewPlugin.h
   ctkVTKScalarBarWidgetPlugin.h
   ctkVTKSliceViewPlugin.h

Libs/Visualization/VTK/Widgets/Plugins/ctkVTKMagnifyWidgetPlugin.cpp

@@ -19,25 +19,25 @@
 =========================================================================*/
 
 // CTK includes
-#include "ctkVTKMagnifyWidgetPlugin.h"
-#include "ctkVTKMagnifyWidget.h"
+#include "ctkVTKMagnifyViewPlugin.h"
+#include "ctkVTKMagnifyView.h"
 
 //-----------------------------------------------------------------------------
-ctkVTKMagnifyWidgetPlugin::ctkVTKMagnifyWidgetPlugin(QObject *_parent):QObject(_parent)
+ctkVTKMagnifyViewPlugin::ctkVTKMagnifyViewPlugin(QObject *_parent):QObject(_parent)
 {
 }
 
 //-----------------------------------------------------------------------------
-QWidget *ctkVTKMagnifyWidgetPlugin::createWidget(QWidget *_parent)
+QWidget *ctkVTKMagnifyViewPlugin::createWidget(QWidget *_parent)
 {
-  ctkVTKMagnifyWidget* _widget = new ctkVTKMagnifyWidget(_parent);
+  ctkVTKMagnifyView* _widget = new ctkVTKMagnifyView(_parent);
   return _widget;
 }
 
 //-----------------------------------------------------------------------------
-QString ctkVTKMagnifyWidgetPlugin::domXml() const
+QString ctkVTKMagnifyViewPlugin::domXml() const
 {
-  return "<widget class=\"ctkVTKMagnifyWidget\" \
+  return "<widget class=\"ctkVTKMagnifyView\" \
           name=\"VTKMagnify\">\n"
           " <property name=\"geometry\">\n"
           "  <rect>\n"
@@ -51,19 +51,19 @@ QString ctkVTKMagnifyWidgetPlugin::domXml() const
 }
 
 //-----------------------------------------------------------------------------
-QString ctkVTKMagnifyWidgetPlugin::includeFile() const
+QString ctkVTKMagnifyViewPlugin::includeFile() const
 {
-  return "ctkVTKMagnifyWidget.h";
+  return "ctkVTKMagnifyView.h";
 }
 
 //-----------------------------------------------------------------------------
-bool ctkVTKMagnifyWidgetPlugin::isContainer() const
+bool ctkVTKMagnifyViewPlugin::isContainer() const
 {
   return false;
 }
 
 //-----------------------------------------------------------------------------
-QString ctkVTKMagnifyWidgetPlugin::name() const
+QString ctkVTKMagnifyViewPlugin::name() const
 {
-  return "ctkVTKMagnifyWidget";
+  return "ctkVTKMagnifyView";
 }

Libs/Visualization/VTK/Widgets/Plugins/ctkVTKMagnifyWidgetPlugin.h

@@ -18,20 +18,20 @@
 
 =========================================================================*/
 
-#ifndef __ctkVTKMagnifyWidgetPlugin_h
-#define __ctkVTKMagnifyWidgetPlugin_h
+#ifndef __ctkVTKMagnifyViewPlugin_h
+#define __ctkVTKMagnifyViewPlugin_h
 
 // CTK includes
 #include "ctkVTKWidgetsAbstractPlugin.h"
 
-class CTK_VISUALIZATION_VTK_WIDGETS_PLUGINS_EXPORT ctkVTKMagnifyWidgetPlugin :
+class CTK_VISUALIZATION_VTK_WIDGETS_PLUGINS_EXPORT ctkVTKMagnifyViewPlugin :
   public QObject,
   public ctkVTKWidgetsAbstractPlugin
 {
   Q_OBJECT
 
 public:
-  ctkVTKMagnifyWidgetPlugin(QObject *_parent = 0);
+  ctkVTKMagnifyViewPlugin(QObject *_parent = 0);
   
   QWidget *createWidget(QWidget *_parent);
   QString domXml() const;

Libs/Visualization/VTK/Widgets/Plugins/ctkVTKWidgetsPlugins.h

@@ -27,7 +27,7 @@
 // CTK includes
 #include "ctkVisualizationVTKWidgetsPluginsExport.h"
 #include "ctkVTKDataSetArrayComboBoxPlugin.h"
-#include "ctkVTKMagnifyWidgetPlugin.h"
+#include "ctkVTKMagnifyViewPlugin.h"
 #include "ctkVTKRenderViewPlugin.h"
 #include "ctkVTKScalarBarWidgetPlugin.h"
 #ifdef CTK_USE_CHARTS
@@ -50,7 +50,7 @@ public:
     {
     QList<QDesignerCustomWidgetInterface *> plugins;
     plugins << new ctkVTKDataSetArrayComboBoxPlugin;
-    plugins << new ctkVTKMagnifyWidgetPlugin;
+    plugins << new ctkVTKMagnifyViewPlugin;
     plugins << new ctkVTKRenderViewPlugin;
     plugins << new ctkVTKScalarBarWidgetPlugin;
 #ifdef CTK_USE_CHARTS

Libs/Visualization/VTK/Widgets/Testing/Cpp/CMakeLists.txt

@@ -7,7 +7,7 @@ SET(TEST_SOURCES
   ctkVTKDataSetArrayComboBoxTest1.cpp
   ctkVTKDataSetModelTest1.cpp
   ctkVTKMatrixWidgetTest1.cpp
-  ctkVTKMagnifyWidgetTest1.cpp
+  ctkVTKMagnifyViewTest1.cpp
   ctkVTKScalarBarWidgetTest1.cpp
   ctkTransferFunctionBarsItemTest1.cpp
   ctkTransferFunctionViewTest1.cpp
@@ -38,7 +38,7 @@ ENDIF(CTK_USE_CHARTS)
 #
 IF(EXISTS "${CTKData_DIR}")
   LIST(APPEND TEST_SOURCES
-    ctkVTKMagnifyWidgetTest2.cpp
+    ctkVTKMagnifyViewTest2.cpp
     ctkVTKSliceViewTest2.cpp
     ctkVTKRenderViewTest2.cpp
     )
@@ -84,7 +84,7 @@ ENDMACRO( MAGNIFY_WIDGET_TEST  )
 
 SIMPLE_TEST( ctkVTKDataSetArrayComboBoxTest1 )
 SIMPLE_TEST( ctkVTKDataSetModelTest1 )
-SIMPLE_TEST( ctkVTKMagnifyWidgetTest1 )
+SIMPLE_TEST( ctkVTKMagnifyViewTest1 )
 SIMPLE_TEST( ctkVTKMatrixWidgetTest1 )
 SIMPLE_TEST( ctkVTKScalarBarWidgetTest1 )
 SIMPLE_TEST( ctkTransferFunctionBarsItemTest1 )
@@ -114,19 +114,19 @@ IF(EXISTS "${CTKData_DIR}")
   #
   # Dependencies required so that these tests won't run in parallel
   #
-  MAGNIFY_WIDGET_TEST( ctkVTKMagnifyWidgetTest2 OddOdd 341 17 )
-  MAGNIFY_WIDGET_TEST( ctkVTKMagnifyWidgetTest2 EvenEven 340 18 )
-  SET_TESTS_PROPERTIES( ctkVTKMagnifyWidgetTest2EvenEven
+  MAGNIFY_WIDGET_TEST( ctkVTKMagnifyViewTest2 OddOdd 341 17 )
+  MAGNIFY_WIDGET_TEST( ctkVTKMagnifyViewTest2 EvenEven 340 18 )
+  SET_TESTS_PROPERTIES( ctkVTKMagnifyViewTest2EvenEven
                         PROPERTIES DEPENDS
-                        ctkVTKMagnifyWidgetTest2OddOdd )
-  MAGNIFY_WIDGET_TEST( ctkVTKMagnifyWidgetTest2 OddEven 341 18 )
-  SET_TESTS_PROPERTIES( ctkVTKMagnifyWidgetTest2OddEven
+                        ctkVTKMagnifyViewTest2OddOdd )
+  MAGNIFY_WIDGET_TEST( ctkVTKMagnifyViewTest2 OddEven 341 18 )
+  SET_TESTS_PROPERTIES( ctkVTKMagnifyViewTest2OddEven
                         PROPERTIES DEPENDS
-                        ctkVTKMagnifyWidgetTest2EvenEven )
-  MAGNIFY_WIDGET_TEST( ctkVTKMagnifyWidgetTest2 EvenOdd 340 17 )
-  SET_TESTS_PROPERTIES( ctkVTKMagnifyWidgetTest2EvenOdd
+                        ctkVTKMagnifyViewTest2EvenEven )
+  MAGNIFY_WIDGET_TEST( ctkVTKMagnifyViewTest2 EvenOdd 340 17 )
+  SET_TESTS_PROPERTIES( ctkVTKMagnifyViewTest2EvenOdd
                         PROPERTIES DEPENDS
-                        ctkVTKMagnifyWidgetTest2OddEven )
+                        ctkVTKMagnifyViewTest2OddEven )
   SIMPLE_TEST( ctkVTKSliceViewTest2 )
   SIMPLE_TEST( ctkVTKRenderViewTest2 )
 ENDIF()

Libs/Visualization/VTK/Widgets/Testing/Cpp/ctkVTKMagnifyWidgetTest1.cpp

@@ -23,7 +23,7 @@
 #include <QTimer>
 
 // CTK includes
-#include "ctkVTKMagnifyWidget.h"
+#include "ctkVTKMagnifyView.h"
 
 // VTK includes
 #include <QVTKWidget.h>
@@ -33,32 +33,36 @@
 #include <iostream>
 
 //-----------------------------------------------------------------------------
-int ctkVTKMagnifyWidgetTest1(int argc, char * argv [] )
+int ctkVTKMagnifyViewTest1(int argc, char * argv [] )
 {
   QApplication app(argc, argv);
 
-  ctkVTKMagnifyWidget magnify;
+  ctkVTKMagnifyView magnify;
 
   // check default values
-  if (!magnify.showCursor() ||
-      magnify.cursorPen().color() != magnify.palette().color(QPalette::Highlight) ||
-      magnify.cursorPen().width() != 0 ||
-      magnify.cursorPen().joinStyle() != Qt::MiterJoin ||
-      magnify.cursorType() != ctkCursorPixmapWidget::CrossHairCursor ||
+  if (!magnify.showCrosshair() ||
+      magnify.crosshairPen().color() != magnify.palette().color(QPalette::Highlight) ||
+      magnify.crosshairPen().width() != 0 ||
+      magnify.crosshairPen().joinStyle() != Qt::MiterJoin ||
+      magnify.crosshairType() != ctkCrosshairLabel::SimpleCrosshair ||
       magnify.marginColor() != magnify.palette().color(QPalette::Window) ||
       magnify.bullsEyeWidth() != 15 ||
       magnify.magnification() != 1.0 ||
+      magnify.observeRenderWindowEvents() != true ||
+      magnify.updateInterval() != 20 ||
       magnify.numberObserved() != 0)
     {
-    std::cerr << "ctkVTKMagnifyWidget: Wrong default values. " << std::endl
-              << " " << magnify.showCursor()
-              << " " << qPrintable(magnify.cursorPen().color().name())
-              << " " << magnify.cursorPen().width()
-              << " " << static_cast<int>(magnify.cursorPen().joinStyle())
-              << " " << magnify.cursorType()
+    std::cerr << "ctkVTKMagnifyView: Wrong default values. " << std::endl
+              << " " << magnify.showCrosshair()
+              << " " << qPrintable(magnify.crosshairPen().color().name())
+              << " " << magnify.crosshairPen().width()
+              << " " << static_cast<int>(magnify.crosshairPen().joinStyle())
+              << " " << magnify.crosshairType()
               << " " << qPrintable(magnify.marginColor().name())
               << " " << magnify.bullsEyeWidth()
               << " " << magnify.magnification()
+              << " " << magnify.observeRenderWindowEvents()
+              << " " << magnify.updateInterval()
               << " " << magnify.numberObserved() << std::endl;
     return EXIT_FAILURE;
     }
@@ -67,11 +71,29 @@ int ctkVTKMagnifyWidgetTest1(int argc, char * argv [] )
   magnify.setMagnification(10.5);
   if (magnify.magnification() != 10.5)
     {
-    std::cerr << "ctkVTKMagnifyWidget:setMagnification failed. "
+    std::cerr << "ctkVTKMagnifyView:setMagnification failed. "
               << magnify.magnification() << std::endl;
     return EXIT_FAILURE;
     }
 
+  // Observe render window events
+  magnify.setObserveRenderWindowEvents(false);
+  if (magnify.observeRenderWindowEvents() != false)
+    {
+    std::cerr << "ctkVTKMagnifyView:setObserveRenderWindowEvents failed. "
+              << magnify.observeRenderWindowEvents() << std::endl;
+    return EXIT_FAILURE;
+    }
+
+  // Update interval
+  magnify.setUpdateInterval(0);
+  if (magnify.updateInterval() != 0)
+    {
+    std::cerr << "ctkVTKMagnifyView:setUpdateInterval failed. "
+              << magnify.updateInterval() << std::endl;
+    return EXIT_FAILURE;
+    }
+
   // Adding / removing observed QVTKWidgets
   QList<QVTKWidget *> allVTKWidgets;
   int numVTKWidgets = 3;
@@ -85,7 +107,7 @@ int ctkVTKMagnifyWidgetTest1(int argc, char * argv [] )
   if (!magnify.isObserved(allVTKWidgets[0]) || magnify.isObserved(allVTKWidgets[1]) ||
       magnify.isObserved(allVTKWidgets[2]) || magnify.numberObserved() != 1)
     {
-    std::cerr << "ctkVTKMagnifyWidget:observe(QVTKWidget*) failed. "
+    std::cerr << "ctkVTKMagnifyView:observe(QVTKWidget*) failed. "
               << "Number observed = " << magnify.numberObserved() << std::endl;
     return EXIT_FAILURE;
     }
@@ -95,7 +117,7 @@ int ctkVTKMagnifyWidgetTest1(int argc, char * argv [] )
   if (!magnify.isObserved(allVTKWidgets[0]) || !magnify.isObserved(allVTKWidgets[1]) ||
       !magnify.isObserved(allVTKWidgets[2]) || magnify.numberObserved() != 3)
     {
-    std::cerr << "ctkVTKMagnifyWidget:observe(QList<QVTKWidget*>) failed. "
+    std::cerr << "ctkVTKMagnifyView:observe(QList<QVTKWidget*>) failed. "
               << "Number observed = " << magnify.numberObserved() << std::endl;
     return EXIT_FAILURE;
     }
@@ -105,7 +127,7 @@ int ctkVTKMagnifyWidgetTest1(int argc, char * argv [] )
   if (!magnify.isObserved(allVTKWidgets[0]) || !magnify.isObserved(allVTKWidgets[1]) ||
       !magnify.isObserved(allVTKWidgets[2]) || magnify.numberObserved() != 3)
     {
-    std::cerr << "ctkVTKMagnifyWidget:observe(QVTKWidget*) failed on re-observe. "
+    std::cerr << "ctkVTKMagnifyView:observe(QVTKWidget*) failed on re-observe. "
               << "Number observed = " << magnify.numberObserved() << std::endl;
     return EXIT_FAILURE;
     }
@@ -115,8 +137,9 @@ int ctkVTKMagnifyWidgetTest1(int argc, char * argv [] )
   if (!magnify.isObserved(allVTKWidgets[0]) || !magnify.isObserved(allVTKWidgets[1]) ||
       !magnify.isObserved(allVTKWidgets[2]) || magnify.numberObserved() != 3)
     {
-    std::cerr << "ctkVTKMagnifyWidget:observe(QList<QVTKWidget*>) failed on re-observe. "
-              << "Number observed = " << magnify.numberObserved() << std::endl;
+    std::cerr << "ctkVTKMagnifyView:observe(QList<QVTKWidget*>) failed on re-"
+              << "observe. Number observed = " << magnify.numberObserved()
+              << std::endl;
     return EXIT_FAILURE;
     }
 
@@ -125,7 +148,7 @@ int ctkVTKMagnifyWidgetTest1(int argc, char * argv [] )
   if (!magnify.isObserved(allVTKWidgets[0]) || !magnify.isObserved(allVTKWidgets[1]) ||
       magnify.isObserved(allVTKWidgets[2]) || magnify.numberObserved() != 2)
     {
-    std::cerr << "ctkVTKMagnifyWidget:remove(QVTKWidget*) failed. "
+    std::cerr << "ctkVTKMagnifyView:remove(QVTKWidget*) failed. "
               << "Number observed = " << magnify.numberObserved() << std::endl;
     return EXIT_FAILURE;
     }
@@ -135,7 +158,7 @@ int ctkVTKMagnifyWidgetTest1(int argc, char * argv [] )
   if (!magnify.isObserved(allVTKWidgets[0]) || !magnify.isObserved(allVTKWidgets[1]) ||
       magnify.isObserved(allVTKWidgets[2]) || magnify.numberObserved() != 2)
     {
-    std::cerr << "ctkVTKMagnifyWidget:remove(QVTKWidget*) failed on re-remove. "
+    std::cerr << "ctkVTKMagnifyView:remove(QVTKWidget*) failed on re-remove. "
               << "Number observed = " << magnify.numberObserved() << std::endl;
     return EXIT_FAILURE;
     }
@@ -145,7 +168,7 @@ int ctkVTKMagnifyWidgetTest1(int argc, char * argv [] )
   if (magnify.isObserved(allVTKWidgets[0]) || magnify.isObserved(allVTKWidgets[1]) ||
       magnify.isObserved(allVTKWidgets[2]) || magnify.numberObserved() != 0)
     {
-    std::cerr << "ctkVTKMagnifyWidget:remove(QList<QVTKWidget*>) failed. "
+    std::cerr << "ctkVTKMagnifyView:remove(QList<QVTKWidget*>) failed. "
               << "Number observed = " << magnify.numberObserved() << std::endl;
     return EXIT_FAILURE;
     }
@@ -155,8 +178,8 @@ int ctkVTKMagnifyWidgetTest1(int argc, char * argv [] )
   if (magnify.isObserved(allVTKWidgets[0]) || magnify.isObserved(allVTKWidgets[1]) ||
       magnify.isObserved(allVTKWidgets[2]) || magnify.numberObserved() != 0)
     {
-    std::cerr << "ctkVTKMagnifyWidget:remove(QList<QVTKWidget*>) failed on re-remove. "
-              << "Number observed = " << magnify.numberObserved() << std::endl;
+    std::cerr << "ctkVTKMagnifyView:remove(QList<QVTKWidget*>) failed on re-remove."
+              << " Number observed = " << magnify.numberObserved() << std::endl;
     return EXIT_FAILURE;
     }
 
@@ -165,8 +188,9 @@ int ctkVTKMagnifyWidgetTest1(int argc, char * argv [] )
   if (magnify.isObserved(allVTKWidgets[0]) || !magnify.isObserved(allVTKWidgets[1]) ||
       magnify.isObserved(allVTKWidgets[2]) || magnify.numberObserved() != 1)
     {
-    std::cerr << "ctkVTKMagnifyWidget:observe(QList<QVTKWidget*>) failed on lists of "
-              << "length 1. Number observed = " << magnify.numberObserved() << std::endl;
+    std::cerr << "ctkVTKMagnifyView:observe(QList<QVTKWidget*>) failed on lists of "
+              << "length 1. Number observed = " << magnify.numberObserved()
+              << std::endl;
     return EXIT_FAILURE;
     }
 

Libs/Visualization/VTK/Widgets/Testing/Cpp/ctkVTKMagnifyWidgetTest2.cpp

@@ -28,7 +28,7 @@
 #include <QTimer>
 
 // CTK includes
-#include "ctkVTKMagnifyWidget.h"
+#include "ctkVTKMagnifyView.h"
 #include "ctkCommandLineParser.h"
 #include "ctkVTKSliceView.h"
 
@@ -36,6 +36,7 @@
 #include <vtkImageReader2Factory.h>
 #include <vtkImageReader2.h>
 #include <vtkImageData.h>
+#include <vtkImageGaussianSmooth.h>
 #include <vtkSmartPointer.h>
 
 // STD includes
@@ -43,7 +44,7 @@
 #include <iostream>
 
 //-----------------------------------------------------------------------------
-bool imageCompare(ctkVTKMagnifyWidget * magnify, QString baselineDirectory,
+bool imageCompare(ctkVTKMagnifyView * magnify, QString baselineDirectory,
                   QString baselineFilename)
   {
   QImage output = QPixmap::grabWidget(magnify).toImage();
@@ -53,7 +54,7 @@ bool imageCompare(ctkVTKMagnifyWidget * magnify, QString baselineDirectory,
 
 //-----------------------------------------------------------------------------
 // (Used to create baselines, not during testing).
-void imageSave(ctkVTKMagnifyWidget * magnify, QString baselineDirectory,
+void imageSave(ctkVTKMagnifyView * magnify, QString baselineDirectory,
                QString baselineFilename)
   {
   QImage output = QPixmap::grabWidget(magnify).toImage();
@@ -61,7 +62,7 @@ void imageSave(ctkVTKMagnifyWidget * magnify, QString baselineDirectory,
   }
 
 //-----------------------------------------------------------------------------
-bool runBaselineTest(int time, QApplication& app, ctkVTKMagnifyWidget * magnify,
+bool runBaselineTest(int time, QApplication& app, ctkVTKMagnifyView * magnify,
                      QWidget * underWidget, bool shouldBeUnder,
                      QString baselineDirectory, QString testName,
                      QString testNumber, QString errorMessage)
@@ -69,21 +70,21 @@ bool runBaselineTest(int time, QApplication& app, ctkVTKMagnifyWidget * magnify,
   QTimer::singleShot(time, &app, SLOT(quit()));
   if (app.exec() == EXIT_FAILURE)
     {
-    std::cerr << "ctkVTKMagnifyWidget exec failed when "
+    std::cerr << "ctkVTKMagnifyView exec failed when "
         << qPrintable(errorMessage) << std::endl;
     return false;
     }
   if (underWidget->underMouse() != shouldBeUnder)
     {
-    std::cerr << "ctkMagnifyWidget mouse position failed when "
+    std::cerr << "ctkMagnifyView mouse position failed when "
         << qPrintable(errorMessage) << std::endl;
     return false;
     }
   QString baselineFilename
-      = "ctkVTKMagnifyWidgetTest2" + testNumber + testName + ".png";
+      = "ctkVTKMagnifyViewTest2" + testNumber + testName + ".png";
   if (!imageCompare(magnify, baselineDirectory, baselineFilename))
     {
-    std::cerr << "ctkVTKMagnifyWidget baseline comparison failed when "
+    std::cerr << "ctkVTKMagnifyView baseline comparison failed when "
               << qPrintable(errorMessage) << "." << std::endl;
     return false;
     }
@@ -91,7 +92,7 @@ bool runBaselineTest(int time, QApplication& app, ctkVTKMagnifyWidget * magnify,
 }
 
 //-----------------------------------------------------------------------------
-int ctkVTKMagnifyWidgetTest2(int argc, char * argv [] )
+int ctkVTKMagnifyViewTest2(int argc, char * argv [] )
 {
   QApplication app(argc, argv);
 
@@ -122,63 +123,78 @@ int ctkVTKMagnifyWidgetTest2(int argc, char * argv [] )
   QHBoxLayout layout(&parentWidget);
 
   // Magnify widget parameters (we want an odd widget size and odd bullsEye)
-  bool showCursor = true;
-  QPen cursorPen(QPen(Qt::yellow));
-  cursorPen.setJoinStyle(Qt::MiterJoin);
-  ctkCursorPixmapWidget::CursorType cursorType
-      = ctkCursorPixmapWidget::BullsEyeCursor;
+  bool showCrosshair = true;
+  QPen crosshairPen(QPen(Qt::yellow));
+  crosshairPen.setJoinStyle(Qt::MiterJoin);
+  ctkCrosshairLabel::CrosshairType crosshairType
+      = ctkCrosshairLabel::BullsEyeCrosshair;
   double bullsEyeWidth = magnification + 2;
   QColor marginColor = Qt::magenta;
+  bool observeRenderWindowEvents = false;
+  int updateInterval = 0;
 
   // Create the magnify widget
-  ctkVTKMagnifyWidget * magnify = new ctkVTKMagnifyWidget(&parentWidget);
+  ctkVTKMagnifyView * magnify = new ctkVTKMagnifyView(&parentWidget);
   magnify->setMinimumSize(size,size);
   magnify->setMaximumSize(size,size);
-  magnify->setShowCursor(showCursor);
-  magnify->setCursorPen(cursorPen);
-  magnify->setCursorType(cursorType);
+  magnify->setShowCrosshair(showCrosshair);
+  magnify->setCrosshairPen(crosshairPen);
+  magnify->setCrosshairType(crosshairType);
   magnify->setBullsEyeWidth(bullsEyeWidth);
   magnify->setMarginColor(marginColor);
   magnify->setMagnification(magnification);
+  magnify->setObserveRenderWindowEvents(observeRenderWindowEvents);
+  magnify->setUpdateInterval(updateInterval);
   layout.addWidget(magnify);
 
   // Test magnify widget parameters
-  if (magnify->showCursor() != showCursor)
+  if (magnify->showCrosshair() != showCrosshair)
     {
-    std::cerr << "ctkVTKMagnifyWidget:setShowCursor failed. "
-              << magnify->showCursor() << std::endl;
+    std::cerr << "ctkVTKMagnifyView:setShowCrosshair failed. "
+              << magnify->showCrosshair() << std::endl;
     return EXIT_FAILURE;
     }
-  if (magnify->cursorPen() != cursorPen)
+  if (magnify->crosshairPen() != crosshairPen)
     {
-    std::cerr << "ctkVTKMagnifyWidget:setCursorPen failed. "
-              << qPrintable(magnify->cursorPen().color().name()) << std::endl;
+    std::cerr << "ctkVTKMagnifyView:setCrosshairPen failed. "
+              << qPrintable(magnify->crosshairPen().color().name()) << std::endl;
     return EXIT_FAILURE;
     }
-  if (magnify->cursorType() != cursorType)
+  if (magnify->crosshairType() != crosshairType)
     {
-    std::cerr << "ctkVTKMagnifyWidget:setCursorType failed. "
-              << magnify->cursorType() << std::endl;
+    std::cerr << "ctkVTKMagnifyView:setCrosshairType failed. "
+              << magnify->crosshairType() << std::endl;
     return EXIT_FAILURE;
     }
   if (magnify->bullsEyeWidth() != bullsEyeWidth)
     {
-    std::cerr << "ctkVTKMagnifyWidget:setBullsEyeWidth failed. "
+    std::cerr << "ctkVTKMagnifyView:setBullsEyeWidth failed. "
               << magnify->bullsEyeWidth() << std::endl;
     return EXIT_FAILURE;
     }
   if (magnify->marginColor() != marginColor)
     {
-    std::cerr << "ctkVTKMagnifyWidget:setMarginColor failed. "
+    std::cerr << "ctkVTKMagnifyView:setMarginColor failed. "
               << qPrintable(magnify->marginColor().name()) << std::endl;
     return EXIT_FAILURE;
     }
   if (magnify->magnification() != magnification)
     {
-    std::cerr << "ctkVTKMagnifyWidget:setMagnification failed. "
+    std::cerr << "ctkVTKMagnifyView:setMagnification failed. "
               << magnify->magnification() << std::endl;
     return EXIT_FAILURE;
     }
+  if (magnify->observeRenderWindowEvents() != observeRenderWindowEvents)
+    {
+    std::cerr << "ctkVTKMagnifyView:setObserveRenderWindowEvents failed. "
+              << magnify->observeRenderWindowEvents() << std::endl;
+    }
+  if (magnify->updateInterval() != updateInterval)
+    {
+    std::cerr << "ctkVTKMagnifyView:setUpdateInterval failed. "
+              << magnify->updateInterval() << std::endl;
+    return EXIT_FAILURE;
+    }
 
   // The remainder is interactive, so abort now if command line args specify otherwise
   if (interactive)
@@ -203,7 +219,7 @@ int ctkVTKMagnifyWidgetTest2(int argc, char * argv [] )
       magnify->isObserved(allSliceViews[2]->VTKWidget()) ||
       magnify->numberObserved() != 2)
     {
-    std::cerr << "ctkVTKMagnifyWidget:observe(QVTKWidget*) failed. "
+    std::cerr << "ctkVTKMagnifyView:observe(QVTKWidget*) failed. "
               << "Number observed = " << magnify->numberObserved() << std::endl;
     return EXIT_FAILURE;
     }
@@ -241,13 +257,13 @@ int ctkVTKMagnifyWidgetTest2(int argc, char * argv [] )
 
   int time = 200;
 
-  // Get cursor points of interest, used in the following tests
+  // Get crosshair points of interest, used in the following tests
   parentWidget.move(0,0);
   parentWidget.show();
   QTimer::singleShot(time, &app, SLOT(quit()));
   if (app.exec() == EXIT_FAILURE)
     {
-    std::cerr << "ctkVTKMagnifyWidget:show failed the first time." << std::endl;
+    std::cerr << "ctkVTKMagnifyView:show failed the first time." << std::endl;
     return EXIT_FAILURE;
     }
   QPoint insideSlice0 = allSliceViews[0]->mapToGlobal(
@@ -266,25 +282,25 @@ int ctkVTKMagnifyWidgetTest2(int argc, char * argv [] )
         QPoint(0,0));
   parentWidget.hide();
 
-  // Make sure the magnify widget magnifies right away when shown with the cursor inside
+  // Make sure the magnify widget magnifies right away when shown with the crosshair inside
   // an observed QVTKWidget
   QCursor::setPos(insideSlice0);
   parentWidget.show();
   if (!runBaselineTest(time, app, magnify, allSliceViews[0], true,
                        baselineDirectory, testType, "a",
-                       "magnify widget first shown with cursor inside observed widget"))
+                       "magnify widget first shown with crosshair inside observed widget"))
     {
     return EXIT_FAILURE;
     }
   parentWidget.hide();
 
-  // Make sure the magnify widget shows blank right away when shown with the cursor
+  // Make sure the magnify widget shows blank right away when shown with the crosshair
   // outside the observed QVTKWidgets
   QCursor::setPos(outside);
   parentWidget.show();
   if (!runBaselineTest(time, app, magnify, &parentWidget, false,
                        baselineDirectory, testType, "b",
-                       "magnify widget first shown with cursor outside observed widget"))
+                       "magnify widget first shown with crosshair outside observed widget"))
     {
     return EXIT_FAILURE;
     }
@@ -293,7 +309,7 @@ int ctkVTKMagnifyWidgetTest2(int argc, char * argv [] )
   QCursor::setPos(insideSlice1);
   if (!runBaselineTest(time, app, magnify, allSliceViews[1], true,
                        baselineDirectory, testType, "c",
-                       "cursor moved inside 2nd observed widget the first time"))
+                       "crosshair moved inside 2nd observed widget the first time"))
     {
     return EXIT_FAILURE;
     }
@@ -302,7 +318,7 @@ int ctkVTKMagnifyWidgetTest2(int argc, char * argv [] )
   QCursor::setPos(insideSlice1edge);
   if (!runBaselineTest(time, app, magnify, allSliceViews[1], true,
                        baselineDirectory, testType, "d",
-                       "cursor moved inside 2nd observed widget the second time"))
+                       "crosshair moved inside 2nd observed widget the second time"))
     {
     return EXIT_FAILURE;
     }
@@ -311,7 +327,7 @@ int ctkVTKMagnifyWidgetTest2(int argc, char * argv [] )
   QCursor::setPos(insideSlice2);
   if (!runBaselineTest(time, app, magnify, allSliceViews[2], true,
                        baselineDirectory, testType, "e",
-                       "cursor moved inside unobserved widget"))
+                       "crosshair moved inside unobserved widget"))
     {
     return EXIT_FAILURE;
     }
@@ -321,7 +337,7 @@ int ctkVTKMagnifyWidgetTest2(int argc, char * argv [] )
   QCursor::setPos(insideSlice0bottomRightCorner);
   if (!runBaselineTest(time, app, magnify, allSliceViews[0], true,
                        baselineDirectory, testType, "f",
-                       "cursor moved to bottom-right corner of observed widget"))
+                       "crosshair moved to bottom-right corner of observed widget"))
     {
     return EXIT_FAILURE;
     }
@@ -331,11 +347,90 @@ int ctkVTKMagnifyWidgetTest2(int argc, char * argv [] )
   QCursor::setPos(insideSlice0topLeftCorner);
   if (!runBaselineTest(time, app, magnify, allSliceViews[0], true,
                        baselineDirectory, testType, "g",
-                       "cursor moved to top-left corner of observed widget"))
+                       "crosshair moved to top-left corner of observed widget"))
+    {
+    return EXIT_FAILURE;
+    }
+
+  // Go back inside the widget
+  QCursor::setPos(insideSlice0);
+  if (!runBaselineTest(time, app, magnify, allSliceViews[0], true,
+                       baselineDirectory, testType, "a",
+                       "crosshair moved again inside observed widget"))
+    {
+    return EXIT_FAILURE;
+    }
+
+  // Test enabling observing render window events (trigger a render window event by
+  // changing the image data)
+  observeRenderWindowEvents = true;
+  magnify->setObserveRenderWindowEvents(observeRenderWindowEvents);
+  if (magnify->observeRenderWindowEvents() != observeRenderWindowEvents)
+    {
+    std::cerr << "ctkVTKMagnifyView:setObserveRenderWindowEvents failed. "
+              << magnify->observeRenderWindowEvents() << std::endl;
+    return EXIT_FAILURE;
+    }
+
+  vtkImageGaussianSmooth * gaussian = vtkImageGaussianSmooth::New();
+  gaussian->SetInput(image);
+  gaussian->SetRadiusFactors(5,5);
+  gaussian->Update();
+  allSliceViews[0]->setImageData(gaussian->GetOutput());
+  allSliceViews[0]->scheduleRender();
+  if (!runBaselineTest(time, app, magnify, allSliceViews[0], true,
+                       baselineDirectory, testType, "h",
+                       "after Gaussian blur when observing render window events"))
     {
     return EXIT_FAILURE;
     }
 
+  // Test disabling observing render window events (trigger a render window event by
+  // changing the image data)
+  observeRenderWindowEvents = false;
+  magnify->setObserveRenderWindowEvents(observeRenderWindowEvents);
+  if (magnify->observeRenderWindowEvents() != observeRenderWindowEvents)
+    {
+    std::cerr << "ctkVTKMagnifyView:setObserveRenderWindowEvents failed. "
+              << magnify->observeRenderWindowEvents() << std::endl;
+    return EXIT_FAILURE;
+    }
+
+  gaussian->SetInput(image);
+  gaussian->SetRadiusFactors(0,0);
+  gaussian->Update();
+  allSliceViews[0]->setImageData(gaussian->GetOutput());
+  allSliceViews[0]->scheduleRender();
+  if (!runBaselineTest(time, app, magnify, allSliceViews[0], true,
+                       baselineDirectory, testType, "h",
+                       "after Gaussian blur when not observing render window events"))
+    {
+    return EXIT_FAILURE;
+    }
+
+  // Test changing the update interval
+  magnify->setUpdateInterval(time * 2);
+  magnify->setObserveRenderWindowEvents(true);
+  allSliceViews[0]->setImageData(image);
+  allSliceViews[0]->scheduleRender();
+  QCursor::setPos(insideSlice0bottomRightCorner);
+  // It should be waiting to update here
+  if (!runBaselineTest(time, app, magnify, allSliceViews[0], true,
+                       baselineDirectory, testType, "h",
+                       "after changing update interval: updated too quickly"))
+    {
+    return EXIT_FAILURE;
+    }
+  // It should have updated by now
+  if (!runBaselineTest(time + 50, app, magnify, allSliceViews[0], true,
+                       baselineDirectory, testType, "f",
+                       "after changing update interval: didn't update after waiting"))
+    {
+    return EXIT_FAILURE;
+    }
+
+  gaussian->Delete();
+
   return EXIT_SUCCESS;
 
 }

Libs/Visualization/VTK/Widgets/ctkVTKMagnifyWidget.cpp

@@ -22,9 +22,11 @@
 #include <QEvent>
 #include <QMouseEvent>
 #include <QPointF>
+#include <QTimerEvent>
 
 // CTK includes
-#include "ctkVTKMagnifyWidget.h"
+#include "ctkVTKMagnifyView.h"
+#include "ctkVTKMagnifyView_p.h"
 #include "ctkLogger.h"
 
 // VTK includes
@@ -33,62 +35,166 @@
 #include <vtkUnsignedCharArray.h>
 
 // STD includes
-#include <math.h>
+#include <cmath>
 
 // Convenient macro
 #define VTK_CREATE(type, name) \
   vtkSmartPointer<type> name = vtkSmartPointer<type>::New()
 
 //--------------------------------------------------------------------------
-static ctkLogger logger("org.commontk.visualization.vtk.widgets.ctkVTKMagnifyWidget");
+static ctkLogger logger("org.commontk.visualization.vtk.widgets.ctkVTKMagnifyView");
 //--------------------------------------------------------------------------
 
-//-----------------------------------------------------------------------------
-class ctkVTKMagnifyWidgetPrivate
-{
-  Q_DECLARE_PUBLIC(ctkVTKMagnifyWidget);
-protected:
-  ctkVTKMagnifyWidget* const q_ptr;
-public:
-  ctkVTKMagnifyWidgetPrivate(ctkVTKMagnifyWidget& object);
-
-  void init();
-  void removePixmap();
-  void observe(QVTKWidget * widget);
-  void remove(QVTKWidget * widget);
-  void updatePixmap(QVTKWidget * widget, QPointF pos);
-
-  QList<QVTKWidget *> ObservedQVTKWidgets;
-  double Magnification;
-};
-
 // --------------------------------------------------------------------------
-// ctkVTKMagnifyWidgetPrivate methods
+// ctkVTKMagnifyViewPrivate methods
 
 // --------------------------------------------------------------------------
-ctkVTKMagnifyWidgetPrivate::ctkVTKMagnifyWidgetPrivate(ctkVTKMagnifyWidget& object)
-  :q_ptr(&object)
+ctkVTKMagnifyViewPrivate::ctkVTKMagnifyViewPrivate(ctkVTKMagnifyView& object)
+  : QObject(&object), q_ptr(&object)
 {
   this->ObservedQVTKWidgets = QList<QVTKWidget *>();
   this->Magnification = 1.0;
+  this->ObserveRenderWindowEvents = true;
+
+  this->EventHandler.EventType = NoEvent;
+  this->EventHandler.Widget = 0;
+  this->EventHandler.Position = QPointF(0,0);
+
+  this->EventHandler.UpdateInterval = 20;
+  this->EventHandler.TimerId = 0;
+
 }
 
 // --------------------------------------------------------------------------
-void ctkVTKMagnifyWidgetPrivate::init()
+ctkVTKMagnifyViewPrivate::~ctkVTKMagnifyViewPrivate()
 {
+  if (this->EventHandler.TimerId != 0)
+    {
+    this->killTimer(this->EventHandler.TimerId);
+    }
+}
+
+// --------------------------------------------------------------------------
+void ctkVTKMagnifyViewPrivate::init()
+{
+  // Start by removing the pixmap
+  this->EventHandler.EventType = RemovePixmapEvent;
   this->removePixmap();
+
+  // Start the timer
+  this->restartTimer();
 }
 
 // --------------------------------------------------------------------------
-void ctkVTKMagnifyWidgetPrivate::removePixmap()
+void ctkVTKMagnifyViewPrivate::restartTimer()
 {
-  Q_Q(ctkVTKMagnifyWidget);
-  QPixmap nullPixmap;
-  q->setPixmap(nullPixmap);
+  // Kill any old timers
+  if (this->EventHandler.TimerId != 0)
+    {
+    this->killTimer(this->EventHandler.TimerId);
+    this->EventHandler.TimerId = 0;
+    }
+
+  // Start timer if appropriate
+  if (this->EventHandler.UpdateInterval != 0)
+    {
+    this->EventHandler.TimerId = this->startTimer(this->EventHandler.UpdateInterval);
+    Q_ASSERT(this->EventHandler.TimerId);
+    }
+  // Not using any timers, process events as they come
+  else
+    {
+    this->EventHandler.TimerId = 0;
+    }
+}
+
+// --------------------------------------------------------------------------
+void ctkVTKMagnifyViewPrivate::resetEventHandler()
+{
+  this->EventHandler.EventType = NoEvent;
+}
+
+// --------------------------------------------------------------------------
+void ctkVTKMagnifyViewPrivate::timerEvent(QTimerEvent * event)
+{
+  Q_ASSERT(event->timerId() == this->EventHandler.TimerId);
+
+  if (this->EventHandler.EventType == UpdatePixmapEvent)
+    {
+    this->updatePixmap();
+    }
+  else if (this->EventHandler.EventType == RemovePixmapEvent)
+    {
+    this->removePixmap();
+    }
 }
 
 // --------------------------------------------------------------------------
-void ctkVTKMagnifyWidgetPrivate::observe(QVTKWidget * widget)
+void ctkVTKMagnifyViewPrivate::pushUpdatePixmapEvent()
+{
+  Q_ASSERT(this->EventHandler.Widget);
+  this->pushUpdatePixmapEvent(
+        this->EventHandler.Widget->mapFromGlobal(QCursor::pos()));
+}
+
+// --------------------------------------------------------------------------
+void ctkVTKMagnifyViewPrivate::pushUpdatePixmapEvent(QPointF pos)
+{
+  Q_ASSERT(this->EventHandler.Widget);
+
+  // Add this event to the queue
+  this->EventHandler.EventType = UpdatePixmapEvent;
+  this->EventHandler.Position = pos;
+
+  // Process the event if we handle all events
+  if (this->EventHandler.UpdateInterval == 0)
+    {
+    this->updatePixmap();
+    }
+}
+
+// --------------------------------------------------------------------------
+void ctkVTKMagnifyViewPrivate::pushRemovePixmapEvent()
+{
+  // Add this event to the queue
+  this->EventHandler.EventType = RemovePixmapEvent;
+
+  // Process the event if we handle all events
+  if (this->EventHandler.UpdateInterval == 0)
+    {
+    this->removePixmap();
+    }
+}
+
+// --------------------------------------------------------------------------
+void ctkVTKMagnifyViewPrivate::connectRenderWindow(QVTKWidget * widget)
+{
+  Q_ASSERT(widget);
+  Q_ASSERT(this->ObserveRenderWindowEvents);
+
+  vtkRenderWindow * renderWindow = widget->GetRenderWindow();
+  if (renderWindow)
+    {
+    this->qvtkConnect(renderWindow, vtkCommand::EndEvent,
+                      this, SLOT(pushUpdatePixmapEvent()));
+    }
+}
+
+// --------------------------------------------------------------------------
+void ctkVTKMagnifyViewPrivate::disconnectRenderWindow(QVTKWidget * widget)
+{
+  Q_ASSERT(widget);
+
+  vtkRenderWindow * renderWindow = widget->GetRenderWindow();
+  if (renderWindow)
+    {
+    this->qvtkDisconnect(renderWindow, vtkCommand::EndEvent,
+                         this, SLOT(pushUpdatePixmapEvent()));
+    }
+}
+
+// --------------------------------------------------------------------------
+void ctkVTKMagnifyViewPrivate::observe(QVTKWidget * widget)
 {
   Q_ASSERT(widget);
 
@@ -97,13 +203,17 @@ void ctkVTKMagnifyWidgetPrivate::observe(QVTKWidget * widget)
   if (!this->ObservedQVTKWidgets.contains(widget))
     {
     this->ObservedQVTKWidgets.append(widget);
-    Q_Q(ctkVTKMagnifyWidget);
+    Q_Q(ctkVTKMagnifyView);
     widget->installEventFilter(q);
+    if (this->ObserveRenderWindowEvents)
+      {
+      this->connectRenderWindow(widget);
+      }
     }
 }
 
 // --------------------------------------------------------------------------
-void ctkVTKMagnifyWidgetPrivate::remove(QVTKWidget * widget)
+void ctkVTKMagnifyViewPrivate::remove(QVTKWidget * widget)
 {
   Q_ASSERT(widget);
 
@@ -113,32 +223,47 @@ void ctkVTKMagnifyWidgetPrivate::remove(QVTKWidget * widget)
     {
     Q_ASSERT(this->ObservedQVTKWidgets.count(widget) == 1);
     this->ObservedQVTKWidgets.removeOne(widget);
-    Q_Q(ctkVTKMagnifyWidget);
+    Q_Q(ctkVTKMagnifyView);
     widget->removeEventFilter(q);
+    if (this->ObserveRenderWindowEvents)
+      {
+      this->disconnectRenderWindow(widget);
+      }
     }
 }
 
 // --------------------------------------------------------------------------
-void ctkVTKMagnifyWidgetPrivate::updatePixmap(QVTKWidget * widget, QPointF pos)
+void ctkVTKMagnifyViewPrivate::removePixmap()
 {
-  Q_ASSERT(widget);
-  Q_Q(ctkVTKMagnifyWidget);
+  Q_ASSERT(this->EventHandler.EventType == RemovePixmapEvent);
+  Q_Q(ctkVTKMagnifyView);
+  QPixmap nullPixmap;
+  q->setPixmap(nullPixmap);
+  q->update();
+  this->resetEventHandler();
+}
+
+// -------------------------------------------------------------------------
+void ctkVTKMagnifyViewPrivate::updatePixmap()
+{
+  Q_ASSERT(this->EventHandler.EventType == UpdatePixmapEvent);
+  Q_ASSERT(this->EventHandler.Widget);
+  Q_Q(ctkVTKMagnifyView);
 
   // Retrieve buffer of given QVTKWidget from its render window
-  vtkRenderWindow * renderWindow = widget->GetRenderWindow();
+  vtkRenderWindow * renderWindow = this->EventHandler.Widget->GetRenderWindow();
   if (!renderWindow)
     {
-    this->removePixmap();
     return;
     }
 
   // Get the window size and mouse position, and do error checking
+  QPointF pos = this->EventHandler.Position;
   int * windowSize = renderWindow->GetSize();
   QPointF mouseWindowPos(pos.x(), static_cast<double>(windowSize[1]-1)-pos.y());
   if (mouseWindowPos.x() < 0 || mouseWindowPos.x() >= windowSize[0] ||
       mouseWindowPos.y() < 0 || mouseWindowPos.y() >= windowSize[1])
     {
-    this->removePixmap();
     return;
     }
 
@@ -155,10 +280,10 @@ void ctkVTKMagnifyWidgetPrivate::updatePixmap(QVTKWidget * widget, QPointF pos)
   double posTop = (mouseWindowPos.y() + ((sizeToMagnify.height()-1.0) / 2.0));
 
   // Round to ints, for indexing into the pixel array
-  int indexLeft = floor(posLeft);
-  int indexRight = ceil(posRight);
-  int indexBottom = floor(posBottom);
-  int indexTop = ceil(posTop);
+  int indexLeft = std::floor(posLeft);
+  int indexRight = std::ceil(posRight);
+  int indexBottom = std::floor(posBottom);
+  int indexTop = std::ceil(posTop);
 
   // Handle when mouse is near the border
   int minLeft = 0;
@@ -196,7 +321,6 @@ void ctkVTKMagnifyWidgetPrivate::updatePixmap(QVTKWidget * widget, QPointF pos)
   // Error case
   if (indexLeft > indexRight || indexBottom > indexTop)
     {
-    this->removePixmap();
     return;
     }
 
@@ -239,7 +363,6 @@ void ctkVTKMagnifyWidgetPrivate::updatePixmap(QVTKWidget * widget, QPointF pos)
       indexLeft, indexBottom, indexRight, indexTop, front, pixelData);
   if (!success)
     {
-    this->removePixmap();
     return;
     }
   pixelData->Delete();
@@ -308,34 +431,36 @@ void ctkVTKMagnifyWidgetPrivate::updatePixmap(QVTKWidget * widget, QPointF pos)
   image = image.copy(cropRect);
 
 
-  // Finally, set the pixelmap to the new one we have created
+  // Finally, set the pixelmap to the new one we have created and update
   q->setPixmap(QPixmap::fromImage(image));
+  q->update();
+  this->resetEventHandler();
 }
 
 //---------------------------------------------------------------------------
-// ctkVTKMagnifyWidget methods
+// ctkVTKMagnifyView methods
 
 // --------------------------------------------------------------------------
-ctkVTKMagnifyWidget::ctkVTKMagnifyWidget(QWidget* parentWidget)
+ctkVTKMagnifyView::ctkVTKMagnifyView(QWidget* parentWidget)
   : Superclass(parentWidget)
-  , d_ptr(new ctkVTKMagnifyWidgetPrivate(*this))
+  , d_ptr(new ctkVTKMagnifyViewPrivate(*this))
 {
-  Q_D(ctkVTKMagnifyWidget);
+  Q_D(ctkVTKMagnifyView);
   d->init();
 }
 
 // --------------------------------------------------------------------------
-ctkVTKMagnifyWidget::~ctkVTKMagnifyWidget()
+ctkVTKMagnifyView::~ctkVTKMagnifyView()
 {
 }
 
 // --------------------------------------------------------------------------
-CTK_GET_CPP(ctkVTKMagnifyWidget, double, magnification, Magnification);
+CTK_GET_CPP(ctkVTKMagnifyView, double, magnification, Magnification);
 
 // --------------------------------------------------------------------------
-void ctkVTKMagnifyWidget::setMagnification(double newMagnification)
+void ctkVTKMagnifyView::setMagnification(double newMagnification)
 {
-  Q_D(ctkVTKMagnifyWidget);
+  Q_D(ctkVTKMagnifyView);
   if (newMagnification == d->Magnification || newMagnification <= 0)
     {
     return;
@@ -346,9 +471,62 @@ void ctkVTKMagnifyWidget::setMagnification(double newMagnification)
 }
 
 // --------------------------------------------------------------------------
-void ctkVTKMagnifyWidget::observe(QVTKWidget * widget)
+CTK_GET_CPP(ctkVTKMagnifyView, bool,
+            observeRenderWindowEvents, ObserveRenderWindowEvents);
+
+// --------------------------------------------------------------------------
+void ctkVTKMagnifyView::setObserveRenderWindowEvents(bool newObserve)
 {
-  Q_D(ctkVTKMagnifyWidget);
+  Q_D(ctkVTKMagnifyView);
+  if (newObserve == d->ObserveRenderWindowEvents)
+    {
+    return;
+    }
+
+  d->ObserveRenderWindowEvents = newObserve;
+
+  // Connect/disconnect observations on vtkRenderWindow EndEvents, depending
+  // on whether we are switching from not-observing to observing or from
+  // observing to not-observing
+  QList<QVTKWidget *>::iterator it = d->ObservedQVTKWidgets.begin();
+  while (it != d->ObservedQVTKWidgets.end())
+    {
+    if (newObserve)
+      {
+      d->connectRenderWindow(*it);
+      }
+    else
+      {
+      d->disconnectRenderWindow(*it);
+      }
+    ++it;
+    }
+}
+
+// --------------------------------------------------------------------------
+int ctkVTKMagnifyView::updateInterval() const
+  {
+  Q_D(const ctkVTKMagnifyView);
+  return d->EventHandler.UpdateInterval;
+  }
+
+// --------------------------------------------------------------------------
+void ctkVTKMagnifyView::setUpdateInterval(int newInterval)
+{
+  Q_D(ctkVTKMagnifyView);
+  if (newInterval == d->EventHandler.UpdateInterval || newInterval < 0)
+    {
+    return;
+    }
+
+  d->EventHandler.UpdateInterval = newInterval;
+  d->restartTimer();
+}
+
+// --------------------------------------------------------------------------
+void ctkVTKMagnifyView::observe(QVTKWidget * widget)
+{
+  Q_D(ctkVTKMagnifyView);
   if (widget)
     {
     d->observe(widget);
@@ -356,7 +534,7 @@ void ctkVTKMagnifyWidget::observe(QVTKWidget * widget)
 }
 
 // --------------------------------------------------------------------------
-void ctkVTKMagnifyWidget::observe(QList<QVTKWidget *> widgets)
+void ctkVTKMagnifyView::observe(QList<QVTKWidget *> widgets)
 {
   foreach(QVTKWidget * widget, widgets)
     {
@@ -365,27 +543,27 @@ void ctkVTKMagnifyWidget::observe(QList<QVTKWidget *> widgets)
 }
 
 // --------------------------------------------------------------------------
-bool ctkVTKMagnifyWidget::isObserved(QVTKWidget * widget) const
+bool ctkVTKMagnifyView::isObserved(QVTKWidget * widget) const
 {
   if (!widget)
     {
     return false;
     }
-  Q_D(const ctkVTKMagnifyWidget);
+  Q_D(const ctkVTKMagnifyView);
   return d->ObservedQVTKWidgets.contains(widget);
 }
 
 // --------------------------------------------------------------------------
-int ctkVTKMagnifyWidget::numberObserved() const
+int ctkVTKMagnifyView::numberObserved() const
   {
-  Q_D(const ctkVTKMagnifyWidget);
+  Q_D(const ctkVTKMagnifyView);
   return d->ObservedQVTKWidgets.length();
   }
 
 // --------------------------------------------------------------------------
-void ctkVTKMagnifyWidget::remove(QVTKWidget * widget)
+void ctkVTKMagnifyView::remove(QVTKWidget * widget)
 {
-  Q_D(ctkVTKMagnifyWidget);
+  Q_D(ctkVTKMagnifyView);
   if (widget)
     {
     d->remove(widget);
@@ -393,7 +571,7 @@ void ctkVTKMagnifyWidget::remove(QVTKWidget * widget)
 }
 
 // --------------------------------------------------------------------------
-void ctkVTKMagnifyWidget::remove(QList<QVTKWidget *> widgets)
+void ctkVTKMagnifyView::remove(QList<QVTKWidget *> widgets)
 {
   foreach(QVTKWidget * widget, widgets)
     {
@@ -402,45 +580,42 @@ void ctkVTKMagnifyWidget::remove(QList<QVTKWidget *> widgets)
 }
 
 // --------------------------------------------------------------------------
-bool ctkVTKMagnifyWidget::eventFilter(QObject * obj, QEvent * event)
+bool ctkVTKMagnifyView::eventFilter(QObject * obj, QEvent * event)
 {
   // The given object should be a QVTKWidget in our list
   QVTKWidget * widget = static_cast<QVTKWidget *>(obj);
   Q_ASSERT(widget);
-  Q_D(ctkVTKMagnifyWidget);
+  Q_D(ctkVTKMagnifyView);
   Q_ASSERT(d->ObservedQVTKWidgets.contains(widget));
+  d->EventHandler.Widget = widget;
 
   QEvent::Type eventType = event->type();
+
   // On mouse move, update the pixmap with the zoomed image
   if (eventType == QEvent::MouseMove)
     {
     QMouseEvent * mouseEvent = static_cast<QMouseEvent *>(event);
     Q_ASSERT(mouseEvent);
-    d->updatePixmap(widget, mouseEvent->posF());
-    this->update();
-    return false;
+    d->pushUpdatePixmapEvent(mouseEvent->posF());
     }
-  // On enter, update the pixmap with the zoomed image (required for zooming when widget
-  // is created with mouse already within it), and emit signal of enter event
+  // On enter, update the pixmap with the zoomed image (required for zooming when
+  // widget is created with mouse already within it), and emit signal of enter event
   else if (eventType == QEvent::Enter)
     {
-    QPointF posF = widget->mapFromGlobal(QCursor::pos());
-    d->updatePixmap(widget, posF);
-    this->update();
+    d->pushUpdatePixmapEvent();
     emit enteredObservedWidget(widget);
-    return false;
     }
   // On leave, fill the pixmap with a solid color and emit signal of leave event
   else if (eventType == QEvent::Leave)
     {
-    d->removePixmap();
-    this->update();
+    d->pushRemovePixmapEvent();
     emit leftObservedWidget(widget);
-    return false;
     }
   // For other event types, use standard event processing
   else
     {
     return QObject::eventFilter(obj, event);
     }
+
+  return false;
 }

Libs/Visualization/VTK/Widgets/ctkVTKMagnifyWidget.h

@@ -18,43 +18,59 @@
 
 =========================================================================*/
 
-#ifndef __ctkVTKMagnifyWidget_h
-#define __ctkVTKMagnifyWidget_h
+#ifndef __ctkVTKMagnifyView_h
+#define __ctkVTKMagnifyView_h
 
 // QT includes
 #include <QList>
 
 // CTK includes
-#include "ctkCursorPixmapWidget.h"
+#include "ctkCrosshairLabel.h"
 #include "ctkVisualizationVTKWidgetsExport.h"
 
 // VTK includes
 class QVTKWidget;
 
-class ctkVTKMagnifyWidgetPrivate;
+class ctkVTKMagnifyViewPrivate;
 
 /// Gives a magnified view of a QVTKWidget around the mouse position, with
-/// overlaid cursor (ex. cross-hair).  You must specify the QVTKWidget(s) to be
+/// overlaid crosshair (ex. cross-hair).  You must specify the QVTKWidget(s) to be
 /// observed.
-/// \sa ctkCursorPixmapWidget
+/// \sa ctkCrosshairLabel
 
-class CTK_VISUALIZATION_VTK_WIDGETS_EXPORT ctkVTKMagnifyWidget
-  : public ctkCursorPixmapWidget
+class CTK_VISUALIZATION_VTK_WIDGETS_EXPORT ctkVTKMagnifyView
+  : public ctkCrosshairLabel
 {
   Q_OBJECT
   Q_PROPERTY(double magnification READ magnification WRITE setMagnification);
+  Q_PROPERTY(bool observeRenderWindowEvents
+             READ observeRenderWindowEvents WRITE setObserveRenderWindowEvents);
+  Q_PROPERTY(int updateInterval READ updateInterval WRITE setUpdateInterval)
 
 public:
   /// Constructors
-  typedef ctkCursorPixmapWidget Superclass;
-  explicit ctkVTKMagnifyWidget(QWidget* parent = 0);
-  virtual ~ctkVTKMagnifyWidget();
+  typedef ctkCrosshairLabel Superclass;
+  explicit ctkVTKMagnifyView(QWidget* parent = 0);
+  virtual ~ctkVTKMagnifyView();
 
   /// Set/get the magnification (zoom).  Looks best when the magnification and
   /// the widget size are both either even or odd.  Default 1.0.
   double magnification() const;
   void setMagnification(double newMagnification);
 
+  /// Set/get whether or not to observe EndEvents emitted by the observed
+  /// QVTKWidgets' vtkRenderWindows after they have rendered.  This triggers
+  /// updates to the magnify widget whenever the vtkRenderWindow does a render,
+  /// even if the mouse position does not move. Default true.
+  bool observeRenderWindowEvents() const;
+  void setObserveRenderWindowEvents(bool newObserve);
+
+  /// Set/get a fixed interval, in milliseconds, at which this widget will update
+  /// itself.  Default 20.  Specify an update interval of 0 to handle all events as
+  /// they occur.
+  int updateInterval() const;
+  void setUpdateInterval(int newInterval);
+
   /// Add a QVTKWidget to observe mouse events on.  You can call this function
   /// multiple times to observe multiple QVTKWidgets.
   /// \sa observe
@@ -82,7 +98,7 @@ public:
   int numberObserved()const;
 
 protected:
-  QScopedPointer<ctkVTKMagnifyWidgetPrivate> d_ptr;
+  QScopedPointer<ctkVTKMagnifyViewPrivate> d_ptr;
 
   /// Handles mouse events on the observed QVTKWidgets (specifically,
   /// enterEvent, leaveEvent and mouseMoveEvent).
@@ -93,8 +109,8 @@ signals:
   void leftObservedWidget(QVTKWidget * widget);
 
 private:
-  Q_DECLARE_PRIVATE(ctkVTKMagnifyWidget);
-  Q_DISABLE_COPY(ctkVTKMagnifyWidget);
+  Q_DECLARE_PRIVATE(ctkVTKMagnifyView);
+  Q_DISABLE_COPY(ctkVTKMagnifyView);
 }; 
 
 #endif

Libs/Visualization/VTK/Widgets/ctkVTKMagnifyView_p.h

@@ -0,0 +1,87 @@
+/*=========================================================================
+
+  Library:   CTK
+
+  Copyright (c) Kitware Inc.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.commontk.org/LICENSE
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+=========================================================================*/
+
+#ifndef __ctkVTKMagnifyView_p_h
+#define __ctkVTKMagnifyView_p_h
+
+// Qt includes
+#include <QObject>
+class QPointF;
+class QTimerEvent;
+
+// CTK includes
+#include "ctkVTKMagnifyView.h"
+#include <ctkVTKObject.h>
+
+// VTK includes
+class QVTKWidget;
+
+class ctkVTKMagnifyViewPrivate : public QObject
+{
+  Q_OBJECT
+  QVTK_OBJECT
+  Q_DECLARE_PUBLIC(ctkVTKMagnifyView);
+protected:
+  ctkVTKMagnifyView* const q_ptr;
+public:
+  ctkVTKMagnifyViewPrivate(ctkVTKMagnifyView& object);
+  virtual ~ctkVTKMagnifyViewPrivate();
+
+  void init();
+  void observe(QVTKWidget * widget);
+  void remove(QVTKWidget * widget);
+  void connectRenderWindow(QVTKWidget * widget);
+  void disconnectRenderWindow(QVTKWidget * widget);
+
+protected:
+  void updatePixmap();
+  void removePixmap();
+  void timerEvent(QTimerEvent * event);
+  void restartTimer();
+  void resetEventHandler();
+
+  enum PendingEventType {
+    NoEvent = 0,
+    UpdatePixmapEvent,
+    RemovePixmapEvent
+    };
+
+  struct EventHandlerStruct
+    {
+    PendingEventType EventType;
+    QVTKWidget * Widget;
+    QPointF Position;
+    int UpdateInterval;
+    int TimerId;
+    };
+
+public slots:
+  void pushUpdatePixmapEvent();
+  void pushUpdatePixmapEvent(QPointF pos);
+  void pushRemovePixmapEvent();
+
+public:
+  QList<QVTKWidget *> ObservedQVTKWidgets;
+  double Magnification;
+  bool ObserveRenderWindowEvents;
+  EventHandlerStruct EventHandler;
+};
+
+#endif

Libs/Widgets/CMakeLists.txt

@@ -40,8 +40,8 @@ SET(KIT_SRCS
   ctkConfirmExitDialog.h
   ctkCoordinatesWidget.cpp
   ctkCoordinatesWidget.h
-  ctkCursorPixmapWidget.cpp
-  ctkCursorPixmapWidget.h
+  ctkCrosshairLabel.cpp
+  ctkCrosshairLabel.h
   ctkDirectoryButton.cpp
   ctkDirectoryButton.h
   ctkDoubleRangeSlider.cpp
@@ -166,7 +166,7 @@ SET(KIT_MOC_SRCS
   ctkConsole.h
   ctkConsole_p.h
   ctkCoordinatesWidget.h
-  ctkCursorPixmapWidget.h
+  ctkCrosshairLabel.h
   ctkDirectoryButton.h
   ctkDoubleRangeSlider.h
   ctkDoubleSlider.h

Libs/Widgets/Plugins/CMakeLists.txt

@@ -27,8 +27,8 @@ SET(PLUGIN_SRCS
   ctkComboBoxPlugin.h
   ctkCoordinatesWidgetPlugin.cpp
   ctkCoordinatesWidgetPlugin.h
-  ctkCursorPixmapWidgetPlugin.cpp
-  ctkCursorPixmapWidgetPlugin.h
+  ctkCrosshairLabelPlugin.cpp
+  ctkCrosshairLabelPlugin.h
   ctkDirectoryButtonPlugin.cpp
   ctkDirectoryButtonPlugin.h
   ctkDoubleRangeSliderPlugin.cpp
@@ -86,7 +86,7 @@ SET(PLUGIN_MOC_SRCS
   ctkColorPickerButtonPlugin.h
   ctkComboBoxPlugin.h
   ctkCoordinatesWidgetPlugin.h
-  ctkCursorPixmapWidgetPlugin.h
+  ctkCrosshairLabelPlugin.h
   ctkDirectoryButtonPlugin.h
   ctkDoubleRangeSliderPlugin.h
   ctkDoubleSliderPlugin.h

Libs/Widgets/Plugins/ctkCursorPixmapWidgetPlugin.cpp

@@ -19,28 +19,28 @@
 =========================================================================*/
 
 // CTK includes
-#include "ctkCursorPixmapWidgetPlugin.h"
-#include "ctkCursorPixmapWidget.h"
+#include "ctkCrosshairLabelPlugin.h"
+#include "ctkCrosshairLabel.h"
 
 //-----------------------------------------------------------------------------
-ctkCursorPixmapWidgetPlugin::ctkCursorPixmapWidgetPlugin(QObject *_parent)
+ctkCrosshairLabelPlugin::ctkCrosshairLabelPlugin(QObject *_parent)
         : QObject(_parent)
 {
 
 }
 
 //-----------------------------------------------------------------------------
-QWidget *ctkCursorPixmapWidgetPlugin::createWidget(QWidget *_parent)
+QWidget *ctkCrosshairLabelPlugin::createWidget(QWidget *_parent)
 {
-  ctkCursorPixmapWidget* _widget = new ctkCursorPixmapWidget(_parent);
+  ctkCrosshairLabel* _widget = new ctkCrosshairLabel(_parent);
   return _widget;
 }
 
 //-----------------------------------------------------------------------------
-QString ctkCursorPixmapWidgetPlugin::domXml() const
+QString ctkCrosshairLabelPlugin::domXml() const
 {
-  return "<widget class=\"ctkCursorPixmapWidget\" \
-          name=\"CursorPixmapWidget\">\n"
+  return "<widget class=\"ctkCrosshairLabel\" \
+          name=\"CrosshairLabel\">\n"
       " <property name=\"geometry\">\n"
       "  <rect>\n"
       "   <x>0</x>\n"
@@ -53,25 +53,25 @@ QString ctkCursorPixmapWidgetPlugin::domXml() const
 }
 
 // --------------------------------------------------------------------------
- QIcon ctkCursorPixmapWidgetPlugin::icon() const
+ QIcon ctkCrosshairLabelPlugin::icon() const
  {
    return QIcon();
  }
 
 //-----------------------------------------------------------------------------
-QString ctkCursorPixmapWidgetPlugin::includeFile() const
+QString ctkCrosshairLabelPlugin::includeFile() const
 {
-  return "ctkCursorPixmapWidget.h";
+  return "ctkCrosshairLabel.h";
 }
 
 //-----------------------------------------------------------------------------
-bool ctkCursorPixmapWidgetPlugin::isContainer() const
+bool ctkCrosshairLabelPlugin::isContainer() const
 {
   return false;
 }
 
 //-----------------------------------------------------------------------------
-QString ctkCursorPixmapWidgetPlugin::name() const
+QString ctkCrosshairLabelPlugin::name() const
 {
-  return "ctkCursorPixmapWidget";
+  return "ctkCrosshairLabel";
 }

Libs/Widgets/Plugins/ctkCursorPixmapWidgetPlugin.h

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

Libs/Widgets/Plugins/ctkWidgetsPlugins.h

@@ -33,7 +33,7 @@
 #include "ctkColorPickerButtonPlugin.h"
 #include "ctkComboBoxPlugin.h"
 #include "ctkCoordinatesWidgetPlugin.h"
-#include "ctkCursorPixmapWidgetPlugin.h"
+#include "ctkCrosshairLabelPlugin.h"
 #include "ctkDirectoryButtonPlugin.h"
 #include "ctkDoubleRangeSliderPlugin.h"
 #include "ctkDoubleSliderPlugin.h"
@@ -74,7 +74,7 @@ public:
             << new ctkColorPickerButtonPlugin
             << new ctkComboBoxPlugin
             << new ctkCoordinatesWidgetPlugin
-            << new ctkCursorPixmapWidgetPlugin
+            << new ctkCrosshairLabelPlugin
             << new ctkDirectoryButtonPlugin
             << new ctkDoubleRangeSliderPlugin
             << new ctkDoubleSliderPlugin

Libs/Widgets/Testing/Cpp/CMakeLists.txt

@@ -19,7 +19,7 @@ SET(TEST_SOURCES
   ctkConfirmExitDialogTest1.cpp
   ctkConsoleTest1.cpp
   ctkCoordinatesWidgetTest1.cpp
-  ctkCursorPixmapWidgetTest1.cpp
+  ctkCrosshairLabelTest1.cpp
   ctkDirectoryButtonTest1.cpp
   ctkDoubleRangeSliderTest1.cpp
   ctkDoubleRangeSliderTest2.cpp
@@ -61,7 +61,7 @@ SET(TEST_SOURCES
 #
 IF(EXISTS "${CTKData_DIR}")
   LIST(APPEND TEST_SOURCES
-    ctkCursorPixmapWidgetTest2.cpp
+    ctkCrosshairLabelTest2.cpp
     )
 ENDIF()
 
@@ -124,7 +124,7 @@ SIMPLE_TEST( ctkComboBoxTest1 )
 SIMPLE_TEST( ctkConfirmExitDialogTest1 )
 SIMPLE_TEST( ctkConsoleTest1 )
 SIMPLE_TEST( ctkCoordinatesWidgetTest1 )
-SIMPLE_TEST( ctkCursorPixmapWidgetTest1 )
+SIMPLE_TEST( ctkCrosshairLabelTest1 )
 SIMPLE_TEST( ctkDateRangeWidgetTest1 )
 SIMPLE_TEST( ctkDirectoryButtonTest1 )
 SIMPLE_TEST( ctkDoubleRangeSliderTest1 )
@@ -164,5 +164,5 @@ SIMPLE_TEST( ctkWorkflowWidgetTest2 )
 # Add Tests expecting CTKData to be set
 #
 IF(EXISTS "${CTKData_DIR}")
-  SIMPLE_TEST( ctkCursorPixmapWidgetTest2 )
+  SIMPLE_TEST( ctkCrosshairLabelTest2 )
 ENDIF()

Libs/Widgets/Testing/Cpp/ctkCrosshairLabelTest1.cpp

@@ -0,0 +1,131 @@
+/*=========================================================================
+
+  Library:   CTK
+
+  Copyright (c) Kitware Inc.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.commontk.org/LICENSE
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+=========================================================================*/
+
+// Qt includes
+#include <QApplication>
+#include <QTimer>
+
+// CTK includes
+#include "ctkCrosshairLabel.h"
+
+// STD includes
+#include <cstdlib>
+#include <iostream>
+
+//-----------------------------------------------------------------------------
+int ctkCrosshairLabelTest1(int argc, char * argv [] )
+{
+  QApplication app(argc, argv);
+
+  ctkCrosshairLabel crosshair;
+
+  // check default values
+  if (!crosshair.showCrosshair() ||
+      crosshair.crosshairPen().color()
+      != crosshair.palette().color(QPalette::Highlight) ||
+      crosshair.crosshairPen().width() != 0 ||
+      crosshair.crosshairPen().joinStyle() != Qt::MiterJoin ||
+      crosshair.crosshairType() != ctkCrosshairLabel::SimpleCrosshair ||
+      crosshair.marginColor() != crosshair.palette().color(QPalette::Window) ||
+      crosshair.bullsEyeWidth() != 15)
+    {
+    std::cerr << "ctkCrosshairLabel: Wrong default values. " << std::endl
+              << " " << crosshair.showCrosshair()
+              << " " << qPrintable(crosshair.crosshairPen().color().name())
+              << " " << crosshair.crosshairPen().width()
+              << " " << static_cast<int>(crosshair.crosshairPen().joinStyle())
+              << " " << crosshair.crosshairType()
+              << " " << qPrintable(crosshair.marginColor().name())
+              << " " << crosshair.bullsEyeWidth() << std::endl;
+    return EXIT_FAILURE;
+    }
+
+  // Show crosshair
+  crosshair.setShowCrosshair(false);
+  if (crosshair.showCrosshair())
+    {
+    std::cerr << "ctkCrosshairLabel:setShowCrosshair failed. "
+              << crosshair.showCrosshair() << std::endl;
+    return EXIT_FAILURE;
+    }
+  crosshair.setShowCrosshair(true);
+
+  // Crosshair pen
+  QPen crosshairPen(Qt::yellow);
+  crosshairPen.setJoinStyle(Qt::MiterJoin);
+  crosshair.setCrosshairPen(crosshairPen);
+  if (crosshair.crosshairPen() != crosshairPen)
+    {
+    std::cerr << "ctkCrosshairLabel:setCrosshairPen failed. "
+              << qPrintable(crosshair.crosshairPen().color().name()) << std::endl;
+    return EXIT_FAILURE;
+    }
+
+  // Crosshair type
+  crosshair.setCrosshairType(ctkCrosshairLabel::BullsEyeCrosshair);
+  if (crosshair.crosshairType() != ctkCrosshairLabel::BullsEyeCrosshair)
+    {
+    std::cerr << "ctkCrosshairLabel:setCrosshairType failed. "
+              << crosshair.crosshairType() << std::endl;
+    return EXIT_FAILURE;
+    }
+
+  // Margin color - invalid input
+  QColor transparentBlue(Qt::blue);
+  transparentBlue.setAlphaF(0.25);
+  QColor origColor = crosshair.marginColor();
+  crosshair.setMarginColor(QColor());
+  if (crosshair.marginColor() != origColor)
+    {
+    std::cerr << "ctkCrosshairLabel:setMarginColor failed - invalid input. "
+              << qPrintable(crosshair.marginColor().name()) << std::endl;
+    return EXIT_FAILURE;
+    }
+
+  // Margin color - should ignore alpha channel
+  crosshair.setMarginColor(transparentBlue);
+  if (crosshair.marginColor() != Qt::blue)
+    {
+      {
+      std::cerr << "ctkCrosshairLabel:setMarginColor failed - valid input. "
+                << qPrintable(crosshair.marginColor().name()) << std::endl;
+      return EXIT_FAILURE;
+      }
+    }
+
+  // Bulls eye width
+  crosshair.setBullsEyeWidth(0);
+  if (crosshair.bullsEyeWidth() != 0)
+    {
+    std::cerr << "ctkCrosshairLabel:setBullsEyeWidth failed. "
+              << crosshair.bullsEyeWidth() << std::endl;
+    return EXIT_FAILURE;
+    }
+
+  crosshair.show();
+  if (argc < 2 || QString(argv[1]) != "-I" )
+    {
+    QTimer::singleShot(200, &app, SLOT(quit()));
+    }
+
+  return app.exec();
+
+}
+

Libs/Widgets/Testing/Cpp/ctkCrosshairLabelTest2.cpp

@@ -0,0 +1,248 @@
+/*=========================================================================
+
+  Library:   CTK
+
+  Copyright (c) Kitware Inc.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.commontk.org/LICENSE
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+=========================================================================*/
+
+// Qt includes
+#include <QApplication>
+#include <QIcon>
+#include <QSignalSpy>
+#include <QStyle>
+#include <QTimer>
+
+// CTK includes
+#include "ctkCrosshairLabel.h"
+#include "ctkCommandLineParser.h"
+
+// STD includes
+#include <cstdlib>
+#include <iostream>
+
+//-----------------------------------------------------------------------------
+bool imageCompare(ctkCrosshairLabel& crosshair, QString baselineDirectory,
+                  QString baselineFilename)
+{
+  QImage output = QPixmap::grabWidget(&crosshair).toImage();
+  QImage baseline(baselineDirectory + "/" + baselineFilename);
+  return output == baseline;
+}
+
+//-----------------------------------------------------------------------------
+// (Used to create baselines, not during testing).
+void imageSave(ctkCrosshairLabel& crosshair, QString baselineDirectory,
+               QString baselineFilename)
+{
+  QImage output = QPixmap::grabWidget(&crosshair).toImage();
+  output.save(baselineDirectory + "/" + baselineFilename);
+}
+
+//-----------------------------------------------------------------------------
+bool runBaselineTest(ctkCrosshairLabel& crosshair,
+                     QString baselineDirectory, QString baselineFilename,
+                     QString errorMessage)
+{
+  QApplication::processEvents();
+  if (!imageCompare(crosshair, baselineDirectory, baselineFilename))
+    {
+    std::cerr << "ctkCrosshairLabel baseline comparison failed when "
+              << qPrintable(errorMessage) << "." << std::endl;
+    return false;
+    }
+  return true;
+}
+
+//-----------------------------------------------------------------------------
+int ctkCrosshairLabelTest2(int argc, char * argv [] )
+{
+  QApplication app(argc, argv);
+
+  // Command line parser
+  ctkCommandLineParser parser;
+  parser.addArgument("", "-D", QVariant::String);
+  parser.addArgument("", "-V", QVariant::String);
+  parser.addArgument("", "-I", QVariant::String);
+  bool ok = false;
+  QHash<QString, QVariant> parsedArgs = parser.parseArguments(app.arguments(), &ok);
+  if (!ok)
+    {
+    std::cerr << qPrintable(parser.errorString()) << std::endl;
+    return EXIT_FAILURE;
+    }
+  QString dataDirectory = parsedArgs["-D"].toString();
+  QString baselineDirectory = parsedArgs["-V"].toString();
+  bool interactive = parsedArgs["-I"].toBool();
+
+  // The remainder is interactive, so abort now if command line args specify otherwise
+  if (interactive)
+    {
+    return EXIT_SUCCESS;
+    }
+
+  // Create the crosshair widget
+  ctkCrosshairLabel crosshair;
+  QPen crosshairPen(Qt::yellow);
+  crosshairPen.setJoinStyle(Qt::MiterJoin);
+  crosshair.setCrosshairPen(crosshairPen);
+  crosshair.setMarginColor(Qt::blue);
+
+  QPixmap pixmap(dataDirectory + "/" + "computerIcon.png");
+
+  // Basesize is always odd
+  QSize baseSize = pixmap.size();
+  if (pixmap.width() % 2 == 0)
+    {
+    baseSize.setWidth(baseSize.width()+1);
+    }
+  if (pixmap.height() % 2 == 0)
+    {
+    baseSize.setHeight(baseSize.height()+1);
+    }
+
+  // Odd widget size
+  crosshair.setMinimumSize(baseSize);
+  crosshair.setPixmap(pixmap.scaled(baseSize));
+  crosshair.show();
+
+  // Test bullsEyeWidth and line width with odd widget size
+  crosshair.setCrosshairType(ctkCrosshairLabel::BullsEyeCrosshair);
+
+  ///
+  crosshair.setBullsEyeWidth(15);
+  crosshairPen.setWidth(1);
+  crosshair.setCrosshairPen(crosshairPen);
+  if (!runBaselineTest(crosshair, baselineDirectory,
+                       "ctkCrosshairLabelTest2a.png",
+                       "using bulls-eye crosshair (odd size, bullsEye 15, width 1)"))
+    {
+    return EXIT_FAILURE;
+    }
+
+  ///
+  crosshairPen.setWidth(5);
+  crosshair.setCrosshairPen(crosshairPen);
+  if (!runBaselineTest(crosshair, baselineDirectory,
+                       "ctkCrosshairLabelTest2b.png",
+                       "using bulls-eye crosshair (odd size, bullsEye 15, width 5)"))
+    {
+    return EXIT_FAILURE;
+    }
+
+  ///
+  crosshair.setBullsEyeWidth(14);
+  crosshairPen.setWidth(0); // equivalent to 1
+  crosshair.setCrosshairPen(crosshairPen);
+  if (!runBaselineTest(crosshair, baselineDirectory,
+                       "ctkCrosshairLabelTest2c.png",
+                       "using bulls-eye crosshair (odd size, bullsEye 14, width 1)"))
+    {
+    return EXIT_FAILURE;
+    }
+
+  ///
+  crosshairPen.setWidth(4);
+  crosshair.setCrosshairPen(crosshairPen);
+  if (!runBaselineTest(crosshair, baselineDirectory,
+                       "ctkCrosshairLabelTest2d.png",
+                       "using bulls-eye crosshair (odd size, bullsEye 14, width 4)"))
+    {
+    return EXIT_FAILURE;
+    }
+
+  // Test bullsEyeWidth and line width with even widget size
+  crosshair.resize(baseSize.width()+1, baseSize.height()+1);
+
+  ///
+  crosshair.setBullsEyeWidth(14);
+  crosshairPen.setWidth(1);
+  crosshair.setCrosshairPen(crosshairPen);
+  if (!runBaselineTest(crosshair, baselineDirectory,
+                       "ctkCrosshairLabelTest2e.png",
+                       "using bulls-eye crosshair (even size, bullsEye 14, width 1)"))
+    {
+    return EXIT_FAILURE;
+    }
+
+  ///
+  crosshairPen.setWidth(4);
+  crosshair.setCrosshairPen(crosshairPen);
+  if (!runBaselineTest(crosshair, baselineDirectory,
+                       "ctkCrosshairLabelTest2f.png",
+                       "using bulls-eye crosshair (even size, bullsEye 14, width 4)"))
+    {
+    return EXIT_FAILURE;
+    }
+
+  ///
+  crosshair.setBullsEyeWidth(15);
+  crosshairPen.setWidth(0);
+  crosshair.setCrosshairPen(crosshairPen);
+  if (!runBaselineTest(crosshair, baselineDirectory,
+                       "ctkCrosshairLabelTest2g.png",
+                       "using bulls-eye crosshair (even size, bullsEye 15, width 1)"))
+    {
+    return EXIT_FAILURE;
+    }
+
+  ///
+  crosshairPen.setWidth(5);
+  crosshair.setCrosshairPen(crosshairPen);
+  if (!runBaselineTest(crosshair, baselineDirectory,
+                       "ctkCrosshairLabelTest2h.png",
+                       "using bulls-eye crosshair (even size, bullsEye 15, width 5)"))
+    {
+    return EXIT_FAILURE;
+    }
+
+  // Crosshair not shown
+  crosshair.resize(baseSize);
+  crosshair.setShowCrosshair(false);
+  crosshair.setCrosshairPen(crosshairPen);
+  if (!runBaselineTest(crosshair, baselineDirectory,
+                       "ctkCrosshairLabelTest2i.png",
+                       "show crosshair false"))
+    {
+    return EXIT_FAILURE;
+    }
+
+  // Crosshair crosshair
+  crosshair.setShowCrosshair(true);
+  crosshair.setCrosshairType(ctkCrosshairLabel::SimpleCrosshair);
+  crosshairPen.setWidth(0);
+  crosshair.setCrosshairPen(crosshairPen);
+  if (!runBaselineTest(crosshair, baselineDirectory,
+                       "ctkCrosshairLabelTest2j.png",
+                       "using cross-hair crosshair (odd size)"))
+    {
+    return EXIT_FAILURE;
+    }
+  crosshair.resize(baseSize.width()+1, baseSize.height()+1);
+  crosshairPen.setWidth(1);
+  crosshair.setCrosshairPen(crosshairPen);
+  if (!runBaselineTest(crosshair, baselineDirectory,
+                       "ctkCrosshairLabelTest2k.png",
+                       "using cross-hair crosshair (even size)"))
+    {
+    return EXIT_FAILURE;
+    }
+
+  // We already tested for interactive mode
+  QTimer::singleShot(200, &app, SLOT(quit()));
+  return app.exec();
+
+}
+

Libs/Widgets/Testing/Cpp/ctkCursorPixmapWidgetTest1.cpp

@@ -1,130 +0,0 @@
-/*=========================================================================
-
-  Library:   CTK
-
-  Copyright (c) Kitware Inc.
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      http://www.commontk.org/LICENSE
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-
-=========================================================================*/
-
-// Qt includes
-#include <QApplication>
-#include <QTimer>
-
-// CTK includes
-#include "ctkCursorPixmapWidget.h"
-
-// STD includes
-#include <cstdlib>
-#include <iostream>
-
-//-----------------------------------------------------------------------------
-int ctkCursorPixmapWidgetTest1(int argc, char * argv [] )
-{
-  QApplication app(argc, argv);
-
-  ctkCursorPixmapWidget cursor;
-
-  // check default values
-  if (!cursor.showCursor() ||
-      cursor.cursorPen().color() != cursor.palette().color(QPalette::Highlight) ||
-      cursor.cursorPen().width() != 0 ||
-      cursor.cursorPen().joinStyle() != Qt::MiterJoin ||
-      cursor.cursorType() != ctkCursorPixmapWidget::CrossHairCursor ||
-      cursor.marginColor() != cursor.palette().color(QPalette::Window) ||
-      cursor.bullsEyeWidth() != 15)
-    {
-    std::cerr << "ctkCursorPixmapWidget: Wrong default values. " << std::endl
-              << " " << cursor.showCursor()
-              << " " << qPrintable(cursor.cursorPen().color().name())
-              << " " << cursor.cursorPen().width()
-              << " " << static_cast<int>(cursor.cursorPen().joinStyle())
-              << " " << cursor.cursorType()
-              << " " << qPrintable(cursor.marginColor().name())
-              << " " << cursor.bullsEyeWidth() << std::endl;
-    return EXIT_FAILURE;
-    }
-
-  // Show cursor
-  cursor.setShowCursor(false);
-  if (cursor.showCursor())
-    {
-    std::cerr << "ctkCursorPixmapWidget:setShowCursor failed. "
-              << cursor.showCursor() << std::endl;
-    return EXIT_FAILURE;
-    }
-  cursor.setShowCursor(true);
-
-  // Cursor pen
-  QPen cursorPen(Qt::yellow);
-  cursorPen.setJoinStyle(Qt::MiterJoin);
-  cursor.setCursorPen(cursorPen);
-  if (cursor.cursorPen() != cursorPen)
-    {
-    std::cerr << "ctkCursorPixmapWidget:setCursorPen failed. "
-              << qPrintable(cursor.cursorPen().color().name()) << std::endl;
-    return EXIT_FAILURE;
-    }
-
-  // Cursor type
-  cursor.setCursorType(ctkCursorPixmapWidget::BullsEyeCursor);
-  if (cursor.cursorType() != ctkCursorPixmapWidget::BullsEyeCursor)
-    {
-    std::cerr << "ctkCursorPixmapWidget:setCursorType failed. "
-              << cursor.cursorType() << std::endl;
-    return EXIT_FAILURE;
-    }
-
-  // Margin color - invalid input
-  QColor transparentBlue(Qt::blue);
-  transparentBlue.setAlphaF(0.25);
-  QColor origColor = cursor.marginColor();
-  cursor.setMarginColor(QColor());
-  if (cursor.marginColor() != origColor)
-    {
-    std::cerr << "ctkCursorPixmapWidget:setMarginColor failed - invalid input. "
-              << qPrintable(cursor.marginColor().name()) << std::endl;
-    return EXIT_FAILURE;
-    }
-
-  // Margin color - should ignore alpha channel
-  cursor.setMarginColor(transparentBlue);
-  if (cursor.marginColor() != Qt::blue)
-    {
-      {
-      std::cerr << "ctkCursorPixmapWidget:setMarginColor failed - valid input. "
-                << qPrintable(cursor.marginColor().name()) << std::endl;
-      return EXIT_FAILURE;
-      }
-    }
-
-  // Bulls eye width
-  cursor.setBullsEyeWidth(0);
-  if (cursor.bullsEyeWidth() != 0)
-    {
-    std::cerr << "ctkCursorPixmapWidget:setBullsEyeWidth failed. "
-              << cursor.bullsEyeWidth() << std::endl;
-    return EXIT_FAILURE;
-    }
-
-  cursor.show();
-  if (argc < 2 || QString(argv[1]) != "-I" )
-    {
-    QTimer::singleShot(200, &app, SLOT(quit()));
-    }
-
-  return app.exec();
-
-}
-

Libs/Widgets/Testing/Cpp/ctkCursorPixmapWidgetTest2.cpp

@@ -1,252 +0,0 @@
-/*=========================================================================
-
-  Library:   CTK
-
-  Copyright (c) Kitware Inc.
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      http://www.commontk.org/LICENSE
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-
-=========================================================================*/
-
-// Qt includes
-#include <QApplication>
-#include <QIcon>
-#include <QSignalSpy>
-#include <QStyle>
-#include <QTimer>
-
-// CTK includes
-#include "ctkCursorPixmapWidget.h"
-#include "ctkCommandLineParser.h"
-
-// STD includes
-#include <cstdlib>
-#include <iostream>
-
-//-----------------------------------------------------------------------------
-bool imageCompare(ctkCursorPixmapWidget& cursor, QString baselineDirectory,
-                  QString baselineFilename)
-{
-  QImage output = QPixmap::grabWidget(&cursor).toImage();
-  QImage baseline(baselineDirectory + "/" + baselineFilename);
-  return output == baseline;
-}
-
-//-----------------------------------------------------------------------------
-// (Used to create baselines, not during testing).
-void imageSave(ctkCursorPixmapWidget& cursor, QString baselineDirectory,
-               QString baselineFilename)
-{
-  QImage output = QPixmap::grabWidget(&cursor).toImage();
-  output.save(baselineDirectory + "/" + baselineFilename);
-}
-
-//-----------------------------------------------------------------------------
-bool runBaselineTest(int time, QApplication& app, ctkCursorPixmapWidget& cursor,
-                     QString baselineDirectory, QString baselineFilename,
-                     QString errorMessage)
-{
-  QTimer::singleShot(time, &app, SLOT(quit()));
-  if (app.exec() == EXIT_FAILURE)
-    {
-    std::cerr << "ctkCursorPixmapWidget exec failed "
-        << qPrintable(errorMessage) << std::endl;
-    return false;
-    }
-  if (!imageCompare(cursor, baselineDirectory, baselineFilename))
-    {
-    std::cerr << "ctkCursorPixmapWidget baseline comparison failed when "
-              << qPrintable(errorMessage) << "." << std::endl;
-    return false;
-    }
-  return true;
-}
-
-//-----------------------------------------------------------------------------
-int ctkCursorPixmapWidgetTest2(int argc, char * argv [] )
-{
-  QApplication app(argc, argv);
-
-  // Command line parser
-  ctkCommandLineParser parser;
-  parser.addArgument("", "-D", QVariant::String);
-  parser.addArgument("", "-V", QVariant::String);
-  parser.addArgument("", "-I", QVariant::String);
-  bool ok = false;
-  QHash<QString, QVariant> parsedArgs = parser.parseArguments(app.arguments(), &ok);
-  if (!ok)
-    {
-    std::cerr << qPrintable(parser.errorString()) << std::endl;
-    return EXIT_FAILURE;
-    }
-  QString dataDirectory = parsedArgs["-D"].toString();
-  QString baselineDirectory = parsedArgs["-V"].toString();
-  bool interactive = parsedArgs["-I"].toBool();
-
-  // The remainder is interactive, so abort now if command line args specify otherwise
-  if (interactive)
-    {
-    return EXIT_SUCCESS;
-    }
-
-  // Create the cursor widget
-  ctkCursorPixmapWidget cursor;
-  QPen cursorPen(Qt::yellow);
-  cursorPen.setJoinStyle(Qt::MiterJoin);
-  cursor.setCursorPen(cursorPen);
-  cursor.setMarginColor(Qt::blue);
-
-  int time = 200;
-  QPixmap pixmap(dataDirectory + "/" + "computerIcon.png");
-
-  // Basesize is always odd
-  QSize baseSize = pixmap.size();
-  if (pixmap.width() % 2 == 0)
-    {
-    baseSize.setWidth(baseSize.width()+1);
-    }
-  if (pixmap.height() % 2 == 0)
-    {
-    baseSize.setHeight(baseSize.height()+1);
-    }
-
-  // Odd widget size
-  cursor.setMinimumSize(baseSize);
-  cursor.setPixmap(pixmap.scaled(baseSize));
-  cursor.show();
-
-  // Test bullsEyeWidth and line width with odd widget size
-  cursor.setCursorType(ctkCursorPixmapWidget::BullsEyeCursor);
-
-  ///
-  cursor.setBullsEyeWidth(15);
-  cursorPen.setWidth(1);
-  cursor.setCursorPen(cursorPen);
-  if (!runBaselineTest(time, app, cursor, baselineDirectory,
-                       "ctkCursorPixmapWidgetTest2a.png",
-                       "using bulls-eye cursor (odd size, bullsEye 15, width 1)"))
-    {
-    return EXIT_FAILURE;
-    }
-
-  ///
-  cursorPen.setWidth(5);
-  cursor.setCursorPen(cursorPen);
-  if (!runBaselineTest(time, app, cursor, baselineDirectory,
-                       "ctkCursorPixmapWidgetTest2b.png",
-                       "using bulls-eye cursor (odd size, bullsEye 15, width 5)"))
-    {
-    return EXIT_FAILURE;
-    }
-
-  ///
-  cursor.setBullsEyeWidth(14);
-  cursorPen.setWidth(0); // equivalent to 1
-  cursor.setCursorPen(cursorPen);
-  if (!runBaselineTest(time, app, cursor, baselineDirectory,
-                       "ctkCursorPixmapWidgetTest2c.png",
-                       "using bulls-eye cursor (odd size, bullsEye 14, width 1)"))
-    {
-    return EXIT_FAILURE;
-    }
-
-  ///
-  cursorPen.setWidth(4);
-  cursor.setCursorPen(cursorPen);
-  if (!runBaselineTest(time, app, cursor, baselineDirectory,
-                       "ctkCursorPixmapWidgetTest2d.png",
-                       "using bulls-eye cursor (odd size, bullsEye 14, width 4)"))
-    {
-    return EXIT_FAILURE;
-    }
-
-  // Test bullsEyeWidth and line width with even widget size
-  cursor.resize(baseSize.width()+1, baseSize.height()+1);
-
-  ///
-  cursor.setBullsEyeWidth(14);
-  cursorPen.setWidth(1);
-  cursor.setCursorPen(cursorPen);
-  if (!runBaselineTest(time, app, cursor, baselineDirectory,
-                       "ctkCursorPixmapWidgetTest2e.png",
-                       "using bulls-eye cursor (even size, bullsEye 14, width 1)"))
-    {
-    return EXIT_FAILURE;
-    }
-
-  ///
-  cursorPen.setWidth(4);
-  cursor.setCursorPen(cursorPen);
-  if (!runBaselineTest(time, app, cursor, baselineDirectory,
-                       "ctkCursorPixmapWidgetTest2f.png",
-                       "using bulls-eye cursor (even size, bullsEye 14, width 4)"))
-    {
-    return EXIT_FAILURE;
-    }
-
-  ///
-  cursor.setBullsEyeWidth(15);
-  cursorPen.setWidth(0);
-  cursor.setCursorPen(cursorPen);
-  if (!runBaselineTest(time, app, cursor, baselineDirectory,
-                       "ctkCursorPixmapWidgetTest2g.png",
-                       "using bulls-eye cursor (even size, bullsEye 15, width 1)"))
-    {
-    return EXIT_FAILURE;
-    }
-
-  ///
-  cursorPen.setWidth(5);
-  cursor.setCursorPen(cursorPen);
-  if (!runBaselineTest(time, app, cursor, baselineDirectory,
-                       "ctkCursorPixmapWidgetTest2h.png",
-                       "using bulls-eye cursor (even size, bullsEye 15, width 5)"))
-    {
-    return EXIT_FAILURE;
-    }
-
-  // Cursor not shown
-  cursor.resize(baseSize);
-  cursor.setShowCursor(false);
-  cursor.setCursorPen(cursorPen);
-  if (!runBaselineTest(time, app, cursor, baselineDirectory,
-                       "ctkCursorPixmapWidgetTest2i.png",
-                       "show cursor false"))
-    {
-    return EXIT_FAILURE;
-    }
-
-  // Crosshair cursor
-  cursor.setShowCursor(true);
-  cursor.setCursorType(ctkCursorPixmapWidget::CrossHairCursor);
-  cursorPen.setWidth(0);
-  cursor.setCursorPen(cursorPen);
-  if (!runBaselineTest(time, app, cursor, baselineDirectory,
-                       "ctkCursorPixmapWidgetTest2j.png",
-                       "using cross-hair cursor (odd size)"))
-    {
-    return EXIT_FAILURE;
-    }
-  cursor.resize(baseSize.width()+1, baseSize.height()+1);
-  cursorPen.setWidth(1);
-  cursor.setCursorPen(cursorPen);
-  if (!runBaselineTest(time, app, cursor, baselineDirectory,
-                       "ctkCursorPixmapWidgetTest2k.png",
-                       "using cross-hair cursor (even size)"))
-    {
-    return EXIT_FAILURE;
-    }
-
-  return EXIT_SUCCESS;
-}
-

Libs/Widgets/ctkCursorPixmapWidget.cpp

@@ -26,94 +26,94 @@
 #include <QSize>
 
 // CTK includes
-#include "ctkCursorPixmapWidget.h"
+#include "ctkCrosshairLabel.h"
 #include "ctkLogger.h"
 
 // STD includes
 #include <math.h>
 
 //--------------------------------------------------------------------------
-static ctkLogger logger("org.commontk.visualization.vtk.widgets.ctkCursorPixmapWidget");
+static ctkLogger logger("org.commontk.visualization.vtk.widgets.ctkCrosshairLabel");
 //--------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------
-class ctkCursorPixmapWidgetPrivate
+class ctkCrosshairLabelPrivate
 {
-  Q_DECLARE_PUBLIC(ctkCursorPixmapWidget);
+  Q_DECLARE_PUBLIC(ctkCrosshairLabel);
 protected:
-  ctkCursorPixmapWidget* const q_ptr;
+  ctkCrosshairLabel* const q_ptr;
 public:
-  ctkCursorPixmapWidgetPrivate(ctkCursorPixmapWidget& object);
+  ctkCrosshairLabelPrivate(ctkCrosshairLabel& object);
 
   void init();
-  void drawCursor();
-  void drawCrossHairCursor(QPainter& painter);
-  void drawBullsEyeCursor(QPainter& painter);
+  void drawCrosshair();
+  void drawSimpleCrosshair(QPainter& painter);
+  void drawBullsEyeCrosshair(QPainter& painter);
 
-  bool      ShowCursor;
-  QPen      CursorPen;
-  ctkCursorPixmapWidget::CursorTypes CursorType;
+  bool      ShowCrosshair;
+  QPen      CrosshairPen;
+  ctkCrosshairLabel::CrosshairTypes CrosshairType;
   int       BullsEyeWidth;
 
   static const double BULLS_EYE_BLANK_FRACTION = 0.1;
 };
 
 // --------------------------------------------------------------------------
-// ctkCursorPixmapWidgetPrivate methods
+// ctkCrosshairLabelPrivate methods
 
 // --------------------------------------------------------------------------
-ctkCursorPixmapWidgetPrivate::ctkCursorPixmapWidgetPrivate(ctkCursorPixmapWidget& object)
+ctkCrosshairLabelPrivate::ctkCrosshairLabelPrivate(ctkCrosshairLabel& object)
   :q_ptr(&object)
 {
-  this->ShowCursor = true;
-  this->CursorType = ctkCursorPixmapWidget::CrossHairCursor;
+  this->ShowCrosshair = true;
+  this->CrosshairType = ctkCrosshairLabel::SimpleCrosshair;
   this->BullsEyeWidth = 15;
 }
 
 //---------------------------------------------------------------------------
-void ctkCursorPixmapWidgetPrivate::init()
+void ctkCrosshairLabelPrivate::init()
 {
-  Q_Q(ctkCursorPixmapWidget);
+  Q_Q(ctkCrosshairLabel);
   q->setAutoFillBackground(true);
   q->setAlignment(Qt::AlignCenter);
-  this->CursorPen.setColor(q->palette().color(QPalette::Highlight));
-  this->CursorPen.setWidth(0);
-  this->CursorPen.setJoinStyle(Qt::MiterJoin);
+  this->CrosshairPen.setColor(q->palette().color(QPalette::Highlight));
+  this->CrosshairPen.setWidth(0);
+  this->CrosshairPen.setJoinStyle(Qt::MiterJoin);
 }
 
 //---------------------------------------------------------------------------
-void ctkCursorPixmapWidgetPrivate::drawCursor()
+void ctkCrosshairLabelPrivate::drawCrosshair()
 {
-  // Abort if we are not to draw the cursor
-  if (!this->ShowCursor)
+  // Abort if we are not to draw the crosshair
+  if (!this->ShowCrosshair)
     {
     return;
     }
 
   // Setup the painter object to paint on the label
-  Q_Q(ctkCursorPixmapWidget);
+  Q_Q(ctkCrosshairLabel);
   QPainter painter(q);
-  painter.setPen(this->CursorPen);
+  painter.setPen(this->CrosshairPen);
 
-  // Draw cursor (based on current parameters) onto the label
-  switch (this->CursorType)
+  // Draw crosshair (based on current parameters) onto the label
+  switch (this->CrosshairType)
     {
-    case ctkCursorPixmapWidget::CrossHairCursor:
-      this->drawCrossHairCursor(painter);
+    case ctkCrosshairLabel::SimpleCrosshair:
+      this->drawSimpleCrosshair(painter);
       break;
-    case ctkCursorPixmapWidget::BullsEyeCursor:
-      this->drawBullsEyeCursor(painter);
+    case ctkCrosshairLabel::BullsEyeCrosshair:
+      this->drawBullsEyeCrosshair(painter);
       break;
     default:
-      qDebug() << "Unsupported cursor type" << this->CursorType;
+      qDebug() << "Unsupported crosshair type" << this->CrosshairType;
       break;
     }
 }
 
 //---------------------------------------------------------------------------
-void ctkCursorPixmapWidgetPrivate::drawCrossHairCursor(QPainter& painter)
+void ctkCrosshairLabelPrivate::drawSimpleCrosshair(QPainter& painter)
 {
-  Q_Q(ctkCursorPixmapWidget);
+  Q_Q(ctkCrosshairLabel);
   QSize size = q->size();
   double halfWidth = (size.width()-1.0) / 2.0;
   double halfHeight = (size.height()-1.0) / 2.0;
@@ -122,9 +122,9 @@ void ctkCursorPixmapWidgetPrivate::drawCrossHairCursor(QPainter& painter)
 }
 
 // --------------------------------------------------------------------------
-void ctkCursorPixmapWidgetPrivate::drawBullsEyeCursor(QPainter& painter)
+void ctkCrosshairLabelPrivate::drawBullsEyeCrosshair(QPainter& painter)
 {
-  Q_Q(ctkCursorPixmapWidget);
+  Q_Q(ctkCrosshairLabel);
   QSize size = q->size();
 
   // Draw rectangle
@@ -146,127 +146,131 @@ void ctkCursorPixmapWidgetPrivate::drawBullsEyeCursor(QPainter& painter)
   // Draw the lines
   double halfWidth = (size.width()-1.0) / 2.0;
   double halfHeight = (size.height()-1.0) / 2.0;
-  double blank = round(std::min(halfWidth, halfHeight) * this->BULLS_EYE_BLANK_FRACTION);
+  double blank = round(std::min(halfWidth, halfHeight)
+                       * this->BULLS_EYE_BLANK_FRACTION);
 
   painter.drawLine(QPointF(0, halfHeight), QPointF(x-blank-1.0, halfHeight));
-  painter.drawLine(QPointF(x+bullsEye+blank, halfHeight), QPointF(size.width(), halfHeight));
+  painter.drawLine(QPointF(x+bullsEye+blank, halfHeight),
+                   QPointF(size.width(), halfHeight));
   painter.drawLine(QPointF(halfWidth, 0), QPointF(halfWidth, y-blank-1.0));
-  painter.drawLine(QPointF(halfWidth, y+bullsEye+blank), QPointF(halfWidth, size.height()));
+  painter.drawLine(QPointF(halfWidth, y+bullsEye+blank),
+                   QPointF(halfWidth, size.height()));
 }
 
 //---------------------------------------------------------------------------
-// ctkCursorPixmapWidget methods
+// ctkCrosshairLabel methods
 
 // --------------------------------------------------------------------------
-ctkCursorPixmapWidget::ctkCursorPixmapWidget(QWidget* parent)
+ctkCrosshairLabel::ctkCrosshairLabel(QWidget* parent)
   : Superclass(parent)
-  , d_ptr(new ctkCursorPixmapWidgetPrivate(*this))
+  , d_ptr(new ctkCrosshairLabelPrivate(*this))
 {
-  Q_D(ctkCursorPixmapWidget);
+  Q_D(ctkCrosshairLabel);
   d->init();
 }
 
 // --------------------------------------------------------------------------
-ctkCursorPixmapWidget::~ctkCursorPixmapWidget()
+ctkCrosshairLabel::~ctkCrosshairLabel()
 {
 }
 
 // --------------------------------------------------------------------------
-CTK_GET_CPP(ctkCursorPixmapWidget, bool, showCursor, ShowCursor);
+CTK_GET_CPP(ctkCrosshairLabel, bool, showCrosshair, ShowCrosshair);
 
 // --------------------------------------------------------------------------
-void ctkCursorPixmapWidget::setShowCursor(bool newShow)
+void ctkCrosshairLabel::setShowCrosshair(bool newShow)
 {
-  Q_D(ctkCursorPixmapWidget);
-  if (newShow == d->ShowCursor)
+  Q_D(ctkCrosshairLabel);
+  if (newShow == d->ShowCrosshair)
     {
     return;
     }
 
-  d->ShowCursor = newShow;
+  d->ShowCrosshair = newShow;
   this->update();
 }
 
 // --------------------------------------------------------------------------
-CTK_GET_CPP(ctkCursorPixmapWidget, QPen, cursorPen, CursorPen);
+CTK_GET_CPP(ctkCrosshairLabel, QPen, crosshairPen, CrosshairPen);
 
 // --------------------------------------------------------------------------
-void ctkCursorPixmapWidget::setCursorPen(const QPen& newPen)
+void ctkCrosshairLabel::setCrosshairPen(const QPen& newPen)
 {
-  Q_D(ctkCursorPixmapWidget);
-  if (newPen == d->CursorPen)
+  Q_D(ctkCrosshairLabel);
+  if (newPen == d->CrosshairPen)
     {
     return;
     }
 
-  d->CursorPen = newPen;
+  d->CrosshairPen = newPen;
   this->update();
 }
 
 // --------------------------------------------------------------------------
-QColor ctkCursorPixmapWidget::cursorColor() const
+QColor ctkCrosshairLabel::crosshairColor() const
 {
-  Q_D(const ctkCursorPixmapWidget);
-  return d->CursorPen.color();
+  Q_D(const ctkCrosshairLabel);
+  return d->CrosshairPen.color();
 }
 
 // --------------------------------------------------------------------------
-void ctkCursorPixmapWidget::setCursorColor(const QColor& newColor)
+void ctkCrosshairLabel::setCrosshairColor(const QColor& newColor)
 {
-  Q_D(ctkCursorPixmapWidget);
-  if (d->CursorPen.color() == newColor)
+  Q_D(ctkCrosshairLabel);
+  if (d->CrosshairPen.color() == newColor)
     {
     return;
     }
 
-  d->CursorPen.setColor(newColor);
+  d->CrosshairPen.setColor(newColor);
   this->update();
 }
 
 // --------------------------------------------------------------------------
-int ctkCursorPixmapWidget::lineWidth() const
+int ctkCrosshairLabel::lineWidth() const
 {
-  Q_D(const ctkCursorPixmapWidget);
-  return d->CursorPen.width();
+  Q_D(const ctkCrosshairLabel);
+  return d->CrosshairPen.width();
 }
 
 // --------------------------------------------------------------------------
-void ctkCursorPixmapWidget::setLineWidth(int newWidth)
+void ctkCrosshairLabel::setLineWidth(int newWidth)
 {
-  Q_D(ctkCursorPixmapWidget);
-  if (d->CursorPen.width() == newWidth || newWidth < 0)
+  Q_D(ctkCrosshairLabel);
+  if (d->CrosshairPen.width() == newWidth || newWidth < 0)
     {
     return;
     }
 
-  d->CursorPen.setWidth(newWidth);
+  d->CrosshairPen.setWidth(newWidth);
   this->update();
 }
 
 // --------------------------------------------------------------------------
-CTK_GET_CPP(ctkCursorPixmapWidget, ctkCursorPixmapWidget::CursorTypes, cursorType, CursorType);
+CTK_GET_CPP(ctkCrosshairLabel, ctkCrosshairLabel::CrosshairTypes,
+            crosshairType, CrosshairType);
 
 // --------------------------------------------------------------------------
-void ctkCursorPixmapWidget::setCursorType(const CursorTypes& newType)
+void ctkCrosshairLabel::setCrosshairType(const CrosshairTypes& newType)
 {
-  Q_D(ctkCursorPixmapWidget);
-  if (newType == d->CursorType)
+  Q_D(ctkCrosshairLabel);
+  if (newType == d->CrosshairType)
     {
     return;
     }
 
-  d->CursorType = newType;
+  d->CrosshairType = newType;
   this->update();
 }
 
 // --------------------------------------------------------------------------
-QColor ctkCursorPixmapWidget::marginColor() const
+QColor ctkCrosshairLabel::marginColor() const
   {
   return this->palette().color(QPalette::Window);
   }
 
 // --------------------------------------------------------------------------
-void ctkCursorPixmapWidget::setMarginColor(const QColor& newColor)
+void ctkCrosshairLabel::setMarginColor(const QColor& newColor)
 {
   if (!newColor.isValid())
     {
@@ -285,12 +289,12 @@ void ctkCursorPixmapWidget::setMarginColor(const QColor& newColor)
 }
 
 // --------------------------------------------------------------------------
-CTK_GET_CPP(ctkCursorPixmapWidget, int, bullsEyeWidth, BullsEyeWidth);
+CTK_GET_CPP(ctkCrosshairLabel, int, bullsEyeWidth, BullsEyeWidth);
 
 // --------------------------------------------------------------------------
-void ctkCursorPixmapWidget::setBullsEyeWidth(int newWidth)
+void ctkCrosshairLabel::setBullsEyeWidth(int newWidth)
 {
-  Q_D(ctkCursorPixmapWidget);
+  Q_D(ctkCrosshairLabel);
   if (newWidth == d->BullsEyeWidth || newWidth < 0)
     {
     return;
@@ -301,35 +305,35 @@ void ctkCursorPixmapWidget::setBullsEyeWidth(int newWidth)
 }
 
 // --------------------------------------------------------------------------
-void ctkCursorPixmapWidget::paintEvent(QPaintEvent * event)
+void ctkCrosshairLabel::paintEvent(QPaintEvent * event)
 {
   Superclass::paintEvent(event);
-  Q_D(ctkCursorPixmapWidget);
-  d->drawCursor();
+  Q_D(ctkCrosshairLabel);
+  d->drawCrosshair();
 }
 
 // --------------------------------------------------------------------------
-QSize ctkCursorPixmapWidget::minimumSizeHint()const
+QSize ctkCrosshairLabel::minimumSizeHint()const
 {
   // Pretty arbitrary size (matches ctkVTKAbstractView)
   return QSize(50, 50);
 }
 
 // --------------------------------------------------------------------------
-QSize ctkCursorPixmapWidget::sizeHint()const
+QSize ctkCrosshairLabel::sizeHint()const
 {
   // Pretty arbitrary size (matches ctkVTKAbstractView)
   return QSize(300, 300);
 }
 
 //----------------------------------------------------------------------------
-bool ctkCursorPixmapWidget::hasHeightForWidth()const
+bool ctkCrosshairLabel::hasHeightForWidth()const
 {
   return true;
 }
 
 //----------------------------------------------------------------------------
-int ctkCursorPixmapWidget::heightForWidth(int width)const
+int ctkCrosshairLabel::heightForWidth(int width)const
 {
   // Tends to be square
   return width;

Libs/Widgets/ctkCursorPixmapWidget.h

@@ -18,8 +18,8 @@
 
 =========================================================================*/
 
-#ifndef __ctkCursorPixmapWidget_h
-#define __ctkCursorPixmapWidget_h
+#ifndef __ctkCrosshairLabel_h
+#define __ctkCrosshairLabel_h
 
 // QT includes
 #include <QLabel>
@@ -30,69 +30,70 @@ class QSize;
 // CTK includes
 #include "ctkWidgetsExport.h"
 
-class ctkCursorPixmapWidgetPrivate;
+class ctkCrosshairLabelPrivate;
 
-/// Draws a cursor onto a QLabel.  This widget is designed to be used to show
-/// a cursor overlaid onto an image (the QLabel's pixmap).
+/// Draws a crosshair onto a QLabel.  This widget is designed to be used to show
+/// a crosshair overlaid onto an image (the QLabel's pixmap).
 /// Since painting must be done in discrete pixels, this widget looks best
-/// when the widget size and the cursor line width are both either even or odd.
-/// If using a bulls-eye cursor, this widget looks best if the cursor line
+/// when the widget size and the crosshair line width are both either even or odd.
+/// If using a bulls-eye crosshair, this widget looks best if the crosshair line
 /// width and the bullsEyeWidth are both either even or odd.
 
-class CTK_WIDGETS_EXPORT ctkCursorPixmapWidget : public QLabel
+class CTK_WIDGETS_EXPORT ctkCrosshairLabel : public QLabel
 {
   Q_OBJECT
-  Q_FLAGS(CursorType CursorTypes)
-  Q_PROPERTY(bool showCursor READ showCursor WRITE setShowCursor)
+  Q_FLAGS(CrosshairType CrosshairTypes)
+  Q_PROPERTY(bool showCrosshair READ showCrosshair WRITE setShowCrosshair)
   // QT designer does not yet support QPen properties, so we provide the
-  // temporary properties cursorColor and lineWidth.
-  Q_PROPERTY(QPen cursorPen READ cursorPen WRITE setCursorPen DESIGNABLE false)
-  Q_PROPERTY(QColor cursorColor READ cursorColor WRITE setCursorColor)
+  // temporary properties crosshairColor and lineWidth.
+  Q_PROPERTY(QPen crosshairPen READ crosshairPen WRITE setCrosshairPen
+             DESIGNABLE false)
+  Q_PROPERTY(QColor crosshairColor READ crosshairColor WRITE setCrosshairColor)
   Q_PROPERTY(int lineWidth READ lineWidth WRITE setLineWidth)
-  Q_PROPERTY(CursorTypes cursorType READ cursorType WRITE setCursorType)
+  Q_PROPERTY(CrosshairTypes crosshairType READ crosshairType WRITE setCrosshairType)
   Q_PROPERTY(QColor marginColor READ marginColor WRITE setMarginColor)
   Q_PROPERTY(int bullsEyeWidth READ bullsEyeWidth WRITE setBullsEyeWidth)
 
 public:
   /// Constructors
   typedef QLabel Superclass;
-  explicit ctkCursorPixmapWidget(QWidget* parent = 0);
-  virtual ~ctkCursorPixmapWidget();
+  explicit ctkCrosshairLabel(QWidget* parent = 0);
+  virtual ~ctkCrosshairLabel();
 
-  /// Enumeration over types of cursors
-  enum CursorType {
-    CrossHairCursor = 0,
-    BullsEyeCursor
+  /// Enumeration over types of crosshairs
+  enum CrosshairType {
+    SimpleCrosshair = 0,
+    BullsEyeCrosshair
   };
-  Q_DECLARE_FLAGS(CursorTypes, CursorType)
+  Q_DECLARE_FLAGS(CrosshairTypes, CrosshairType)
 
-  /// Set/get whether or not to draw the cursor.  Default True.
-  bool showCursor() const;
-  void setShowCursor(bool newShow);
+  /// Set/get whether or not to draw the crosshair.  Default True.
+  bool showCrosshair() const;
+  void setShowCrosshair(bool newShow);
 
-  /// Set/get the pen used to draw the cursor.  Default color is from the
+  /// Set/get the pen used to draw the crosshair.  Default color is from the
   /// widget's palette's Highlight role, default width is 0 (which draws
   /// at 1 pixel wide regardless of painter transformation).  Since painting
   /// must be done in discrete pixels, this widget looks best when the widget
-  /// size and the cursor pen width are both either even or odd.
-  QPen cursorPen() const;
-  void setCursorPen(const QPen& newPen);
+  /// size and the crosshair pen width are both either even or odd.
+  QPen crosshairPen() const;
+  void setCrosshairPen(const QPen& newPen);
 
-  /// Temporary: Set/get the cursor color (via QPen).  This will be removed once
+  /// Temporary: Set/get the crosshair color (via QPen).  This will be removed once
   /// Qt Designer supports QPen properties.
-  QColor cursorColor() const;
-  void setCursorColor(const QColor& newColor);
+  QColor crosshairColor() const;
+  void setCrosshairColor(const QColor& newColor);
 
-  /// Temporary: Set/get the cursor line width (via QPen).  This will be removed
+  /// Temporary: Set/get the crosshair line width (via QPen).  This will be removed
   /// once Qt Designer supports QPen properties.  Since painting
   /// must be done in discrete pixels, this widget looks best when the widget
-  /// size and the cursor pen width are both either even or odd.
+  /// size and the crosshair pen width are both either even or odd.
   int lineWidth() const;
   void setLineWidth(int newWidth);
 
-  /// Set/get the cursor type.  Default CursorType_CrossHair.
-  CursorTypes cursorType() const;
-  void setCursorType(const CursorTypes& newType);
+  /// Set/get the crosshair type.  Default SimpleCrosshair.
+  CrosshairTypes crosshairType() const;
+  void setCrosshairType(const CrosshairTypes& newType);
 
   /// Set/get color to set the widget to when not magnifying or when label
   /// size is larger than pixmap size.  Default is the color from the widget's
@@ -104,7 +105,7 @@ public:
   /// Set/get the width of the crosshair when in BullsEye mode.
   /// Looks best when the BullsEye width and the widget size are both either
   /// even or odd, preferably odd.  Default 15.  Since painting must be done
-  /// in discrete pixels, this widget looks best if the cursor pen width and
+  /// in discrete pixels, this widget looks best if the crosshair pen width and
   /// the bullsEyeWidth are both either even or odd.
   int bullsEyeWidth() const;
   void setBullsEyeWidth(int newWidth);
@@ -116,14 +117,14 @@ public:
   virtual int heightForWidth(int width)const;
 
 protected:
-  QScopedPointer<ctkCursorPixmapWidgetPrivate> d_ptr;
+  QScopedPointer<ctkCrosshairLabelPrivate> d_ptr;
 
-  // Draws the cursor on top of the widget.
+  // Draws the crosshair on top of the widget.
   virtual void paintEvent(QPaintEvent * event);
 
 private:
-  Q_DECLARE_PRIVATE(ctkCursorPixmapWidget);
-  Q_DISABLE_COPY(ctkCursorPixmapWidget);
+  Q_DECLARE_PRIVATE(ctkCrosshairLabel);
+  Q_DISABLE_COPY(ctkCrosshairLabel);
 }; 
 
 #endif