--- a/libgui/graphics/Canvas.cc	Wed Aug 31 14:37:33 2016 -0400
+++ b/libgui/graphics/Canvas.cc	Wed Aug 31 12:20:46 2016 -0700
@@ -50,983 +50,985 @@
 namespace QtHandles
 {
 
-void
-Canvas::redraw (bool sync)
-{
-  QWidget *w = qWidget ();
+  void
+  Canvas::redraw (bool sync)
+  {
+    QWidget *w = qWidget ();
 
-  if (w)
-    {
-      if (sync)
-        w->repaint ();
-      else
-        w->update ();
-    }
-}
-
-void
-Canvas::blockRedraw (bool block)
-{
-  m_redrawBlocked = block;
-}
-
-void
-Canvas::setCursor (MouseMode mode)
-{
-  QWidget *w = qWidget ();
+    if (w)
+      {
+        if (sync)
+          w->repaint ();
+        else
+          w->update ();
+      }
+  }
 
-  if (w)
-    {
-      static QCursor origCursor = w->cursor ();
-
-      switch (mode)
-        {
-        case PanMode:
-        case RotateMode:
-          w->setCursor (Qt::OpenHandCursor);
-          break;
+  void
+  Canvas::blockRedraw (bool block)
+  {
+    m_redrawBlocked = block;
+  }
 
-        case ZoomInMode:
-          w->setCursor (QPixmap (":/images/zoom-in.png"));
-          break;
+  void
+  Canvas::setCursor (MouseMode mode)
+  {
+    QWidget *w = qWidget ();
 
-        case ZoomOutMode:
-          w->setCursor (QPixmap (":/images/zoom-out.png"));
-          break;
-
-        default:
-          w->setCursor (origCursor);
-          break;
-        }
-    }
-}
+    if (w)
+      {
+        static QCursor origCursor = w->cursor ();
 
-void
-Canvas::print (const QString& file_cmd, const QString& term)
-{
-  gh_manager::auto_lock lock;
-  graphics_object obj = gh_manager::get_object (m_handle);
-
-  if (obj.valid_object ())
-    {
-      graphics_object figObj (obj.get_ancestor ("figure"));
+        switch (mode)
+          {
+          case PanMode:
+          case RotateMode:
+            w->setCursor (Qt::OpenHandCursor);
+            break;
 
-      gl2ps_print (figObj, file_cmd.toStdString (), term.toStdString ());
-    }
-}
+          case ZoomInMode:
+            w->setCursor (QPixmap (":/images/zoom-in.png"));
+            break;
 
-/*
-   Two updateCurrentPoint() routines are required:
-   1) Used for QMouseEvents where cursor position data is in callback from Qt.
-   2) Used for QKeyEvents where cursor position must be determined.
-*/
-void
-Canvas::updateCurrentPoint(const graphics_object& fig,
-                           const graphics_object& obj, QMouseEvent* event)
-{
-  gh_manager::auto_lock lock;
+          case ZoomOutMode:
+            w->setCursor (QPixmap (":/images/zoom-out.png"));
+            break;
 
-  gh_manager::post_set (fig.get_handle (), "currentpoint",
-                        Utils::figureCurrentPoint (fig, event), false);
-
-  Matrix children = obj.get_properties ().get_children ();
-  octave_idx_type num_children = children.numel ();
-
-  for (int i = 0; i < num_children; i++)
-    {
-      graphics_object childObj (gh_manager::get_object (children(i)));
+          default:
+            w->setCursor (origCursor);
+            break;
+          }
+      }
+  }
 
-      if (childObj.isa ("axes"))
-        {
-          axes::properties& ap = Utils::properties<axes> (childObj);
-          Matrix x_zlim = ap.get_transform_zlim ();
-          graphics_xform x_form = ap.get_transform ();
+  void
+  Canvas::print (const QString& file_cmd, const QString& term)
+  {
+    gh_manager::auto_lock lock;
+    graphics_object obj = gh_manager::get_object (m_handle);
 
-          ColumnVector p1 = x_form.untransform (event->x (), event->y (),
-                                                x_zlim(0));
-          ColumnVector p2 = x_form.untransform (event->x (), event->y (),
-                                                x_zlim(1));
-
-          Matrix cp (2, 3, 0.0);
-
-          cp(0,0) = p1(0); cp(0,1) = p1(1); cp(0,2) = p1(2);
-          cp(1,0) = p2(0); cp(1,1) = p2(1); cp(1,2) = p2(2);
+    if (obj.valid_object ())
+      {
+        graphics_object figObj (obj.get_ancestor ("figure"));
 
-          gh_manager::post_set (childObj.get_handle (), "currentpoint", cp,
-                                false);
-        }
-    }
-}
+        gl2ps_print (figObj, file_cmd.toStdString (), term.toStdString ());
+      }
+  }
 
-void
-Canvas::updateCurrentPoint(const graphics_object& fig,
-                           const graphics_object& obj)
-{
-  gh_manager::auto_lock lock;
-
-  gh_manager::post_set (fig.get_handle (), "currentpoint",
-                        Utils::figureCurrentPoint (fig), false);
-
-  Matrix children = obj.get_properties ().get_children ();
-  octave_idx_type num_children = children.numel ();
-
-  for (int i = 0; i < num_children; i++)
-    {
-      graphics_object childObj (gh_manager::get_object (children(i)));
+  /*
+     Two updateCurrentPoint() routines are required:
+     1) Used for QMouseEvents where cursor position data is in callback from Qt.
+     2) Used for QKeyEvents where cursor position must be determined.
+  */
+  void
+  Canvas::updateCurrentPoint(const graphics_object& fig,
+                             const graphics_object& obj, QMouseEvent* event)
+  {
+    gh_manager::auto_lock lock;
 
-      if (childObj.isa ("axes"))
-        {
-          // FIXME: QCursor::pos() may give inaccurate results with asynchronous
-          //        window systems like X11 over ssh.
-          QWidget *w = qWidget ();
-          QPoint p = w->mapFromGlobal (QCursor::pos ());
-          axes::properties& ap = Utils::properties<axes> (childObj);
-          Matrix x_zlim = ap.get_transform_zlim ();
-          graphics_xform x_form = ap.get_transform ();
+    gh_manager::post_set (fig.get_handle (), "currentpoint",
+                          Utils::figureCurrentPoint (fig, event), false);
 
-          ColumnVector p1 = x_form.untransform (p.x (), p.y (), x_zlim(0));
-          ColumnVector p2 = x_form.untransform (p.x (), p.y (), x_zlim(1));
+    Matrix children = obj.get_properties ().get_children ();
+    octave_idx_type num_children = children.numel ();
 
-          Matrix cp (2, 3, 0.0);
-
-          cp(0,0) = p1(0); cp(0,1) = p1(1); cp(0,2) = p1(2);
-          cp(1,0) = p2(0); cp(1,1) = p2(1); cp(1,2) = p2(2);
+    for (int i = 0; i < num_children; i++)
+      {
+        graphics_object childObj (gh_manager::get_object (children(i)));
 
-          gh_manager::post_set (childObj.get_handle (), "currentpoint", cp,
-                                false);
-        }
-    }
-}
-
-void
-Canvas::annotation_callback (const octave_value_list& args)
-{
-  Ffeval (ovl ("annotation").append (args));
+        if (childObj.isa ("axes"))
+          {
+            axes::properties& ap = Utils::properties<axes> (childObj);
+            Matrix x_zlim = ap.get_transform_zlim ();
+            graphics_xform x_form = ap.get_transform ();
 
-  redraw ();
-}
+            ColumnVector p1 = x_form.untransform (event->x (), event->y (),
+                                                  x_zlim(0));
+            ColumnVector p2 = x_form.untransform (event->x (), event->y (),
+                                                  x_zlim(1));
 
-void
-Canvas::canvasToggleAxes (const graphics_handle& handle)
-{
-  gh_manager::auto_lock lock;
-
-  graphics_object go = gh_manager::get_object (handle);
+            Matrix cp (2, 3, 0.0);
 
-  if (go.valid_object ())
-    {
-      figure::properties& fp = Utils::properties<figure> (go);
-
-      graphics_handle ah = fp.get_currentaxes ();
-
-      graphics_object ax = gh_manager::get_object (ah);
+            cp(0,0) = p1(0); cp(0,1) = p1(1); cp(0,2) = p1(2);
+            cp(1,0) = p2(0); cp(1,1) = p2(1); cp(1,2) = p2(2);
 
-      if (ax.valid_object ())
-        {
-          axes::properties& ap = Utils::properties<axes> (ax);
-
-          if (ap.handlevisibility_is ("on"))
-            {
-              ap.set_visible (! ap.is_visible ());
+            gh_manager::post_set (childObj.get_handle (), "currentpoint", cp,
+                                  false);
+          }
+      }
+  }
 
-              redraw (true);
-            }
-        }
-    }
-}
-
-void
-Canvas::canvasToggleGrid (const graphics_handle& handle)
-{
-  gh_manager::auto_lock lock;
-
-  graphics_object go = gh_manager::get_object (handle);
+  void
+  Canvas::updateCurrentPoint(const graphics_object& fig,
+                             const graphics_object& obj)
+  {
+    gh_manager::auto_lock lock;
 
-  if (go.valid_object ())
-    {
-      figure::properties& fp = Utils::properties<figure> (go);
-
-      graphics_handle ah = fp.get_currentaxes ();
-
-      graphics_object ax = gh_manager::get_object (ah);
+    gh_manager::post_set (fig.get_handle (), "currentpoint",
+                          Utils::figureCurrentPoint (fig), false);
 
-      if (ax.valid_object ())
-        {
-          axes::properties& ap = Utils::properties<axes> (ax);
+    Matrix children = obj.get_properties ().get_children ();
+    octave_idx_type num_children = children.numel ();
 
-          std::string tmp;
-
-          // If any grid is off, then turn them all on.  If they are all
-          // on, then turn them off.
+    for (int i = 0; i < num_children; i++)
+      {
+        graphics_object childObj (gh_manager::get_object (children(i)));
 
-          std::string state = ((ap.get_xgrid () == "off"
-                                || ap.get_ygrid () == "off"
-                                || ap.get_zgrid () == "off")
-                               ? "on" : "off");
-
-          ap.set_xgrid (state);
-          ap.set_ygrid (state);
-          ap.set_zgrid (state);
+        if (childObj.isa ("axes"))
+          {
+            // FIXME: QCursor::pos() may give inaccurate results with asynchronous
+            //        window systems like X11 over ssh.
+            QWidget *w = qWidget ();
+            QPoint p = w->mapFromGlobal (QCursor::pos ());
+            axes::properties& ap = Utils::properties<axes> (childObj);
+            Matrix x_zlim = ap.get_transform_zlim ();
+            graphics_xform x_form = ap.get_transform ();
 
-          redraw (true);
-        }
-    }
-}
-
-static void
-autoscale_axes (axes::properties& ap)
-{
-  ap.clear_zoom_stack ();
-
-  ap.set_xlimmode ("auto");
-  ap.set_ylimmode ("auto");
-  ap.set_zlimmode ("auto");
-}
+            ColumnVector p1 = x_form.untransform (p.x (), p.y (), x_zlim(0));
+            ColumnVector p2 = x_form.untransform (p.x (), p.y (), x_zlim(1));
 
-void
-Canvas::canvasAutoAxes (const graphics_handle& handle)
-{
-  gh_manager::auto_lock lock;
+            Matrix cp (2, 3, 0.0);
 
-  graphics_object go = gh_manager::get_object (handle);
-
-  if (go.valid_object ())
-    {
-      figure::properties& fp = Utils::properties<figure> (go);
-
-      graphics_handle ah = fp.get_currentaxes ();
+            cp(0,0) = p1(0); cp(0,1) = p1(1); cp(0,2) = p1(2);
+            cp(1,0) = p2(0); cp(1,1) = p2(1); cp(1,2) = p2(2);
 
-      graphics_object ax = gh_manager::get_object (ah);
-
-      if (ax.valid_object ())
-        {
-          axes::properties& ap = Utils::properties<axes> (ax);
+            gh_manager::post_set (childObj.get_handle (), "currentpoint", cp,
+                                  false);
+          }
+      }
+  }
 
-          autoscale_axes (ap);
-
-          redraw (true);
-        }
-    }
-}
+  void
+  Canvas::annotation_callback (const octave_value_list& args)
+  {
+    Ffeval (ovl ("annotation").append (args));
 
-void
-Canvas::canvasPaintEvent (void)
-{
-  if (! m_redrawBlocked)
-    {
-      gh_manager::auto_lock lock;
+    redraw ();
+  }
 
-      draw (m_handle);
+  void
+  Canvas::canvasToggleAxes (const graphics_handle& handle)
+  {
+    gh_manager::auto_lock lock;
 
-      if ((m_mouseMode == ZoomInMode && m_mouseAxes.ok ()) || m_rectMode)
-        drawZoomBox (m_mouseAnchor, m_mouseCurrent);
-    }
-}
+    graphics_object go = gh_manager::get_object (handle);
 
-static bool
-pan_enabled (const graphics_object figObj)
-{
-  // Getting pan mode property:
-  octave_value ov_pm
-    = Utils::properties<figure> (figObj).get___pan_mode__ ();
+    if (go.valid_object ())
+      {
+        figure::properties& fp = Utils::properties<figure> (go);
 
-  octave_scalar_map pm = ov_pm.scalar_map_value ();
-
-  return pm.contents ("Enable").string_value () == "on";
-}
+        graphics_handle ah = fp.get_currentaxes ();
 
-static std::string
-pan_mode (const graphics_object figObj)
-{
-  // Getting pan mode property:
-  octave_value ov_pm
-    = Utils::properties<figure> (figObj).get___pan_mode__ ();
+        graphics_object ax = gh_manager::get_object (ah);
 
-  octave_scalar_map pm = ov_pm.scalar_map_value ();
-
-  return pm.contents ("Motion").string_value ();
-}
+        if (ax.valid_object ())
+          {
+            axes::properties& ap = Utils::properties<axes> (ax);
 
-static bool
-zoom_enabled (const graphics_object figObj)
-{
-  // Getting zoom mode property:
-  octave_value ov_zm
-    = Utils::properties<figure> (figObj).get___zoom_mode__ ();
-
-  octave_scalar_map zm = ov_zm.scalar_map_value ();
+            if (ap.handlevisibility_is ("on"))
+              {
+                ap.set_visible (! ap.is_visible ());
 
-  return zm.contents ("Enable").string_value () == "on";
-}
-
-static std::string
-zoom_mode (const graphics_object figObj)
-{
-  // Getting zoom mode property:
-  octave_value ov_zm
-    = Utils::properties<figure> (figObj).get___zoom_mode__ ();
+                redraw (true);
+              }
+          }
+      }
+  }
 
-  octave_scalar_map zm = ov_zm.scalar_map_value ();
-
-  return zm.contents ("Motion").string_value ();
-}
+  void
+  Canvas::canvasToggleGrid (const graphics_handle& handle)
+  {
+    gh_manager::auto_lock lock;
 
-void
-Canvas::select_object (graphics_object obj, QMouseEvent* event,
-                       graphics_object &currentObj, graphics_object &axesObj,
-                       bool axes_only)
-{
-  QList<graphics_object> axesList;
-  Matrix children = obj.get_properties ().get_all_children ();
-  octave_idx_type num_children = children.numel ();
+    graphics_object go = gh_manager::get_object (handle);
 
-  for (int i = 0; i < num_children; i++)
-    {
-      graphics_object childObj (gh_manager::get_object (children(i)));
+    if (go.valid_object ())
+      {
+        figure::properties& fp = Utils::properties<figure> (go);
+
+        graphics_handle ah = fp.get_currentaxes ();
 
-      if (childObj.isa ("axes"))
-        axesList.append (childObj);
-      else if (childObj.isa ("uicontrol") || childObj.isa ("uipanel")
-               || childObj.isa ("uibuttongroup"))
-        {
-          Matrix bb = childObj.get_properties ().get_boundingbox (false);
-          QRectF r (bb(0), bb(1), bb(2), bb(3));
+        graphics_object ax = gh_manager::get_object (ah);
 
-          r.adjust (-5, -5, 5, 5);
+        if (ax.valid_object ())
+          {
+            axes::properties& ap = Utils::properties<axes> (ax);
+
+            std::string tmp;
 
-#if (HAVE_QT4)
-          bool rect_contains_pos = r.contains (event->posF ());
-#else
-          bool rect_contains_pos = r.contains (event->localPos ());
-#endif
-          if (rect_contains_pos)
-            {
-              currentObj = childObj;
-              break;
-            }
-        }
-    }
+            // If any grid is off, then turn them all on.  If they are all
+            // on, then turn them off.
 
-  if (axes_only)
-    {
-      QPoint pt = event->pos ();
-
-      for (QList<graphics_object>::ConstIterator it = axesList.begin ();
-           it != axesList.end (); ++it)
-        {
-          const axes::properties& ap =
-            dynamic_cast<const axes::properties&> ((*it).get_properties ());
+            std::string state = ((ap.get_xgrid () == "off"
+                                  || ap.get_ygrid () == "off"
+                                  || ap.get_zgrid () == "off")
+                                 ? "on" : "off");
 
-          ColumnVector p0 = ap.pixel2coord (pt.x (), pt.y ());
-          Matrix xlim = ap.get_xlim ().matrix_value ();
-          Matrix ylim = ap.get_ylim ().matrix_value ();
+            ap.set_xgrid (state);
+            ap.set_ygrid (state);
+            ap.set_zgrid (state);
 
-          if (xlim(0) < p0(0) && xlim(1) > p0(0)
-              && ylim(0) < p0(1) && ylim(1) > p0(1))
-            {
-              axesObj = *it;
-              return;
-            }
-        }
-    }
-  else if (! currentObj)
-    {
-      for (QList<graphics_object>::ConstIterator it = axesList.begin ();
-           it != axesList.end (); ++it)
-        {
-          graphics_object go = selectFromAxes (*it, event->pos ());
+            redraw (true);
+          }
+      }
+  }
+
+  static void
+  autoscale_axes (axes::properties& ap)
+  {
+    ap.clear_zoom_stack ();
 
-          if (go)
-            {
-              currentObj = go;
-              axesObj = *it;
-            }
-          // FIXME: is this really necessary? the axes object should
-          //        have been selected through selectFromAxes anyway
-          else if (it->get_properties ().is_hittest ())
-            {
-              Matrix bb = it->get_properties ().get_boundingbox (true);
-              QRectF r (bb(0), bb(1), bb(2), bb(3));
+    ap.set_xlimmode ("auto");
+    ap.set_ylimmode ("auto");
+    ap.set_zlimmode ("auto");
+  }
+
+  void
+  Canvas::canvasAutoAxes (const graphics_handle& handle)
+  {
+    gh_manager::auto_lock lock;
 
-#if defined (HAVE_QT4)
-              bool rect_contains_pos = r.contains (event->posF ());
-#else
-              bool rect_contains_pos = r.contains (event->localPos ());
-#endif
-              if (rect_contains_pos)
-                axesObj = *it;
-            }
+    graphics_object go = gh_manager::get_object (handle);
+
+    if (go.valid_object ())
+      {
+        figure::properties& fp = Utils::properties<figure> (go);
 
-          if (axesObj && currentObj)
-            break;
-        }
-    }
-}
+        graphics_handle ah = fp.get_currentaxes ();
 
-void
-Canvas::canvasMouseMoveEvent (QMouseEvent* event)
-{
-  gh_manager::auto_lock lock;
-  graphics_object ax = gh_manager::get_object (m_mouseAxes);
+        graphics_object ax = gh_manager::get_object (ah);
 
-  if (m_mouseMode != NoMode && (ax.valid_object () || m_mouseMode == TextMode))
-    {
-      switch (m_mouseMode)
-        {
-        case RotateMode:
+        if (ax.valid_object ())
           {
             axes::properties& ap = Utils::properties<axes> (ax);
 
-            ap.rotate3d (m_mouseCurrent.x (), event->x (),
-                         m_mouseCurrent.y (), event->y ());
+            autoscale_axes (ap);
 
-            // Update current mouse position
-            m_mouseCurrent = event->pos ();
-
-            // Force immediate redraw
             redraw (true);
           }
-          break;
-        case TextMode:
-        case ZoomInMode:
-        case ZoomOutMode:
-          m_mouseCurrent = event->pos ();
-          redraw (true);
-          break;
+      }
+  }
+
+  void
+  Canvas::canvasPaintEvent (void)
+  {
+    if (! m_redrawBlocked)
+      {
+        gh_manager::auto_lock lock;
+
+        draw (m_handle);
+
+        if ((m_mouseMode == ZoomInMode && m_mouseAxes.ok ()) || m_rectMode)
+          drawZoomBox (m_mouseAnchor, m_mouseCurrent);
+      }
+  }
+
+  static bool
+  pan_enabled (const graphics_object figObj)
+  {
+    // Getting pan mode property:
+    octave_value ov_pm
+      = Utils::properties<figure> (figObj).get___pan_mode__ ();
+
+    octave_scalar_map pm = ov_pm.scalar_map_value ();
+
+    return pm.contents ("Enable").string_value () == "on";
+  }
+
+  static std::string
+  pan_mode (const graphics_object figObj)
+  {
+    // Getting pan mode property:
+    octave_value ov_pm
+      = Utils::properties<figure> (figObj).get___pan_mode__ ();
+
+    octave_scalar_map pm = ov_pm.scalar_map_value ();
+
+    return pm.contents ("Motion").string_value ();
+  }
+
+  static bool
+  zoom_enabled (const graphics_object figObj)
+  {
+    // Getting zoom mode property:
+    octave_value ov_zm
+      = Utils::properties<figure> (figObj).get___zoom_mode__ ();
+
+    octave_scalar_map zm = ov_zm.scalar_map_value ();
+
+    return zm.contents ("Enable").string_value () == "on";
+  }
+
+  static std::string
+  zoom_mode (const graphics_object figObj)
+  {
+    // Getting zoom mode property:
+    octave_value ov_zm
+      = Utils::properties<figure> (figObj).get___zoom_mode__ ();
+
+    octave_scalar_map zm = ov_zm.scalar_map_value ();
+
+    return zm.contents ("Motion").string_value ();
+  }
+
+  void
+  Canvas::select_object (graphics_object obj, QMouseEvent* event,
+                         graphics_object &currentObj, graphics_object &axesObj,
+                         bool axes_only)
+  {
+    QList<graphics_object> axesList;
+    Matrix children = obj.get_properties ().get_all_children ();
+    octave_idx_type num_children = children.numel ();
 
-        case PanMode:
+    for (int i = 0; i < num_children; i++)
+      {
+        graphics_object childObj (gh_manager::get_object (children(i)));
+
+        if (childObj.isa ("axes"))
+          axesList.append (childObj);
+        else if (childObj.isa ("uicontrol") || childObj.isa ("uipanel")
+                 || childObj.isa ("uibuttongroup"))
+          {
+            Matrix bb = childObj.get_properties ().get_boundingbox (false);
+            QRectF r (bb(0), bb(1), bb(2), bb(3));
+
+            r.adjust (-5, -5, 5, 5);
+
+#if (HAVE_QT4)
+            bool rect_contains_pos = r.contains (event->posF ());
+#else
+            bool rect_contains_pos = r.contains (event->localPos ());
+#endif
+            if (rect_contains_pos)
+              {
+                currentObj = childObj;
+                break;
+              }
+          }
+      }
+
+    if (axes_only)
+      {
+        QPoint pt = event->pos ();
+
+        for (QList<graphics_object>::ConstIterator it = axesList.begin ();
+             it != axesList.end (); ++it)
           {
-            axes::properties& ap = Utils::properties<axes> (ax);
+            const axes::properties& ap =
+              dynamic_cast<const axes::properties&> ((*it).get_properties ());
+
+            ColumnVector p0 = ap.pixel2coord (pt.x (), pt.y ());
+            Matrix xlim = ap.get_xlim ().matrix_value ();
+            Matrix ylim = ap.get_ylim ().matrix_value ();
 
-            graphics_object figObj (ax.get_ancestor ("figure"));
+            if (xlim(0) < p0(0) && xlim(1) > p0(0)
+                && ylim(0) < p0(1) && ylim(1) > p0(1))
+              {
+                axesObj = *it;
+                return;
+              }
+          }
+      }
+    else if (! currentObj)
+      {
+        for (QList<graphics_object>::ConstIterator it = axesList.begin ();
+             it != axesList.end (); ++it)
+          {
+            graphics_object go = selectFromAxes (*it, event->pos ());
+
+            if (go)
+              {
+                currentObj = go;
+                axesObj = *it;
+              }
+            // FIXME: is this really necessary? the axes object should
+            //        have been selected through selectFromAxes anyway
+            else if (it->get_properties ().is_hittest ())
+              {
+                Matrix bb = it->get_properties ().get_boundingbox (true);
+                QRectF r (bb(0), bb(1), bb(2), bb(3));
+
+#if defined (HAVE_QT4)
+                bool rect_contains_pos = r.contains (event->posF ());
+#else
+                bool rect_contains_pos = r.contains (event->localPos ());
+#endif
+                if (rect_contains_pos)
+                  axesObj = *it;
+              }
 
-            std::string mode = pan_mode (figObj);
+            if (axesObj && currentObj)
+              break;
+          }
+      }
+  }
+
+  void
+  Canvas::canvasMouseMoveEvent (QMouseEvent* event)
+  {
+    gh_manager::auto_lock lock;
+    graphics_object ax = gh_manager::get_object (m_mouseAxes);
+
+    if (m_mouseMode != NoMode && (ax.valid_object () || m_mouseMode == TextMode))
+      {
+        switch (m_mouseMode)
+          {
+          case RotateMode:
+            {
+              axes::properties& ap = Utils::properties<axes> (ax);
+
+              ap.rotate3d (m_mouseCurrent.x (), event->x (),
+                           m_mouseCurrent.y (), event->y ());
+
+              // Update current mouse position
+              m_mouseCurrent = event->pos ();
+
+              // Force immediate redraw
+              redraw (true);
+            }
+            break;
+          case TextMode:
+          case ZoomInMode:
+          case ZoomOutMode:
+            m_mouseCurrent = event->pos ();
+            redraw (true);
+            break;
 
-            ColumnVector p0 = ap.pixel2coord (m_mouseCurrent.x (),
-                                              m_mouseCurrent.y ());
-            ColumnVector p1 = ap.pixel2coord (event->x (),
-                                              event->y ());
+          case PanMode:
+            {
+              axes::properties& ap = Utils::properties<axes> (ax);
+
+              graphics_object figObj (ax.get_ancestor ("figure"));
+
+              std::string mode = pan_mode (figObj);
+
+              ColumnVector p0 = ap.pixel2coord (m_mouseCurrent.x (),
+                                                m_mouseCurrent.y ());
+              ColumnVector p1 = ap.pixel2coord (event->x (),
+                                                event->y ());
+
+              ap.translate_view (mode, p0(0), p1(0), p0(1), p1(1));
+
+              // Update current mouse position
+              m_mouseCurrent = event->pos ();
+
+              // Force immediate redraw
+              redraw (true);
+            }
+
+          default:
+            break;
+          }
+      }
+    else if (m_mouseMode == NoMode)
+      {
+        graphics_object obj = gh_manager::get_object (m_handle);
+
+        if (obj.valid_object ())
+          {
+            graphics_object figObj (obj.get_ancestor ("figure"));
+
+            if (figObj.valid_object () &&
+                ! figObj.get ("windowbuttonmotionfcn").is_empty ())
+              {
+                updateCurrentPoint (figObj, obj, event);
+                gh_manager::post_callback (figObj.get_handle (),
+                                           "windowbuttonmotionfcn");
+              }
+          }
+      }
 
-            ap.translate_view (mode, p0(0), p1(0), p0(1), p1(1));
+    // Update mouse coordinates in the figure window status bar
+    graphics_object obj = gh_manager::get_object (m_handle);
+    graphics_object figObj = obj.get_ancestor ("figure");
+
+    if (figObj.valid_object () && obj.valid_object ())
+      {
+        graphics_object currentObj, axesObj;
+        select_object (obj, event, currentObj, axesObj, true);
+
+        if (axesObj.valid_object ())
+          {
+            // FIXME: should we use signal/slot mechanism instead of
+            //        directly calling parent fig methods
+            Figure* fig =
+              dynamic_cast<Figure*> (Backend::toolkitObject (figObj));
+            axes::properties& ap = Utils::properties<axes> (axesObj);
+
+            if (fig)
+              fig->updateStatusBar (ap.pixel2coord (event->x (), event->y ()));
+          }
+      }
+  }
+
+  void
+  Canvas::canvasMouseDoubleClickEvent (QMouseEvent* event)
+  {
+    // same processing as normal click, but event type is MouseButtonDblClick
+    canvasMousePressEvent (event);
+  }
+
+  static double
+  button_number (QMouseEvent *event)
+  {
+    double retval = 0;
 
-            // Update current mouse position
-            m_mouseCurrent = event->pos ();
+    switch (event->button ())
+      {
+      case Qt::LeftButton:
+        retval = 1;
+        break;
+
+      case Qt::MidButton:
+        retval = 2;
+        break;
+
+      case Qt::RightButton:
+        retval = 3;
+        break;
+
+      default:
+        break;
+      }
+
+    return retval;
+  }
 
-            // Force immediate redraw
-            redraw (true);
+  void
+  Canvas::canvasMousePressEvent (QMouseEvent* event)
+  {
+    gh_manager::auto_lock lock;
+    graphics_object obj = gh_manager::get_object (m_handle);
+
+    bool isdblclick = (event->type () == QEvent::MouseButtonDblClick);
+
+    if (obj.valid_object ())
+      {
+        graphics_object figObj (obj.get_ancestor ("figure"));
+        graphics_object currentObj, axesObj;
+
+        select_object (obj, event, currentObj, axesObj);
+
+        if (axesObj)
+          {
+            if (axesObj.get_properties ().handlevisibility_is ("on")
+                && axesObj.get_properties ().get_tag () != "legend"
+                && axesObj.get_properties ().get_tag () != "colorbar")
+              Utils::properties<figure> (figObj)
+              .set_currentaxes (axesObj.get_handle ().as_octave_value ());
+            if (! currentObj)
+              currentObj = axesObj;
           }
 
-        default:
-          break;
-        }
-    }
-  else if (m_mouseMode == NoMode)
-    {
-      graphics_object obj = gh_manager::get_object (m_handle);
-
-      if (obj.valid_object ())
-        {
-          graphics_object figObj (obj.get_ancestor ("figure"));
-
-          if (figObj.valid_object () &&
-              ! figObj.get ("windowbuttonmotionfcn").is_empty ())
-            {
-              updateCurrentPoint (figObj, obj, event);
-              gh_manager::post_callback (figObj.get_handle (),
-                                         "windowbuttonmotionfcn");
-            }
-        }
-    }
-
-  // Update mouse coordinates in the figure window status bar
-  graphics_object obj = gh_manager::get_object (m_handle);
-  graphics_object figObj = obj.get_ancestor ("figure");
-
-  if (figObj.valid_object () && obj.valid_object ())
-    {
-      graphics_object currentObj, axesObj;
-      select_object (obj, event, currentObj, axesObj, true);
+        if (! currentObj)
+          currentObj = obj;
 
-      if (axesObj.valid_object ())
-        {
-          // FIXME: should we use signal/slot mechanism instead of
-          //        directly calling parent fig methods
-          Figure* fig =
-            dynamic_cast<Figure*> (Backend::toolkitObject (figObj));
-          axes::properties& ap = Utils::properties<axes> (axesObj);
-
-          if (fig)
-            fig->updateStatusBar (ap.pixel2coord (event->x (), event->y ()));
-        }
-    }
-}
+        if (currentObj.get_properties ().handlevisibility_is ("on"))
+          Utils::properties<figure> (figObj)
+          .set_currentobject (currentObj.get_handle ().as_octave_value ());
+        else
+          Utils::properties<figure> (figObj).set_currentobject (
+            octave::numeric_limits<double>::NaN ());
 
-void
-Canvas::canvasMouseDoubleClickEvent (QMouseEvent* event)
-{
-  // same processing as normal click, but event type is MouseButtonDblClick
-  canvasMousePressEvent (event);
-}
-
-static double
-button_number (QMouseEvent *event)
-{
-  double retval = 0;
+        Figure* fig = dynamic_cast<Figure*> (Backend::toolkitObject (figObj));
 
-  switch (event->button ())
-    {
-    case Qt::LeftButton:
-      retval = 1;
-      break;
-
-    case Qt::MidButton:
-      retval = 2;
-      break;
-
-    case Qt::RightButton:
-      retval = 3;
-      break;
+        MouseMode newMouseMode = NoMode;
 
-    default:
-      break;
-    }
-
-  return retval;
-}
-
-void
-Canvas::canvasMousePressEvent (QMouseEvent* event)
-{
-  gh_manager::auto_lock lock;
-  graphics_object obj = gh_manager::get_object (m_handle);
-
-  bool isdblclick = (event->type () == QEvent::MouseButtonDblClick);
-
-  if (obj.valid_object ())
-    {
-      graphics_object figObj (obj.get_ancestor ("figure"));
-      graphics_object currentObj, axesObj;
-
-      select_object (obj, event, currentObj, axesObj);
-
-      if (axesObj)
-        {
-              if (axesObj.get_properties ().handlevisibility_is ("on")
-                  && axesObj.get_properties ().get_tag () != "legend"
-                  && axesObj.get_properties ().get_tag () != "colorbar")
-            Utils::properties<figure> (figObj)
-              .set_currentaxes (axesObj.get_handle ().as_octave_value ());
-          if (! currentObj)
-            currentObj = axesObj;
-        }
-
-      if (! currentObj)
-        currentObj = obj;
+        if (fig)
+          newMouseMode = fig->mouseMode ();
 
-      if (currentObj.get_properties ().handlevisibility_is ("on"))
-        Utils::properties<figure> (figObj)
-          .set_currentobject (currentObj.get_handle ().as_octave_value ());
-      else
-        Utils::properties<figure> (figObj).set_currentobject (octave::numeric_limits<double>::NaN ());
-
-      Figure* fig = dynamic_cast<Figure*> (Backend::toolkitObject (figObj));
-
-      MouseMode newMouseMode = NoMode;
-
-      if (fig)
-        newMouseMode = fig->mouseMode ();
-
-      switch (newMouseMode)
-        {
-        case NoMode:
-          gh_manager::post_set (figObj.get_handle (), "selectiontype",
-                                Utils::figureSelectionType (event, isdblclick), false);
+        switch (newMouseMode)
+          {
+          case NoMode:
+            gh_manager::post_set (figObj.get_handle (), "selectiontype",
+                                  Utils::figureSelectionType (event, isdblclick), false);
 
-          updateCurrentPoint (figObj, obj, event);
-
-          gh_manager::post_callback (figObj.get_handle (),
-                                     "windowbuttondownfcn",
-                                     button_number (event));
+            updateCurrentPoint (figObj, obj, event);
 
-          if (currentObj.get ("buttondownfcn").is_empty ())
-            {
-              graphics_object parentObj =
-                gh_manager::get_object (currentObj.get_parent ());
-
-              if (parentObj.valid_object () && parentObj.isa ("hggroup"))
-                gh_manager::post_callback (parentObj.get_handle (),
-                                           "buttondownfcn",
-                                           button_number (event));
-            }
-          else
-            gh_manager::post_callback (currentObj.get_handle (),
-                                       "buttondownfcn",
+            gh_manager::post_callback (figObj.get_handle (),
+                                       "windowbuttondownfcn",
                                        button_number (event));
 
-          if (event->button () == Qt::RightButton)
-            ContextMenu::executeAt (currentObj.get_properties (),
-                                    event->globalPos ());
-          break;
-
-        case TextMode:
-          {
-            if (event->modifiers () == Qt::NoModifier)
+            if (currentObj.get ("buttondownfcn").is_empty ())
               {
-                switch (event->buttons ())
-                  {
-                  case Qt::LeftButton:
-                    m_mouseAnchor = m_mouseCurrent = event->pos ();
-                    m_mouseMode = newMouseMode;
-                    m_rectMode = true;
-                  }
-              }
-            redraw (false);
-          }
-          break;
+                graphics_object parentObj =
+                  gh_manager::get_object (currentObj.get_parent ());
 
-        case PanMode:
-        case RotateMode:
-        case ZoomInMode:
-        case ZoomOutMode:
-          if (axesObj && axesObj.get_properties ().handlevisibility_is ("on"))
-            {
-              bool redraw_figure = true;
+                if (parentObj.valid_object () && parentObj.isa ("hggroup"))
+                  gh_manager::post_callback (parentObj.get_handle (),
+                                             "buttondownfcn",
+                                             button_number (event));
+              }
+            else
+              gh_manager::post_callback (currentObj.get_handle (),
+                                         "buttondownfcn",
+                                         button_number (event));
 
-              if (isdblclick)
-                {
-                  if (event->button () == Qt::LeftButton)
-                    {
-                      axes::properties& ap = Utils::properties<axes> (axesObj);
+            if (event->button () == Qt::RightButton)
+              ContextMenu::executeAt (currentObj.get_properties (),
+                                      event->globalPos ());
+            break;
 
-                      autoscale_axes (ap);
-                    }
-                  else
-                    {
-                      redraw_figure = false;
-                    }
-                }
-              else if (event->modifiers () == Qt::NoModifier)
+          case TextMode:
+            {
+              if (event->modifiers () == Qt::NoModifier)
                 {
                   switch (event->buttons ())
                     {
                     case Qt::LeftButton:
                       m_mouseAnchor = m_mouseCurrent = event->pos ();
-                      m_mouseAxes = axesObj.get_handle ();
                       m_mouseMode = newMouseMode;
-                      m_clickMode = newMouseMode == ZoomInMode;
-                      break;
+                      m_rectMode = true;
+                    }
+                }
+              redraw (false);
+            }
+            break;
+
+          case PanMode:
+          case RotateMode:
+          case ZoomInMode:
+          case ZoomOutMode:
+            if (axesObj && axesObj.get_properties ().handlevisibility_is ("on"))
+              {
+                bool redraw_figure = true;
+
+                if (isdblclick)
+                  {
+                    if (event->button () == Qt::LeftButton)
+                      {
+                        axes::properties& ap = Utils::properties<axes> (axesObj);
 
-                    case Qt::RightButton:
-                      if (newMouseMode == ZoomInMode)
-                        {
-                          m_mouseAnchor = m_mouseCurrent = event->pos ();
-                          m_mouseAxes = axesObj.get_handle ();
-                          m_mouseMode = newMouseMode;
-                          m_clickMode = false;
-                        }
+                        autoscale_axes (ap);
+                      }
+                    else
+                      {
+                        redraw_figure = false;
+                      }
+                  }
+                else if (event->modifiers () == Qt::NoModifier)
+                  {
+                    switch (event->buttons ())
+                      {
+                      case Qt::LeftButton:
+                        m_mouseAnchor = m_mouseCurrent = event->pos ();
+                        m_mouseAxes = axesObj.get_handle ();
+                        m_mouseMode = newMouseMode;
+                        m_clickMode = newMouseMode == ZoomInMode;
+                        break;
 
-                      break;
+                      case Qt::RightButton:
+                        if (newMouseMode == ZoomInMode)
+                          {
+                            m_mouseAnchor = m_mouseCurrent = event->pos ();
+                            m_mouseAxes = axesObj.get_handle ();
+                            m_mouseMode = newMouseMode;
+                            m_clickMode = false;
+                          }
 
-                    case Qt::MidButton:
+                        break;
+
+                      case Qt::MidButton:
                         {
                           axes::properties& ap =
                             Utils::properties<axes> (axesObj);
 
                           autoscale_axes (ap);
                         }
-                      break;
+                        break;
 
-                    default:
-                      redraw_figure = false;
-                      break;
-                    }
-                }
-              else if (event->modifiers () == Qt::ShiftModifier)
-                {
-                  switch (event->buttons ())
-                    {
-                    case Qt::LeftButton:
-                      if (newMouseMode == ZoomInMode)
-                        {
-                          m_mouseAnchor = m_mouseCurrent = event->pos ();
-                          m_mouseAxes = axesObj.get_handle ();
-                          m_mouseMode = newMouseMode;
-                          m_clickMode = false;
-                        }
-                      break;
+                      default:
+                        redraw_figure = false;
+                        break;
+                      }
+                  }
+                else if (event->modifiers () == Qt::ShiftModifier)
+                  {
+                    switch (event->buttons ())
+                      {
+                      case Qt::LeftButton:
+                        if (newMouseMode == ZoomInMode)
+                          {
+                            m_mouseAnchor = m_mouseCurrent = event->pos ();
+                            m_mouseAxes = axesObj.get_handle ();
+                            m_mouseMode = newMouseMode;
+                            m_clickMode = false;
+                          }
+                        break;
 
-                    default:
-                      redraw_figure = false;
-                      break;
-                    }
-                }
+                      default:
+                        redraw_figure = false;
+                        break;
+                      }
+                  }
 
-              if (redraw_figure)
-                redraw (false);
-            }
-          break;
+                if (redraw_figure)
+                  redraw (false);
+              }
+            break;
 
-        default:
-          break;
-        }
-    }
+          default:
+            break;
+          }
+      }
 
-}
+  }
 
