--- a/libgui/graphics/QtHandlesUtils.cc	Wed Aug 31 14:37:33 2016 -0400
+++ b/libgui/graphics/QtHandlesUtils.cc	Wed Aug 31 12:20:46 2016 -0700
@@ -44,345 +44,349 @@
 namespace QtHandles
 {
 
-namespace Utils
-{
+  namespace Utils
+  {
 
-QString
-fromStdString (const std::string& s)
-{
-  return QString::fromLocal8Bit (s.c_str ());
-}
-
-std::string
-toStdString (const QString& s)
-{
-  return std::string (s.toLocal8Bit ().data ());
-}
+    QString
+    fromStdString (const std::string& s)
+    {
+      return QString::fromLocal8Bit (s.c_str ());
+    }
 
-QStringList
-fromStringVector (const string_vector& v)
-{
-  QStringList l;
-  octave_idx_type n = v.numel ();
-
-  for (octave_idx_type i = 0; i < n; i++)
-    l << fromStdString (v[i]);
-
-  return l;
-}
+    std::string
+    toStdString (const QString& s)
+    {
+      return std::string (s.toLocal8Bit ().data ());
+    }
 
-string_vector
-toStringVector (const QStringList& l)
-{
-  string_vector v (l.length ());
-  int i = 0;
+    QStringList
+    fromStringVector (const string_vector& v)
+    {
+      QStringList l;
+      octave_idx_type n = v.numel ();
 
-  foreach (const QString& s, l)
-    v[i++] = toStdString (s);
+      for (octave_idx_type i = 0; i < n; i++)
+        l << fromStdString (v[i]);
 
-  return v;
-}
+      return l;
+    }
 
-Cell toCellString (const QStringList& l)
-{
-  QStringList tmp = l;
-
-  // don't get any empty lines from end of the list
-  while ((tmp.length () > 0) && tmp.last ().isEmpty ())
+    string_vector
+    toStringVector (const QStringList& l)
     {
-      tmp.removeLast ();
+      string_vector v (l.length ());
+      int i = 0;
+
+      foreach (const QString& s, l)
+      v[i++] = toStdString (s);
+
+      return v;
     }
-  // no strings converts to a 1x1 cell with empty string
-  if (tmp.isEmpty ())
-    tmp += "";
-
-  Cell v(toStringVector (tmp));
-  return v;
-}
 
-template <typename T>
-QFont
-computeFont (const typename T::properties& props, int height)
-{
-  QFont f (fromStdString (props.get_fontname ()));
-
-  static std::map<std::string, QFont::Weight> weightMap;
-  static std::map<std::string, QFont::Style> angleMap;
-  static bool mapsInitialized = false;
+    Cell toCellString (const QStringList& l)
+    {
+      QStringList tmp = l;
 
-  if (! mapsInitialized)
-    {
-      weightMap[std::string ("normal")] = QFont::Normal;
-      weightMap[std::string ("light")] = QFont::Light;
-      weightMap[std::string ("demi")] = QFont::DemiBold;
-      weightMap[std::string ("bold")] = QFont::Normal;
+      // don't get any empty lines from end of the list
+      while ((tmp.length () > 0) && tmp.last ().isEmpty ())
+        {
+          tmp.removeLast ();
+        }
+      // no strings converts to a 1x1 cell with empty string
+      if (tmp.isEmpty ())
+        tmp += "";
 
-      angleMap[std::string ("normal")] = QFont::StyleNormal;
-      angleMap[std::string ("italic")] = QFont::StyleItalic;
-      angleMap[std::string ("oblique")] = QFont::StyleOblique;
-
-      mapsInitialized = true;
+      Cell v(toStringVector (tmp));
+      return v;
     }
 
-  f.setPointSizeF (props.get_fontsize_points (height));
-  f.setWeight (weightMap[props.get_fontweight ()]);
-  f.setStyle (angleMap[props.get_fontangle ()]);
+    template <typename T>
+    QFont
+    computeFont (const typename T::properties& props, int height)
+    {
+      QFont f (fromStdString (props.get_fontname ()));
 
-  return f;
-}
+      static std::map<std::string, QFont::Weight> weightMap;
+      static std::map<std::string, QFont::Style> angleMap;
+      static bool mapsInitialized = false;
 
-template QFont computeFont<uicontrol> (const uicontrol::properties& props,
-                                       int height);
+      if (! mapsInitialized)
+        {
+          weightMap[std::string ("normal")] = QFont::Normal;
+          weightMap[std::string ("light")] = QFont::Light;
+          weightMap[std::string ("demi")] = QFont::DemiBold;
+          weightMap[std::string ("bold")] = QFont::Normal;
+
+          angleMap[std::string ("normal")] = QFont::StyleNormal;
+          angleMap[std::string ("italic")] = QFont::StyleItalic;
+          angleMap[std::string ("oblique")] = QFont::StyleOblique;
 
-template QFont computeFont<uipanel> (const uipanel::properties& props,
-                                     int height);
+          mapsInitialized = true;
+        }
 
-template QFont computeFont<uibuttongroup> (const uibuttongroup::properties& props,
+      f.setPointSizeF (props.get_fontsize_points (height));
+      f.setWeight (weightMap[props.get_fontweight ()]);
+      f.setStyle (angleMap[props.get_fontangle ()]);
+
+      return f;
+    }
+
+    template QFont computeFont<uicontrol> (const uicontrol::properties& props,
                                            int height);
-QColor
-fromRgb (const Matrix& rgb)
-{
-  QColor c;
 
-  if (rgb.numel () == 3)
-    c.setRgbF (rgb(0), rgb(1), rgb(2));
+    template QFont computeFont<uipanel> (const uipanel::properties& props,
+                                         int height);
 
-  return c;
-}
+    template QFont computeFont<uibuttongroup> (const uibuttongroup::properties&
+        props,
+        int height);
+    QColor
+    fromRgb (const Matrix& rgb)
+    {
+      QColor c;
 
-Matrix
-toRgb (const QColor& c)
-{
-  Matrix rgb (1, 3);
-  double* rgbData = rgb.fortran_vec ();
+      if (rgb.numel () == 3)
+        c.setRgbF (rgb(0), rgb(1), rgb(2));
 
-  // qreal is a typedef for double except for ARM CPU architectures
-  // where it is a typedef for float (Bug #44970).
-  qreal tmp[3];
-  c.getRgbF (tmp, tmp+1, tmp+2);
-  rgbData[0] = tmp[0]; rgbData[1] = tmp[1]; rgbData[2] = tmp[2];
+      return c;
+    }
 
-  return rgb;
-}
+    Matrix
+    toRgb (const QColor& c)
+    {
+      Matrix rgb (1, 3);
+      double* rgbData = rgb.fortran_vec ();
 
-std::string
-figureSelectionType (QMouseEvent* event, bool isDoubleClick)
-{
-  if (isDoubleClick)
-    return std::string ("open");
-  else
-    {
-      Qt::MouseButtons buttons = event->buttons ();
-      Qt::KeyboardModifiers mods = event->modifiers ();
+      // qreal is a typedef for double except for ARM CPU architectures
+      // where it is a typedef for float (Bug #44970).
+      qreal tmp[3];
+      c.getRgbF (tmp, tmp+1, tmp+2);
+      rgbData[0] = tmp[0]; rgbData[1] = tmp[1]; rgbData[2] = tmp[2];
+
+      return rgb;
+    }
 
-      if (mods == Qt::NoModifier)
+    std::string
+    figureSelectionType (QMouseEvent* event, bool isDoubleClick)
+    {
+      if (isDoubleClick)
+        return std::string ("open");
+      else
         {
-          if (buttons == Qt::LeftButton)
-            return std::string ("normal");
-          else if (buttons == Qt::RightButton)
-            return std::string ("alt");
+          Qt::MouseButtons buttons = event->buttons ();
+          Qt::KeyboardModifiers mods = event->modifiers ();
+
+          if (mods == Qt::NoModifier)
+            {
+              if (buttons == Qt::LeftButton)
+                return std::string ("normal");
+              else if (buttons == Qt::RightButton)
+                return std::string ("alt");
 #if defined (Q_WS_WIN)
-          else if (buttons == (Qt::LeftButton | Qt::RightButton))
-            return std::string ("extend");
+              else if (buttons == (Qt::LeftButton | Qt::RightButton))
+                return std::string ("extend");
 #elif defined (Q_WS_X11)
-          else if (buttons == Qt::MidButton)
-            return std::string ("extend");
+              else if (buttons == Qt::MidButton)
+                return std::string ("extend");
 #endif
+            }
+          else if (buttons == Qt::LeftButton)
+            {
+              if (mods == Qt::ShiftModifier)
+                return std::string ("extend");
+              else if (mods == Qt::ControlModifier)
+                return std::string ("alt");
+            }
         }
-      else if (buttons == Qt::LeftButton)
-        {
-          if (mods == Qt::ShiftModifier)
-            return std::string ("extend");
-          else if (mods == Qt::ControlModifier)
-            return std::string ("alt");
-        }
+
+      return std::string ("normal");
     }
 
-  return std::string ("normal");
-}
+    /*
+       Two figureCurrentPoint() 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.
+    */
+    Matrix
+    figureCurrentPoint (const graphics_object& fig, QMouseEvent* event)
+    {
+      Object* tkFig = Backend::toolkitObject (fig);
 
-/*
-   Two figureCurrentPoint() 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.
-*/
-Matrix
-figureCurrentPoint (const graphics_object& fig, QMouseEvent* event)
-{
-  Object* tkFig = Backend::toolkitObject (fig);
+      if (tkFig)
+        {
+          Container* c = tkFig->innerContainer ();
 
-  if (tkFig)
-    {
-      Container* c = tkFig->innerContainer ();
+          if (c)
+            {
+              QPoint qp = c->mapFromGlobal (event->globalPos ());
 
-      if (c)
-        {
-          QPoint qp = c->mapFromGlobal (event->globalPos ());
+              return tkFig->properties<figure> ().map_from_boundingbox (qp.x (),
+                     qp.y ());
+            }
+        }
 
-          return tkFig->properties<figure> ().map_from_boundingbox (qp.x (),
-                                                                    qp.y ());
-        }
+      return Matrix (1, 2, 0.0);
     }
 
-  return Matrix (1, 2, 0.0);
-}
-
-Matrix
-figureCurrentPoint (const graphics_object& fig)
-{
-  Object* tkFig = Backend::toolkitObject (fig);
-
-  if (tkFig)
+    Matrix
+    figureCurrentPoint (const graphics_object& fig)
     {
-      Container* c = tkFig->innerContainer ();
+      Object* tkFig = Backend::toolkitObject (fig);
 
-      if (c)
+      if (tkFig)
         {
-          // FIXME: QCursor::pos() may give inaccurate results with asynchronous
-          //        window systems like X11 over ssh.
-          QPoint qp = c->mapFromGlobal (QCursor::pos ());
+          Container* c = tkFig->innerContainer ();
+
+          if (c)
+            {
+              // FIXME: QCursor::pos() may give inaccurate results with asynchronous
+              //        window systems like X11 over ssh.
+              QPoint qp = c->mapFromGlobal (QCursor::pos ());
+
+              return tkFig->properties<figure> ().map_from_boundingbox (qp.x (),
+                     qp.y ());
+            }
+        }
+
+      return Matrix (1, 2, 0.0);
+    }
 
-          return tkFig->properties<figure> ().map_from_boundingbox (qp.x (),
-                                                                    qp.y ());
-        }
+    Qt::Alignment
+    fromHVAlign (const std::string& halign, const std::string& valign)
+    {
+      Qt::Alignment flags;
+
+      if (octave::string::strcmpi (halign, "left"))
+        flags |= Qt::AlignLeft;
+      else if (octave::string::strcmpi (halign, "center"))
+        flags |= Qt::AlignHCenter;
+      else if (octave::string::strcmpi (halign, "right"))
+        flags |= Qt::AlignRight;
+      else
+        flags |= Qt::AlignLeft;
+
+      if (octave::string::strcmpi (valign, "middle"))
+        flags |= Qt::AlignVCenter;
+      else if (octave::string::strcmpi (valign, "top"))
+        flags |= Qt::AlignTop;
+      else if (octave::string::strcmpi (valign, "bottom"))
+        flags |= Qt::AlignBottom;
+      else
+        flags |= Qt::AlignVCenter;
+
+      return flags;
     }
 
-  return Matrix (1, 2, 0.0);
-}
-
-Qt::Alignment
-fromHVAlign (const std::string& halign, const std::string& valign)
-{
-  Qt::Alignment flags;
+    QImage
+    makeImageFromCData (const octave_value& v, int width, int height)
+    {
+      dim_vector dv (v.dims ());
 
-  if (octave::string::strcmpi (halign, "left"))
-    flags |= Qt::AlignLeft;
-  else if (octave::string::strcmpi (halign, "center"))
-    flags |= Qt::AlignHCenter;
-  else if (octave::string::strcmpi (halign, "right"))
-    flags |= Qt::AlignRight;
-  else
-    flags |= Qt::AlignLeft;
+      if (dv.ndims () == 3 && dv(2) == 3)
+        {
+          int w = qMin (dv(1), static_cast<octave_idx_type> (width));
+          int h = qMin (dv(0), static_cast<octave_idx_type> (height));
+
+          int x_off = (w < width ? (width - w) / 2 : 0);
+          int y_off = (h < height ? (height - h) / 2 : 0);
+
+          QImage img (width, height, QImage::Format_ARGB32);
+          img.fill (qRgba (0, 0, 0, 0));
 
-  if (octave::string::strcmpi (valign, "middle"))
-    flags |= Qt::AlignVCenter;
-  else if (octave::string::strcmpi (valign, "top"))
-    flags |= Qt::AlignTop;
-  else if (octave::string::strcmpi (valign, "bottom"))
-    flags |= Qt::AlignBottom;
-  else
-    flags |= Qt::AlignVCenter;
-
-  return flags;
-}
+          if (v.is_uint8_type ())
+            {
+              uint8NDArray d = v.uint8_array_value ();
 
-QImage
-makeImageFromCData (const octave_value& v, int width, int height)
-{
-  dim_vector dv (v.dims ());
-
-  if (dv.ndims () == 3 && dv(2) == 3)
-    {
-      int w = qMin (dv(1), static_cast<octave_idx_type> (width));
-      int h = qMin (dv(0), static_cast<octave_idx_type> (height));
+              for (int i = 0; i < w; i++)
+                for (int j = 0; j < h; j++)
+                  {
+                    int r = d(j, i, 0);
+                    int g = d(j, i, 1);
+                    int b = d(j, i, 2);
+                    int a = 255;
 
-      int x_off = (w < width ? (width - w) / 2 : 0);
-      int y_off = (h < height ? (height - h) / 2 : 0);
-
-      QImage img (width, height, QImage::Format_ARGB32);
-      img.fill (qRgba (0, 0, 0, 0));
-
-      if (v.is_uint8_type ())
-        {
-          uint8NDArray d = v.uint8_array_value ();
+                    img.setPixel (x_off + i, y_off + j, qRgba (r, g, b, a));
+                  }
+            }
+          else if (v.is_single_type ())
+            {
+              FloatNDArray f = v.float_array_value ();
 
-          for (int i = 0; i < w; i++)
-            for (int j = 0; j < h; j++)
-              {
-                int r = d(j, i, 0);
-                int g = d(j, i, 1);
-                int b = d(j, i, 2);
-                int a = 255;
-
-                img.setPixel (x_off + i, y_off + j, qRgba (r, g, b, a));
-              }
-        }
-      else if (v.is_single_type ())
-        {
-          FloatNDArray f = v.float_array_value ();
-
-          for (int i = 0; i < w; i++)
-            for (int j = 0; j < h; j++)
-              {
-                float r = f(j, i, 0);
-                float g = f(j, i, 1);
-                float b = f(j, i, 2);
-                int a = (octave::math::isnan (r) || octave::math::isnan (g) || octave::math::isnan (b) ? 0 : 255);
+              for (int i = 0; i < w; i++)
+                for (int j = 0; j < h; j++)
+                  {
+                    float r = f(j, i, 0);
+                    float g = f(j, i, 1);
+                    float b = f(j, i, 2);
+                    int a = (octave::math::isnan (r) || octave::math::isnan (g)
+                             || octave::math::isnan (b) ? 0 : 255);
 
-                img.setPixel (x_off + i, y_off + j,
-                              qRgba (octave::math::round (r * 255),
-                                     octave::math::round (g * 255),
-                                     octave::math::round (b * 255),
-                                     a));
-              }
-        }
-      else if (v.is_real_type ())
-        {
-          NDArray d = v.array_value ();
+                    img.setPixel (x_off + i, y_off + j,
+                                  qRgba (octave::math::round (r * 255),
+                                         octave::math::round (g * 255),
+                                         octave::math::round (b * 255),
+                                         a));
+                  }
+            }
+          else if (v.is_real_type ())
+            {
+              NDArray d = v.array_value ();
 
-          for (int i = 0; i < w; i++)
-            for (int j = 0; j < h; j++)
-              {
-                double r = d(j, i, 0);
-                double g = d(j, i, 1);
-                double b = d(j, i, 2);
-                int a = (octave::math::isnan (r) || octave::math::isnan (g) || octave::math::isnan (b) ? 0 : 255);
+              for (int i = 0; i < w; i++)
+                for (int j = 0; j < h; j++)
+                  {
+                    double r = d(j, i, 0);
+                    double g = d(j, i, 1);
+                    double b = d(j, i, 2);
+                    int a = (octave::math::isnan (r) || octave::math::isnan (g)
+                             || octave::math::isnan (b) ? 0 : 255);
 
-                img.setPixel (x_off + i, y_off + j,
-                              qRgba (octave::math::round (r * 255),
-                                     octave::math::round (g * 255),
-                                     octave::math::round (b * 255),
-                                     a));
-              }
+                    img.setPixel (x_off + i, y_off + j,
+                                  qRgba (octave::math::round (r * 255),
+                                         octave::math::round (g * 255),
+                                         octave::math::round (b * 255),
+                                         a));
+                  }
+            }
+
+          return img;
         }
 
-      return img;
+      return QImage ();
     }
 
-  return QImage ();
-}
+    octave_scalar_map
+    makeKeyEventStruct (QKeyEvent* event)
+    {
+      octave_scalar_map retval;
 
-octave_scalar_map
-makeKeyEventStruct (QKeyEvent* event)
-{
-  octave_scalar_map retval;
+      retval.setfield ("Key", KeyMap::qKeyToKeyString (event->key ()));
+      retval.setfield ("Character", toStdString (event->text ()));
 
-  retval.setfield ("Key", KeyMap::qKeyToKeyString (event->key ()));
-  retval.setfield ("Character", toStdString (event->text ()));
-
-  std::list<std::string> modList;
-  Qt::KeyboardModifiers mods = event->modifiers ();
+      std::list<std::string> modList;
+      Qt::KeyboardModifiers mods = event->modifiers ();
 
-  if (mods & Qt::ShiftModifier)
-    modList.push_back ("shift");
-  if (mods & Qt::ControlModifier)
+      if (mods & Qt::ShiftModifier)
+        modList.push_back ("shift");
+      if (mods & Qt::ControlModifier)
 #if defined (Q_OS_MAC)
-    modList.push_back ("command");
+        modList.push_back ("command");
 #else
-    modList.push_back ("control");
+        modList.push_back ("control");
 #endif
-  if (mods & Qt::AltModifier)
-    modList.push_back ("alt");
+      if (mods & Qt::AltModifier)
+        modList.push_back ("alt");
 #if defined (Q_OS_MAC)
-  if (mods & Qt::MetaModifier)
-    modList.push_back ("control");
+      if (mods & Qt::MetaModifier)
+        modList.push_back ("control");
 #endif
 
-  retval.setfield ("Modifier", Cell (modList));
+      retval.setfield ("Modifier", Cell (modList));
 
-  return retval;
-}
+      return retval;
+    }
 
-}; // namespace Utils
+  }; // namespace Utils
 
 }; // namespace QtHandles
+