Merge branch 'wordWrapToolTips'

* wordWrapToolTips:
  ENH: Do tool tip word wrap
  STYLE: Rename enabled to toolTipsTrapped

Libs/Widgets/Testing/Cpp/ctkToolTipTrapperTest1.cpp

@@ -37,26 +37,47 @@ int ctkToolTipTrapperTest1(int argc, char * argv [] )
 
   ctkToolTipTrapper trapper;
   
-  if (trapper.isEnabled() != true)
+  if (trapper.toolTipsTrapped() != true)
     {
-    std::cerr << "ctkToolTipTrapper::isEnabled default value" << std::endl;
+    std::cerr << "ctkToolTipTrapper::toolTipsTrapped default value" << std::endl;
     return EXIT_FAILURE;
     }
 
-  trapper.setEnabled(false);
+  trapper.setToolTipsTrapped(false);
 
-  if (trapper.isEnabled() != false)
+  if (trapper.toolTipsTrapped() != false)
     {
-    std::cerr << "ctkToolTipTrapper::setEnabled failed" << std::endl;
+    std::cerr << "ctkToolTipTrapper::setToolTipsTrapped failed" << std::endl;
+    return EXIT_FAILURE;
+    }
+
+  if (trapper.toolTipsWordWrapped() != false)
+    {
+    std::cerr << "ctkToolTipTrapper::toolTipsWordWrapped default value" << std::endl;
+    return EXIT_FAILURE;
+    }
+
+  trapper.setToolTipsWordWrapped(true);
+
+  if (trapper.toolTipsWordWrapped() != true)
+    {
+    std::cerr << "ctkToolTipTrapper::setToolTipsWordWrapped failed" << std::endl;
     return EXIT_FAILURE;
     }
   
-  QPushButton button("button");
-  button.setToolTip("Button tooltip text");
-  button.setCheckable(true);
-  QObject::connect(&button, SIGNAL(toggled(bool)),
-                   &trapper, SLOT(setEnabled(bool)));
-  button.show();
+  QPushButton trapButton("button");
+  trapButton.setToolTip("Button tooltip text");
+  trapButton.setCheckable(true);
+  QObject::connect(&trapButton, SIGNAL(toggled(bool)),
+                   &trapper, SLOT(setToolTipsTrapped(bool)));
+  trapButton.show();
+
+  QPushButton wrapButton("button");
+  wrapButton.setToolTip("Button tooltip text");
+  wrapButton.setCheckable(true);
+  QObject::connect(&wrapButton, SIGNAL(toggled(bool)),
+                   &trapper, SLOT(setToolTipsWordWrapped(bool)));
+  wrapButton.show();
 
   if (argc < 2 || QString(argv[1]) != "-I" )
     {

Libs/Widgets/ctkToolTipTrapper.cpp

@@ -51,6 +51,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // Qt includes
 #include <QCoreApplication>
+#include <QTextDocument>
+#include <QWidget>
 
 // CTK includes
 #include "ctkToolTipTrapper.h"
@@ -63,14 +65,44 @@ protected:
 public:
   ctkToolTipTrapperPrivate(ctkToolTipTrapper& object);
 
-  bool Enabled;
+  enum EventFilterToDo
+    {
+    EVENT_FILTER_DO_NOTHING,
+    EVENT_FILTER_INSTALL,
+    EVENT_FILTER_REMOVE
+    };
+
+  static EventFilterToDo getEventFilterToDo(bool beforeToolTipsTrapped,
+                                            bool beforeToolTipsWordWrapped,
+                                            bool afterToolTipsTrapped,
+                                            bool afterToolTipsWordWrapped)
+    {
+    bool eventFilterWasInstalled = beforeToolTipsTrapped || beforeToolTipsWordWrapped;
+    bool eventFilterShouldBeInstalled = afterToolTipsTrapped || afterToolTipsWordWrapped;
+    if (eventFilterWasInstalled == eventFilterShouldBeInstalled)
+      {
+      return EVENT_FILTER_DO_NOTHING;
+      }
+    else if (eventFilterShouldBeInstalled)
+      {
+      return EVENT_FILTER_INSTALL;
+      }
+    else
+      {
+      return EVENT_FILTER_REMOVE;
+      }
+    };
+
+  bool ToolTipsTrapped;
+  bool ToolTipsWordWrapped;
 };
 
 // --------------------------------------------------------------------------
 ctkToolTipTrapperPrivate::ctkToolTipTrapperPrivate(ctkToolTipTrapper& object)
   : q_ptr(&object)
 {
-  this->Enabled = false;
+  this->ToolTipsTrapped = false;
+  this->ToolTipsWordWrapped = false;
 }
 
 //------------------------------------------------------------------------------