-void
-Canvas::canvasMouseReleaseEvent (QMouseEvent* event)
-{
-  if ((m_mouseMode == ZoomInMode || m_mouseMode == ZoomOutMode)
-      && m_mouseAxes.ok ())
-    {
-      gh_manager::auto_lock lock;
-      graphics_object ax = gh_manager::get_object (m_mouseAxes);
+  void
+  Canvas::canvasMouseReleaseEvent (QMouseEvent* event)
+  {
+    if ((m_mouseMode == ZoomInMode || m_mouseMode == ZoomOutMode)
+        && m_mouseAxes.ok ())
+      {
+        gh_manager::auto_lock lock;
+        graphics_object ax = gh_manager::get_object (m_mouseAxes);
 
-      if (ax.valid_object ())
-        {
-          axes::properties& ap = Utils::properties<axes> (ax);
+        if (ax.valid_object ())
+          {
+            axes::properties& ap = Utils::properties<axes> (ax);
 
-          graphics_object obj = gh_manager::get_object (m_handle);
+            graphics_object obj = gh_manager::get_object (m_handle);
 
-          graphics_object figObj (obj.get_ancestor ("figure"));
+            graphics_object figObj (obj.get_ancestor ("figure"));
 
-          std::string zm = zoom_mode (figObj);
+            std::string zm = zoom_mode (figObj);
 
-          if (m_mouseAnchor == event->pos ())
-            {
-              double factor = m_clickMode ? 2.0 : 0.5;
+            if (m_mouseAnchor == event->pos ())
+              {
+                double factor = m_clickMode ? 2.0 : 0.5;
 
-              ColumnVector p1 = ap.pixel2coord (event->x (), event->y ());
+                ColumnVector p1 = ap.pixel2coord (event->x (), event->y ());
 
-              ap.zoom_about_point (zm, p1(0), p1(1), factor);
-            }
-          else if (m_mouseMode == ZoomInMode)
-            {
-              ColumnVector p0 = ap.pixel2coord (m_mouseAnchor.x (),
-                                                m_mouseAnchor.y ());
-              ColumnVector p1 = ap.pixel2coord (event->x (),
-                                                event->y ());
+                ap.zoom_about_point (zm, p1(0), p1(1), factor);
+              }
+            else if (m_mouseMode == ZoomInMode)
+              {
+                ColumnVector p0 = ap.pixel2coord (m_mouseAnchor.x (),
+                                                  m_mouseAnchor.y ());
+                ColumnVector p1 = ap.pixel2coord (event->x (),
+                                                  event->y ());
 
-              Matrix xl (1, 2, 0.0);
-              Matrix yl (1, 2, 0.0);
+                Matrix xl (1, 2, 0.0);
+                Matrix yl (1, 2, 0.0);
 
-              xl(0) = std::min (p0(0), p1(0));
-              xl(1) = std::max (p0(0), p1(0));
-              yl(0) = std::min (p0(1), p1(1));
-              yl(1) = std::max (p0(1), p1(1));
+                xl(0) = std::min (p0(0), p1(0));
+                xl(1) = std::max (p0(0), p1(0));
+                yl(0) = std::min (p0(1), p1(1));
+                yl(1) = std::max (p0(1), p1(1));
 
-              ap.zoom (zm, xl, yl);
-            }
+                ap.zoom (zm, xl, yl);
+              }
 
-          redraw (false);
-        }
-    }
-  else if (m_mouseMode == NoMode)
-    {
-      gh_manager::auto_lock lock;
-      graphics_object obj = gh_manager::get_object (m_handle);
+            redraw (false);
+          }
+      }
+    else if (m_mouseMode == NoMode)
+      {
+        gh_manager::auto_lock lock;
+        graphics_object obj = gh_manager::get_object (m_handle);
 
-      if (obj.valid_object ())
-        {
-          graphics_object figObj (obj.get_ancestor ("figure"));
+        if (obj.valid_object ())
+          {
+            graphics_object figObj (obj.get_ancestor ("figure"));
 
-          updateCurrentPoint (figObj, obj, event);
-          gh_manager::post_callback (figObj.get_handle (),
-                                     "windowbuttonupfcn");
-        }
-    }
-  else if (m_mouseMode == TextMode)
-    {
-      gh_manager::auto_lock lock;
+            updateCurrentPoint (figObj, obj, event);
+            gh_manager::post_callback (figObj.get_handle (),
+                                       "windowbuttonupfcn");
+          }
+      }
+    else if (m_mouseMode == TextMode)
+      {
+        gh_manager::auto_lock lock;
 
-      graphics_object figObj =
-        gh_manager::get_object (m_handle).get_ancestor ("figure");
-      if (figObj.valid_object ())
-        {
-          QWidget *w = qWidget ();
-          if (w)
-            {
-              Matrix bb = figObj.get ("position").matrix_value ();
-              bb(0) = m_mouseAnchor.x () / bb(2);
-              bb(1) = 1.0 - (m_mouseAnchor.y () / bb(3));
-              bb(2) = (event->x () - m_mouseAnchor.x ()) / bb(2);
-              bb(3) = (m_mouseAnchor.y () - event->y ()) / bb(3);
+        graphics_object figObj =
+          gh_manager::get_object (m_handle).get_ancestor ("figure");
+        if (figObj.valid_object ())
+          {
+            QWidget *w = qWidget ();
+            if (w)
+              {
+                Matrix bb = figObj.get ("position").matrix_value ();
+                bb(0) = m_mouseAnchor.x () / bb(2);
+                bb(1) = 1.0 - (m_mouseAnchor.y () / bb(3));
+                bb(2) = (event->x () - m_mouseAnchor.x ()) / bb(2);
+                bb(3) = (m_mouseAnchor.y () - event->y ()) / bb(3);
 
-              octave_value_list props = ovl ("textbox", bb);
+                octave_value_list props = ovl ("textbox", bb);
 
-              annotation_dialog anno_dlg (w, props);
+                annotation_dialog anno_dlg (w, props);
 
-              if (anno_dlg.exec () == QDialog::Accepted)
-                {
-                  props = anno_dlg.get_properties ();
-                  props.prepend (figObj.get_handle ().as_octave_value ());
+                if (anno_dlg.exec () == QDialog::Accepted)
+                  {
+                    props = anno_dlg.get_properties ();
+                    props.prepend (figObj.get_handle ().as_octave_value ());
 
-                  octave_link::post_event (this, &Canvas::annotation_callback,
-                                           props);
-                }
-            }
-        }
-    }
-  m_rectMode = false;
-  m_mouseAxes = graphics_handle ();
-  m_mouseMode = NoMode;
-}
+                    octave_link::post_event (this, &Canvas::annotation_callback,
+                                             props);
+                  }
+              }
+          }
+      }
+    m_rectMode = false;
+    m_mouseAxes = graphics_handle ();
+    m_mouseMode = NoMode;
+  }
 
