freetype-commit
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[freetype2-demos] gsoc-2022-chariri-final fbeb288b 4/6: [ftinspect] Rena


From: Werner Lemberg
Subject: [freetype2-demos] gsoc-2022-chariri-final fbeb288b 4/6: [ftinspect] Rename all private member variables with an underscore suffix.
Date: Fri, 2 Sep 2022 01:19:24 -0400 (EDT)

branch: gsoc-2022-chariri-final
commit fbeb288b6d5f45ccfde33b210500729630bbd641
Author: Charlie Jiang <w@chariri.moe>
Commit: Charlie Jiang <w@chariri.moe>

    [ftinspect] Rename all private member variables with an underscore suffix.
    
    (pure mechnical commit)
    
    * src/ftinspect/**: Renaming. Also some variables with abbreviations
    were renamed.
    
    This will enable nicer getter/setters, as discussed in #13.
---
 src/ftinspect/engine/engine.cpp               |  240 ++---
 src/ftinspect/engine/engine.hpp               |   82 +-
 src/ftinspect/engine/fontfilemanager.cpp      |   40 +-
 src/ftinspect/engine/fontfilemanager.hpp      |    8 +-
 src/ftinspect/maingui.cpp                     | 1204 ++++++++++++-------------
 src/ftinspect/maingui.hpp                     |  250 ++---
 src/ftinspect/rendering/glyphbitmap.cpp       |   44 +-
 src/ftinspect/rendering/glyphbitmap.hpp       |   12 +-
 src/ftinspect/rendering/glyphoutline.cpp      |   16 +-
 src/ftinspect/rendering/glyphoutline.hpp      |    6 +-
 src/ftinspect/rendering/glyphpointnumbers.cpp |   24 +-
 src/ftinspect/rendering/glyphpointnumbers.hpp |    8 +-
 src/ftinspect/rendering/glyphpoints.cpp       |   34 +-
 src/ftinspect/rendering/glyphpoints.hpp       |    8 +-
 src/ftinspect/rendering/grid.cpp              |    8 +-
 src/ftinspect/rendering/grid.hpp              |    4 +-
 src/ftinspect/widgets/qgraphicsviewx.cpp      |   12 +-
 src/ftinspect/widgets/qgraphicsviewx.hpp      |    4 +-
 18 files changed, 1002 insertions(+), 1002 deletions(-)

diff --git a/src/ftinspect/engine/engine.cpp b/src/ftinspect/engine/engine.cpp
index 9fd1dcf8..877015c0 100644
--- a/src/ftinspect/engine/engine.cpp
+++ b/src/ftinspect/engine/engine.cpp
@@ -87,7 +87,7 @@ faceRequester(FTC_FaceID ftcFaceID,
              "Pointer size must be at least the size of int"
              " in order to treat FTC_FaceID correctly");
 
-  const FaceID& faceID = engine->faceIDMap.key(val);
+  const FaceID& faceID = engine->faceIDMap_.key(val);
 
   // this is the only place where we have to check the validity of the font
   // index; note that the validity of both the face and named instance index
@@ -96,7 +96,7 @@ faceRequester(FTC_FaceID ftcFaceID,
       || faceID.fontIndex >= engine->numberOfOpenedFonts())
     return FT_Err_Invalid_Argument;
 
-  QString font = engine->fileManager[faceID.fontIndex].filePath();
+  QString font = engine->fontFileManager_[faceID.fontIndex].filePath();
   long faceIndex = faceID.faceIndex;
 
   if (faceID.namedInstanceIndex > 0)
@@ -116,34 +116,34 @@ faceRequester(FTC_FaceID ftcFaceID,
 /////////////////////////////////////////////////////////////////////////////
 
 Engine::Engine()
-: fileManager(this)
+: fontFileManager_(this)
 {
-  ftSize = NULL;
+  ftSize_ = NULL;
   // we reserve value 0 for the `invalid face ID'
-  faceCounter = 1;
+  faceCounter_ = 1;
 
   FT_Error error;
 
-  error = FT_Init_FreeType(&library);
+  error = FT_Init_FreeType(&library_);
   if (error)
   {
     // XXX error handling
   }
 
-  error = FTC_Manager_New(library, 0, 0, 0,
-                          faceRequester, this, &cacheManager);
+  error = FTC_Manager_New(library_, 0, 0, 0,
+                          faceRequester, this, &cacheManager_);
   if (error)
   {
     // XXX error handling
   }
 
-  error = FTC_SBitCache_New(cacheManager, &sbitsCache);
+  error = FTC_SBitCache_New(cacheManager_, &sbitsCache_);
   if (error)
   {
     // XXX error handling
   }
 
-  error = FTC_ImageCache_New(cacheManager, &imageCache);
+  error = FTC_ImageCache_New(cacheManager_, &imageCache_);
   if (error)
   {
     // XXX error handling
@@ -155,8 +155,8 @@ Engine::Engine()
 
 Engine::~Engine()
 {
-  FTC_Manager_Done(cacheManager);
-  FT_Done_FreeType(library);
+  FTC_Manager_Done(cacheManager_);
+  FT_Done_FreeType(library_);
 }
 
 
@@ -168,28 +168,28 @@ Engine::numberOfFaces(int fontIndex)
 
   // search triplet (fontIndex, 0, 0)
   FTC_FaceID ftcFaceID = reinterpret_cast<FTC_FaceID>
-                           (faceIDMap.value(FaceID(fontIndex,
+                           (faceIDMap_.value(FaceID(fontIndex,
                                                    0,
                                                    0)));
   if (ftcFaceID)
   {
     // found
-    if (!FTC_Manager_LookupFace(cacheManager, ftcFaceID, &face))
+    if (!FTC_Manager_LookupFace(cacheManager_, ftcFaceID, &face))
       numFaces = face->num_faces;
   }
   else
   {
     // not found; try to load triplet (fontIndex, 0, 0)
-    ftcFaceID = reinterpret_cast<FTC_FaceID>(faceCounter);
-    faceIDMap.insert(FaceID(fontIndex, 0, 0),
-                     faceCounter++);
+    ftcFaceID = reinterpret_cast<FTC_FaceID>(faceCounter_);
+    faceIDMap_.insert(FaceID(fontIndex, 0, 0),
+                     faceCounter_++);
 
-    if (!FTC_Manager_LookupFace(cacheManager, ftcFaceID, &face))
+    if (!FTC_Manager_LookupFace(cacheManager_, ftcFaceID, &face))
       numFaces = face->num_faces;
     else
     {
-      faceIDMap.remove(FaceID(fontIndex, 0, 0));
-      faceCounter--;
+      faceIDMap_.remove(FaceID(fontIndex, 0, 0));
+      faceCounter_--;
     }
   }
 
@@ -208,28 +208,28 @@ Engine::numberOfNamedInstances(int fontIndex,
 
   // search triplet (fontIndex, faceIndex, 0)
   FTC_FaceID ftcFaceID = reinterpret_cast<FTC_FaceID>
-                           (faceIDMap.value(FaceID(fontIndex,
+                           (faceIDMap_.value(FaceID(fontIndex,
                                                    faceIndex,
                                                    0)));
   if (ftcFaceID)
   {
     // found
-    if (!FTC_Manager_LookupFace(cacheManager, ftcFaceID, &face))
+    if (!FTC_Manager_LookupFace(cacheManager_, ftcFaceID, &face))
       numNamedInstances = static_cast<int>((face->style_flags >> 16) + 1);
   }
   else
   {
     // not found; try to load triplet (fontIndex, faceIndex, 0)
-    ftcFaceID = reinterpret_cast<FTC_FaceID>(faceCounter);
-    faceIDMap.insert(FaceID(fontIndex, faceIndex, 0),
-                     faceCounter++);
+    ftcFaceID = reinterpret_cast<FTC_FaceID>(faceCounter_);
+    faceIDMap_.insert(FaceID(fontIndex, faceIndex, 0),
+                     faceCounter_++);
 
-    if (!FTC_Manager_LookupFace(cacheManager, ftcFaceID, &face))
+    if (!FTC_Manager_LookupFace(cacheManager_, ftcFaceID, &face))
       numNamedInstances = static_cast<int>((face->style_flags >> 16) + 1);
     else
     {
-      faceIDMap.remove(FaceID(fontIndex, faceIndex, 0));
-      faceCounter--;
+      faceIDMap_.remove(FaceID(fontIndex, faceIndex, 0));
+      faceCounter_--;
     }
   }
 
@@ -243,60 +243,60 @@ Engine::loadFont(int fontIndex,
                  int namedInstanceIndex)
 {
   int numGlyphs = -1;
-  fontType = FontType_Other;
+  fontType_ = FontType_Other;
 
   update();
 
   // search triplet (fontIndex, faceIndex, namedInstanceIndex)
-  scaler.face_id = reinterpret_cast<FTC_FaceID>
-                     (faceIDMap.value(FaceID(fontIndex,
+  scaler_.face_id = reinterpret_cast<FTC_FaceID>
+                     (faceIDMap_.value(FaceID(fontIndex,
                                              faceIndex,
                                              namedInstanceIndex)));
-  if (scaler.face_id)
+  if (scaler_.face_id)
   {
     // found
-    if (!FTC_Manager_LookupSize(cacheManager, &scaler, &ftSize))
-      numGlyphs = ftSize->face->num_glyphs;
+    if (!FTC_Manager_LookupSize(cacheManager_, &scaler_, &ftSize_))
+      numGlyphs = ftSize_->face->num_glyphs;
   }
   else
   {
     // not found; try to load triplet
     // (fontIndex, faceIndex, namedInstanceIndex)
-    scaler.face_id = reinterpret_cast<FTC_FaceID>(faceCounter);
-    faceIDMap.insert(FaceID(fontIndex,
+    scaler_.face_id = reinterpret_cast<FTC_FaceID>(faceCounter_);
+    faceIDMap_.insert(FaceID(fontIndex,
                             faceIndex,
                             namedInstanceIndex),
-                     faceCounter++);
+                     faceCounter_++);
 
-    if (!FTC_Manager_LookupSize(cacheManager, &scaler, &ftSize))
-      numGlyphs = ftSize->face->num_glyphs;
+    if (!FTC_Manager_LookupSize(cacheManager_, &scaler_, &ftSize_))
+      numGlyphs = ftSize_->face->num_glyphs;
     else
     {
-      faceIDMap.remove(FaceID(fontIndex,
+      faceIDMap_.remove(FaceID(fontIndex,
                               faceIndex,
                               namedInstanceIndex));
-      faceCounter--;
+      faceCounter_--;
     }
   }
 
   if (numGlyphs < 0)
   {
-    ftSize = NULL;
-    curFamilyName = QString();
-    curStyleName = QString();
+    ftSize_ = NULL;
+    curFamilyName_ = QString();
+    curStyleName_ = QString();
   }
   else
   {
-    curFamilyName = QString(ftSize->face->family_name);
-    curStyleName = QString(ftSize->face->style_name);
+    curFamilyName_ = QString(ftSize_->face->family_name);
+    curStyleName_ = QString(ftSize_->face->style_name);
 
-    const char* moduleName = FT_FACE_DRIVER_NAME( ftSize->face );
+    const char* moduleName = FT_FACE_DRIVER_NAME( ftSize_->face );
 
     // XXX cover all available modules
     if (!strcmp(moduleName, "cff"))
-      fontType = FontType_CFF;
+      fontType_ = FontType_CFF;
     else if (!strcmp(moduleName, "truetype"))
-      fontType = FontType_TrueType;
+      fontType_ = FontType_TrueType;
   }
 
   return numGlyphs;
@@ -309,11 +309,11 @@ Engine::removeFont(int fontIndex, bool closeFile)
   // we iterate over all triplets that contain the given font index
   // and remove them
   QMap<FaceID, FTC_IDType>::iterator iter
-    = faceIDMap.lowerBound(FaceID(fontIndex, 0, 0));
+    = faceIDMap_.lowerBound(FaceID(fontIndex, 0, 0));
 
   for (;;)
   {
-    if (iter == faceIDMap.end())
+    if (iter == faceIDMap_.end())
       break;
 
     FaceID faceID = iter.key();
@@ -321,13 +321,13 @@ Engine::removeFont(int fontIndex, bool closeFile)
       break;
 
     FTC_FaceID ftcFaceID = reinterpret_cast<FTC_FaceID>(iter.value());
-    FTC_Manager_RemoveFaceID(cacheManager, ftcFaceID);
+    FTC_Manager_RemoveFaceID(cacheManager_, ftcFaceID);
 
-    iter = faceIDMap.erase(iter);
+    iter = faceIDMap_.erase(iter);
   }
 
   if (closeFile)
-    fileManager.remove(fontIndex);
+    fontFileManager_.remove(fontIndex);
 }
 
 
@@ -339,10 +339,10 @@ Engine::glyphName(int index)
   if (index < 0)
     throw std::runtime_error("Invalid glyph index");
 
-  if (ftSize && FT_HAS_GLYPH_NAMES(ftSize->face))
+  if (ftSize_ && FT_HAS_GLYPH_NAMES(ftSize_->face))
   {
     char buffer[256];
-    if (!FT_Get_Glyph_Name(ftSize->face,
+    if (!FT_Get_Glyph_Name(ftSize_->face,
                            static_cast<unsigned int>(index),
                            buffer,
                            sizeof(buffer)))
@@ -367,9 +367,9 @@ Engine::loadOutline(int glyphIndex)
 
   // the `scaler' object is set up by the
   // `update' and `loadFont' methods
-  if (FTC_ImageCache_LookupScaler(imageCache,
-                                  &scaler,
-                                  loadFlags | FT_LOAD_NO_BITMAP,
+  if (FTC_ImageCache_LookupScaler(imageCache_,
+                                  &scaler_,
+                                  loadFlags_ | FT_LOAD_NO_BITMAP,
                                   static_cast<unsigned int>(glyphIndex),
                                   &glyph,
                                   NULL))
@@ -390,45 +390,45 @@ Engine::loadOutline(int glyphIndex)
 int
 Engine::numberOfOpenedFonts()
 {
-  return fileManager.size();
+  return fontFileManager_.size();
 }
 
 
 void
 Engine::openFonts(QStringList fontFileNames)
 {
-  fileManager.append(fontFileNames, true);
+  fontFileManager_.append(fontFileNames, true);
 }
 
 
 void
 Engine::setSizeByPixel(double pixelSize)
 {
-  this->pixelSize = pixelSize;
-  pointSize = pixelSize * 72.0 / dpi;
-  usingPixelSize = true;
+  this->pixelSize_ = pixelSize;
+  pointSize_ = pixelSize * 72.0 / dpi_;
+  usingPixelSize_ = true;
 }
 
 void
 Engine::setSizeByPoint(double pointSize)
 {
-  this->pointSize = pointSize;
-  pixelSize = pointSize * dpi / 72.0;
-  usingPixelSize = false;
+  this->pointSize_ = pointSize;
+  pixelSize_ = pointSize * dpi_ / 72.0;
+  usingPixelSize_ = false;
 }
 
 
 void
 Engine::setLcdFilter(FT_LcdFilter filter)
 {
-  FT_Library_SetLcdFilter(library, filter);
+  FT_Library_SetLcdFilter(library_, filter);
 }
 
 
 void
 Engine::setCFFHintingMode(int mode)
 {
-  FT_Error error = FT_Property_Set(library,
+  FT_Error error = FT_Property_Set(library_,
                                    "cff",
                                    "hinting-engine",
                                    &mode);
@@ -440,7 +440,7 @@ Engine::setCFFHintingMode(int mode)
 void
 Engine::setTTInterpreterVersion(int version)
 {
-  FT_Error error = FT_Property_Set(library,
+  FT_Error error = FT_Property_Set(library_,
                                    "truetype",
                                    "interpreter-version",
                                    &version);
@@ -452,20 +452,20 @@ Engine::setTTInterpreterVersion(int version)
 void
 Engine::update()
 {
-  loadFlags = FT_LOAD_DEFAULT;
-  if (doAutoHinting)
-    loadFlags |= FT_LOAD_FORCE_AUTOHINT;
-  loadFlags |= FT_LOAD_NO_BITMAP; // XXX handle bitmap fonts also
+  loadFlags_ = FT_LOAD_DEFAULT;
+  if (doAutoHinting_)
+    loadFlags_ |= FT_LOAD_FORCE_AUTOHINT;
+  loadFlags_ |= FT_LOAD_NO_BITMAP; // XXX handle bitmap fonts also
 
-  if (doHinting)
+  if (doHinting_)
   {
     unsigned long target;
 
-    if (antiAliasingMode == AntiAliasing_None)
+    if (antiAliasingMode_ == AntiAliasing_None)
       target = FT_LOAD_TARGET_MONO;
     else
     {
-      switch (antiAliasingMode)
+      switch (antiAliasingMode_)
       {
       case AntiAliasing_Light:
         target = FT_LOAD_TARGET_LIGHT;
@@ -486,33 +486,33 @@ Engine::update()
       }
     }
 
-    loadFlags |= target;
+    loadFlags_ |= target;
   }
   else
   {
-    loadFlags |= FT_LOAD_NO_HINTING;
+    loadFlags_ |= FT_LOAD_NO_HINTING;
 
-    if (antiAliasingMode == AntiAliasing_None)
-      loadFlags |= FT_LOAD_MONOCHROME;
+    if (antiAliasingMode_ == AntiAliasing_None)
+      loadFlags_ |= FT_LOAD_MONOCHROME;
   }
 
   // XXX handle color fonts also
 
-  scaler.pixel = 0; // use 26.6 format
+  scaler_.pixel = 0; // use 26.6 format
 
-  if (usingPixelSize)
+  if (usingPixelSize_)
   {
-    scaler.width = static_cast<unsigned int>(pixelSize * 64.0);
-    scaler.height = static_cast<unsigned int>(pixelSize * 64.0);
-    scaler.x_res = 0;
-    scaler.y_res = 0;
+    scaler_.width = static_cast<unsigned int>(pixelSize_ * 64.0);
+    scaler_.height = static_cast<unsigned int>(pixelSize_ * 64.0);
+    scaler_.x_res = 0;
+    scaler_.y_res = 0;
   }
   else
   {
-    scaler.width = static_cast<unsigned int>(pointSize * 64.0);
-    scaler.height = static_cast<unsigned int>(pointSize * 64.0);
-    scaler.x_res = dpi;
-    scaler.y_res = dpi;
+    scaler_.width = static_cast<unsigned int>(pointSize_ * 64.0);
+    scaler_.height = static_cast<unsigned int>(pointSize_ * 64.0);
+    scaler_.x_res = dpi_;
+    scaler_.y_res = dpi_;
   }
 }
 
@@ -521,8 +521,8 @@ void
 Engine::resetCache()
 {
   // reset the cache
-  FTC_Manager_Reset(cacheManager);
-  ftSize = NULL;
+  FTC_Manager_Reset(cacheManager_);
+  ftSize_ = NULL;
 }
 
 
@@ -534,15 +534,15 @@ Engine::queryEngine()
   // query engines and check for alternatives
 
   // CFF
-  error = FT_Property_Get(library,
+  error = FT_Property_Get(library_,
                           "cff",
                           "hinting-engine",
-                          &defaults.cffHintingEngineDefault);
+                          &engineDefaults_.cffHintingEngineDefault);
   if (error)
   {
     // no CFF engine
-    defaults.cffHintingEngineDefault = -1;
-    defaults.cffHintingEngineOther = -1;
+    engineDefaults_.cffHintingEngineDefault = -1;
+    engineDefaults_.cffHintingEngineOther = -1;
   }
   else
   {
@@ -554,36 +554,36 @@ Engine::queryEngine()
 
     int i;
     for (i = 0; i < 2; i++)
-      if (defaults.cffHintingEngineDefault == engines[i])
+      if (engineDefaults_.cffHintingEngineDefault == engines[i])
         break;
 
-    defaults.cffHintingEngineOther = engines[(i + 1) % 2];
+    engineDefaults_.cffHintingEngineOther = engines[(i + 1) % 2];
 
-    error = FT_Property_Set(library,
+    error = FT_Property_Set(library_,
                             "cff",
                             "hinting-engine",
-                            &defaults.cffHintingEngineOther);
+                            &engineDefaults_.cffHintingEngineOther);
     if (error)
-      defaults.cffHintingEngineOther = -1;
+      engineDefaults_.cffHintingEngineOther = -1;
 
     // reset
-    FT_Property_Set(library,
+    FT_Property_Set(library_,
                     "cff",
                     "hinting-engine",
-                    &defaults.cffHintingEngineDefault);
+                    &engineDefaults_.cffHintingEngineDefault);
   }
 
   // TrueType
-  error = FT_Property_Get(library,
+  error = FT_Property_Get(library_,
                           "truetype",
                           "interpreter-version",
-                          &defaults.ttInterpreterVersionDefault);
+                          &engineDefaults_.ttInterpreterVersionDefault);
   if (error)
   {
     // no TrueType engine
-    defaults.ttInterpreterVersionDefault = -1;
-    defaults.ttInterpreterVersionOther = -1;
-    defaults.ttInterpreterVersionOther1 = -1;
+    engineDefaults_.ttInterpreterVersionDefault = -1;
+    engineDefaults_.ttInterpreterVersionOther = -1;
+    engineDefaults_.ttInterpreterVersionOther1 = -1;
   }
   else
   {
@@ -596,32 +596,32 @@ Engine::queryEngine()
 
     int i;
     for (i = 0; i < 3; i++)
-      if (defaults.ttInterpreterVersionDefault == interpreters[i])
+      if (engineDefaults_.ttInterpreterVersionDefault == interpreters[i])
         break;
 
-    defaults.ttInterpreterVersionOther = interpreters[(i + 1) % 3];
+    engineDefaults_.ttInterpreterVersionOther = interpreters[(i + 1) % 3];
 
-    error = FT_Property_Set(library,
+    error = FT_Property_Set(library_,
                             "truetype",
                             "interpreter-version",
-                            &defaults.ttInterpreterVersionOther);
+                            &engineDefaults_.ttInterpreterVersionOther);
     if (error)
-      defaults.ttInterpreterVersionOther = -1;
+      engineDefaults_.ttInterpreterVersionOther = -1;
 
-    defaults.ttInterpreterVersionOther1 = interpreters[(i + 2) % 3];
+    engineDefaults_.ttInterpreterVersionOther1 = interpreters[(i + 2) % 3];
 
-    error = FT_Property_Set(library,
+    error = FT_Property_Set(library_,
                             "truetype",
                             "interpreter-version",
-                            &defaults.ttInterpreterVersionOther1);
+                            &engineDefaults_.ttInterpreterVersionOther1);
     if (error)
-      defaults.ttInterpreterVersionOther1 = -1;
+      engineDefaults_.ttInterpreterVersionOther1 = -1;
 
     // reset
-    FT_Property_Set(library,
+    FT_Property_Set(library_,
                     "truetype",
                     "interpreter-version",
-                    &defaults.ttInterpreterVersionDefault);
+                    &engineDefaults_.ttInterpreterVersionDefault);
   }
 }
 
diff --git a/src/ftinspect/engine/engine.hpp b/src/ftinspect/engine/engine.hpp
index eb7a794e..2a7ec245 100644
--- a/src/ftinspect/engine/engine.hpp
+++ b/src/ftinspect/engine/engine.hpp
@@ -81,16 +81,16 @@ public:
 
   //////// Getters
 
-  FT_Library ftLibrary() const { return library; }
-  FontFileManager& fontFileManager() { return fileManager; }
-  EngineDefaultValues& engineDefaults() { return defaults; }
+  FT_Library ftLibrary() const { return library_; }
+  FontFileManager& fontFileManager() { return fontFileManager_; }
+  EngineDefaultValues& engineDefaults() { return engineDefaults_; }
 
   int numberOfOpenedFonts();
 
   // (for current fonts)
-  int currentFontType() const { return fontType; }
-  const QString& currentFamilyName() { return curFamilyName; }
-  const QString& currentStyleName() { return curStyleName; }
+  int currentFontType() const { return fontType_; }
+  const QString& currentFamilyName() { return curFamilyName_; }
+  const QString& currentStyleName() { return curStyleName_; }
   QString glyphName(int glyphIndex);
   long numberOfFaces(int fontIndex);
   int numberOfNamedInstances(int fontIndex,
@@ -98,26 +98,26 @@ public:
 
   //////// Setters (direct or indirect)
 
-  void setDPI(int d) { dpi = d; }
+  void setDPI(int d) { dpi_ = d; }
   void setSizeByPixel(double pixelSize);
   void setSizeByPoint(double pointSize);
-  void setHinting(bool hinting) { doHinting = hinting; }
-  void setAutoHinting(bool autoHinting) { doAutoHinting = autoHinting; }
+  void setHinting(bool hinting) { doHinting_ = hinting; }
+  void setAutoHinting(bool autoHinting) { doAutoHinting_ = autoHinting; }
   void setHorizontalHinting(bool horHinting)
   {
-    doHorizontalHinting = horHinting;
+    doHorizontalHinting_ = horHinting;
   }
   void setVerticalHinting(bool verticalHinting)
   {
-    doVerticalHinting = verticalHinting;
+    doVerticalHinting_ = verticalHinting;
   }
   void setBlueZoneHinting(bool blueZoneHinting)
   {
-    doBlueZoneHinting = blueZoneHinting;
+    doBlueZoneHinting_ = blueZoneHinting;
   }
-  void setShowSegments(bool showSegments) { this->showSegments = showSegments; 
}
-  void setGamma(double gamma) { this->gamma = gamma; }
-  void setAntiAliasingMode(AntiAliasing mode) { antiAliasingMode = mode; }
+  void setShowSegments(bool showSegments) { showSegments_ = showSegments; }
+  void setGamma(double gamma) { gamma_ = gamma; }
+  void setAntiAliasingMode(AntiAliasing mode) { antiAliasingMode_ = mode; }
 
   // Note: These 3 functions now takes actual mode/version from FreeType,
   // instead of values from enum in MainGUI!
@@ -134,42 +134,42 @@ public:
 
 private:
   using FTC_IDType = uintptr_t;
-  FTC_IDType faceCounter; // a running number used to initialize `faceIDMap'
-  QMap<FaceID, FTC_IDType> faceIDMap;
+  FTC_IDType faceCounter_; // a running number used to initialize `faceIDMap'
+  QMap<FaceID, FTC_IDType> faceIDMap_;
 
-  FontFileManager fileManager;
+  FontFileManager fontFileManager_;
 
-  QString curFamilyName;
-  QString curStyleName;
+  QString curFamilyName_;
+  QString curStyleName_;
 
-  FT_Library library;
-  FTC_Manager cacheManager;
-  FTC_ImageCache imageCache;
-  FTC_SBitCache sbitsCache;
+  FT_Library library_;
+  FTC_Manager cacheManager_;
+  FTC_ImageCache imageCache_;
+  FTC_SBitCache sbitsCache_;
 
-  FTC_ScalerRec scaler;
-  FT_Size ftSize;
+  FTC_ScalerRec scaler_;
+  FT_Size ftSize_;
 
-  EngineDefaultValues defaults;
+  EngineDefaultValues engineDefaults_;
 
-  int fontType;
+  int fontType_;
 
-  bool usingPixelSize = false;
-  double pointSize;
-  double pixelSize;
-  unsigned int dpi;
+  bool usingPixelSize_ = false;
+  double pointSize_;
+  double pixelSize_;
+  unsigned int dpi_;
 
-  bool doHinting;
-  bool doAutoHinting;
-  bool doHorizontalHinting;
-  bool doVerticalHinting;
-  bool doBlueZoneHinting;
-  bool showSegments;
-  AntiAliasing antiAliasingMode;
+  bool doHinting_;
+  bool doAutoHinting_;
+  bool doHorizontalHinting_;
+  bool doVerticalHinting_;
+  bool doBlueZoneHinting_;
+  bool showSegments_;
+  AntiAliasing antiAliasingMode_;
 
-  double gamma;
+  double gamma_;
 
-  unsigned long loadFlags;
+  unsigned long loadFlags_;
 
   void queryEngine();
 
diff --git a/src/ftinspect/engine/fontfilemanager.cpp 
b/src/ftinspect/engine/fontfilemanager.cpp
index 13c5cbdb..c9956249 100644
--- a/src/ftinspect/engine/fontfilemanager.cpp
+++ b/src/ftinspect/engine/fontfilemanager.cpp
@@ -13,16 +13,16 @@
 
 
 FontFileManager::FontFileManager(Engine* engine)
-: engine(engine)
+: engine_(engine)
 {
-  fontWatcher = new QFileSystemWatcher(this);
+  fontWatcher_ = new QFileSystemWatcher(this);
   // if the current input file is invalid we retry once a second to load it
-  watchTimer = new QTimer;
-  watchTimer->setInterval(1000);
+  watchTimer_ = new QTimer;
+  watchTimer_->setInterval(1000);
 
-  connect(fontWatcher, &QFileSystemWatcher::fileChanged,
+  connect(fontWatcher_, &QFileSystemWatcher::fileChanged,
           this, &FontFileManager::onWatcherFire);
-  connect(watchTimer, &QTimer::timeout,
+  connect(watchTimer_, &QTimer::timeout,
           this, &FontFileManager::onTimerFire);
 }
 
@@ -30,7 +30,7 @@ FontFileManager::FontFileManager(Engine* engine)
 int
 FontFileManager::size()
 {
-  return fontFileNameList.size();
+  return fontFileNameList_.size();
 }
 
 
@@ -73,7 +73,7 @@ FontFileManager::append(QStringList const& newFileNames, bool 
alertNotExist)
     // Uniquify elements
     auto absPath = info.absoluteFilePath();
     auto existing = false;
-    for (auto& existingName : fontFileNameList)
+    for (auto& existingName : fontFileNameList_)
       if (existingName.absoluteFilePath() == absPath)
       {
         existing = true;
@@ -84,7 +84,7 @@ FontFileManager::append(QStringList const& newFileNames, bool 
alertNotExist)
 
     if (info.size() >= INT_MAX)
       return; // Prevent overflowing
-    fontFileNameList.append(info);
+    fontFileNameList_.append(info);
   }
 
   if (alertNotExist && !failedFiles.empty())
@@ -116,47 +116,47 @@ FontFileManager::remove(int index)
   if (index < 0 || index >= size())
     return;
 
-  fontWatcher->removePath(fontFileNameList[index].filePath());
-  fontFileNameList.removeAt(index);
+  fontWatcher_->removePath(fontFileNameList_[index].filePath());
+  fontFileNameList_.removeAt(index);
 }
 
 
 QFileInfo&
 FontFileManager::operator[](int index)
 {
-  return fontFileNameList[index];
+  return fontFileNameList_[index];
 }
 
 
 void
 FontFileManager::updateWatching(int index)
 {
-  QFileInfo& fileInfo = fontFileNameList[index];
+  QFileInfo& fileInfo = fontFileNameList_[index];
 
-  auto watching = fontWatcher->files();
+  auto watching = fontWatcher_->files();
   if (!watching.empty())
-    fontWatcher->removePaths(watching);
+    fontWatcher_->removePaths(watching);
 
   // Qt's file watcher doesn't handle symlinks;
   // we thus fall back to polling
   if (fileInfo.isSymLink() || !fileInfo.exists())
-    watchTimer->start();
+    watchTimer_->start();
   else
-    fontWatcher->addPath(fileInfo.filePath());
+    fontWatcher_->addPath(fileInfo.filePath());
 }
 
 
 void
 FontFileManager::timerStart()
 {
-  watchTimer->start();
+  watchTimer_->start();
 }
 
 
 void
 FontFileManager::onWatcherFire()
 {
-  watchTimer->stop();
+  watchTimer_->stop();
   emit currentFileChanged();
 }
 
@@ -164,7 +164,7 @@ FontFileManager::onWatcherFire()
 FT_Error
 FontFileManager::validateFontFile(QString const& fileName)
 {
-  return FT_New_Face(engine->ftLibrary(), fileName.toUtf8(), -1, NULL);
+  return FT_New_Face(engine_->ftLibrary(), fileName.toUtf8(), -1, NULL);
 }
 
 
diff --git a/src/ftinspect/engine/fontfilemanager.hpp 
b/src/ftinspect/engine/fontfilemanager.hpp
index 93916852..a13714eb 100644
--- a/src/ftinspect/engine/fontfilemanager.hpp
+++ b/src/ftinspect/engine/fontfilemanager.hpp
@@ -41,10 +41,10 @@ private slots:
   void onWatcherFire();
 
 private:
-  Engine* engine;
-  QList<QFileInfo> fontFileNameList;
-  QFileSystemWatcher* fontWatcher;
-  QTimer* watchTimer;
+  Engine* engine_;
+  QList<QFileInfo> fontFileNameList_;
+  QFileSystemWatcher* fontWatcher_;
+  QTimer* watchTimer_;
 
   FT_Error validateFontFile(QString const& fileName);
 };
diff --git a/src/ftinspect/maingui.cpp b/src/ftinspect/maingui.cpp
index cc4c09c3..026b6566 100644
--- a/src/ftinspect/maingui.cpp
+++ b/src/ftinspect/maingui.cpp
@@ -15,7 +15,7 @@
 
 
 MainGUI::MainGUI(Engine* engine)
-: engine(engine)
+: engine_(engine)
 {
   setGraphicsDefaults();
   createLayout();
@@ -80,7 +80,7 @@ MainGUI::aboutQt()
 void
 MainGUI::loadFonts()
 {
-  int oldSize = engine->numberOfOpenedFonts();
+  int oldSize = engine_->numberOfOpenedFonts();
 
   QStringList files = QFileDialog::getOpenFileNames(
                         this,
@@ -90,11 +90,11 @@ MainGUI::loadFonts()
                         NULL,
                         QFileDialog::ReadOnly);
 
-  engine->openFonts(files);
+  engine_->openFonts(files);
 
   // if we have new fonts, set the current index to the first new one
-  if (oldSize < engine->numberOfOpenedFonts())
-    currentFontIndex = oldSize;
+  if (oldSize < engine_->numberOfOpenedFonts())
+    currentFontIndex_ = oldSize;
 
   showFont();
 }
@@ -103,20 +103,20 @@ MainGUI::loadFonts()
 void
 MainGUI::closeFont()
 {
-  if (currentFontIndex < engine->numberOfOpenedFonts())
+  if (currentFontIndex_ < engine_->numberOfOpenedFonts())
   {
-    engine->removeFont(currentFontIndex);
+    engine_->removeFont(currentFontIndex_);
   }
 
   // show next font after deletion, i.e., retain index if possible
-  int num = engine->numberOfOpenedFonts();
+  int num = engine_->numberOfOpenedFonts();
   if (num)
   {
-    if (currentFontIndex >= num)
-      currentFontIndex = num - 1;
+    if (currentFontIndex_ >= num)
+      currentFontIndex_ = num - 1;
   }
   else
-    currentFontIndex = 0;
+    currentFontIndex_ = 0;
 
   showFont();
 }
@@ -134,12 +134,12 @@ MainGUI::showFont()
 {
   // we do lazy computation of FT_Face objects
 
-  if (currentFontIndex < engine->numberOfOpenedFonts())
+  if (currentFontIndex_ < engine_->numberOfOpenedFonts())
   {
-    QFileInfo& fileInfo = engine->fontFileManager()[currentFontIndex];
+    QFileInfo& fileInfo = engine_->fontFileManager()[currentFontIndex_];
     QString fontName = fileInfo.fileName();
 
-    engine->fontFileManager().updateWatching(currentFontIndex);
+    engine_->fontFileManager().updateWatching(currentFontIndex_);
     if (fileInfo.isSymLink())
     {
       fontName.prepend("<i>");
@@ -154,39 +154,39 @@ MainGUI::showFont()
       // For this reason, we remove the font to enforce a reload.
       // However, we're just removing it from the Engine cache,
       // not deleting the entry in the font file manager
-      engine->removeFont(currentFontIndex, false);
+      engine_->removeFont(currentFontIndex_, false);
     }
 
-    fontFilenameLabel->setText(fontName);
+    fontFilenameLabel_->setText(fontName);
   }
   else
-    fontFilenameLabel->clear();
+    fontFilenameLabel_->clear();
 
   applySettings();
-  currentNumberOfFaces
-    = engine->numberOfFaces(currentFontIndex);
-  currentNumberOfNamedInstances
-    = engine->numberOfNamedInstances(currentFontIndex,
-                                     currentFaceIndex);
-  currentNumberOfGlyphs
-    = engine->loadFont(currentFontIndex,
-                       currentFaceIndex,
-                       currentNamedInstanceIndex);
-
-  if (currentNumberOfGlyphs < 0)
+  currentNumberOfFaces_
+    = engine_->numberOfFaces(currentFontIndex_);
+  currentNumberOfNamedInstances_
+    = engine_->numberOfNamedInstances(currentFontIndex_,
+                                     currentFaceIndex_);
+  currentNumberOfGlyphs_
+    = engine_->loadFont(currentFontIndex_,
+                       currentFaceIndex_,
+                       currentNamedInstanceIndex_);
+
+  if (currentNumberOfGlyphs_ < 0)
   {
     // there might be various reasons why the current
     // (file, face, instance) triplet is invalid or missing;
     // we thus start our timer to periodically test
     // whether the font starts working
-    if (currentFontIndex > 0
-        && currentFontIndex < engine->numberOfOpenedFonts())
-      engine->fontFileManager().timerStart();
+    if (currentFontIndex_ > 0
+        && currentFontIndex_ < engine_->numberOfOpenedFonts())
+      engine_->fontFileManager().timerStart();
   }
 
-  fontNameLabel->setText(QString("%1 %2")
-                         .arg(engine->currentFamilyName())
-                         .arg(engine->currentStyleName()));
+  fontNameLabel_->setText(QString("%1 %2")
+                         .arg(engine_->currentFamilyName())
+                         .arg(engine_->currentStyleName()));
 
   checkCurrentFontIndex();
   checkCurrentFaceIndex();
@@ -202,24 +202,24 @@ void
 MainGUI::applySettings()
 {
   // Spinbox value cannot become negative
-  engine->setDPI(static_cast<unsigned int>(dpiSpinBox->value()));
+  engine_->setDPI(static_cast<unsigned int>(dpiSpinBox_->value()));
 
-  if (unitsComboBox->currentIndex() == Units_px)
-    engine->setSizeByPixel(sizeDoubleSpinBox->value());
+  if (unitsComboBox_->currentIndex() == Units_px)
+    engine_->setSizeByPixel(sizeDoubleSpinBox_->value());
   else
-    engine->setSizeByPoint(sizeDoubleSpinBox->value());
+    engine_->setSizeByPoint(sizeDoubleSpinBox_->value());
 
-  engine->setHinting(hintingCheckBox->isChecked());
-  engine->setAutoHinting(autoHintingCheckBox->isChecked());
-  engine->setHorizontalHinting(horizontalHintingCheckBox->isChecked());
-  engine->setVerticalHinting(verticalHintingCheckBox->isChecked());
-  engine->setBlueZoneHinting(blueZoneHintingCheckBox->isChecked());
-  engine->setShowSegments(segmentDrawingCheckBox->isChecked());
+  engine_->setHinting(hintingCheckBox_->isChecked());
+  engine_->setAutoHinting(autoHintingCheckBox_->isChecked());
+  engine_->setHorizontalHinting(horizontalHintingCheckBox_->isChecked());
+  engine_->setVerticalHinting(verticalHintingCheckBox_->isChecked());
+  engine_->setBlueZoneHinting(blueZoneHintingCheckBox_->isChecked());
+  engine_->setShowSegments(segmentDrawingCheckBox_->isChecked());
 
-  engine->setGamma(gammaSlider->value());
+  engine_->setGamma(gammaSlider_->value());
 
-  engine->setAntiAliasingMode(static_cast<Engine::AntiAliasing>(
-      antiAliasingComboBoxx->currentIndex()));
+  engine_->setAntiAliasingMode(static_cast<Engine::AntiAliasing>(
+      antiAliasingComboBoxx_->currentIndex()));
 }
 
 
@@ -234,57 +234,57 @@ MainGUI::clearStatusBar()
 void
 MainGUI::checkHinting()
 {
-  if (hintingCheckBox->isChecked())
+  if (hintingCheckBox_->isChecked())
   {
-    if (engine->currentFontType() == Engine::FontType_CFF)
+    if (engine_->currentFontType() == Engine::FontType_CFF)
     {
-      for (int i = 0; i < hintingModeComboBoxx->count(); i++)
+      for (int i = 0; i < hintingModeComboBoxx_->count(); i++)
       {
-        if (hintingModesCFFHash.key(i, -1) != -1)
-          hintingModeComboBoxx->setItemEnabled(i, true);
+        if (hintingModesCFFHash_.key(i, -1) != -1)
+          hintingModeComboBoxx_->setItemEnabled(i, true);
         else
-          hintingModeComboBoxx->setItemEnabled(i, false);
+          hintingModeComboBoxx_->setItemEnabled(i, false);
       }
 
-      hintingModeComboBoxx->setCurrentIndex(currentCFFHintingMode);
+      hintingModeComboBoxx_->setCurrentIndex(currentCFFHintingMode_);
     }
-    else if (engine->currentFontType() == Engine::FontType_TrueType)
+    else if (engine_->currentFontType() == Engine::FontType_TrueType)
     {
-      for (int i = 0; i < hintingModeComboBoxx->count(); i++)
+      for (int i = 0; i < hintingModeComboBoxx_->count(); i++)
       {
-        if (hintingModesTrueTypeHash.key(i, -1) != -1)
-          hintingModeComboBoxx->setItemEnabled(i, true);
+        if (hintingModesTrueTypeHash_.key(i, -1) != -1)
+          hintingModeComboBoxx_->setItemEnabled(i, true);
         else
-          hintingModeComboBoxx->setItemEnabled(i, false);
+          hintingModeComboBoxx_->setItemEnabled(i, false);
       }
 
-      hintingModeComboBoxx->setCurrentIndex(currentTTInterpreterVersion);
+      hintingModeComboBoxx_->setCurrentIndex(currentTTInterpreterVersion_);
     }
     else
     {
-      hintingModeLabel->setEnabled(false);
-      hintingModeComboBoxx->setEnabled(false);
+      hintingModeLabel_->setEnabled(false);
+      hintingModeComboBoxx_->setEnabled(false);
     }
 
-    for (int i = 0; i < hintingModesAlwaysDisabled.size(); i++)
-      hintingModeComboBoxx->setItemEnabled(hintingModesAlwaysDisabled[i],
+    for (int i = 0; i < hintingModesAlwaysDisabled_.size(); i++)
+      hintingModeComboBoxx_->setItemEnabled(hintingModesAlwaysDisabled_[i],
                                            false);
 
-    autoHintingCheckBox->setEnabled(true);
+    autoHintingCheckBox_->setEnabled(true);
     checkAutoHinting();
   }
   else
   {
-    hintingModeLabel->setEnabled(false);
-    hintingModeComboBoxx->setEnabled(false);
+    hintingModeLabel_->setEnabled(false);
+    hintingModeComboBoxx_->setEnabled(false);
 
-    autoHintingCheckBox->setEnabled(false);
-    horizontalHintingCheckBox->setEnabled(false);
-    verticalHintingCheckBox->setEnabled(false);
-    blueZoneHintingCheckBox->setEnabled(false);
-    segmentDrawingCheckBox->setEnabled(false);
+    autoHintingCheckBox_->setEnabled(false);
+    horizontalHintingCheckBox_->setEnabled(false);
+    verticalHintingCheckBox_->setEnabled(false);
+    blueZoneHintingCheckBox_->setEnabled(false);
+    segmentDrawingCheckBox_->setEnabled(false);
 
-    antiAliasingComboBoxx->setItemEnabled(Engine::AntiAliasing_Light, false);
+    antiAliasingComboBoxx_->setItemEnabled(Engine::AntiAliasing_Light, false);
   }
 
   drawGlyph();
@@ -294,17 +294,17 @@ MainGUI::checkHinting()
 void
 MainGUI::checkHintingMode()
 {
-  int index = hintingModeComboBoxx->currentIndex();
+  int index = hintingModeComboBoxx_->currentIndex();
 
-  if (engine->currentFontType() == Engine::FontType_CFF)
+  if (engine_->currentFontType() == Engine::FontType_CFF)
   {
-    engine->setCFFHintingMode(hintingModesCFFHash.key(index));
-    currentCFFHintingMode = index;
+    engine_->setCFFHintingMode(hintingModesCFFHash_.key(index));
+    currentCFFHintingMode_ = index;
   }
-  else if (engine->currentFontType() == Engine::FontType_TrueType)
+  else if (engine_->currentFontType() == Engine::FontType_TrueType)
   {
-    engine->setTTInterpreterVersion(hintingModesTrueTypeHash.key(index));
-    currentTTInterpreterVersion = index;
+    engine_->setTTInterpreterVersion(hintingModesTrueTypeHash_.key(index));
+    currentTTInterpreterVersion_ = index;
   }
 
   // this enforces reloading of the font
@@ -315,36 +315,36 @@ MainGUI::checkHintingMode()
 void
 MainGUI::checkAutoHinting()
 {
-  if (autoHintingCheckBox->isChecked())
+  if (autoHintingCheckBox_->isChecked())
   {
-    hintingModeLabel->setEnabled(false);
-    hintingModeComboBoxx->setEnabled(false);
+    hintingModeLabel_->setEnabled(false);
+    hintingModeComboBoxx_->setEnabled(false);
 
-    horizontalHintingCheckBox->setEnabled(true);
-    verticalHintingCheckBox->setEnabled(true);
-    blueZoneHintingCheckBox->setEnabled(true);
-    segmentDrawingCheckBox->setEnabled(true);
+    horizontalHintingCheckBox_->setEnabled(true);
+    verticalHintingCheckBox_->setEnabled(true);
+    blueZoneHintingCheckBox_->setEnabled(true);
+    segmentDrawingCheckBox_->setEnabled(true);
 
-    antiAliasingComboBoxx->setItemEnabled(Engine::AntiAliasing_Light, true);
+    antiAliasingComboBoxx_->setItemEnabled(Engine::AntiAliasing_Light, true);
   }
   else
   {
-    if (engine->currentFontType() == Engine::FontType_CFF
-        || engine->currentFontType() == Engine::FontType_TrueType)
+    if (engine_->currentFontType() == Engine::FontType_CFF
+        || engine_->currentFontType() == Engine::FontType_TrueType)
     {
-      hintingModeLabel->setEnabled(true);
-      hintingModeComboBoxx->setEnabled(true);
+      hintingModeLabel_->setEnabled(true);
+      hintingModeComboBoxx_->setEnabled(true);
     }
 
-    horizontalHintingCheckBox->setEnabled(false);
-    verticalHintingCheckBox->setEnabled(false);
-    blueZoneHintingCheckBox->setEnabled(false);
-    segmentDrawingCheckBox->setEnabled(false);
+    horizontalHintingCheckBox_->setEnabled(false);
+    verticalHintingCheckBox_->setEnabled(false);
+    blueZoneHintingCheckBox_->setEnabled(false);
+    segmentDrawingCheckBox_->setEnabled(false);
 
-    antiAliasingComboBoxx->setItemEnabled(Engine::AntiAliasing_Light, false);
+    antiAliasingComboBoxx_->setItemEnabled(Engine::AntiAliasing_Light, false);
 
-    if (antiAliasingComboBoxx->currentIndex() == Engine::AntiAliasing_Light)
-      antiAliasingComboBoxx->setCurrentIndex(Engine::AntiAliasing_Normal);
+    if (antiAliasingComboBoxx_->currentIndex() == Engine::AntiAliasing_Light)
+      antiAliasingComboBoxx_->setCurrentIndex(Engine::AntiAliasing_Normal);
   }
 
   drawGlyph();
@@ -354,19 +354,19 @@ MainGUI::checkAutoHinting()
 void
 MainGUI::checkAntiAliasing()
 {
-  int index = antiAliasingComboBoxx->currentIndex();
+  int index = antiAliasingComboBoxx_->currentIndex();
 
   if (index == Engine::AntiAliasing_None
       || index == Engine::AntiAliasing_Normal
       || index == Engine::AntiAliasing_Light)
   {
-    lcdFilterLabel->setEnabled(false);
-    lcdFilterComboBox->setEnabled(false);
+    lcdFilterLabel_->setEnabled(false);
+    lcdFilterComboBox_->setEnabled(false);
   }
   else
   {
-    lcdFilterLabel->setEnabled(true);
-    lcdFilterComboBox->setEnabled(true);
+    lcdFilterLabel_->setEnabled(true);
+    lcdFilterComboBox_->setEnabled(true);
   }
 
   drawGlyph();
@@ -376,18 +376,18 @@ MainGUI::checkAntiAliasing()
 void
 MainGUI::checkLcdFilter()
 {
-  int index = lcdFilterComboBox->currentIndex();
-  engine->setLcdFilter(lcdFilterHash.key(index));
+  int index = lcdFilterComboBox_->currentIndex();
+  engine_->setLcdFilter(lcdFilterHash_.key(index));
 }
 
 
 void
 MainGUI::checkShowPoints()
 {
-  if (showPointsCheckBox->isChecked())
-    showPointNumbersCheckBox->setEnabled(true);
+  if (showPointsCheckBox_->isChecked())
+    showPointNumbersCheckBox_->setEnabled(true);
   else
-    showPointNumbersCheckBox->setEnabled(false);
+    showPointNumbersCheckBox_->setEnabled(false);
 
   drawGlyph();
 }
@@ -396,20 +396,20 @@ MainGUI::checkShowPoints()
 void
 MainGUI::checkUnits()
 {
-  int index = unitsComboBox->currentIndex();
+  int index = unitsComboBox_->currentIndex();
 
   if (index == Units_px)
   {
-    dpiLabel->setEnabled(false);
-    dpiSpinBox->setEnabled(false);
-    sizeDoubleSpinBox->setSingleStep(1);
-    sizeDoubleSpinBox->setValue(qRound(sizeDoubleSpinBox->value()));
+    dpiLabel_->setEnabled(false);
+    dpiSpinBox_->setEnabled(false);
+    sizeDoubleSpinBox_->setSingleStep(1);
+    sizeDoubleSpinBox_->setValue(qRound(sizeDoubleSpinBox_->value()));
   }
   else
   {
-    dpiLabel->setEnabled(true);
-    dpiSpinBox->setEnabled(true);
-    sizeDoubleSpinBox->setSingleStep(0.5);
+    dpiLabel_->setEnabled(true);
+    dpiSpinBox_->setEnabled(true);
+    sizeDoubleSpinBox_->setSingleStep(0.5);
   }
 
   drawGlyph();
@@ -420,19 +420,19 @@ void
 MainGUI::adjustGlyphIndex(int delta)
 {
   // only adjust current glyph index if we have a valid font
-  if (currentNumberOfGlyphs > 0)
+  if (currentNumberOfGlyphs_ > 0)
   {
-    currentGlyphIndex += delta;
-    currentGlyphIndex = qBound(0,
-                               currentGlyphIndex,
-                               currentNumberOfGlyphs - 1);
+    currentGlyphIndex_ += delta;
+    currentGlyphIndex_ = qBound(0,
+                               currentGlyphIndex_,
+                               currentNumberOfGlyphs_ - 1);
   }
 
-  QString upperHex = QString::number(currentGlyphIndex, 16).toUpper();
-  glyphIndexLabel->setText(QString("%1 (0x%2)")
-                                   .arg(currentGlyphIndex)
+  QString upperHex = QString::number(currentGlyphIndex_, 16).toUpper();
+  glyphIndexLabel_->setText(QString("%1 (0x%2)")
+                                   .arg(currentGlyphIndex_)
                                    .arg(upperHex));
-  glyphNameLabel->setText(engine->glyphName(currentGlyphIndex));
+  glyphNameLabel_->setText(engine_->glyphName(currentGlyphIndex_));
 
   drawGlyph();
 }
@@ -441,25 +441,25 @@ MainGUI::adjustGlyphIndex(int delta)
 void
 MainGUI::checkCurrentFontIndex()
 {
-  if (engine->numberOfOpenedFonts() < 2)
+  if (engine_->numberOfOpenedFonts() < 2)
   {
-    previousFontButton->setEnabled(false);
-    nextFontButton->setEnabled(false);
+    previousFontButton_->setEnabled(false);
+    nextFontButton_->setEnabled(false);
   }
-  else if (currentFontIndex == 0)
+  else if (currentFontIndex_ == 0)
   {
-    previousFontButton->setEnabled(false);
-    nextFontButton->setEnabled(true);
+    previousFontButton_->setEnabled(false);
+    nextFontButton_->setEnabled(true);
   }
-  else if (currentFontIndex >= engine->numberOfOpenedFonts() - 1)
+  else if (currentFontIndex_ >= engine_->numberOfOpenedFonts() - 1)
   {
-    previousFontButton->setEnabled(true);
-    nextFontButton->setEnabled(false);
+    previousFontButton_->setEnabled(true);
+    nextFontButton_->setEnabled(false);
   }
   else
   {
-    previousFontButton->setEnabled(true);
-    nextFontButton->setEnabled(true);
+    previousFontButton_->setEnabled(true);
+    nextFontButton_->setEnabled(true);
   }
 }
 
@@ -467,25 +467,25 @@ MainGUI::checkCurrentFontIndex()
 void
 MainGUI::checkCurrentFaceIndex()
 {
-  if (currentNumberOfFaces < 2)
+  if (currentNumberOfFaces_ < 2)
   {
-    previousFaceButton->setEnabled(false);
-    nextFaceButton->setEnabled(false);
+    previousFaceButton_->setEnabled(false);
+    nextFaceButton_->setEnabled(false);
   }
-  else if (currentFaceIndex == 0)
+  else if (currentFaceIndex_ == 0)
   {
-    previousFaceButton->setEnabled(false);
-    nextFaceButton->setEnabled(true);
+    previousFaceButton_->setEnabled(false);
+    nextFaceButton_->setEnabled(true);
   }
-  else if (currentFaceIndex >= currentNumberOfFaces - 1)
+  else if (currentFaceIndex_ >= currentNumberOfFaces_ - 1)
   {
-    previousFaceButton->setEnabled(true);
-    nextFaceButton->setEnabled(false);
+    previousFaceButton_->setEnabled(true);
+    nextFaceButton_->setEnabled(false);
   }
   else
   {
-    previousFaceButton->setEnabled(true);
-    nextFaceButton->setEnabled(true);
+    previousFaceButton_->setEnabled(true);
+    nextFaceButton_->setEnabled(true);
   }
 }
 
@@ -493,25 +493,25 @@ MainGUI::checkCurrentFaceIndex()
 void
 MainGUI::checkCurrentNamedInstanceIndex()
 {
-  if (currentNumberOfNamedInstances < 2)
+  if (currentNumberOfNamedInstances_ < 2)
   {
-    previousNamedInstanceButton->setEnabled(false);
-    nextNamedInstanceButton->setEnabled(false);
+    previousNamedInstanceButton_->setEnabled(false);
+    nextNamedInstanceButton_->setEnabled(false);
   }
-  else if (currentNamedInstanceIndex == 0)
+  else if (currentNamedInstanceIndex_ == 0)
   {
-    previousNamedInstanceButton->setEnabled(false);
-    nextNamedInstanceButton->setEnabled(true);
+    previousNamedInstanceButton_->setEnabled(false);
+    nextNamedInstanceButton_->setEnabled(true);
   }
-  else if (currentNamedInstanceIndex >= currentNumberOfNamedInstances - 1)
+  else if (currentNamedInstanceIndex_ >= currentNumberOfNamedInstances_ - 1)
   {
-    previousNamedInstanceButton->setEnabled(true);
-    nextNamedInstanceButton->setEnabled(false);
+    previousNamedInstanceButton_->setEnabled(true);
+    nextNamedInstanceButton_->setEnabled(false);
   }
   else
   {
-    previousNamedInstanceButton->setEnabled(true);
-    nextNamedInstanceButton->setEnabled(true);
+    previousNamedInstanceButton_->setEnabled(true);
+    nextNamedInstanceButton_->setEnabled(true);
   }
 }
 
@@ -519,11 +519,11 @@ MainGUI::checkCurrentNamedInstanceIndex()
 void
 MainGUI::previousFont()
 {
-  if (currentFontIndex > 0)
+  if (currentFontIndex_ > 0)
   {
-    currentFontIndex--;
-    currentFaceIndex = 0;
-    currentNamedInstanceIndex = 0;
+    currentFontIndex_--;
+    currentFaceIndex_ = 0;
+    currentNamedInstanceIndex_ = 0;
     showFont();
   }
 }
@@ -532,11 +532,11 @@ MainGUI::previousFont()
 void
 MainGUI::nextFont()
 {
-  if (currentFontIndex < engine->numberOfOpenedFonts() - 1)
+  if (currentFontIndex_ < engine_->numberOfOpenedFonts() - 1)
   {
-    currentFontIndex++;
-    currentFaceIndex = 0;
-    currentNamedInstanceIndex = 0;
+    currentFontIndex_++;
+    currentFaceIndex_ = 0;
+    currentNamedInstanceIndex_ = 0;
     showFont();
   }
 }
@@ -545,10 +545,10 @@ MainGUI::nextFont()
 void
 MainGUI::previousFace()
 {
-  if (currentFaceIndex > 0)
+  if (currentFaceIndex_ > 0)
   {
-    currentFaceIndex--;
-    currentNamedInstanceIndex = 0;
+    currentFaceIndex_--;
+    currentNamedInstanceIndex_ = 0;
     showFont();
   }
 }
@@ -557,10 +557,10 @@ MainGUI::previousFace()
 void
 MainGUI::nextFace()
 {
-  if (currentFaceIndex < currentNumberOfFaces - 1)
+  if (currentFaceIndex_ < currentNumberOfFaces_ - 1)
   {
-    currentFaceIndex++;
-    currentNamedInstanceIndex = 0;
+    currentFaceIndex_++;
+    currentNamedInstanceIndex_ = 0;
     showFont();
   }
 }
@@ -569,9 +569,9 @@ MainGUI::nextFace()
 void
 MainGUI::previousNamedInstance()
 {
-  if (currentNamedInstanceIndex > 0)
+  if (currentNamedInstanceIndex_ > 0)
   {
-    currentNamedInstanceIndex--;
+    currentNamedInstanceIndex_--;
     showFont();
   }
 }
@@ -580,9 +580,9 @@ MainGUI::previousNamedInstance()
 void
 MainGUI::nextNamedInstance()
 {
-  if (currentNamedInstanceIndex < currentNumberOfNamedInstances - 1)
+  if (currentNamedInstanceIndex_ < currentNumberOfNamedInstances_ - 1)
   {
-    currentNamedInstanceIndex++;
+    currentNamedInstanceIndex_++;
     showFont();
   }
 }
@@ -591,7 +591,7 @@ MainGUI::nextNamedInstance()
 void
 MainGUI::zoom()
 {
-  int scale = zoomSpinBox->value();
+  int scale = zoomSpinBox_->value();
 
   QTransform transform;
   transform.scale(scale, scale);
@@ -602,7 +602,7 @@ MainGUI::zoom()
   qreal shift = 0.5 / scale;
   transform.translate(shift, shift);
 
-  glyphView->setTransform(transform);
+  glyphView_->setTransform(transform);
 }
 
 
@@ -611,28 +611,28 @@ MainGUI::setGraphicsDefaults()
 {
   // color tables (with suitable opacity values) for converting
   // FreeType's pixmaps to something Qt understands
-  monoColorTable.append(QColor(Qt::transparent).rgba());
-  monoColorTable.append(QColor(Qt::black).rgba());
+  monoColorTable_.append(QColor(Qt::transparent).rgba());
+  monoColorTable_.append(QColor(Qt::black).rgba());
 
   for (int i = 0xFF; i >= 0; i--)
-    grayColorTable.append(qRgba(i, i, i, 0xFF - i));
+    grayColorTable_.append(qRgba(i, i, i, 0xFF - i));
 
   // XXX make this user-configurable
 
-  axisPen.setColor(Qt::black);
-  axisPen.setWidth(0);
-  blueZonePen.setColor(QColor(64, 64, 255, 64)); // light blue
-  blueZonePen.setWidth(0);
-  gridPen.setColor(Qt::lightGray);
-  gridPen.setWidth(0);
-  offPen.setColor(Qt::darkGreen);
-  offPen.setWidth(3);
-  onPen.setColor(Qt::red);
-  onPen.setWidth(3);
-  outlinePen.setColor(Qt::red);
-  outlinePen.setWidth(0);
-  segmentPen.setColor(QColor(64, 255, 128, 64)); // light green
-  segmentPen.setWidth(0);
+  axisPen_.setColor(Qt::black);
+  axisPen_.setWidth(0);
+  blueZonePen_.setColor(QColor(64, 64, 255, 64)); // light blue
+  blueZonePen_.setWidth(0);
+  gridPen_.setColor(Qt::lightGray);
+  gridPen_.setWidth(0);
+  offPen_.setColor(Qt::darkGreen);
+  offPen_.setWidth(3);
+  onPen_.setColor(Qt::red);
+  onPen_.setWidth(3);
+  outlinePen_.setColor(Qt::red);
+  outlinePen_.setWidth(0);
+  segmentPen_.setColor(QColor(64, 255, 128, 64)); // light green
+  segmentPen_.setWidth(0);
 }
 
 
@@ -641,82 +641,82 @@ MainGUI::drawGlyph()
 {
   // the call to `engine->loadOutline' updates FreeType's load flags
 
-  if (!engine)
+  if (!engine_)
     return;
 
-  if (currentGlyphBitmapItem)
+  if (currentGlyphBitmapItem_)
   {
-    glyphScene->removeItem(currentGlyphBitmapItem);
-    delete currentGlyphBitmapItem;
+    glyphScene_->removeItem(currentGlyphBitmapItem_);
+    delete currentGlyphBitmapItem_;
 
-    currentGlyphBitmapItem = NULL;
+    currentGlyphBitmapItem_ = NULL;
   }
 
-  if (currentGlyphOutlineItem)
+  if (currentGlyphOutlineItem_)
   {
-    glyphScene->removeItem(currentGlyphOutlineItem);
-    delete currentGlyphOutlineItem;
+    glyphScene_->removeItem(currentGlyphOutlineItem_);
+    delete currentGlyphOutlineItem_;
 
-    currentGlyphOutlineItem = NULL;
+    currentGlyphOutlineItem_ = NULL;
   }
 
-  if (currentGlyphPointsItem)
+  if (currentGlyphPointsItem_)
   {
-    glyphScene->removeItem(currentGlyphPointsItem);
-    delete currentGlyphPointsItem;
+    glyphScene_->removeItem(currentGlyphPointsItem_);
+    delete currentGlyphPointsItem_;
 
-    currentGlyphPointsItem = NULL;
+    currentGlyphPointsItem_ = NULL;
   }
 
-  if (currentGlyphPointNumbersItem)
+  if (currentGlyphPointNumbersItem_)
   {
-    glyphScene->removeItem(currentGlyphPointNumbersItem);
-    delete currentGlyphPointNumbersItem;
+    glyphScene_->removeItem(currentGlyphPointNumbersItem_);
+    delete currentGlyphPointNumbersItem_;
 
-    currentGlyphPointNumbersItem = NULL;
+    currentGlyphPointNumbersItem_ = NULL;
   }
 
   applySettings();
-  FT_Outline* outline = engine->loadOutline(currentGlyphIndex);
+  FT_Outline* outline = engine_->loadOutline(currentGlyphIndex_);
   if (outline)
   {
-    if (showBitmapCheckBox->isChecked())
+    if (showBitmapCheckBox_->isChecked())
     {
       // XXX support LCD
       FT_Pixel_Mode pixelMode = FT_PIXEL_MODE_GRAY;
-      if (antiAliasingComboBoxx->currentIndex() == Engine::AntiAliasing_None)
+      if (antiAliasingComboBoxx_->currentIndex() == Engine::AntiAliasing_None)
         pixelMode = FT_PIXEL_MODE_MONO;
 
-      currentGlyphBitmapItem = new GlyphBitmap(outline,
-                                               engine->ftLibrary(),
+      currentGlyphBitmapItem_ = new GlyphBitmap(outline,
+                                               engine_->ftLibrary(),
                                                pixelMode,
-                                               monoColorTable,
-                                               grayColorTable);
-      glyphScene->addItem(currentGlyphBitmapItem);
+                                               monoColorTable_,
+                                               grayColorTable_);
+      glyphScene_->addItem(currentGlyphBitmapItem_);
     }
 
-    if (showOutlinesCheckBox->isChecked())
+    if (showOutlinesCheckBox_->isChecked())
     {
-      currentGlyphOutlineItem = new GlyphOutline(outlinePen, outline);
-      glyphScene->addItem(currentGlyphOutlineItem);
+      currentGlyphOutlineItem_ = new GlyphOutline(outlinePen_, outline);
+      glyphScene_->addItem(currentGlyphOutlineItem_);
     }
 
-    if (showPointsCheckBox->isChecked())
+    if (showPointsCheckBox_->isChecked())
     {
-      currentGlyphPointsItem = new GlyphPoints(onPen, offPen, outline);
-      glyphScene->addItem(currentGlyphPointsItem);
+      currentGlyphPointsItem_ = new GlyphPoints(onPen_, offPen_, outline);
+      glyphScene_->addItem(currentGlyphPointsItem_);
 
-      if (showPointNumbersCheckBox->isChecked())
+      if (showPointNumbersCheckBox_->isChecked())
       {
-        currentGlyphPointNumbersItem = new GlyphPointNumbers(onPen,
-                                                             offPen,
+        currentGlyphPointNumbersItem_ = new GlyphPointNumbers(onPen_,
+                                                             offPen_,
                                                              outline);
-        glyphScene->addItem(currentGlyphPointNumbersItem);
+        glyphScene_->addItem(currentGlyphPointNumbersItem_);
       }
     }
   }
 
-  glyphScene->update();
+  glyphScene_->update();
 }
 
 
@@ -726,308 +726,308 @@ void
 MainGUI::createLayout()
 {
   // left side
-  fontFilenameLabel = new QLabel;
+  fontFilenameLabel_ = new QLabel;
 
-  hintingCheckBox = new QCheckBox(tr("Hinting"));
+  hintingCheckBox_ = new QCheckBox(tr("Hinting"));
 
-  hintingModeLabel = new QLabel(tr("Hinting Mode"));
-  hintingModeLabel->setAlignment(Qt::AlignRight);
-  hintingModeComboBoxx = new QComboBoxx;
-  hintingModeComboBoxx->insertItem(HintingMode_TrueType_v35,
+  hintingModeLabel_ = new QLabel(tr("Hinting Mode"));
+  hintingModeLabel_->setAlignment(Qt::AlignRight);
+  hintingModeComboBoxx_ = new QComboBoxx;
+  hintingModeComboBoxx_->insertItem(HintingMode_TrueType_v35,
                                    tr("TrueType v35"));
-  hintingModeComboBoxx->insertItem(HintingMode_TrueType_v38,
+  hintingModeComboBoxx_->insertItem(HintingMode_TrueType_v38,
                                    tr("TrueType v38"));
-  hintingModeComboBoxx->insertItem(HintingMode_TrueType_v40,
+  hintingModeComboBoxx_->insertItem(HintingMode_TrueType_v40,
                                    tr("TrueType v40"));
-  hintingModeComboBoxx->insertItem(HintingMode_CFF_FreeType,
+  hintingModeComboBoxx_->insertItem(HintingMode_CFF_FreeType,
                                    tr("CFF (FreeType)"));
-  hintingModeComboBoxx->insertItem(HintingMode_CFF_Adobe,
+  hintingModeComboBoxx_->insertItem(HintingMode_CFF_Adobe,
                                    tr("CFF (Adobe)"));
-  hintingModeLabel->setBuddy(hintingModeComboBoxx);
-
-  autoHintingCheckBox = new QCheckBox(tr("Auto-Hinting"));
-  horizontalHintingCheckBox = new QCheckBox(tr("Horizontal Hinting"));
-  verticalHintingCheckBox = new QCheckBox(tr("Vertical Hinting"));
-  blueZoneHintingCheckBox = new QCheckBox(tr("Blue-Zone Hinting"));
-  segmentDrawingCheckBox = new QCheckBox(tr("Segment Drawing"));
-
-  antiAliasingLabel = new QLabel(tr("Anti-Aliasing"));
-  antiAliasingLabel->setAlignment(Qt::AlignRight);
-  antiAliasingComboBoxx = new QComboBoxx;
-  antiAliasingComboBoxx->insertItem(Engine::AntiAliasing_None,
+  hintingModeLabel_->setBuddy(hintingModeComboBoxx_);
+
+  autoHintingCheckBox_ = new QCheckBox(tr("Auto-Hinting"));
+  horizontalHintingCheckBox_ = new QCheckBox(tr("Horizontal Hinting"));
+  verticalHintingCheckBox_ = new QCheckBox(tr("Vertical Hinting"));
+  blueZoneHintingCheckBox_ = new QCheckBox(tr("Blue-Zone Hinting"));
+  segmentDrawingCheckBox_ = new QCheckBox(tr("Segment Drawing"));
+
+  antiAliasingLabel_ = new QLabel(tr("Anti-Aliasing"));
+  antiAliasingLabel_->setAlignment(Qt::AlignRight);
+  antiAliasingComboBoxx_ = new QComboBoxx;
+  antiAliasingComboBoxx_->insertItem(Engine::AntiAliasing_None,
                                     tr("None"));
-  antiAliasingComboBoxx->insertItem(Engine::AntiAliasing_Normal,
+  antiAliasingComboBoxx_->insertItem(Engine::AntiAliasing_Normal,
                                     tr("Normal"));
-  antiAliasingComboBoxx->insertItem(Engine::AntiAliasing_Light,
+  antiAliasingComboBoxx_->insertItem(Engine::AntiAliasing_Light,
                                     tr("Light"));
-  antiAliasingComboBoxx->insertItem(Engine::AntiAliasing_LCD,
+  antiAliasingComboBoxx_->insertItem(Engine::AntiAliasing_LCD,
                                     tr("LCD (RGB)"));
-  antiAliasingComboBoxx->insertItem(Engine::AntiAliasing_LCD_BGR,
+  antiAliasingComboBoxx_->insertItem(Engine::AntiAliasing_LCD_BGR,
                                     tr("LCD (BGR)"));
-  antiAliasingComboBoxx->insertItem(Engine::AntiAliasing_LCD_Vertical,
+  antiAliasingComboBoxx_->insertItem(Engine::AntiAliasing_LCD_Vertical,
                                     tr("LCD (vert. RGB)"));
-  antiAliasingComboBoxx->insertItem(Engine::AntiAliasing_LCD_Vertical_BGR,
+  antiAliasingComboBoxx_->insertItem(Engine::AntiAliasing_LCD_Vertical_BGR,
                                     tr("LCD (vert. BGR)"));
-  antiAliasingLabel->setBuddy(antiAliasingComboBoxx);
+  antiAliasingLabel_->setBuddy(antiAliasingComboBoxx_);
 
-  lcdFilterLabel = new QLabel(tr("LCD Filter"));
-  lcdFilterLabel->setAlignment(Qt::AlignRight);
-  lcdFilterComboBox = new QComboBox;
-  lcdFilterComboBox->insertItem(LCDFilter_Default, tr("Default"));
-  lcdFilterComboBox->insertItem(LCDFilter_Light, tr("Light"));
-  lcdFilterComboBox->insertItem(LCDFilter_None, tr("None"));
-  lcdFilterComboBox->insertItem(LCDFilter_Legacy, tr("Legacy"));
-  lcdFilterLabel->setBuddy(lcdFilterComboBox);
+  lcdFilterLabel_ = new QLabel(tr("LCD Filter"));
+  lcdFilterLabel_->setAlignment(Qt::AlignRight);
+  lcdFilterComboBox_ = new QComboBox;
+  lcdFilterComboBox_->insertItem(LCDFilter_Default, tr("Default"));
+  lcdFilterComboBox_->insertItem(LCDFilter_Light, tr("Light"));
+  lcdFilterComboBox_->insertItem(LCDFilter_None, tr("None"));
+  lcdFilterComboBox_->insertItem(LCDFilter_Legacy, tr("Legacy"));
+  lcdFilterLabel_->setBuddy(lcdFilterComboBox_);
 
   int width;
   // make all labels have the same width
-  width = hintingModeLabel->minimumSizeHint().width();
-  width = qMax(antiAliasingLabel->minimumSizeHint().width(), width);
-  width = qMax(lcdFilterLabel->minimumSizeHint().width(), width);
-  hintingModeLabel->setMinimumWidth(width);
-  antiAliasingLabel->setMinimumWidth(width);
-  lcdFilterLabel->setMinimumWidth(width);
+  width = hintingModeLabel_->minimumSizeHint().width();
+  width = qMax(antiAliasingLabel_->minimumSizeHint().width(), width);
+  width = qMax(lcdFilterLabel_->minimumSizeHint().width(), width);
+  hintingModeLabel_->setMinimumWidth(width);
+  antiAliasingLabel_->setMinimumWidth(width);
+  lcdFilterLabel_->setMinimumWidth(width);
 
   // ensure that all items in combo boxes fit completely;
   // also make all combo boxes have the same width
-  width = hintingModeComboBoxx->minimumSizeHint().width();
-  width = qMax(antiAliasingComboBoxx->minimumSizeHint().width(), width);
-  width = qMax(lcdFilterComboBox->minimumSizeHint().width(), width);
-  hintingModeComboBoxx->setMinimumWidth(width);
-  antiAliasingComboBoxx->setMinimumWidth(width);
-  lcdFilterComboBox->setMinimumWidth(width);
-
-  gammaLabel = new QLabel(tr("Gamma"));
-  gammaLabel->setAlignment(Qt::AlignRight);
-  gammaSlider = new QSlider(Qt::Horizontal);
-  gammaSlider->setRange(0, 30); // in 1/10th
-  gammaSlider->setTickPosition(QSlider::TicksBelow);
-  gammaSlider->setTickInterval(5);
-  gammaLabel->setBuddy(gammaSlider);
-
-  showBitmapCheckBox = new QCheckBox(tr("Show Bitmap"));
-  showPointsCheckBox = new QCheckBox(tr("Show Points"));
-  showPointNumbersCheckBox = new QCheckBox(tr("Show Point Numbers"));
-  showOutlinesCheckBox = new QCheckBox(tr("Show Outlines"));
-
-  infoLeftLayout = new QHBoxLayout;
-  infoLeftLayout->addWidget(fontFilenameLabel);
-
-  hintingModeLayout = new QHBoxLayout;
-  hintingModeLayout->addWidget(hintingModeLabel);
-  hintingModeLayout->addWidget(hintingModeComboBoxx);
-
-  horizontalHintingLayout = new QHBoxLayout;
-  horizontalHintingLayout->addSpacing(20); // XXX px
-  horizontalHintingLayout->addWidget(horizontalHintingCheckBox);
-
-  verticalHintingLayout = new QHBoxLayout;
-  verticalHintingLayout->addSpacing(20); // XXX px
-  verticalHintingLayout->addWidget(verticalHintingCheckBox);
-
-  blueZoneHintingLayout = new QHBoxLayout;
-  blueZoneHintingLayout->addSpacing(20); // XXX px
-  blueZoneHintingLayout->addWidget(blueZoneHintingCheckBox);
-
-  segmentDrawingLayout = new QHBoxLayout;
-  segmentDrawingLayout->addSpacing(20); // XXX px
-  segmentDrawingLayout->addWidget(segmentDrawingCheckBox);
-
-  antiAliasingLayout = new QHBoxLayout;
-  antiAliasingLayout->addWidget(antiAliasingLabel);
-  antiAliasingLayout->addWidget(antiAliasingComboBoxx);
-
-  lcdFilterLayout = new QHBoxLayout;
-  lcdFilterLayout->addWidget(lcdFilterLabel);
-  lcdFilterLayout->addWidget(lcdFilterComboBox);
-
-  gammaLayout = new QHBoxLayout;
-  gammaLayout->addWidget(gammaLabel);
-  gammaLayout->addWidget(gammaSlider);
-
-  pointNumbersLayout = new QHBoxLayout;
-  pointNumbersLayout->addSpacing(20); // XXX px
-  pointNumbersLayout->addWidget(showPointNumbersCheckBox);
-
-  generalTabLayout = new QVBoxLayout;
-  generalTabLayout->addWidget(hintingCheckBox);
-  generalTabLayout->addLayout(hintingModeLayout);
-  generalTabLayout->addWidget(autoHintingCheckBox);
-  generalTabLayout->addLayout(horizontalHintingLayout);
-  generalTabLayout->addLayout(verticalHintingLayout);
-  generalTabLayout->addLayout(blueZoneHintingLayout);
-  generalTabLayout->addLayout(segmentDrawingLayout);
-  generalTabLayout->addSpacing(20); // XXX px
-  generalTabLayout->addStretch(1);
-  generalTabLayout->addLayout(antiAliasingLayout);
-  generalTabLayout->addLayout(lcdFilterLayout);
-  generalTabLayout->addSpacing(20); // XXX px
-  generalTabLayout->addStretch(1);
-  generalTabLayout->addLayout(gammaLayout);
-  generalTabLayout->addSpacing(20); // XXX px
-  generalTabLayout->addStretch(1);
-  generalTabLayout->addWidget(showBitmapCheckBox);
-  generalTabLayout->addWidget(showPointsCheckBox);
-  generalTabLayout->addLayout(pointNumbersLayout);
-  generalTabLayout->addWidget(showOutlinesCheckBox);
-
-  generalTabWidget = new QWidget;
-  generalTabWidget->setLayout(generalTabLayout);
-
-  mmgxTabWidget = new QWidget;
-
-  tabWidget = new QTabWidget;
-  tabWidget->addTab(generalTabWidget, tr("General"));
-  tabWidget->addTab(mmgxTabWidget, tr("MM/GX"));
-
-  leftLayout = new QVBoxLayout;
-  leftLayout->addLayout(infoLeftLayout);
-  leftLayout->addWidget(tabWidget);
+  width = hintingModeComboBoxx_->minimumSizeHint().width();
+  width = qMax(antiAliasingComboBoxx_->minimumSizeHint().width(), width);
+  width = qMax(lcdFilterComboBox_->minimumSizeHint().width(), width);
+  hintingModeComboBoxx_->setMinimumWidth(width);
+  antiAliasingComboBoxx_->setMinimumWidth(width);
+  lcdFilterComboBox_->setMinimumWidth(width);
+
+  gammaLabel_ = new QLabel(tr("Gamma"));
+  gammaLabel_->setAlignment(Qt::AlignRight);
+  gammaSlider_ = new QSlider(Qt::Horizontal);
+  gammaSlider_->setRange(0, 30); // in 1/10th
+  gammaSlider_->setTickPosition(QSlider::TicksBelow);
+  gammaSlider_->setTickInterval(5);
+  gammaLabel_->setBuddy(gammaSlider_);
+
+  showBitmapCheckBox_ = new QCheckBox(tr("Show Bitmap"));
+  showPointsCheckBox_ = new QCheckBox(tr("Show Points"));
+  showPointNumbersCheckBox_ = new QCheckBox(tr("Show Point Numbers"));
+  showOutlinesCheckBox_ = new QCheckBox(tr("Show Outlines"));
+
+  infoLeftLayout_ = new QHBoxLayout;
+  infoLeftLayout_->addWidget(fontFilenameLabel_);
+
+  hintingModeLayout_ = new QHBoxLayout;
+  hintingModeLayout_->addWidget(hintingModeLabel_);
+  hintingModeLayout_->addWidget(hintingModeComboBoxx_);
+
+  horizontalHintingLayout_ = new QHBoxLayout;
+  horizontalHintingLayout_->addSpacing(20); // XXX px
+  horizontalHintingLayout_->addWidget(horizontalHintingCheckBox_);
+
+  verticalHintingLayout_ = new QHBoxLayout;
+  verticalHintingLayout_->addSpacing(20); // XXX px
+  verticalHintingLayout_->addWidget(verticalHintingCheckBox_);
+
+  blueZoneHintingLayout_ = new QHBoxLayout;
+  blueZoneHintingLayout_->addSpacing(20); // XXX px
+  blueZoneHintingLayout_->addWidget(blueZoneHintingCheckBox_);
+
+  segmentDrawingLayout_ = new QHBoxLayout;
+  segmentDrawingLayout_->addSpacing(20); // XXX px
+  segmentDrawingLayout_->addWidget(segmentDrawingCheckBox_);
+
+  antiAliasingLayout_ = new QHBoxLayout;
+  antiAliasingLayout_->addWidget(antiAliasingLabel_);
+  antiAliasingLayout_->addWidget(antiAliasingComboBoxx_);
+
+  lcdFilterLayout_ = new QHBoxLayout;
+  lcdFilterLayout_->addWidget(lcdFilterLabel_);
+  lcdFilterLayout_->addWidget(lcdFilterComboBox_);
+
+  gammaLayout_ = new QHBoxLayout;
+  gammaLayout_->addWidget(gammaLabel_);
+  gammaLayout_->addWidget(gammaSlider_);
+
+  pointNumbersLayout_ = new QHBoxLayout;
+  pointNumbersLayout_->addSpacing(20); // XXX px
+  pointNumbersLayout_->addWidget(showPointNumbersCheckBox_);
+
+  generalTabLayout_ = new QVBoxLayout;
+  generalTabLayout_->addWidget(hintingCheckBox_);
+  generalTabLayout_->addLayout(hintingModeLayout_);
+  generalTabLayout_->addWidget(autoHintingCheckBox_);
+  generalTabLayout_->addLayout(horizontalHintingLayout_);
+  generalTabLayout_->addLayout(verticalHintingLayout_);
+  generalTabLayout_->addLayout(blueZoneHintingLayout_);
+  generalTabLayout_->addLayout(segmentDrawingLayout_);
+  generalTabLayout_->addSpacing(20); // XXX px
+  generalTabLayout_->addStretch(1);
+  generalTabLayout_->addLayout(antiAliasingLayout_);
+  generalTabLayout_->addLayout(lcdFilterLayout_);
+  generalTabLayout_->addSpacing(20); // XXX px
+  generalTabLayout_->addStretch(1);
+  generalTabLayout_->addLayout(gammaLayout_);
+  generalTabLayout_->addSpacing(20); // XXX px
+  generalTabLayout_->addStretch(1);
+  generalTabLayout_->addWidget(showBitmapCheckBox_);
+  generalTabLayout_->addWidget(showPointsCheckBox_);
+  generalTabLayout_->addLayout(pointNumbersLayout_);
+  generalTabLayout_->addWidget(showOutlinesCheckBox_);
+
+  generalTabWidget_ = new QWidget;
+  generalTabWidget_->setLayout(generalTabLayout_);
+
+  mmgxTabWidget_ = new QWidget;
+
+  tabWidget_ = new QTabWidget;
+  tabWidget_->addTab(generalTabWidget_, tr("General"));
+  tabWidget_->addTab(mmgxTabWidget_, tr("MM/GX"));
+
+  leftLayout_ = new QVBoxLayout;
+  leftLayout_->addLayout(infoLeftLayout_);
+  leftLayout_->addWidget(tabWidget_);
 
   // we don't want to expand the left side horizontally;
   // to change the policy we have to use a widget wrapper
-  leftWidget = new QWidget;
-  leftWidget->setLayout(leftLayout);
+  leftWidget_ = new QWidget;
+  leftWidget_->setLayout(leftLayout_);
 
   QSizePolicy leftWidgetPolicy(QSizePolicy::Fixed, QSizePolicy::Preferred);
   leftWidgetPolicy.setHorizontalStretch(0);
-  
leftWidgetPolicy.setVerticalPolicy(leftWidget->sizePolicy().verticalPolicy());
-  
leftWidgetPolicy.setHeightForWidth(leftWidget->sizePolicy().hasHeightForWidth());
+  
leftWidgetPolicy.setVerticalPolicy(leftWidget_->sizePolicy().verticalPolicy());
+  
leftWidgetPolicy.setHeightForWidth(leftWidget_->sizePolicy().hasHeightForWidth());
 
-  leftWidget->setSizePolicy(leftWidgetPolicy);
+  leftWidget_->setSizePolicy(leftWidgetPolicy);
 
   // right side
-  glyphIndexLabel = new QLabel;
-  glyphNameLabel = new QLabel;
-  fontNameLabel = new QLabel;
-
-  glyphScene = new QGraphicsScene;
-  glyphScene->addItem(new Grid(gridPen, axisPen));
-
-  currentGlyphBitmapItem = NULL;
-  currentGlyphOutlineItem = NULL;
-  currentGlyphPointsItem = NULL;
-  currentGlyphPointNumbersItem = NULL;
-
-  glyphView = new QGraphicsViewx;
-  glyphView->setRenderHint(QPainter::Antialiasing, true);
-  glyphView->setDragMode(QGraphicsView::ScrollHandDrag);
-  glyphView->setOptimizationFlags(QGraphicsView::DontSavePainterState);
-  glyphView->setViewportUpdateMode(QGraphicsView::SmartViewportUpdate);
-  glyphView->setTransformationAnchor(QGraphicsView::AnchorUnderMouse);
-  glyphView->setScene(glyphScene);
-
-  sizeLabel = new QLabel(tr("Size "));
-  sizeLabel->setAlignment(Qt::AlignRight);
-  sizeDoubleSpinBox = new QDoubleSpinBox;
-  sizeDoubleSpinBox->setAlignment(Qt::AlignRight);
-  sizeDoubleSpinBox->setDecimals(1);
-  sizeDoubleSpinBox->setRange(1, 500);
-  sizeLabel->setBuddy(sizeDoubleSpinBox);
-
-  unitsComboBox = new QComboBox;
-  unitsComboBox->insertItem(Units_px, "px");
-  unitsComboBox->insertItem(Units_pt, "pt");
-
-  dpiLabel = new QLabel(tr("DPI "));
-  dpiLabel->setAlignment(Qt::AlignRight);
-  dpiSpinBox = new QSpinBox;
-  dpiSpinBox->setAlignment(Qt::AlignRight);
-  dpiSpinBox->setRange(10, 600);
-  dpiLabel->setBuddy(dpiSpinBox);
-
-  toStartButtonx = new QPushButtonx("|<");
-  toM1000Buttonx = new QPushButtonx("-1000");
-  toM100Buttonx = new QPushButtonx("-100");
-  toM10Buttonx = new QPushButtonx("-10");
-  toM1Buttonx = new QPushButtonx("-1");
-  toP1Buttonx = new QPushButtonx("+1");
-  toP10Buttonx = new QPushButtonx("+10");
-  toP100Buttonx = new QPushButtonx("+100");
-  toP1000Buttonx = new QPushButtonx("+1000");
-  toEndButtonx = new QPushButtonx(">|");
-
-  zoomLabel = new QLabel(tr("Zoom Factor"));
-  zoomLabel->setAlignment(Qt::AlignRight);
-  zoomSpinBox = new QSpinBoxx;
-  zoomSpinBox->setAlignment(Qt::AlignRight);
-  zoomSpinBox->setRange(1, 1000 - 1000 % 64);
-  zoomSpinBox->setKeyboardTracking(false);
-  zoomLabel->setBuddy(zoomSpinBox);
-
-  previousFontButton = new QPushButton(tr("Previous Font"));
-  nextFontButton = new QPushButton(tr("Next Font"));
-  previousFaceButton = new QPushButton(tr("Previous Face"));
-  nextFaceButton = new QPushButton(tr("Next Face"));
-  previousNamedInstanceButton = new QPushButton(tr("Previous Named Instance"));
-  nextNamedInstanceButton = new QPushButton(tr("Next Named Instance"));
+  glyphIndexLabel_ = new QLabel;
+  glyphNameLabel_ = new QLabel;
+  fontNameLabel_ = new QLabel;
+
+  glyphScene_ = new QGraphicsScene;
+  glyphScene_->addItem(new Grid(gridPen_, axisPen_));
+
+  currentGlyphBitmapItem_ = NULL;
+  currentGlyphOutlineItem_ = NULL;
+  currentGlyphPointsItem_ = NULL;
+  currentGlyphPointNumbersItem_ = NULL;
+
+  glyphView_ = new QGraphicsViewx;
+  glyphView_->setRenderHint(QPainter::Antialiasing, true);
+  glyphView_->setDragMode(QGraphicsView::ScrollHandDrag);
+  glyphView_->setOptimizationFlags(QGraphicsView::DontSavePainterState);
+  glyphView_->setViewportUpdateMode(QGraphicsView::SmartViewportUpdate);
+  glyphView_->setTransformationAnchor(QGraphicsView::AnchorUnderMouse);
+  glyphView_->setScene(glyphScene_);
+
+  sizeLabel_ = new QLabel(tr("Size "));
+  sizeLabel_->setAlignment(Qt::AlignRight);
+  sizeDoubleSpinBox_ = new QDoubleSpinBox;
+  sizeDoubleSpinBox_->setAlignment(Qt::AlignRight);
+  sizeDoubleSpinBox_->setDecimals(1);
+  sizeDoubleSpinBox_->setRange(1, 500);
+  sizeLabel_->setBuddy(sizeDoubleSpinBox_);
+
+  unitsComboBox_ = new QComboBox;
+  unitsComboBox_->insertItem(Units_px, "px");
+  unitsComboBox_->insertItem(Units_pt, "pt");
+
+  dpiLabel_ = new QLabel(tr("DPI "));
+  dpiLabel_->setAlignment(Qt::AlignRight);
+  dpiSpinBox_ = new QSpinBox;
+  dpiSpinBox_->setAlignment(Qt::AlignRight);
+  dpiSpinBox_->setRange(10, 600);
+  dpiLabel_->setBuddy(dpiSpinBox_);
+
+  toStartButtonx_ = new QPushButtonx("|<");
+  toM1000Buttonx_ = new QPushButtonx("-1000");
+  toM100Buttonx_ = new QPushButtonx("-100");
+  toM10Buttonx_ = new QPushButtonx("-10");
+  toM1Buttonx_ = new QPushButtonx("-1");
+  toP1Buttonx_ = new QPushButtonx("+1");
+  toP10Buttonx_ = new QPushButtonx("+10");
+  toP100Buttonx_ = new QPushButtonx("+100");
+  toP1000Buttonx_ = new QPushButtonx("+1000");
+  toEndButtonx_ = new QPushButtonx(">|");
+
+  zoomLabel_ = new QLabel(tr("Zoom Factor"));
+  zoomLabel_->setAlignment(Qt::AlignRight);
+  zoomSpinBox_ = new QSpinBoxx;
+  zoomSpinBox_->setAlignment(Qt::AlignRight);
+  zoomSpinBox_->setRange(1, 1000 - 1000 % 64);
+  zoomSpinBox_->setKeyboardTracking(false);
+  zoomLabel_->setBuddy(zoomSpinBox_);
+
+  previousFontButton_ = new QPushButton(tr("Previous Font"));
+  nextFontButton_ = new QPushButton(tr("Next Font"));
+  previousFaceButton_ = new QPushButton(tr("Previous Face"));
+  nextFaceButton_ = new QPushButton(tr("Next Face"));
+  previousNamedInstanceButton_ = new QPushButton(tr("Previous Named 
Instance"));
+  nextNamedInstanceButton_ = new QPushButton(tr("Next Named Instance"));
 
   infoRightLayout = new QGridLayout;
-  infoRightLayout->addWidget(glyphIndexLabel, 0, 0);
-  infoRightLayout->addWidget(glyphNameLabel, 0, 1);
-  infoRightLayout->addWidget(fontNameLabel, 0, 2);
-
-  navigationLayout = new QHBoxLayout;
-  navigationLayout->setSpacing(0);
-  navigationLayout->addStretch(1);
-  navigationLayout->addWidget(toStartButtonx);
-  navigationLayout->addWidget(toM1000Buttonx);
-  navigationLayout->addWidget(toM100Buttonx);
-  navigationLayout->addWidget(toM10Buttonx);
-  navigationLayout->addWidget(toM1Buttonx);
-  navigationLayout->addWidget(toP1Buttonx);
-  navigationLayout->addWidget(toP10Buttonx);
-  navigationLayout->addWidget(toP100Buttonx);
-  navigationLayout->addWidget(toP1000Buttonx);
-  navigationLayout->addWidget(toEndButtonx);
-  navigationLayout->addStretch(1);
-
-  sizeLayout = new QHBoxLayout;
-  sizeLayout->addStretch(2);
-  sizeLayout->addWidget(sizeLabel);
-  sizeLayout->addWidget(sizeDoubleSpinBox);
-  sizeLayout->addWidget(unitsComboBox);
-  sizeLayout->addStretch(1);
-  sizeLayout->addWidget(dpiLabel);
-  sizeLayout->addWidget(dpiSpinBox);
-  sizeLayout->addStretch(1);
-  sizeLayout->addWidget(zoomLabel);
-  sizeLayout->addWidget(zoomSpinBox);
-  sizeLayout->addStretch(2);
+  infoRightLayout->addWidget(glyphIndexLabel_, 0, 0);
+  infoRightLayout->addWidget(glyphNameLabel_, 0, 1);
+  infoRightLayout->addWidget(fontNameLabel_, 0, 2);
+
+  navigationLayout_ = new QHBoxLayout;
+  navigationLayout_->setSpacing(0);
+  navigationLayout_->addStretch(1);
+  navigationLayout_->addWidget(toStartButtonx_);
+  navigationLayout_->addWidget(toM1000Buttonx_);
+  navigationLayout_->addWidget(toM100Buttonx_);
+  navigationLayout_->addWidget(toM10Buttonx_);
+  navigationLayout_->addWidget(toM1Buttonx_);
+  navigationLayout_->addWidget(toP1Buttonx_);
+  navigationLayout_->addWidget(toP10Buttonx_);
+  navigationLayout_->addWidget(toP100Buttonx_);
+  navigationLayout_->addWidget(toP1000Buttonx_);
+  navigationLayout_->addWidget(toEndButtonx_);
+  navigationLayout_->addStretch(1);
+
+  sizeLayout_ = new QHBoxLayout;
+  sizeLayout_->addStretch(2);
+  sizeLayout_->addWidget(sizeLabel_);
+  sizeLayout_->addWidget(sizeDoubleSpinBox_);
+  sizeLayout_->addWidget(unitsComboBox_);
+  sizeLayout_->addStretch(1);
+  sizeLayout_->addWidget(dpiLabel_);
+  sizeLayout_->addWidget(dpiSpinBox_);
+  sizeLayout_->addStretch(1);
+  sizeLayout_->addWidget(zoomLabel_);
+  sizeLayout_->addWidget(zoomSpinBox_);
+  sizeLayout_->addStretch(2);
 
   fontLayout = new QGridLayout;
   fontLayout->setColumnStretch(0, 2);
-  fontLayout->addWidget(nextFontButton, 0, 1);
-  fontLayout->addWidget(previousFontButton, 1, 1);
+  fontLayout->addWidget(nextFontButton_, 0, 1);
+  fontLayout->addWidget(previousFontButton_, 1, 1);
   fontLayout->setColumnStretch(2, 1);
-  fontLayout->addWidget(nextFaceButton, 0, 3);
-  fontLayout->addWidget(previousFaceButton, 1, 3);
+  fontLayout->addWidget(nextFaceButton_, 0, 3);
+  fontLayout->addWidget(previousFaceButton_, 1, 3);
   fontLayout->setColumnStretch(4, 1);
-  fontLayout->addWidget(nextNamedInstanceButton, 0, 5);
-  fontLayout->addWidget(previousNamedInstanceButton, 1, 5);
+  fontLayout->addWidget(nextNamedInstanceButton_, 0, 5);
+  fontLayout->addWidget(previousNamedInstanceButton_, 1, 5);
   fontLayout->setColumnStretch(6, 2);
 
-  rightLayout = new QVBoxLayout;
-  rightLayout->addLayout(infoRightLayout);
-  rightLayout->addWidget(glyphView);
-  rightLayout->addLayout(navigationLayout);
-  rightLayout->addSpacing(10); // XXX px
-  rightLayout->addLayout(sizeLayout);
-  rightLayout->addSpacing(10); // XXX px
-  rightLayout->addLayout(fontLayout);
+  rightLayout_ = new QVBoxLayout;
+  rightLayout_->addLayout(infoRightLayout);
+  rightLayout_->addWidget(glyphView_);
+  rightLayout_->addLayout(navigationLayout_);
+  rightLayout_->addSpacing(10); // XXX px
+  rightLayout_->addLayout(sizeLayout_);
+  rightLayout_->addSpacing(10); // XXX px
+  rightLayout_->addLayout(fontLayout);
 
   // for symmetry with the left side use a widget also
-  rightWidget = new QWidget;
-  rightWidget->setLayout(rightLayout);
+  rightWidget_ = new QWidget;
+  rightWidget_->setLayout(rightLayout_);
 
   // the whole thing
-  ftinspectLayout = new QHBoxLayout;
-  ftinspectLayout->addWidget(leftWidget);
-  ftinspectLayout->addWidget(rightWidget);
+  ftinspectLayout_ = new QHBoxLayout;
+  ftinspectLayout_->addWidget(leftWidget_);
+  ftinspectLayout_->addWidget(rightWidget_);
 
-  ftinspectWidget = new QWidget;
-  ftinspectWidget->setLayout(ftinspectLayout);
-  setCentralWidget(ftinspectWidget);
+  ftinspectWidget_ = new QWidget;
+  ftinspectWidget_->setLayout(ftinspectLayout_);
+  setCentralWidget(ftinspectWidget_);
   setWindowTitle("ftinspect");
 }
 
@@ -1035,125 +1035,125 @@ MainGUI::createLayout()
 void
 MainGUI::createConnections()
 {
-  connect(hintingCheckBox, SIGNAL(clicked()),
+  connect(hintingCheckBox_, SIGNAL(clicked()),
           SLOT(checkHinting()));
 
-  connect(hintingModeComboBoxx, SIGNAL(currentIndexChanged(int)),
+  connect(hintingModeComboBoxx_, SIGNAL(currentIndexChanged(int)),
           SLOT(checkHintingMode()));
-  connect(antiAliasingComboBoxx, SIGNAL(currentIndexChanged(int)),
+  connect(antiAliasingComboBoxx_, SIGNAL(currentIndexChanged(int)),
           SLOT(checkAntiAliasing()));
-  connect(lcdFilterComboBox, SIGNAL(currentIndexChanged(int)),
+  connect(lcdFilterComboBox_, SIGNAL(currentIndexChanged(int)),
           SLOT(checkLcdFilter()));
 
-  connect(autoHintingCheckBox, SIGNAL(clicked()),
+  connect(autoHintingCheckBox_, SIGNAL(clicked()),
           SLOT(checkAutoHinting()));
-  connect(showBitmapCheckBox, SIGNAL(clicked()),
+  connect(showBitmapCheckBox_, SIGNAL(clicked()),
           SLOT(drawGlyph()));
-  connect(showPointsCheckBox, SIGNAL(clicked()),
+  connect(showPointsCheckBox_, SIGNAL(clicked()),
           SLOT(checkShowPoints()));
-  connect(showPointNumbersCheckBox, SIGNAL(clicked()),
+  connect(showPointNumbersCheckBox_, SIGNAL(clicked()),
           SLOT(drawGlyph()));
-  connect(showOutlinesCheckBox, SIGNAL(clicked()),
+  connect(showOutlinesCheckBox_, SIGNAL(clicked()),
           SLOT(drawGlyph()));
 
-  connect(sizeDoubleSpinBox, SIGNAL(valueChanged(double)),
+  connect(sizeDoubleSpinBox_, SIGNAL(valueChanged(double)),
           SLOT(drawGlyph()));
-  connect(unitsComboBox, SIGNAL(currentIndexChanged(int)),
+  connect(unitsComboBox_, SIGNAL(currentIndexChanged(int)),
           SLOT(checkUnits()));
-  connect(dpiSpinBox, SIGNAL(valueChanged(int)),
+  connect(dpiSpinBox_, SIGNAL(valueChanged(int)),
           SLOT(drawGlyph()));
 
-  connect(zoomSpinBox, SIGNAL(valueChanged(int)),
+  connect(zoomSpinBox_, SIGNAL(valueChanged(int)),
           SLOT(zoom()));
 
-  connect(previousFontButton, SIGNAL(clicked()),
+  connect(previousFontButton_, SIGNAL(clicked()),
           SLOT(previousFont()));
-  connect(nextFontButton, SIGNAL(clicked()),
+  connect(nextFontButton_, SIGNAL(clicked()),
           SLOT(nextFont()));
-  connect(previousFaceButton, SIGNAL(clicked()),
+  connect(previousFaceButton_, SIGNAL(clicked()),
           SLOT(previousFace()));
-  connect(nextFaceButton, SIGNAL(clicked()),
+  connect(nextFaceButton_, SIGNAL(clicked()),
           SLOT(nextFace()));
-  connect(previousNamedInstanceButton, SIGNAL(clicked()),
+  connect(previousNamedInstanceButton_, SIGNAL(clicked()),
           SLOT(previousNamedInstance()));
-  connect(nextNamedInstanceButton, SIGNAL(clicked()),
+  connect(nextNamedInstanceButton_, SIGNAL(clicked()),
           SLOT(nextNamedInstance()));
 
-  glyphNavigationMapper = new QSignalMapper;
-  connect(glyphNavigationMapper, SIGNAL(mapped(int)),
+  glyphNavigationMapper_ = new QSignalMapper;
+  connect(glyphNavigationMapper_, SIGNAL(mapped(int)),
           SLOT(adjustGlyphIndex(int)));
 
-  connect(toStartButtonx, SIGNAL(clicked()),
-          glyphNavigationMapper, SLOT(map()));
-  connect(toM1000Buttonx, SIGNAL(clicked()),
-          glyphNavigationMapper, SLOT(map()));
-  connect(toM100Buttonx, SIGNAL(clicked()),
-          glyphNavigationMapper, SLOT(map()));
-  connect(toM10Buttonx, SIGNAL(clicked()),
-          glyphNavigationMapper, SLOT(map()));
-  connect(toM1Buttonx, SIGNAL(clicked()),
-          glyphNavigationMapper, SLOT(map()));
-  connect(toP1Buttonx, SIGNAL(clicked()),
-          glyphNavigationMapper, SLOT(map()));
-  connect(toP10Buttonx, SIGNAL(clicked()),
-          glyphNavigationMapper, SLOT(map()));
-  connect(toP100Buttonx, SIGNAL(clicked()),
-          glyphNavigationMapper, SLOT(map()));
-  connect(toP1000Buttonx, SIGNAL(clicked()),
-          glyphNavigationMapper, SLOT(map()));
-  connect(toEndButtonx, SIGNAL(clicked()),
-          glyphNavigationMapper, SLOT(map()));
-
-  glyphNavigationMapper->setMapping(toStartButtonx, -0x10000);
-  glyphNavigationMapper->setMapping(toM1000Buttonx, -1000);
-  glyphNavigationMapper->setMapping(toM100Buttonx, -100);
-  glyphNavigationMapper->setMapping(toM10Buttonx, -10);
-  glyphNavigationMapper->setMapping(toM1Buttonx, -1);
-  glyphNavigationMapper->setMapping(toP1Buttonx, 1);
-  glyphNavigationMapper->setMapping(toP10Buttonx, 10);
-  glyphNavigationMapper->setMapping(toP100Buttonx, 100);
-  glyphNavigationMapper->setMapping(toP1000Buttonx, 1000);
-  glyphNavigationMapper->setMapping(toEndButtonx, 0x10000);
-
-  connect(&engine->fontFileManager(), &FontFileManager::currentFileChanged,
-          this, &MainGUI::watchCurrentFont);
+  connect(toStartButtonx_, SIGNAL(clicked()),
+          glyphNavigationMapper_, SLOT(map()));
+  connect(toM1000Buttonx_, SIGNAL(clicked()),
+          glyphNavigationMapper_, SLOT(map()));
+  connect(toM100Buttonx_, SIGNAL(clicked()),
+          glyphNavigationMapper_, SLOT(map()));
+  connect(toM10Buttonx_, SIGNAL(clicked()),
+          glyphNavigationMapper_, SLOT(map()));
+  connect(toM1Buttonx_, SIGNAL(clicked()),
+          glyphNavigationMapper_, SLOT(map()));
+  connect(toP1Buttonx_, SIGNAL(clicked()),
+          glyphNavigationMapper_, SLOT(map()));
+  connect(toP10Buttonx_, SIGNAL(clicked()),
+          glyphNavigationMapper_, SLOT(map()));
+  connect(toP100Buttonx_, SIGNAL(clicked()),
+          glyphNavigationMapper_, SLOT(map()));
+  connect(toP1000Buttonx_, SIGNAL(clicked()),
+          glyphNavigationMapper_, SLOT(map()));
+  connect(toEndButtonx_, SIGNAL(clicked()),
+          glyphNavigationMapper_, SLOT(map()));
+
+  glyphNavigationMapper_->setMapping(toStartButtonx_, -0x10000);
+  glyphNavigationMapper_->setMapping(toM1000Buttonx_, -1000);
+  glyphNavigationMapper_->setMapping(toM100Buttonx_, -100);
+  glyphNavigationMapper_->setMapping(toM10Buttonx_, -10);
+  glyphNavigationMapper_->setMapping(toM1Buttonx_, -1);
+  glyphNavigationMapper_->setMapping(toP1Buttonx_, 1);
+  glyphNavigationMapper_->setMapping(toP10Buttonx_, 10);
+  glyphNavigationMapper_->setMapping(toP100Buttonx_, 100);
+  glyphNavigationMapper_->setMapping(toP1000Buttonx_, 1000);
+  glyphNavigationMapper_->setMapping(toEndButtonx_, 0x10000);
+
+  connect(&engine_->fontFileManager(), &FontFileManager::currentFileChanged,
+      this, &MainGUI::watchCurrentFont);
 }
 
 
 void
 MainGUI::createActions()
 {
-  loadFontsAct = new QAction(tr("&Load Fonts"), this);
-  loadFontsAct->setShortcuts(QKeySequence::Open);
-  connect(loadFontsAct, SIGNAL(triggered()), SLOT(loadFonts()));
+  loadFontsAct_ = new QAction(tr("&Load Fonts"), this);
+  loadFontsAct_->setShortcuts(QKeySequence::Open);
+  connect(loadFontsAct_, SIGNAL(triggered()), SLOT(loadFonts()));
 
-  closeFontAct = new QAction(tr("&Close Font"), this);
-  closeFontAct->setShortcuts(QKeySequence::Close);
-  connect(closeFontAct, SIGNAL(triggered()), SLOT(closeFont()));
+  closeFontAct_ = new QAction(tr("&Close Font"), this);
+  closeFontAct_->setShortcuts(QKeySequence::Close);
+  connect(closeFontAct_, SIGNAL(triggered()), SLOT(closeFont()));
 
-  exitAct = new QAction(tr("E&xit"), this);
-  exitAct->setShortcuts(QKeySequence::Quit);
-  connect(exitAct, SIGNAL(triggered()), SLOT(close()));
+  exitAct_ = new QAction(tr("E&xit"), this);
+  exitAct_->setShortcuts(QKeySequence::Quit);
+  connect(exitAct_, SIGNAL(triggered()), SLOT(close()));
 
-  aboutAct = new QAction(tr("&About"), this);
-  connect(aboutAct, SIGNAL(triggered()), SLOT(about()));
+  aboutAct_ = new QAction(tr("&About"), this);
+  connect(aboutAct_, SIGNAL(triggered()), SLOT(about()));
 
-  aboutQtAct = new QAction(tr("About &Qt"), this);
-  connect(aboutQtAct, SIGNAL(triggered()), SLOT(aboutQt()));
+  aboutQtAct_ = new QAction(tr("About &Qt"), this);
+  connect(aboutQtAct_, SIGNAL(triggered()), SLOT(aboutQt()));
 }
 
 
 void
 MainGUI::createMenus()
 {
-  menuFile = menuBar()->addMenu(tr("&File"));
-  menuFile->addAction(loadFontsAct);
-  menuFile->addAction(closeFontAct);
-  menuFile->addAction(exitAct);
-
-  menuHelp = menuBar()->addMenu(tr("&Help"));
-  menuHelp->addAction(aboutAct);
-  menuHelp->addAction(aboutQtAct);
+  menuFile_ = menuBar()->addMenu(tr("&File"));
+  menuFile_->addAction(loadFontsAct_);
+  menuFile_->addAction(closeFontAct_);
+  menuFile_->addAction(exitAct_);
+
+  menuHelp_ = menuBar()->addMenu(tr("&Help"));
+  menuHelp_->addAction(aboutAct_);
+  menuHelp_->addAction(aboutQtAct_);
 }
 
 
@@ -1168,22 +1168,22 @@ void
 MainGUI::setDefaults()
 {
   // set up mappings between property values and combo box indices
-  hintingModesTrueTypeHash[TT_INTERPRETER_VERSION_35] = 
HintingMode_TrueType_v35;
-  hintingModesTrueTypeHash[TT_INTERPRETER_VERSION_38] = 
HintingMode_TrueType_v38;
-  hintingModesTrueTypeHash[TT_INTERPRETER_VERSION_40] = 
HintingMode_TrueType_v40;
+  hintingModesTrueTypeHash_[TT_INTERPRETER_VERSION_35] = 
HintingMode_TrueType_v35;
+  hintingModesTrueTypeHash_[TT_INTERPRETER_VERSION_38] = 
HintingMode_TrueType_v38;
+  hintingModesTrueTypeHash_[TT_INTERPRETER_VERSION_40] = 
HintingMode_TrueType_v40;
 
-  hintingModesCFFHash[FT_HINTING_FREETYPE] = HintingMode_CFF_FreeType;
-  hintingModesCFFHash[FT_HINTING_ADOBE] = HintingMode_CFF_Adobe;
+  hintingModesCFFHash_[FT_HINTING_FREETYPE] = HintingMode_CFF_FreeType;
+  hintingModesCFFHash_[FT_HINTING_ADOBE] = HintingMode_CFF_Adobe;
 
-  lcdFilterHash[FT_LCD_FILTER_DEFAULT] = LCDFilter_Default;
-  lcdFilterHash[FT_LCD_FILTER_LIGHT] = LCDFilter_Light;
-  lcdFilterHash[FT_LCD_FILTER_NONE] = LCDFilter_None;
-  lcdFilterHash[FT_LCD_FILTER_LEGACY] = LCDFilter_Legacy;
+  lcdFilterHash_[FT_LCD_FILTER_DEFAULT] = LCDFilter_Default;
+  lcdFilterHash_[FT_LCD_FILTER_LIGHT] = LCDFilter_Light;
+  lcdFilterHash_[FT_LCD_FILTER_NONE] = LCDFilter_None;
+  lcdFilterHash_[FT_LCD_FILTER_LEGACY] = LCDFilter_Legacy;
 
-  Engine::EngineDefaultValues& defaults = engine->engineDefaults();
+  Engine::EngineDefaultValues& defaults = engine_->engineDefaults();
 
   // make copies and remove existing elements...
-  QHash<int, int> hmTTHash = hintingModesTrueTypeHash;
+  QHash<int, int> hmTTHash = hintingModesTrueTypeHash_;
   if (hmTTHash.contains(defaults.ttInterpreterVersionDefault))
     hmTTHash.remove(defaults.ttInterpreterVersionDefault);
   if (hmTTHash.contains(defaults.ttInterpreterVersionOther))
@@ -1191,47 +1191,47 @@ MainGUI::setDefaults()
   if (hmTTHash.contains(defaults.ttInterpreterVersionOther1))
     hmTTHash.remove(defaults.ttInterpreterVersionOther1);
 
-  QHash<int, int> hmCFFHash = hintingModesCFFHash;
+  QHash<int, int> hmCFFHash = hintingModesCFFHash_;
   if (hmCFFHash.contains(defaults.cffHintingEngineDefault))
     hmCFFHash.remove(defaults.cffHintingEngineDefault);
   if (hmCFFHash.contains(defaults.cffHintingEngineOther))
     hmCFFHash.remove(defaults.cffHintingEngineOther);
 
   // ... to construct a list of always disabled hinting mode combo box items
-  hintingModesAlwaysDisabled = hmTTHash.values();
-  hintingModesAlwaysDisabled += hmCFFHash.values();
+  hintingModesAlwaysDisabled_ = hmTTHash.values();
+  hintingModesAlwaysDisabled_ += hmCFFHash.values();
 
-  for (int i = 0; i < hintingModesAlwaysDisabled.size(); i++)
-    hintingModeComboBoxx->setItemEnabled(hintingModesAlwaysDisabled[i],
+  for (int i = 0; i < hintingModesAlwaysDisabled_.size(); i++)
+    hintingModeComboBoxx_->setItemEnabled(hintingModesAlwaysDisabled_[i],
                                          false);
 
   // the next four values always non-negative
-  currentFontIndex = 0;
-  currentFaceIndex = 0;
-  currentNamedInstanceIndex = 0;
-  currentGlyphIndex = 0;
+  currentFontIndex_ = 0;
+  currentFaceIndex_ = 0;
+  currentNamedInstanceIndex_ = 0;
+  currentGlyphIndex_ = 0;
 
-  currentCFFHintingMode
-    = hintingModesCFFHash[defaults.cffHintingEngineDefault];
-  currentTTInterpreterVersion
-    = hintingModesTrueTypeHash[defaults.ttInterpreterVersionDefault];
+  currentCFFHintingMode_
+    = hintingModesCFFHash_[defaults.cffHintingEngineDefault];
+  currentTTInterpreterVersion_
+    = hintingModesTrueTypeHash_[defaults.ttInterpreterVersionDefault];
 
-  hintingCheckBox->setChecked(true);
+  hintingCheckBox_->setChecked(true);
 
-  antiAliasingComboBoxx->setCurrentIndex(Engine::AntiAliasing_Normal);
-  lcdFilterComboBox->setCurrentIndex(LCDFilter_Light);
+  antiAliasingComboBoxx_->setCurrentIndex(Engine::AntiAliasing_Normal);
+  lcdFilterComboBox_->setCurrentIndex(LCDFilter_Light);
 
-  horizontalHintingCheckBox->setChecked(true);
-  verticalHintingCheckBox->setChecked(true);
-  blueZoneHintingCheckBox->setChecked(true);
+  horizontalHintingCheckBox_->setChecked(true);
+  verticalHintingCheckBox_->setChecked(true);
+  blueZoneHintingCheckBox_->setChecked(true);
 
-  showBitmapCheckBox->setChecked(true);
-  showOutlinesCheckBox->setChecked(true);
+  showBitmapCheckBox_->setChecked(true);
+  showOutlinesCheckBox_->setChecked(true);
 
-  gammaSlider->setValue(18); // 1.8
-  sizeDoubleSpinBox->setValue(20);
-  dpiSpinBox->setValue(96);
-  zoomSpinBox->setValue(20);
+  gammaSlider_->setValue(18); // 1.8
+  sizeDoubleSpinBox_->setValue(20);
+  dpiSpinBox_->setValue(96);
+  zoomSpinBox_->setValue(20);
 
   checkHinting();
   checkHintingMode();
diff --git a/src/ftinspect/maingui.hpp b/src/ftinspect/maingui.hpp
index 4a08b51d..e54d220e 100644
--- a/src/ftinspect/maingui.hpp
+++ b/src/ftinspect/maingui.hpp
@@ -93,142 +93,142 @@ private slots:
   void zoom();
 
 private:
-  Engine* engine;
+  Engine* engine_;
   
-  int currentFontIndex;
+  int currentFontIndex_;
 
-  long currentNumberOfFaces;
-  long currentFaceIndex;
+  long currentNumberOfFaces_;
+  long currentFaceIndex_;
 
-  int currentNumberOfNamedInstances;
-  int currentNamedInstanceIndex;
+  int currentNumberOfNamedInstances_;
+  int currentNamedInstanceIndex_;
 
-  int currentNumberOfGlyphs;
-  int currentGlyphIndex;
+  int currentNumberOfGlyphs_;
+  int currentGlyphIndex_;
 
-  int currentCFFHintingMode;
-  int currentTTInterpreterVersion;
+  int currentCFFHintingMode_;
+  int currentTTInterpreterVersion_;
 
   // layout related stuff
-  GlyphOutline *currentGlyphOutlineItem;
-  GlyphPoints *currentGlyphPointsItem;
-  GlyphPointNumbers *currentGlyphPointNumbersItem;
-  GlyphBitmap *currentGlyphBitmapItem;
-
-  QAction *aboutAct;
-  QAction *aboutQtAct;
-  QAction *closeFontAct;
-  QAction *exitAct;
-  QAction *loadFontsAct;
-
-  QCheckBox *autoHintingCheckBox;
-  QCheckBox *blueZoneHintingCheckBox;
-  QCheckBox *hintingCheckBox;
-  QCheckBox *horizontalHintingCheckBox;
-  QCheckBox *segmentDrawingCheckBox;
-  QCheckBox *showBitmapCheckBox;
-  QCheckBox *showOutlinesCheckBox;
-  QCheckBox *showPointNumbersCheckBox;
-  QCheckBox *showPointsCheckBox;
-  QCheckBox *verticalHintingCheckBox;
-
-  QComboBoxx *antiAliasingComboBoxx;
-  QComboBoxx *hintingModeComboBoxx;
-  QComboBox *lcdFilterComboBox;
-  QComboBox *unitsComboBox;
-
-  QDoubleSpinBox *sizeDoubleSpinBox;
-
-  QGraphicsScene *glyphScene;
-  QGraphicsViewx *glyphView;
+  GlyphOutline *currentGlyphOutlineItem_;
+  GlyphPoints *currentGlyphPointsItem_;
+  GlyphPointNumbers *currentGlyphPointNumbersItem_;
+  GlyphBitmap *currentGlyphBitmapItem_;
+
+  QAction *aboutAct_;
+  QAction *aboutQtAct_;
+  QAction *closeFontAct_;
+  QAction *exitAct_;
+  QAction *loadFontsAct_;
+
+  QCheckBox *autoHintingCheckBox_;
+  QCheckBox *blueZoneHintingCheckBox_;
+  QCheckBox *hintingCheckBox_;
+  QCheckBox *horizontalHintingCheckBox_;
+  QCheckBox *segmentDrawingCheckBox_;
+  QCheckBox *showBitmapCheckBox_;
+  QCheckBox *showOutlinesCheckBox_;
+  QCheckBox *showPointNumbersCheckBox_;
+  QCheckBox *showPointsCheckBox_;
+  QCheckBox *verticalHintingCheckBox_;
+
+  QComboBoxx *antiAliasingComboBoxx_;
+  QComboBoxx *hintingModeComboBoxx_;
+  QComboBox *lcdFilterComboBox_;
+  QComboBox *unitsComboBox_;
+
+  QDoubleSpinBox *sizeDoubleSpinBox_;
+
+  QGraphicsScene *glyphScene_;
+  QGraphicsViewx *glyphView_;
 
   QGridLayout *fontLayout;
   QGridLayout *infoRightLayout;
 
-  QHash<int, int> hintingModesTrueTypeHash;
-  QHash<int, int> hintingModesCFFHash;
-  QHash<FT_LcdFilter, int> lcdFilterHash;
-
-  QHBoxLayout *antiAliasingLayout;
-  QHBoxLayout *blueZoneHintingLayout;
-  QHBoxLayout *ftinspectLayout;
-  QHBoxLayout *gammaLayout;
-  QHBoxLayout *hintingModeLayout;
-  QHBoxLayout *horizontalHintingLayout;
-  QHBoxLayout *infoLeftLayout;
-  QHBoxLayout *lcdFilterLayout;
-  QHBoxLayout *navigationLayout;
-  QHBoxLayout *pointNumbersLayout;
-  QHBoxLayout *segmentDrawingLayout;
-  QHBoxLayout *sizeLayout;
-  QHBoxLayout *verticalHintingLayout;
-
-  QLabel *antiAliasingLabel;
-  QLabel *dpiLabel;
-  QLabel *fontFilenameLabel;
-  QLabel *fontNameLabel;
-  QLabel *gammaLabel;
-  QLabel *glyphIndexLabel;
-  QLabel *glyphNameLabel;
-  QLabel *hintingModeLabel;
-  QLabel *lcdFilterLabel;
-  QLabel *sizeLabel;
-  QLabel *zoomLabel;
-
-  QList<int> hintingModesAlwaysDisabled;
-
-  QLocale *locale;
-
-  QMenu *menuFile;
-  QMenu *menuHelp;
-
-  QPen axisPen;
-  QPen blueZonePen;
-  QPen gridPen;
-  QPen offPen;
-  QPen onPen;
-  QPen outlinePen;
-  QPen segmentPen;
-
-  QPushButton *nextFaceButton;
-  QPushButton *nextFontButton;
-  QPushButton *nextNamedInstanceButton;
-  QPushButton *previousFaceButton;
-  QPushButton *previousFontButton;
-  QPushButton *previousNamedInstanceButton;
-
-  QPushButtonx *toEndButtonx;
-  QPushButtonx *toM1000Buttonx;
-  QPushButtonx *toM100Buttonx;
-  QPushButtonx *toM10Buttonx;
-  QPushButtonx *toM1Buttonx;
-  QPushButtonx *toP1000Buttonx;
-  QPushButtonx *toP100Buttonx;
-  QPushButtonx *toP10Buttonx;
-  QPushButtonx *toP1Buttonx;
-  QPushButtonx *toStartButtonx;
-
-  QSignalMapper *glyphNavigationMapper;
-
-  QSlider *gammaSlider;
-
-  QSpinBox *dpiSpinBox;
-  QSpinBoxx *zoomSpinBox;
-
-  QTabWidget *tabWidget;
-
-  QVBoxLayout *generalTabLayout;
-  QVBoxLayout *leftLayout;
-  QVBoxLayout *rightLayout;
-
-  QVector<QRgb> grayColorTable;
-  QVector<QRgb> monoColorTable;
-
-  QWidget *ftinspectWidget;
-  QWidget *generalTabWidget;
-  QWidget *leftWidget;
-  QWidget *rightWidget;
-  QWidget *mmgxTabWidget;
+  QHash<int, int> hintingModesTrueTypeHash_;
+  QHash<int, int> hintingModesCFFHash_;
+  QHash<FT_LcdFilter, int> lcdFilterHash_;
+
+  QHBoxLayout *antiAliasingLayout_;
+  QHBoxLayout *blueZoneHintingLayout_;
+  QHBoxLayout *ftinspectLayout_;
+  QHBoxLayout *gammaLayout_;
+  QHBoxLayout *hintingModeLayout_;
+  QHBoxLayout *horizontalHintingLayout_;
+  QHBoxLayout *infoLeftLayout_;
+  QHBoxLayout *lcdFilterLayout_;
+  QHBoxLayout *navigationLayout_;
+  QHBoxLayout *pointNumbersLayout_;
+  QHBoxLayout *segmentDrawingLayout_;
+  QHBoxLayout *sizeLayout_;
+  QHBoxLayout *verticalHintingLayout_;
+
+  QLabel *antiAliasingLabel_;
+  QLabel *dpiLabel_;
+  QLabel *fontFilenameLabel_;
+  QLabel *fontNameLabel_;
+  QLabel *gammaLabel_;
+  QLabel *glyphIndexLabel_;
+  QLabel *glyphNameLabel_;
+  QLabel *hintingModeLabel_;
+  QLabel *lcdFilterLabel_;
+  QLabel *sizeLabel_;
+  QLabel *zoomLabel_;
+
+  QList<int> hintingModesAlwaysDisabled_;
+
+  QLocale *locale_;
+
+  QMenu *menuFile_;
+  QMenu *menuHelp_;
+
+  QPen axisPen_;
+  QPen blueZonePen_;
+  QPen gridPen_;
+  QPen offPen_;
+  QPen onPen_;
+  QPen outlinePen_;
+  QPen segmentPen_;
+
+  QPushButton *nextFaceButton_;
+  QPushButton *nextFontButton_;
+  QPushButton *nextNamedInstanceButton_;
+  QPushButton *previousFaceButton_;
+  QPushButton *previousFontButton_;
+  QPushButton *previousNamedInstanceButton_;
+
+  QPushButtonx *toEndButtonx_;
+  QPushButtonx *toM1000Buttonx_;
+  QPushButtonx *toM100Buttonx_;
+  QPushButtonx *toM10Buttonx_;
+  QPushButtonx *toM1Buttonx_;
+  QPushButtonx *toP1000Buttonx_;
+  QPushButtonx *toP100Buttonx_;
+  QPushButtonx *toP10Buttonx_;
+  QPushButtonx *toP1Buttonx_;
+  QPushButtonx *toStartButtonx_;
+
+  QSignalMapper *glyphNavigationMapper_;
+
+  QSlider *gammaSlider_;
+
+  QSpinBox *dpiSpinBox_;
+  QSpinBoxx *zoomSpinBox_;
+
+  QTabWidget *tabWidget_;
+
+  QVBoxLayout *generalTabLayout_;
+  QVBoxLayout *leftLayout_;
+  QVBoxLayout *rightLayout_;
+
+  QVector<QRgb> grayColorTable_;
+  QVector<QRgb> monoColorTable_;
+
+  QWidget *ftinspectWidget_;
+  QWidget *generalTabWidget_;
+  QWidget *leftWidget_;
+  QWidget *rightWidget_;
+  QWidget *mmgxTabWidget_;
 
   // TODO these would be dropped with custom QAbstractItemModel
   enum HintingMode
diff --git a/src/ftinspect/rendering/glyphbitmap.cpp 
b/src/ftinspect/rendering/glyphbitmap.cpp
index d5c3cf32..dcef3eeb 100644
--- a/src/ftinspect/rendering/glyphbitmap.cpp
+++ b/src/ftinspect/rendering/glyphbitmap.cpp
@@ -15,17 +15,17 @@ GlyphBitmap::GlyphBitmap(FT_Outline* outline,
                          FT_Pixel_Mode pxlMode,
                          const QVector<QRgb>& monoColorTbl,
                          const QVector<QRgb>& grayColorTbl)
-: library(lib),
-  pixelMode(pxlMode),
-  monoColorTable(monoColorTbl),
-  grayColorTable(grayColorTbl)
+: library_(lib),
+  pixelMode_(pxlMode),
+  monoColorTable_(monoColorTbl),
+  grayColorTable_(grayColorTbl)
 {
   // make a copy of the outline since we are going to manipulate it
-  FT_Outline_New(library,
+  FT_Outline_New(library_,
                  static_cast<unsigned int>(outline->n_points),
                  outline->n_contours,
-                 &transformed);
-  FT_Outline_Copy(outline, &transformed);
+                 &transformed_);
+  FT_Outline_Copy(outline, &transformed_);
 
   FT_BBox cbox;
   FT_Outline_Get_CBox(outline, &cbox);
@@ -36,22 +36,22 @@ GlyphBitmap::GlyphBitmap(FT_Outline* outline,
   cbox.yMax = (cbox.yMax + 63) & ~63;
 
   // we shift the outline to the origin for rendering later on
-  FT_Outline_Translate(&transformed, -cbox.xMin, -cbox.yMin);
+  FT_Outline_Translate(&transformed_, -cbox.xMin, -cbox.yMin);
 
-  bRect.setCoords(cbox.xMin / 64, -cbox.yMax / 64,
+  boundingRect_.setCoords(cbox.xMin / 64, -cbox.yMax / 64,
                   cbox.xMax / 64, -cbox.yMin / 64);
 }
 
 
 GlyphBitmap::~GlyphBitmap()
 {
-  FT_Outline_Done(library, &transformed);
+  FT_Outline_Done(library_, &transformed_);
 }
 
 QRectF
 GlyphBitmap::boundingRect() const
 {
-  return bRect;
+  return boundingRect_;
 }
 
 
@@ -62,20 +62,20 @@ GlyphBitmap::paint(QPainter* painter,
 {
   FT_Bitmap bitmap;
 
-  int height = static_cast<int>(ceil(bRect.height()));
-  int width = static_cast<int>(ceil(bRect.width()));
+  int height = static_cast<int>(ceil(boundingRect_.height()));
+  int width = static_cast<int>(ceil(boundingRect_.width()));
   QImage::Format format = QImage::Format_Indexed8;
 
   // XXX cover LCD and color
-  if (pixelMode == FT_PIXEL_MODE_MONO)
+  if (pixelMode_ == FT_PIXEL_MODE_MONO)
     format = QImage::Format_Mono;
 
   QImage image(QSize(width, height), format);
 
-  if (pixelMode == FT_PIXEL_MODE_MONO)
-    image.setColorTable(monoColorTable);
+  if (pixelMode_ == FT_PIXEL_MODE_MONO)
+    image.setColorTable(monoColorTable_);
   else
-    image.setColorTable(grayColorTable);
+    image.setColorTable(grayColorTable_);
 
   image.fill(0);
 
@@ -83,10 +83,10 @@ GlyphBitmap::paint(QPainter* painter,
   bitmap.width = static_cast<unsigned int>(width);
   bitmap.buffer = image.bits();
   bitmap.pitch = image.bytesPerLine();
-  bitmap.pixel_mode = pixelMode;
+  bitmap.pixel_mode = pixelMode_;
 
-  FT_Error error = FT_Outline_Get_Bitmap(library,
-                                         &transformed,
+  FT_Error error = FT_Outline_Get_Bitmap(library_,
+                                         &transformed_,
                                          &bitmap);
   if (error)
   {
@@ -112,8 +112,8 @@ GlyphBitmap::paint(QPainter* painter,
     {
       // be careful not to lose the alpha channel
       QRgb p = image.pixel(x, y);
-      painter->fillRect(QRectF(x + bRect.left() - 1 / lod / 2,
-                               y + bRect.top() - 1 / lod / 2,
+      painter->fillRect(QRectF(x + boundingRect_.left() - 1 / lod / 2,
+                               y + boundingRect_.top() - 1 / lod / 2,
                                1 + 1 / lod,
                                1 + 1 / lod),
                         QColor(qRed(p),
diff --git a/src/ftinspect/rendering/glyphbitmap.hpp 
b/src/ftinspect/rendering/glyphbitmap.hpp
index 42cb1082..092dccc8 100644
--- a/src/ftinspect/rendering/glyphbitmap.hpp
+++ b/src/ftinspect/rendering/glyphbitmap.hpp
@@ -29,12 +29,12 @@ public:
              QWidget* widget);
 
 private:
-  FT_Outline transformed;
-  FT_Library library;
-  unsigned char pixelMode;
-  const QVector<QRgb>& monoColorTable;
-  const QVector<QRgb>& grayColorTable;
-  QRectF bRect;
+  FT_Outline transformed_;
+  FT_Library library_;
+  unsigned char pixelMode_;
+  const QVector<QRgb>& monoColorTable_;
+  const QVector<QRgb>& grayColorTable_;
+  QRectF boundingRect_;
 };
 
 
diff --git a/src/ftinspect/rendering/glyphoutline.cpp 
b/src/ftinspect/rendering/glyphoutline.cpp
index f088641d..ad5d25c1 100644
--- a/src/ftinspect/rendering/glyphoutline.cpp
+++ b/src/ftinspect/rendering/glyphoutline.cpp
@@ -89,16 +89,16 @@ static FT_Outline_Funcs outlineFuncs =
 
 GlyphOutline::GlyphOutline(const QPen& outlineP,
                            FT_Outline* outln)
-: outlinePen(outlineP),
-  outline(outln)
+: outlinePen_(outlineP),
+  outline_(outln)
 {
   FT_BBox cbox;
 
-  qreal halfPenWidth = outlinePen.widthF();
+  qreal halfPenWidth = outlinePen_.widthF();
 
-  FT_Outline_Get_CBox(outline, &cbox);
+  FT_Outline_Get_CBox(outline_, &cbox);
 
-  bRect.setCoords(qreal(cbox.xMin) / 64 - halfPenWidth,
+  boundingRect_.setCoords(qreal(cbox.xMin) / 64 - halfPenWidth,
                   -qreal(cbox.yMax) / 64 - halfPenWidth,
                   qreal(cbox.xMax) / 64 + halfPenWidth,
                   -qreal(cbox.yMin) / 64 + halfPenWidth);
@@ -108,7 +108,7 @@ GlyphOutline::GlyphOutline(const QPen& outlineP,
 QRectF
 GlyphOutline::boundingRect() const
 {
-  return bRect;
+  return boundingRect_;
 }
 
 
@@ -117,10 +117,10 @@ GlyphOutline::paint(QPainter* painter,
                     const QStyleOptionGraphicsItem*,
                     QWidget*)
 {
-  painter->setPen(outlinePen);
+  painter->setPen(outlinePen_);
 
   QPainterPath path;
-  FT_Outline_Decompose(outline, &outlineFuncs, &path);
+  FT_Outline_Decompose(outline_, &outlineFuncs, &path);
 
   painter->drawPath(path);
 }
diff --git a/src/ftinspect/rendering/glyphoutline.hpp 
b/src/ftinspect/rendering/glyphoutline.hpp
index d18d12e6..fa448f50 100644
--- a/src/ftinspect/rendering/glyphoutline.hpp
+++ b/src/ftinspect/rendering/glyphoutline.hpp
@@ -25,9 +25,9 @@ public:
              QWidget* widget);
 
 private:
-  QPen outlinePen;
-  FT_Outline* outline;
-  QRectF bRect;
+  QPen outlinePen_;
+  FT_Outline* outline_;
+  QRectF boundingRect_;
 };
 
 
diff --git a/src/ftinspect/rendering/glyphpointnumbers.cpp 
b/src/ftinspect/rendering/glyphpointnumbers.cpp
index cc05ca78..bddee891 100644
--- a/src/ftinspect/rendering/glyphpointnumbers.cpp
+++ b/src/ftinspect/rendering/glyphpointnumbers.cpp
@@ -13,16 +13,16 @@
 GlyphPointNumbers::GlyphPointNumbers(const QPen& onP,
                                      const QPen& offP,
                                      FT_Outline* outln)
-: onPen(onP),
-  offPen(offP),
-  outline(outln)
+: onPen_(onP),
+  offPen_(offP),
+  outline_(outln)
 {
   FT_BBox cbox;
 
-  FT_Outline_Get_CBox(outline, &cbox);
+  FT_Outline_Get_CBox(outline_, &cbox);
 
   // XXX fix bRect size
-  bRect.setCoords(qreal(cbox.xMin) / 64,
+  boundingRect_.setCoords(qreal(cbox.xMin) / 64,
                   -qreal(cbox.yMax) / 64,
                   qreal(cbox.xMax) / 64,
                   -qreal(cbox.yMin) / 64);
@@ -32,7 +32,7 @@ GlyphPointNumbers::GlyphPointNumbers(const QPen& onP,
 QRectF
 GlyphPointNumbers::boundingRect() const
 {
-  return bRect;
+  return boundingRect_;
 }
 
 
@@ -60,15 +60,15 @@ GlyphPointNumbers::paint(QPainter* painter,
     font.setPointSizeF(font.pointSizeF() * 3 / 4);
     painter->setFont(font);
 
-    QBrush onBrush(onPen.color());
-    QBrush offBrush(offPen.color());
+    QBrush onBrush(onPen_.color());
+    QBrush offBrush(offPen_.color());
 
     painter->scale(1 / lod, 1 / lod);
 #endif
 
-    FT_Vector* points = outline->points;
-    FT_Short* contours = outline->contours;
-    char* tags = outline->tags;
+    FT_Vector* points = outline_->points;
+    FT_Short* contours = outline_->contours;
+    char* tags = outline_->tags;
 
     QVector2D octants[8] = { QVector2D(1, 0),
                              QVector2D(0.707f, -0.707f),
@@ -81,7 +81,7 @@ GlyphPointNumbers::paint(QPainter* painter,
 
 
     short ptIdx = 0;
-    for (int contIdx = 0; contIdx < outline->n_contours; contIdx++ )
+    for (int contIdx = 0; contIdx < outline_->n_contours; contIdx++ )
     {
       for (;;)
       {
diff --git a/src/ftinspect/rendering/glyphpointnumbers.hpp 
b/src/ftinspect/rendering/glyphpointnumbers.hpp
index 91c6c428..61feaf00 100644
--- a/src/ftinspect/rendering/glyphpointnumbers.hpp
+++ b/src/ftinspect/rendering/glyphpointnumbers.hpp
@@ -26,10 +26,10 @@ public:
              QWidget* widget);
 
 private:
-  QPen onPen;
-  QPen offPen;
-  FT_Outline* outline;
-  QRectF bRect;
+  QPen onPen_;
+  QPen offPen_;
+  FT_Outline* outline_;
+  QRectF boundingRect_;
 };
 
 
diff --git a/src/ftinspect/rendering/glyphpoints.cpp 
b/src/ftinspect/rendering/glyphpoints.cpp
index ffef3030..08960e6a 100644
--- a/src/ftinspect/rendering/glyphpoints.cpp
+++ b/src/ftinspect/rendering/glyphpoints.cpp
@@ -12,17 +12,17 @@
 GlyphPoints::GlyphPoints(const QPen& onP,
                          const QPen& offP,
                          FT_Outline* outln)
-: onPen(onP),
-  offPen(offP),
-  outline(outln)
+: onPen_(onP),
+  offPen_(offP),
+  outline_(outln)
 {
   FT_BBox cbox;
 
-  qreal halfPenWidth = qMax(onPen.widthF(), offPen.widthF()) / 2;
+  qreal halfPenWidth = qMax(onPen_.widthF(), offPen_.widthF()) / 2;
 
-  FT_Outline_Get_CBox(outline, &cbox);
+  FT_Outline_Get_CBox(outline_, &cbox);
 
-  bRect.setCoords(qreal(cbox.xMin) / 64 - halfPenWidth,
+  boundingRect_.setCoords(qreal(cbox.xMin) / 64 - halfPenWidth,
                   -qreal(cbox.yMax) / 64 - halfPenWidth,
                   qreal(cbox.xMax) / 64 + halfPenWidth,
                   -qreal(cbox.yMin) / 64 + halfPenWidth);
@@ -32,7 +32,7 @@ GlyphPoints::GlyphPoints(const QPen& onP,
 QRectF
 GlyphPoints::boundingRect() const
 {
-  return bRect;
+  return boundingRect_;
 }
 
 
@@ -73,29 +73,29 @@ GlyphPoints::paint(QPainter* painter,
     onPen.setWidthF(origOnPenWidth);
     offPen.setWidthF(origOffPenWidth);
 #else
-    QBrush onBrush(onPen.color());
-    QBrush offBrush(offPen.color());
+    QBrush onBrush(onPen_.color());
+    QBrush offBrush(offPen_.color());
 
     painter->setPen(Qt::NoPen);
 
-    qreal onRadius = onPen.widthF() / lod;
-    qreal offRadius = offPen.widthF() / lod;
+    qreal onRadius = onPen_.widthF() / lod;
+    qreal offRadius = offPen_.widthF() / lod;
 
-    for (int i = 0; i < outline->n_points; i++)
+    for (int i = 0; i < outline_->n_points; i++)
     {
-      if (outline->tags[i] & FT_CURVE_TAG_ON)
+      if (outline_->tags[i] & FT_CURVE_TAG_ON)
       {
         painter->setBrush(onBrush);
-        painter->drawEllipse(QPointF(qreal(outline->points[i].x) / 64,
-                                     -qreal(outline->points[i].y) / 64),
+        painter->drawEllipse(QPointF(qreal(outline_->points[i].x) / 64,
+                                     -qreal(outline_->points[i].y) / 64),
                              onRadius,
                              onRadius);
       }
       else
       {
         painter->setBrush(offBrush);
-        painter->drawEllipse(QPointF(qreal(outline->points[i].x) / 64,
-                                     -qreal(outline->points[i].y) / 64),
+        painter->drawEllipse(QPointF(qreal(outline_->points[i].x) / 64,
+                                     -qreal(outline_->points[i].y) / 64),
                              offRadius,
                              offRadius);
       }
diff --git a/src/ftinspect/rendering/glyphpoints.hpp 
b/src/ftinspect/rendering/glyphpoints.hpp
index 8daab61b..d9648269 100644
--- a/src/ftinspect/rendering/glyphpoints.hpp
+++ b/src/ftinspect/rendering/glyphpoints.hpp
@@ -26,10 +26,10 @@ public:
              QWidget* widget);
 
 private:
-  QPen onPen;
-  QPen offPen;
-  FT_Outline* outline;
-  QRectF bRect;
+  QPen onPen_;
+  QPen offPen_;
+  FT_Outline* outline_;
+  QRectF boundingRect_;
 };
 
 
diff --git a/src/ftinspect/rendering/grid.cpp b/src/ftinspect/rendering/grid.cpp
index 3d9b3296..01b17cbe 100644
--- a/src/ftinspect/rendering/grid.cpp
+++ b/src/ftinspect/rendering/grid.cpp
@@ -11,8 +11,8 @@
 
 Grid::Grid(const QPen& gridP,
            const QPen& axisP)
-: gridPen(gridP),
-  axisPen(axisP)
+: gridPen_(gridP),
+  axisPen_(axisP)
 {
  // empty
 }
@@ -40,7 +40,7 @@ Grid::paint(QPainter* painter,
   const qreal lod = option->levelOfDetailFromTransform(
                               painter->worldTransform());
 
-  painter->setPen(gridPen);
+  painter->setPen(gridPen_);
 
   // don't mark pixel center with a cross if magnification is too small
   if (lod > 20)
@@ -81,7 +81,7 @@ Grid::paint(QPainter* painter,
                         100, y);
   }
 
-  painter->setPen(axisPen);
+  painter->setPen(axisPen_);
 
   painter->drawLine(0, -100,
                     0, 100);
diff --git a/src/ftinspect/rendering/grid.hpp b/src/ftinspect/rendering/grid.hpp
index 49dd99af..9740c170 100644
--- a/src/ftinspect/rendering/grid.hpp
+++ b/src/ftinspect/rendering/grid.hpp
@@ -21,8 +21,8 @@ public:
              QWidget* widget);
 
 private:
-  QPen gridPen;
-  QPen axisPen;
+  QPen gridPen_;
+  QPen axisPen_;
 };
 
 
diff --git a/src/ftinspect/widgets/qgraphicsviewx.cpp 
b/src/ftinspect/widgets/qgraphicsviewx.cpp
index a4e0ba9a..47521815 100644
--- a/src/ftinspect/widgets/qgraphicsviewx.cpp
+++ b/src/ftinspect/widgets/qgraphicsviewx.cpp
@@ -9,7 +9,7 @@
 
 
 QGraphicsViewx::QGraphicsViewx()
-: lastBottomLeftPointInitialized(false)
+: lastBottomLeftPointInitialized_(false)
 {
   // empty
 }
@@ -20,7 +20,7 @@ QGraphicsViewx::scrollContentsBy(int dx,
                                  int dy)
 {
   QGraphicsView::scrollContentsBy(dx, dy);
-  lastBottomLeftPoint = viewport()->rect().bottomLeft();
+  lastBottomLeftPoint_ = viewport()->rect().bottomLeft();
 }
 
 
@@ -31,10 +31,10 @@ QGraphicsViewx::resizeEvent(QResizeEvent* event)
 
   // XXX I don't know how to properly initialize this value,
   //     thus the hack with the boolean
-  if (!lastBottomLeftPointInitialized)
+  if (!lastBottomLeftPointInitialized_)
   {
-    lastBottomLeftPoint = viewport()->rect().bottomLeft();
-    lastBottomLeftPointInitialized = true;
+    lastBottomLeftPoint_ = viewport()->rect().bottomLeft();
+    lastBottomLeftPointInitialized_ = true;
   }
 
   QPointF currentBottomLeftPoint = viewport()->rect().bottomLeft();
@@ -42,7 +42,7 @@ QGraphicsViewx::resizeEvent(QResizeEvent* event)
   verticalScrollBar()->setValue(static_cast<int>(
                                   verticalPosition
                                   - (currentBottomLeftPoint.y()
-                                     - lastBottomLeftPoint.y())));
+                                     - lastBottomLeftPoint_.y())));
 }
 
 
diff --git a/src/ftinspect/widgets/qgraphicsviewx.hpp 
b/src/ftinspect/widgets/qgraphicsviewx.hpp
index 1a55b2c2..6ddbf122 100644
--- a/src/ftinspect/widgets/qgraphicsviewx.hpp
+++ b/src/ftinspect/widgets/qgraphicsviewx.hpp
@@ -24,8 +24,8 @@ protected:
                         int dy);
 
 private:
-  QPointF lastBottomLeftPoint;
-  bool lastBottomLeftPointInitialized;
+  QPointF lastBottomLeftPoint_;
+  bool lastBottomLeftPointInitialized_;
 };
 
 



reply via email to

[Prev in Thread] Current Thread [Next in Thread]