@@ -78,15 +110,19 @@ ctkToolTipTrapper::ctkToolTipTrapper(QObject * newParent)
   : Superclass(newParent)
   , d_ptr(new ctkToolTipTrapperPrivate(*this))
 {
-  this->setEnabled(true);
+  this->setToolTipsTrapped(true);
+  this->setToolTipsWordWrapped(false);
 }
 
 //------------------------------------------------------------------------------
-ctkToolTipTrapper::ctkToolTipTrapper(bool enable, QObject * newParent)
+ctkToolTipTrapper::ctkToolTipTrapper(bool toolTipsTrapped,
+                                     bool toolTipsWordWrapped,
+                                     QObject * newParent)
   : Superclass(newParent)
   , d_ptr(new ctkToolTipTrapperPrivate(*this))
 {
-  this->setEnabled(enable);
+  this->setToolTipsTrapped(toolTipsTrapped);
+  this->setToolTipsWordWrapped(toolTipsWordWrapped);
 }
 
 //------------------------------------------------------------------------------
@@ -95,26 +131,61 @@ ctkToolTipTrapper::~ctkToolTipTrapper()
 }
 
 //------------------------------------------------------------------------------
-bool ctkToolTipTrapper::isEnabled()const
+bool ctkToolTipTrapper::toolTipsTrapped()const
+{
+  Q_D(const ctkToolTipTrapper);
+  return d->ToolTipsTrapped;
+}
+
+//------------------------------------------------------------------------------
+bool ctkToolTipTrapper::toolTipsWordWrapped()const
 {
   Q_D(const ctkToolTipTrapper);
-  return d->Enabled;
+  return d->ToolTipsWordWrapped;
+}
+//------------------------------------------------------------------------------
+void ctkToolTipTrapper::setToolTipsTrapped(bool toolTipsTrapped)
+{
+  Q_D(ctkToolTipTrapper);
+  if (toolTipsTrapped == d->ToolTipsTrapped)
+    {
+    return;
+    }
+  ctkToolTipTrapperPrivate::EventFilterToDo todo =
+      ctkToolTipTrapperPrivate::getEventFilterToDo(d->ToolTipsTrapped,
+                                                   d->ToolTipsWordWrapped,
+                                                   toolTipsTrapped,
+                                                   d->ToolTipsWordWrapped);
+  d->ToolTipsTrapped = toolTipsTrapped;
+  if (todo == ctkToolTipTrapperPrivate::EVENT_FILTER_INSTALL)
+    {
+    QCoreApplication::instance()->installEventFilter(this);
+    }
+  else if (todo == ctkToolTipTrapperPrivate::EVENT_FILTER_REMOVE)
+    {
+    QCoreApplication::instance()->removeEventFilter(this);
+    }
 }
 
 //------------------------------------------------------------------------------