-void
-Canvas::canvasWheelEvent (QWheelEvent* event)
-{
-  gh_manager::auto_lock lock;
-  graphics_object obj = gh_manager::get_object (m_handle);
+  void
+  Canvas::canvasWheelEvent (QWheelEvent* event)
+  {
+    gh_manager::auto_lock lock;
+    graphics_object obj = gh_manager::get_object (m_handle);
 
-  if (obj.valid_object ())
-    {
-      std::string mode;
+    if (obj.valid_object ())
+      {
+        std::string mode;
 
-      graphics_object axesObj;
+        graphics_object axesObj;
 
-      Matrix children = obj.get_properties ().get_children ();
-      octave_idx_type num_children = children.numel ();
+        Matrix children = obj.get_properties ().get_children ();
+        octave_idx_type num_children = children.numel ();
 
-      for (int i = 0; i < num_children; i++)
-        {
-          graphics_object childObj (gh_manager::get_object (children(i)));
+        for (int i = 0; i < num_children; i++)
+          {
+            graphics_object childObj (gh_manager::get_object (children(i)));
 
-          if (childObj.isa ("axes"))
-            {
-              graphics_object go = selectFromAxes (childObj, event->pos ());
+            if (childObj.isa ("axes"))
+              {
+                graphics_object go = selectFromAxes (childObj, event->pos ());
 
-              if (go)
-                {
-                  axesObj = childObj;
-                  break;
-                }
-            }
-        }
+                if (go)
+                  {
+                    axesObj = childObj;
+                    break;
+                  }
+              }
+          }
 
-      if (axesObj)
-        {
-          MouseMode newMouseMode = NoMode;
+        if (axesObj)
+          {
+            MouseMode newMouseMode = NoMode;
 
-          graphics_object figObj (obj.get_ancestor ("figure"));
+            graphics_object figObj (obj.get_ancestor ("figure"));
 
-          Figure* fig = dynamic_cast<Figure*> (Backend::toolkitObject (figObj));
+            Figure* fig = dynamic_cast<Figure*> (Backend::toolkitObject (figObj));
 
-          if (fig)
-            newMouseMode = fig->mouseMode ();
+            if (fig)
+              newMouseMode = fig->mouseMode ();
 
-          if (axesObj.get_properties ().handlevisibility_is ("on"))
-            {
-              Utils::properties<figure> (figObj)
+            if (axesObj.get_properties ().handlevisibility_is ("on"))
+              {
+                Utils::properties<figure> (figObj)
                 .set_currentaxes (axesObj.get_handle ().as_octave_value ());
 
-              if (zoom_enabled (figObj))
-                {
-                  if (event->delta () > 0)
-                    newMouseMode = ZoomInMode;
-                  else
-                    newMouseMode = ZoomOutMode;
+                if (zoom_enabled (figObj))
+                  {
+                    if (event->delta () > 0)
+                      newMouseMode = ZoomInMode;
+                    else
+                      newMouseMode = ZoomOutMode;
 
-                  mode = zoom_mode (figObj);
-                }
-              else if (pan_enabled (figObj))
-                {
-                  newMouseMode = PanMode;
+                    mode = zoom_mode (figObj);
+                  }
+                else if (pan_enabled (figObj))
+                  {
+                    newMouseMode = PanMode;
 
-                  mode = pan_mode (figObj);
-                }
-            }
+                    mode = pan_mode (figObj);
+                  }
+              }
 
-          bool redrawFigure = true;
+            bool redrawFigure = true;
 
-          switch (newMouseMode)
-            {
-            case ZoomInMode:
-            case ZoomOutMode:
+            switch (newMouseMode)
               {
-                axes::properties& ap = Utils::properties<axes> (axesObj);
+              case ZoomInMode:
+              case ZoomOutMode:
+                {
+                  axes::properties& ap = Utils::properties<axes> (axesObj);
 
-                // Control how fast to zoom when using scroll wheel.
-                double wheel_zoom_speed = ap.get_mousewheelzoom ();
+                  // Control how fast to zoom when using scroll wheel.
+                  double wheel_zoom_speed = ap.get_mousewheelzoom ();
 
-                // Determine if we're zooming in or out.
-                double factor = (newMouseMode == ZoomInMode
-                                 ? 1 / (1.0 - wheel_zoom_speed)
-                                 : 1.0 - wheel_zoom_speed);
+                  // Determine if we're zooming in or out.
+                  double factor = (newMouseMode == ZoomInMode
+                                   ? 1 / (1.0 - wheel_zoom_speed)
+                                   : 1.0 - wheel_zoom_speed);
 
-                // FIXME: should we zoom about point for 2D plots?
+                  // FIXME: should we zoom about point for 2D plots?
 
-                ap.zoom (mode, factor);
-              }
-              break;
+                  ap.zoom (mode, factor);
+                }
+                break;
 
-            case PanMode:
-              {
-                axes::properties& ap = Utils::properties<axes> (axesObj);
+              case PanMode:
+                {
+                  axes::properties& ap = Utils::properties<axes> (axesObj);
 
-                double factor = event->delta () > 0 ? 0.1 : -0.1;
+                  double factor = event->delta () > 0 ? 0.1 : -0.1;
 
-                ap.pan (mode, factor);
-              }
-              break;
+                  ap.pan (mode, factor);
+                }
+                break;
 
-            default:
-              redrawFigure = false;
-              break;
-            }
+              default:
+                redrawFigure = false;
+                break;
+              }
 
-          if (redrawFigure)
-            redraw (false);
-        }
-    }
-}
+            if (redrawFigure)
+              redraw (false);
+          }
+      }
+  }
 