-void ctkToolTipTrapper::setEnabled(bool enable)
+void ctkToolTipTrapper::setToolTipsWordWrapped(bool toolTipsWordWrapped)
 {
   Q_D(ctkToolTipTrapper);
-  if (enable == d->Enabled)
+  if (toolTipsWordWrapped == d->ToolTipsWordWrapped)
     {
     return;
     }
-  d->Enabled = enable;
-  if (enable)
+  ctkToolTipTrapperPrivate::EventFilterToDo todo =
+      ctkToolTipTrapperPrivate::getEventFilterToDo(d->ToolTipsTrapped,
+                                                   d->ToolTipsWordWrapped,
+                                                   d->ToolTipsTrapped,
+                                                   toolTipsWordWrapped);
+  d->ToolTipsWordWrapped = toolTipsWordWrapped;
+  if (todo == ctkToolTipTrapperPrivate::EVENT_FILTER_INSTALL)
     {
     QCoreApplication::instance()->installEventFilter(this);
     }
-  else
+  else if (todo == ctkToolTipTrapperPrivate::EVENT_FILTER_REMOVE)
     {
     QCoreApplication::instance()->removeEventFilter(this);
     }
@@ -124,9 +195,30 @@ void ctkToolTipTrapper::setEnabled(bool enable)
 bool ctkToolTipTrapper::eventFilter(QObject* watched, QEvent* input_event)
 {
   Q_UNUSED(watched);
-  if(input_event->type() == QEvent::ToolTip)
+  if(input_event->type() == QEvent::ToolTip
+     || input_event->type() == QEvent::ToolTipChange)
     {
-    return true;
+    Q_D(ctkToolTipTrapper);
+    // Trap tooltips so that they are not shown.
+    if (d->ToolTipsTrapped)
+      {
+      return true;
+      }
+    // Convert plain text to rich text to word wrap tooltips, and trigger new
+    // event to show the rich tooltip.
+    // If tooltip is already rich text or empty, let the regular mechanism
+    // handle it.
+    if (d->ToolTipsWordWrapped)
+      {
+      QWidget* widget = qobject_cast<QWidget *>(watched);
+      if (widget && !widget->toolTip().isEmpty()
+          && !Qt::mightBeRichText(widget->toolTip()))
+        {
+        QString richToolTip = Qt::convertFromPlainText(widget->toolTip(), Qt::WhiteSpaceNormal);
+        widget->setToolTip(richToolTip);
+        return true;
+        }
+      }
     }
   return false;
 }

Libs/Widgets/ctkToolTipTrapper.h

@@ -60,34 +60,43 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 class ctkToolTipTrapperPrivate;
 
 /// \ingroup Widgets
-/// To prevent tooltips from appearing, create an instance of this object.
+/// Filters tooltips, to prevent tooltips from appearing or to word wrap
+/// tooltips.
+/// If toolTipsTrapped or toolTipsWordWrapped is true, installs an event filter to
+/// trap or wrap tooltips.
+/// If toolTipsTrapped and toolTipsWordWrapped are false, does not install the event
+/// filter.
+/// Tooltips are trapped and not word wrapped by default.
 class CTK_WIDGETS_EXPORT ctkToolTipTrapper : public QObject
 {
   Q_OBJECT
-  Q_PROPERTY( bool enabled READ isEnabled WRITE setEnabled)
+  Q_PROPERTY( bool toolTipsTrapped READ toolTipsTrapped WRITE setToolTipsTrapped)
+  Q_PROPERTY( bool toolTipsWordWrapped READ toolTipsWordWrapped WRITE setToolTipsWordWrapped)
 public:
   typedef QObject Superclass;
   /// Constructs a ToolTip trapper which is a child of objectParent
-  /// The trapper is enabled by default 
   explicit ctkToolTipTrapper(QObject* objectParent = 0);
-  /// Constructs a ToolTip trapper which is a child of objectParent
-  /// If enable is false, the trapper doesn't install the event filter
-  explicit ctkToolTipTrapper(bool enable, QObject* objectParent = 0);
+  explicit ctkToolTipTrapper(bool toolTipsTrapped,
+                             bool toolTipsWordWordWrapped,
+                             QObject* objectParent = 0);
   virtual ~ctkToolTipTrapper();
 
-  /// Returns true if the eventFilter is installed and ToolTip events are
-  /// filtered
-  bool isEnabled()const;
+  /// Returns true if the tooltips are trapped to prevent them from appearing.
+  bool toolTipsTrapped()const;
+
+  /// Returns true if the tooltips are word wrapped.
+  bool toolTipsWordWrapped()const;
 
-  /// Automatically called when the tooltip is enabled. It prevents the
-  /// tooltips events from being processed. You shouldn't have to call
-  /// it manually.
+  /// Automatically called when the tooltips are trapped or word wrapped.
+  /// You shouldn't have to call it manually.
   bool eventFilter(QObject* watched, QEvent* event);
 
 public Q_SLOTS:
-  /// If true, it installs the eventFilter on the application. Otherwise
-  /// it removes it.
-  void setEnabled(bool enable);
+  /// If true, installs the eventFilter on the application if it isn't already
+  /// installed.  Otherwise, removes the eventFilter if tooltips are neither
+  /// trapped nor word wrapped.
+  void setToolTipsTrapped(bool toolTipsTrapped);
+  void setToolTipsWordWrapped(bool toolTipsWordWrapped);
 
 protected:
   QScopedPointer<ctkToolTipTrapperPrivate> d_ptr;