-bool
-Canvas::canvasKeyPressEvent (QKeyEvent* event)
-{
-  if (m_eventMask & KeyPress)
-    {
-      gh_manager::auto_lock lock;
-      graphics_object obj = gh_manager::get_object (m_handle);
+  bool
+  Canvas::canvasKeyPressEvent (QKeyEvent* event)
+  {
+    if (m_eventMask & KeyPress)
+      {
+        gh_manager::auto_lock lock;
+        graphics_object obj = gh_manager::get_object (m_handle);
 
-      if (obj.valid_object ())
-        {
-          graphics_object figObj (obj.get_ancestor ("figure"));
+        if (obj.valid_object ())
+          {
+            graphics_object figObj (obj.get_ancestor ("figure"));
 
-          updateCurrentPoint (figObj, obj);
-        }
+            updateCurrentPoint (figObj, obj);
+          }
 
-      octave_scalar_map eventData = Utils::makeKeyEventStruct (event);
+        octave_scalar_map eventData = Utils::makeKeyEventStruct (event);
 
-      gh_manager::post_set (m_handle, "currentcharacter",
-                            eventData.getfield ("Character"), false);
-      gh_manager::post_callback (m_handle, "keypressfcn", eventData);
+        gh_manager::post_set (m_handle, "currentcharacter",
+                              eventData.getfield ("Character"), false);
+        gh_manager::post_callback (m_handle, "keypressfcn", eventData);
 
-      return true;
-    }
+        return true;
+      }
 
-  return false;
-}
+    return false;
+  }
 
-bool
-Canvas::canvasKeyReleaseEvent (QKeyEvent* event)
-{
-  if (! event->isAutoRepeat () && (m_eventMask & KeyRelease))
-    {
-      gh_manager::post_callback (m_handle, "keyreleasefcn",
-                                 Utils::makeKeyEventStruct (event));
+  bool
+  Canvas::canvasKeyReleaseEvent (QKeyEvent* event)
+  {
+    if (! event->isAutoRepeat () && (m_eventMask & KeyRelease))
+      {
+        gh_manager::post_callback (m_handle, "keyreleasefcn",
+                                   Utils::makeKeyEventStruct (event));
 
-      return true;
-    }
+        return true;
+      }
 
-  return false;
-}
+    return false;
+  }
 
-Canvas*
-Canvas::create (const std::string& /* name */, QWidget* parent,
-                const graphics_handle& handle)
-{
-  // Only OpenGL
-  return new GLCanvas (parent, handle);
-}
+  Canvas*
+  Canvas::create (const std::string& /* name */, QWidget* parent,
+                  const graphics_handle& handle)
+  {
+    // Only OpenGL
+    return new GLCanvas (parent, handle);
+  }
 
 }; // namespace QtHandles
+