[Git][freetype/freetype-demos][reorg-maingui] 3 commits: [ftinspect] Mov

Charlie Jiang pushed to branch reorg-maingui at FreeType / FreeType Demo Programs

Commits:

600a9006

by Charlie Jiang at 2022-06-29T22:57:23+08:00

[ftinspect] Move out font file managing/watching out to a new class.

* src/ftinspect/CMakeLists.txt: Add `fontfilemanager.cpp`.

* src/ftinspect/meson.build: Add `fontfilemanager.cpp`.

* src/ftinspect/fontfilemanager.hpp: Font file managing/watching goes here.

* src/ftinspect/fontfilemanager.cpp: Font file managing/watching goes here.

* src/ftinspect/maingui.hpp: Remove `fontList`, `fontWatcher` and `timer`..

* src/ftinspect/maingui.cpp: Remove code related to font file managing, they
were all moved to `FontFileManager` class.

* src/ftinspect/engine.hpp: `Engine` class now holds `FontFileManager`. Also,
`MainGUI` will open and close fonts indirectly via `Engine`.

* src/ftinspect/engine.cpp: Same as `engine.hpp`.

TODO: Maybe we should remove dependency against `FontFileManager` from
`MainGUI`?

19ad7297

by Charlie Jiang at 2022-06-29T22:58:06+08:00

[ftinspect] Decouple `Engine` from `MainGUI`.

Relevant info can be found in #13. This commit removes dependency against
`MainGUI` from `Engine` class. All settings will be explicitly passed via
setters of `Engine`. Also see `MainGUI::syncSettings` and simplified
`Engine::update`.

This commit removes friend relation between the two classes.

TODO: Some GUI components in MainGUI lacks proper connections. When changing
their value, the glyph isn't updated in time.

* src/ftinspect/ftinspect.cpp: No longer need to pass GUI when constructing
`Engine`.

* src/ftinspect/maingui.hpp: Move `AntiAliasing` enum to `Engine` class, add
`syncSettings` function, reorder some functions.

* src/ftinspect/maingui.cpp: Because of the removal of friend relationship,
change all access to private fields of `Engine` to getter/setter call.
Add implementation of `syncSettings`, and make sure it's called before
loading font and rendering. Moving of `AntiAliasing` enum is also taken care
of.

* src/ftinspect/engine/engine.hpp: Removed dependency against `MainGUI`.
Added getters/setters and reordered some functions. The default values
queried from engine are all grouped together into `EngineDefaultValues`
struct.
Added `queryEngine` function (see below).
New `setSizeByPoint` and `setSizeByPoint` lifted the branch to `MainGUI`.
Note: Setters of LCD filter mode, CFF mode and TTI version now accepts the
actual values of FreeType instead of values of enums in `MainGUI` used to
initialize combo boxes.
However, `antiAliasingMode` is still using enum values (but moved into
`Engine`) because it's complex to convert to FreeType value.

* src/ftinspect/engine/engine.cpp: `faceRequester` now use the `Engine`
object instead of `MainGUI` as `requestData`.
Moved code preparing engine default values to the `queryEngine` function.
Moved some single-line getters to the header file to benefit from inlineing.
Simplified `update` function since we no longer need to actively fetch
settings.
`usingPixelSize` is used to determine if pixel or point unit is used. This
flag is updated by `setSizeByPixel` and `setSizeByPoint` functions.

7d0d3a57

by Charlie Jiang at 2022-06-29T22:59:12+08:00

[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.

21 changed files:

src/ftinspect/CMakeLists.txt
src/ftinspect/engine/engine.cpp
src/ftinspect/engine/engine.hpp
+ src/ftinspect/engine/fontfilemanager.cpp
+ src/ftinspect/engine/fontfilemanager.hpp
src/ftinspect/ftinspect.cpp
src/ftinspect/maingui.cpp
src/ftinspect/maingui.hpp
src/ftinspect/meson.build
src/ftinspect/rendering/glyphbitmap.cpp
src/ftinspect/rendering/glyphbitmap.hpp
src/ftinspect/rendering/glyphoutline.cpp
src/ftinspect/rendering/glyphoutline.hpp
src/ftinspect/rendering/glyphpointnumbers.cpp
src/ftinspect/rendering/glyphpointnumbers.hpp
src/ftinspect/rendering/glyphpoints.cpp
src/ftinspect/rendering/glyphpoints.hpp
src/ftinspect/rendering/grid.cpp
src/ftinspect/rendering/grid.hpp
src/ftinspect/widgets/qgraphicsviewx.cpp
src/ftinspect/widgets/qgraphicsviewx.hpp

Changes:

src/ftinspect/CMakeLists.txt

@@ -20,6 +20,7 @@ add_executable(ftinspect
    "maingui.cpp"
    "engine/engine.cpp"
 +  "engine/fontfilemanager.cpp"
    "rendering/glyphbitmap.cpp"
    "rendering/glyphoutline.cpp"

src/ftinspect/engine/engine.cpp

@@ -4,7 +4,6 @@
  #include "engine.hpp"
 -#include "../maingui.hpp"
  #include <stdexcept>
  #include <stdint.h>
@@ -77,7 +76,7 @@ faceRequester(FTC_FaceID ftcFaceID,
                FT_Pointer requestData,
                FT_Face* faceP)
+ {
 -  MainGUI* gui = static_cast<MainGUI*>(requestData);
 +  Engine* engine = static_cast<Engine*>(requestData);
    // `ftcFaceID' is actually an integer
    // -> first convert pointer to same-width integer, then discard superfluous
    //    bits (e.g., on x86_64 where pointers are wider than int)
@@ -88,16 +87,16 @@ faceRequester(FTC_FaceID ftcFaceID,
               "Pointer size must be at least the size of int"
               " in order to treat FTC_FaceID correctly");
 -  const FaceID& faceID = gui->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
    // is checked by FreeType itself
    if (faceID.fontIndex < 0
 -      || faceID.fontIndex >= gui->fontList.size())
 +      || faceID.fontIndex >= engine->numberOfOpenedFonts())
      return FT_Err_Invalid_Argument;
 -  QString& font = gui->fontList[faceID.fontIndex];
 +  QString font = engine->fontFileManager_[faceID.fontIndex].filePath();
    long faceIndex = faceID.faceIndex;
    if (faceID.namedInstanceIndex > 0)
@@ -116,139 +115,47 @@ faceRequester(FTC_FaceID ftcFaceID,
  //
  /////////////////////////////////////////////////////////////////////////////
 -Engine::Engine(MainGUI* g)
 +Engine::Engine()
+ {
 -  gui = g;
 -  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, gui, &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
+   }
 -  // query engines and check for alternatives
+-
 -  // CFF
 -  error = FT_Property_Get(library,
 -                          "cff",
 -                          "hinting-engine",
 -                          &cffHintingEngineDefault);
 -  if (error)
 -  {
 -    // no CFF engine
 -    cffHintingEngineDefault = -1;
 -    cffHintingEngineOther = -1;
 -  }
 -  else
 -  {
 -    int engines[] =
 -    {
 -      FT_HINTING_FREETYPE,
 -      FT_HINTING_ADOBE
 -    };
+-
 -    int i;
 -    for (i = 0; i < 2; i++)
 -      if (cffHintingEngineDefault == engines[i])
 -        break;
+-
 -    cffHintingEngineOther = engines[(i + 1) % 2];
+-
 -    error = FT_Property_Set(library,
 -                            "cff",
 -                            "hinting-engine",
 -                            &cffHintingEngineOther);
 -    if (error)
 -      cffHintingEngineOther = -1;
+-
 -    // reset
 -    FT_Property_Set(library,
 -                    "cff",
 -                    "hinting-engine",
 -                    &cffHintingEngineDefault);
 -  }
+-
 -  // TrueType
 -  error = FT_Property_Get(library,
 -                          "truetype",
 -                          "interpreter-version",
 -                          &ttInterpreterVersionDefault);
 -  if (error)
 -  {
 -    // no TrueType engine
 -    ttInterpreterVersionDefault = -1;
 -    ttInterpreterVersionOther = -1;
 -    ttInterpreterVersionOther1 = -1;
 -  }
 -  else
 -  {
 -    int interpreters[] =
 -    {
 -      TT_INTERPRETER_VERSION_35,
 -      TT_INTERPRETER_VERSION_38,
 -      TT_INTERPRETER_VERSION_40
 -    };
+-
 -    int i;
 -    for (i = 0; i < 3; i++)
 -      if (ttInterpreterVersionDefault == interpreters[i])
 -        break;
+-
 -    ttInterpreterVersionOther = interpreters[(i + 1) % 3];
+-
 -    error = FT_Property_Set(library,
 -                            "truetype",
 -                            "interpreter-version",
 -                            &ttInterpreterVersionOther);
 -    if (error)
 -      ttInterpreterVersionOther = -1;
+-
 -    ttInterpreterVersionOther1 = interpreters[(i + 2) % 3];
+-
 -    error = FT_Property_Set(library,
 -                            "truetype",
 -                            "interpreter-version",
 -                            &ttInterpreterVersionOther1);
 -    if (error)
 -      ttInterpreterVersionOther1 = -1;
+-
 -    // reset
 -    FT_Property_Set(library,
 -                    "truetype",
 -                    "interpreter-version",
 -                    &ttInterpreterVersionDefault);
 -  }
 +  queryEngine();
+ }
  Engine::~Engine()
+ {
 -  FTC_Manager_Done(cacheManager);
 -  FT_Done_FreeType(library);
 +  FTC_Manager_Done(cacheManager_);
 +  FT_Done_FreeType(library_);
+ }
@@ -260,28 +167,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,
 ,
 )));
    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_--;
+     }
+   }
@@ -300,28 +207,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,
 )));
    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_--;
+     }
+   }
@@ -335,60 +242,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;
@@ -396,16 +303,16 @@ Engine::loadFont(int fontIndex,
  void
 -Engine::removeFont(int fontIndex)
 +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();
@@ -413,24 +320,13 @@ Engine::removeFont(int fontIndex)
        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);
+   }
 -}
+-
 -const QString&
 -Engine::currentFamilyName()
 -{
 -  return curFamilyName;
 -}
+-
+-
 -const QString&
 -Engine::currentStyleName()
 -{
 -  return curStyleName;
 +  if (closeFile)
 +    fontFileManager_.remove(fontIndex);
+ }
@@ -442,10 +338,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)))
@@ -470,9 +366,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))
@@ -490,36 +386,70 @@ Engine::loadOutline(int glyphIndex)
+ }
 +int
 +Engine::numberOfOpenedFonts()
 +{
 +  return fontFileManager_.size();
 +}
++
++
  void
 -Engine::setCFFHintingMode(int mode)
 +Engine::openFonts(QStringList fontFileNames)
 +{
 +  fontFileManager_.append(fontFileNames);
 +}
++
++
 +void
 +Engine::setSizeByPixel(double pixelSize)
 +{
 +  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;
 +}
++
++
 +void
 +Engine::setLcdFilter(FT_LcdFilter filter)
+ {
 -  int index = gui->hintingModesCFFHash.key(mode);
 +  FT_Library_SetLcdFilter(library_, filter);
 +}
 -  FT_Error error = FT_Property_Set(library,
++
 +void
 +Engine::setCFFHintingMode(int mode)
 +{
 +  FT_Error error = FT_Property_Set(library_,
                                     "cff",
                                     "hinting-engine",
 -                                   &index);
 +                                   &mode);
    if (!error)
+   {
      // reset the cache
 -    FTC_Manager_Reset(cacheManager);
 +    FTC_Manager_Reset(cacheManager_);
+   }
+ }
  void
 -Engine::setTTInterpreterVersion(int mode)
 +Engine::setTTInterpreterVersion(int version)
+ {
 -  int index = gui->hintingModesTrueTypeHash.key(mode);
+-
 -  FT_Error error = FT_Property_Set(library,
 +  FT_Error error = FT_Property_Set(library_,
                                     "truetype",
                                     "interpreter-version",
 -                                   &index);
 +                                   &version);
    if (!error)
+   {
      // reset the cache
 -    FTC_Manager_Reset(cacheManager);
 +    FTC_Manager_Reset(cacheManager_);
+   }
+ }
@@ -527,58 +457,32 @@ Engine::setTTInterpreterVersion(int mode)
  void
  Engine::update()
+ {
 -  // Spinbox value cannot become negative
 -  dpi = static_cast<unsigned int>(gui->dpiSpinBox->value());
 +  loadFlags_ = FT_LOAD_DEFAULT;
 +  if (doAutoHinting_)
 +    loadFlags_ |= FT_LOAD_FORCE_AUTOHINT;
 +  loadFlags_ |= FT_LOAD_NO_BITMAP; // XXX handle bitmap fonts also
 -  if (gui->unitsComboBox->currentIndex() == MainGUI::Units_px)
 -  {
 -    pixelSize = gui->sizeDoubleSpinBox->value();
 -    pointSize = pixelSize * 72.0 / dpi;
 -  }
 -  else
 -  {
 -    pointSize = gui->sizeDoubleSpinBox->value();
 -    pixelSize = pointSize * dpi / 72.0;
 -  }
+-
 -  doHinting = gui->hintingCheckBox->isChecked();
+-
 -  doAutoHinting = gui->autoHintingCheckBox->isChecked();
 -  doHorizontalHinting = gui->horizontalHintingCheckBox->isChecked();
 -  doVerticalHinting = gui->verticalHintingCheckBox->isChecked();
 -  doBlueZoneHinting = gui->blueZoneHintingCheckBox->isChecked();
 -  showSegments = gui->segmentDrawingCheckBox->isChecked();
+-
 -  gamma = gui->gammaSlider->value();
+-
 -  loadFlags = FT_LOAD_DEFAULT;
 -  if (doAutoHinting)
 -    loadFlags |= FT_LOAD_FORCE_AUTOHINT;
 -  loadFlags |= FT_LOAD_NO_BITMAP; // XXX handle bitmap fonts also
+-
 -  int index = gui->antiAliasingComboBoxx->currentIndex();
+-
 -  if (doHinting)
 +  if (doHinting_)
+   {
      unsigned long target;
 -    if (index == MainGUI::AntiAliasing_None)
 +    if (antiAliasingMode_ == AntiAliasing_None)
        target = FT_LOAD_TARGET_MONO;
      else
+     {
 -      switch (index)
 +      switch (antiAliasingMode_)
+       {
 -      case MainGUI::AntiAliasing_Light:
 +      case AntiAliasing_Light:
          target = FT_LOAD_TARGET_LIGHT;
          break;
 -      case MainGUI::AntiAliasing_LCD:
 -      case MainGUI::AntiAliasing_LCD_BGR:
 +      case AntiAliasing_LCD:
 +      case AntiAliasing_LCD_BGR: // TODO Differenate RGB/BGR here?
          target = FT_LOAD_TARGET_LCD;
          break;
 -      case MainGUI::AntiAliasing_LCD_Vertical:
 -      case MainGUI::AntiAliasing_LCD_Vertical_BGR:
 +      case AntiAliasing_LCD_Vertical:
 +      case AntiAliasing_LCD_Vertical_BGR:
          target = FT_LOAD_TARGET_LCD_V;
          break;
@@ -587,35 +491,134 @@ Engine::update()
+       }
+     }
 -    loadFlags |= target;
 +    loadFlags_ |= target;
+   }
    else
+   {
 -    loadFlags |= FT_LOAD_NO_HINTING;
 +    loadFlags_ |= FT_LOAD_NO_HINTING;
 -    if (index == MainGUI::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 (gui->unitsComboBox->currentIndex() == MainGUI::Units_px)
 +  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_;
+   }
+ }
 +void
 +Engine::queryEngine()
 +{
 +  FT_Error error;
++
 +  // query engines and check for alternatives
++
 +  // CFF
 +  error = FT_Property_Get(library_,
 +                          "cff",
 +                          "hinting-engine",
 +                          &engineDefaults_.cffHintingEngineDefault);
 +  if (error)
 +  {
 +    // no CFF engine
 +    engineDefaults_.cffHintingEngineDefault = -1;
 +    engineDefaults_.cffHintingEngineOther = -1;
 +  }
 +  else
 +  {
 +    int engines[] =
 +    {
 +      FT_HINTING_FREETYPE,
 +      FT_HINTING_ADOBE
 +    };
++
 +    int i;
 +    for (i = 0; i < 2; i++)
 +      if (engineDefaults_.cffHintingEngineDefault == engines[i])
 +        break;
++
 +    engineDefaults_.cffHintingEngineOther = engines[(i + 1) % 2];
++
 +    error = FT_Property_Set(library_,
 +                            "cff",
 +                            "hinting-engine",
 +                            &engineDefaults_.cffHintingEngineOther);
 +    if (error)
 +      engineDefaults_.cffHintingEngineOther = -1;
++
 +    // reset
 +    FT_Property_Set(library_,
 +                    "cff",
 +                    "hinting-engine",
 +                    &engineDefaults_.cffHintingEngineDefault);
 +  }
++
 +  // TrueType
 +  error = FT_Property_Get(library_,
 +                          "truetype",
 +                          "interpreter-version",
 +                          &engineDefaults_.ttInterpreterVersionDefault);
 +  if (error)
 +  {
 +    // no TrueType engine
 +    engineDefaults_.ttInterpreterVersionDefault = -1;
 +    engineDefaults_.ttInterpreterVersionOther = -1;
 +    engineDefaults_.ttInterpreterVersionOther1 = -1;
 +  }
 +  else
 +  {
 +    int interpreters[] =
 +    {
 +      TT_INTERPRETER_VERSION_35,
 +      TT_INTERPRETER_VERSION_38,
 +      TT_INTERPRETER_VERSION_40
 +    };
++
 +    int i;
 +    for (i = 0; i < 3; i++)
 +      if (engineDefaults_.ttInterpreterVersionDefault == interpreters[i])
 +        break;
++
 +    engineDefaults_.ttInterpreterVersionOther = interpreters[(i + 1) % 3];
++
 +    error = FT_Property_Set(library_,
 +                            "truetype",
 +                            "interpreter-version",
 +                            &engineDefaults_.ttInterpreterVersionOther);
 +    if (error)
 +      engineDefaults_.ttInterpreterVersionOther = -1;
++
 +    engineDefaults_.ttInterpreterVersionOther1 = interpreters[(i + 2) % 3];
++
 +    error = FT_Property_Set(library_,
 +                            "truetype",
 +                            "interpreter-version",
 +                            &engineDefaults_.ttInterpreterVersionOther1);
 +    if (error)
 +      engineDefaults_.ttInterpreterVersionOther1 = -1;
++
 +    // reset
 +    FT_Property_Set(library_,
 +                    "truetype",
 +                    "interpreter-version",
 +                    &engineDefaults_.ttInterpreterVersionDefault);
 +  }
 +}
++
  // end of engine.cpp

src/ftinspect/engine/engine.hpp

@@ -5,6 +5,8 @@
  #pragma once
 +#include "fontfilemanager.hpp"
++
  #include <QString>
  #include <QMap>
@@ -12,6 +14,7 @@
  #include <freetype/freetype.h>
  #include <freetype/ftoutln.h>
  #include <freetype/ftcache.h>
 +#include <freetype/ftlcdfil.h>
  // This structure maps the (font, face, instance) index triplet to abstract
@@ -33,87 +36,165 @@ struct FaceID
    bool operator<(const FaceID& other) const;
  };
+-
 -class MainGUI;
+-
  // FreeType specific data.
  class Engine
+ {
  public:
 -  Engine(MainGUI*);
 +  //////// Nested definitions (forward decl)
++
 +  // TODO these would be dropped with custom QAbstractItemModel
 +  enum AntiAliasing : int;
 +  enum FontType : int;
++
 +  struct EngineDefaultValues
 +  {
 +    int cffHintingEngineDefault;
 +    int cffHintingEngineOther;
++
 +    int ttInterpreterVersionDefault;
 +    int ttInterpreterVersionOther;
 +    int ttInterpreterVersionOther1;
 +  };
++
 +  //////// Ctors & Dtors
++
 +  Engine();
    ~Engine();
 -  const QString& currentFamilyName();
 -  const QString& currentStyleName();
 -  QString glyphName(int glyphIndex);
 -  long numberOfFaces(int fontIndex);
 -  int numberOfNamedInstances(int fontIndex,
 -                             long faceIndex);
 +  // Disable copying
 +  Engine(const Engine& other) = delete;
 +  Engine& operator=(const Engine& other) = delete;
++
 +  //////// Actions
++
    int loadFont(int fontIndex,
                 long faceIndex,
                 int namedInstanceIndex); // return number of glyphs
    FT_Outline* loadOutline(int glyphIndex);
 -  void removeFont(int fontIndex);
++
 +  void openFonts(QStringList fontFileNames);
 +  void removeFont(int fontIndex, bool closeFile = true);
++
 +  void update();
++
 +  //////// Getters
++
 +  FT_Library ftLibrary() const { return library_; }
 +  int currentFontType() const { return fontType_; }
 +  const QString& currentFamilyName() { return curFamilyName_; }
 +  const QString& currentStyleName() { return curStyleName_; }
 +  int numberOfOpenedFonts();
 +  QString glyphName(int glyphIndex);
 +  long numberOfFaces(int fontIndex);
 +  int numberOfNamedInstances(int fontIndex,
 +                             long faceIndex);
++
 +  // XXX We should prepend '_' to all private member variable so we can create
 +  // getter without naming conflict... e.g. var named _fontFileManager while
 +  // getter named fontFileManager
 +  FontFileManager& fontFileManager() { return fontFileManager_; }
 +  EngineDefaultValues& engineDefaults() { return engineDefaults_; }
++
 +  //////// Setters (direct or indirect)
++
 +  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 setHorizontalHinting(bool horHinting)
 +  {
 +    doHorizontalHinting_ = horHinting;
 +  }
 +  void setVerticalHinting(bool verticalHinting)
 +  {
 +    doVerticalHinting_ = verticalHinting;
 +  }
 +  void setBlueZoneHinting(bool blueZoneHinting)
 +  {
 +    doBlueZoneHinting_ = blueZoneHinting;
 +  }
 +  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!
 +  void setLcdFilter(FT_LcdFilter filter);
    void setCFFHintingMode(int mode);
    void setTTInterpreterVersion(int version);
 -  void update();
 -  friend class MainGUI;
 +  //////// Misc
++
    friend FT_Error faceRequester(FTC_FaceID,
                                  FT_Library,
                                  FT_Pointer,
                                  FT_Face*);
 -  // XXX cover all available modules
 -  enum FontType
 -  {
 -    FontType_CFF,
 -    FontType_TrueType,
 -    FontType_Other
 -  };
+-
  private:
 -  MainGUI* gui;
+-
    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 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_;
 -  int cffHintingEngineDefault;
 -  int cffHintingEngineOther;
 +  EngineDefaultValues engineDefaults_;
 -  int ttInterpreterVersionDefault;
 -  int ttInterpreterVersionOther;
 -  int ttInterpreterVersionOther1;
 +  int fontType_;
 -  int fontType;
 +  bool usingPixelSize_ = false;
 +  double pointSize_;
 +  double pixelSize_;
 +  unsigned int dpi_;
 -  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;
 +  double gamma_;
 -  double gamma;
 +  unsigned long loadFlags_;
 -  unsigned long loadFlags;
 +  void queryEngine();
++
 +public:
++
 +  /// Actual definition
++
 +  enum AntiAliasing
 +  {
 +    AntiAliasing_None,
 +    AntiAliasing_Normal,
 +    AntiAliasing_Light,
 +    AntiAliasing_LCD,
 +    AntiAliasing_LCD_BGR,
 +    AntiAliasing_LCD_Vertical,
 +    AntiAliasing_LCD_Vertical_BGR
 +  };
++
 +  // XXX cover all available modules
 +  enum FontType
 +  {
 +    FontType_CFF,
 +    FontType_TrueType,
 +    FontType_Other
 +  };
  };

src/ftinspect/engine/fontfilemanager.cpp

 +// fontfilemanager.cpp
++
 +// Copyright (C) 2022 by Charlie Jiang.
++
++
 +#include "fontfilemanager.hpp"
++
 +FontFileManager::FontFileManager()
 +{
 +  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);
++
 +  connect(fontWatcher_, &QFileSystemWatcher::fileChanged,
 +          this, &FontFileManager::onTimerOrWatcherFire);
 +  connect(watchTimer_, &QTimer::timeout,
 +          this, &FontFileManager::onTimerOrWatcherFire);
 +}
++
++
 +FontFileManager::~FontFileManager()
 +{
 +}
++
++
 +int
 +FontFileManager::size()
 +{
 +  return fontFileNameList_.size();
 +}
++
++
 +void
 +FontFileManager::append(QStringList newFileNames)
 +{
 +  for (auto& name : newFileNames)
 +  {
 +    auto info = QFileInfo(name);
++
 +    // Filter non-file elements
 +    if (!info.isFile())
 +      continue;
++
 +    // Uniquify elements
 +    auto absPath = info.absoluteFilePath();
 +    auto existing = false;
 +    for (auto& existingName : fontFileNameList_)
 +      if (existingName.absoluteFilePath() == absPath)
 +      {
 +        existing = true;
 +        break;
 +      }
 +    if (existing)
 +      continue;
++
 +    fontFileNameList_.append(info);
 +  }
 +}
++
++
 +void
 +FontFileManager::remove(int index)
 +{
 +  if (index < 0 || index >= size())
 +    return;
++
 +  fontWatcher_->removePath(fontFileNameList_[index].filePath());
 +  fontFileNameList_.removeAt(index);
 +}
++
++
 +QFileInfo&
 +FontFileManager::operator[](int index)
 +{
 +  return fontFileNameList_[index];
 +}
++
++
 +void
 +FontFileManager::updateWatching(int index)
 +{
 +  QFileInfo& fileInfo = fontFileNameList_[index];
++
 +  auto watching = fontWatcher_->files();
 +  if (!watching.empty())
 +    fontWatcher_->removePaths(watching);
++
 +  // Qt's file watcher doesn't handle symlinks;
 +  // we thus fall back to polling
 +  if (fileInfo.isSymLink() || !fileInfo.exists())
 +    watchTimer_->start();
 +  else
 +    fontWatcher_->addPath(fileInfo.filePath());
 +}
++
++
 +void
 +FontFileManager::timerStart()
 +{
 +  watchTimer_->start();
 +}
++
++
 +void
 +FontFileManager::onTimerOrWatcherFire()
 +{
 +  watchTimer_->stop();
 +  emit currentFileChanged();
 +}
++
++
 +// end of fontfilemanager.hpp

src/ftinspect/engine/fontfilemanager.hpp

 +// fontfilemanager.hpp
++
 +// Copyright (C) 2022 by Charlie Jiang.
++
 +#pragma once
++
 +#include <QObject>
 +#include <QList>
 +#include <QFileSystemWatcher>
 +#include <QTimer>
 +#include <QFileInfo>
++
++
 +// Class to manage all opened font files, as well as monitoring local file
 +// change.
++
 +class FontFileManager
 +: public QObject
 +{
 +  Q_OBJECT
 +public:
 +  FontFileManager();
 +  ~FontFileManager() override;
++
 +  int size();
 +  void append(QStringList newFileNames);
 +  void remove(int index);
++
 +  QFileInfo& operator[](int index);
 +  void updateWatching(int index);
 +  void timerStart();
++
 +signals:
 +  void currentFileChanged();
++
 +private slots:
 +  void onTimerOrWatcherFire();
++
 +private:
 +  QList<QFileInfo> fontFileNameList_;
 +  QFileSystemWatcher* fontWatcher_;
 +  QTimer* watchTimer_;
 +};
++
++
 +// end of fontfilemanager.hpp

src/ftinspect/ftinspect.cpp

@@ -22,7 +22,7 @@ main(int argc,
    app.setOrganizationDomain("freetype.org");
    MainGUI gui;
 -  Engine engine(&gui);
 +  Engine engine;
    gui.update(&engine);
    gui.setDefaults();

src/ftinspect/maingui.cpp

@@ -7,7 +7,6 @@
  #include "rendering/grid.hpp"
  #include <QApplication>
 -#include <QDir>
  #include <QFileDialog>
  #include <QMessageBox>
  #include <QSettings>
@@ -17,12 +16,7 @@
  MainGUI::MainGUI()
+ {
 -  engine = NULL;
+-
 -  fontWatcher = new QFileSystemWatcher;
 -  // if the current input file is invalid we retry once a second to load it
 -  timer = new QTimer;
 -  timer->setInterval(1000);
 +  engine_ = NULL;
    setGraphicsDefaults();
    createLayout();
@@ -46,7 +40,13 @@ MainGUI::~MainGUI()
  void
  MainGUI::update(Engine* e)
+ {
 -  engine = e;
 +  if (engine_)
 +    disconnect(&engine_->fontFileManager(), &FontFileManager::currentFileChanged,
 +        this, &MainGUI::watchCurrentFont);
++
 +  engine_ = e;
 +  connect(&engine_->fontFileManager(), &FontFileManager::currentFileChanged,
 +          this, &MainGUI::watchCurrentFont);
+ }
@@ -94,7 +94,7 @@ MainGUI::aboutQt()
  void
  MainGUI::loadFonts()
+ {
 -  int oldSize = fontList.size();
 +  int oldSize = engine_->numberOfOpenedFonts();
    QStringList files = QFileDialog::getOpenFileNames(
                          this,
@@ -104,12 +104,11 @@ MainGUI::loadFonts()
                          NULL,
                          QFileDialog::ReadOnly);
 -  // XXX sort data, uniquify elements
 -  fontList.append(files);
 +  engine_->openFonts(files);
    // if we have new fonts, set the current index to the first new one
 -  if (oldSize < fontList.size())
 -    currentFontIndex = oldSize;
 +  if (oldSize < engine_->numberOfOpenedFonts())
 +    currentFontIndex_ = oldSize;
    showFont();
+ }
@@ -118,21 +117,20 @@ MainGUI::loadFonts()
  void
  MainGUI::closeFont()
+ {
 -  if (currentFontIndex < fontList.size())
 +  if (currentFontIndex_ < engine_->numberOfOpenedFonts())
+   {
 -    engine->removeFont(currentFontIndex);
 -    fontWatcher->removePath(fontList[currentFontIndex]);
 -    fontList.removeAt(currentFontIndex);
 +    engine_->removeFont(currentFontIndex_);
+   }
    // show next font after deletion, i.e., retain index if possible
 -  if (fontList.size())
 +  int num = engine_->numberOfOpenedFonts();
 +  if (num)
+   {
 -    if (currentFontIndex >= fontList.size())
 -      currentFontIndex = fontList.size() - 1;
 +    if (currentFontIndex_ >= num)
 +      currentFontIndex_ = num - 1;
+   }
    else
 -    currentFontIndex = 0;
 +    currentFontIndex_ = 0;
    showFont();
+ }
@@ -141,7 +139,6 @@ MainGUI::closeFont()
  void
  MainGUI::watchCurrentFont()
+ {
 -  timer->stop();
    showFont();
+ }
@@ -151,62 +148,57 @@ MainGUI::showFont()
+ {
    // we do lazy computation of FT_Face objects
 -  if (currentFontIndex < fontList.size())
 +  if (currentFontIndex_ < engine_->numberOfOpenedFonts())
+   {
 -    QString& font = fontList[currentFontIndex];
 -    QFileInfo fileInfo(font);
 +    QFileInfo& fileInfo = engine_->fontFileManager()[currentFontIndex_];
      QString fontName = fileInfo.fileName();
 -    if (fileInfo.exists())
 +    engine_->fontFileManager().updateWatching(currentFontIndex_);
 +    if (fileInfo.isSymLink())
+     {
 -      // Qt's file watcher doesn't handle symlinks;
 -      // we thus fall back to polling
 -      if (fileInfo.isSymLink())
 -      {
 -        fontName.prepend("<i>");
 -        fontName.append("</i>");
 -        timer->start();
 -      }
 -      else
 -        fontWatcher->addPath(font);
 +      fontName.prepend("<i>");
 +      fontName.append("</i>");
+     }
 -    else
++
 +    if (!fileInfo.exists())
+     {
        // On Unix-like systems, the symlink's target gets opened; this
        // implies that deletion of a symlink doesn't make `engine->loadFont'
        // fail since it operates on a file handle pointing to the target.
        // For this reason, we remove the font to enforce a reload.
 -      engine->removeFont(currentFontIndex);
 +      engine_->removeFont(currentFontIndex_, false);
+     }
 -    fontFilenameLabel->setText(fontName);
 +    fontFilenameLabel_->setText(fontName);
+   }
    else
 -    fontFilenameLabel->clear();
+-
 -  currentNumberOfFaces
 -    = engine->numberOfFaces(currentFontIndex);
 -  currentNumberOfNamedInstances
 -    = engine->numberOfNamedInstances(currentFontIndex,
 -                                     currentFaceIndex);
 -  currentNumberOfGlyphs
 -    = engine->loadFont(currentFontIndex,
 -                       currentFaceIndex,
 -                       currentNamedInstanceIndex);
+-
 -  if (currentNumberOfGlyphs < 0)
 +    fontFilenameLabel_->clear();
++
 +  syncSettings();
 +  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 < fontList.size())
 -      timer->start();
 +    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();
@@ -218,60 +210,93 @@ MainGUI::showFont()
+ }
 +void
 +MainGUI::syncSettings()
 +{
 +  // Spinbox value cannot become negative
 +  engine_->setDPI(static_cast<unsigned int>(dpiSpinBox_->value()));
++
 +  if (unitsComboBox_->currentIndex() == Units_px)
 +    engine_->setSizeByPixel(sizeDoubleSpinBox_->value());
 +  else
 +    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_->setGamma(gammaSlider_->value());
++
 +  engine_->setAntiAliasingMode(static_cast<Engine::AntiAliasing>(
 +      antiAliasingComboBoxx_->currentIndex()));
 +}
++
++
 +void
 +MainGUI::clearStatusBar()
 +{
 +  statusBar()->clearMessage();
 +  statusBar()->setStyleSheet("");
 +}
++
++
  void
  MainGUI::checkHinting()
+ {
 -  if (hintingCheckBox->isChecked())
 +  if (hintingCheckBox_->isChecked())
+   {
 -    if (engine->fontType == 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->fontType == 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(AntiAliasing_Light, false);
 +    antiAliasingComboBoxx_->setItemEnabled(Engine::AntiAliasing_Light, false);
+   }
    drawGlyph();
@@ -281,17 +306,17 @@ MainGUI::checkHinting()
  void
  MainGUI::checkHintingMode()
+ {
 -  int index = hintingModeComboBoxx->currentIndex();
 +  int index = hintingModeComboBoxx_->currentIndex();
 -  if (engine->fontType == Engine::FontType_CFF)
 +  if (engine_->currentFontType() == Engine::FontType_CFF)
+   {
 -    engine->setCFFHintingMode(index);
 -    currentCFFHintingMode = index;
 +    engine_->setCFFHintingMode(hintingModesCFFHash_.key(index));
 +    currentCFFHintingMode_ = index;
+   }
 -  else if (engine->fontType == Engine::FontType_TrueType)
 +  else if (engine_->currentFontType() == Engine::FontType_TrueType)
+   {
 -    engine->setTTInterpreterVersion(index);
 -    currentTTInterpreterVersion = index;
 +    engine_->setTTInterpreterVersion(hintingModesTrueTypeHash_.key(index));
 +    currentTTInterpreterVersion_ = index;
+   }
    // this enforces reloading of the font
@@ -302,36 +327,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(AntiAliasing_Light, true);
 +    antiAliasingComboBoxx_->setItemEnabled(Engine::AntiAliasing_Light, true);
+   }
    else
+   {
 -    if (engine->fontType == Engine::FontType_CFF
 -        || engine->fontType == 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(AntiAliasing_Light, false);
 +    antiAliasingComboBoxx_->setItemEnabled(Engine::AntiAliasing_Light, false);
 -    if (antiAliasingComboBoxx->currentIndex() == AntiAliasing_Light)
 -      antiAliasingComboBoxx->setCurrentIndex(AntiAliasing_Normal);
 +    if (antiAliasingComboBoxx_->currentIndex() == Engine::AntiAliasing_Light)
 +      antiAliasingComboBoxx_->setCurrentIndex(Engine::AntiAliasing_Normal);
+   }
    drawGlyph();
@@ -341,19 +366,19 @@ MainGUI::checkAutoHinting()
  void
  MainGUI::checkAntiAliasing()
+ {
 -  int index = antiAliasingComboBoxx->currentIndex();
 +  int index = antiAliasingComboBoxx_->currentIndex();
 -  if (index == AntiAliasing_None
 -      || index == AntiAliasing_Normal
 -      || index == AntiAliasing_Light)
 +  if (index == Engine::AntiAliasing_None
 +      || index == Engine::AntiAliasing::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();
@@ -363,18 +388,18 @@ MainGUI::checkAntiAliasing()
  void
  MainGUI::checkLcdFilter()
+ {
 -  int index = lcdFilterComboBox->currentIndex();
 -  FT_Library_SetLcdFilter(engine->library, 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();
+ }
@@ -383,20 +408,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();
@@ -407,19 +432,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();
+ }
@@ -428,25 +453,25 @@ MainGUI::adjustGlyphIndex(int delta)
  void
  MainGUI::checkCurrentFontIndex()
+ {
 -  if (fontList.size() < 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 >= fontList.size() - 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);
+   }
+ }
@@ -454,25 +479,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);
+   }
+ }
@@ -480,25 +505,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);
+   }
+ }
@@ -506,11 +531,11 @@ MainGUI::checkCurrentNamedInstanceIndex()
  void
  MainGUI::previousFont()
+ {
 -  if (currentFontIndex > 0)
 +  if (currentFontIndex_ > 0)
+   {
 -    currentFontIndex--;
 -    currentFaceIndex = 0;
 -    currentNamedInstanceIndex = 0;
 +    currentFontIndex_--;
 +    currentFaceIndex_ = 0;
 +    currentNamedInstanceIndex_ = 0;
      showFont();
+   }
+ }
@@ -519,11 +544,11 @@ MainGUI::previousFont()
  void
  MainGUI::nextFont()
+ {
 -  if (currentFontIndex < fontList.size() - 1)
 +  if (currentFontIndex_ < engine_->numberOfOpenedFonts() - 1)
+   {
 -    currentFontIndex++;
 -    currentFaceIndex = 0;
 -    currentNamedInstanceIndex = 0;
 +    currentFontIndex_++;
 +    currentFaceIndex_ = 0;
 +    currentNamedInstanceIndex_ = 0;
      showFont();
+   }
+ }
@@ -532,10 +557,10 @@ MainGUI::nextFont()
  void
  MainGUI::previousFace()
+ {
 -  if (currentFaceIndex > 0)
 +  if (currentFaceIndex_ > 0)
+   {
 -    currentFaceIndex--;
 -    currentNamedInstanceIndex = 0;
 +    currentFaceIndex_--;
 +    currentNamedInstanceIndex_ = 0;
      showFont();
+   }
+ }
@@ -544,10 +569,10 @@ MainGUI::previousFace()
  void
  MainGUI::nextFace()
+ {
 -  if (currentFaceIndex < currentNumberOfFaces - 1)
 +  if (currentFaceIndex_ < currentNumberOfFaces_ - 1)
+   {
 -    currentFaceIndex++;
 -    currentNamedInstanceIndex = 0;
 +    currentFaceIndex_++;
 +    currentNamedInstanceIndex_ = 0;
      showFont();
+   }
+ }
@@ -556,9 +581,9 @@ MainGUI::nextFace()
  void
  MainGUI::previousNamedInstance()
+ {
 -  if (currentNamedInstanceIndex > 0)
 +  if (currentNamedInstanceIndex_ > 0)
+   {
 -    currentNamedInstanceIndex--;
 +    currentNamedInstanceIndex_--;
      showFont();
+   }
+ }
@@ -567,9 +592,9 @@ MainGUI::previousNamedInstance()
  void
  MainGUI::nextNamedInstance()
+ {
 -  if (currentNamedInstanceIndex < currentNumberOfNamedInstances - 1)
 +  if (currentNamedInstanceIndex_ < currentNumberOfNamedInstances_ - 1)
+   {
 -    currentNamedInstanceIndex++;
 +    currentNamedInstanceIndex_++;
      showFont();
+   }
+ }
@@ -578,7 +603,7 @@ MainGUI::nextNamedInstance()
  void
  MainGUI::zoom()
+ {
 -  int scale = zoomSpinBox->value();
 +  int scale = zoomSpinBox_->value();
    QTransform transform;
    transform.scale(scale, scale);
@@ -589,7 +614,7 @@ MainGUI::zoom()
    qreal shift = 0.5 / scale;
    transform.translate(shift, shift);
 -  glyphView->setTransform(transform);
 +  glyphView_->setTransform(transform);
+ }
@@ -598,28 +623,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);
+ }
@@ -628,81 +653,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;
+   }
 -  FT_Outline* outline = engine->loadOutline(currentGlyphIndex);
 +  syncSettings();
 +  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() == AntiAliasing_None)
 +      if (antiAliasingComboBoxx_->currentIndex() == Engine::AntiAliasing_None)
          pixelMode = FT_PIXEL_MODE_MONO;
 -      currentGlyphBitmapItem = new GlyphBitmap(outline,
 -                                               engine->library,
 +      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();
+ }
@@ -712,309 +738,309 @@ 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(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(AntiAliasing_Normal,
 +  antiAliasingComboBoxx_->insertItem(Engine::AntiAliasing_Normal,
                                      tr("Normal"));
 -  antiAliasingComboBoxx->insertItem(AntiAliasing_Light,
 +  antiAliasingComboBoxx_->insertItem(Engine::AntiAliasing_Light,
                                      tr("Light"));
 -  antiAliasingComboBoxx->insertItem(AntiAliasing_LCD,
 +  antiAliasingComboBoxx_->insertItem(Engine::AntiAliasing_LCD,
                                      tr("LCD (RGB)"));
 -  antiAliasingComboBoxx->insertItem(AntiAliasing_LCD_BGR,
 +  antiAliasingComboBoxx_->insertItem(Engine::AntiAliasing_LCD_BGR,
                                      tr("LCD (BGR)"));
 -  antiAliasingComboBoxx->insertItem(AntiAliasing_LCD_Vertical,
 +  antiAliasingComboBoxx_->insertItem(Engine::AntiAliasing_LCD_Vertical,
                                      tr("LCD (vert. RGB)"));
 -  antiAliasingComboBoxx->insertItem(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;
 +  glyphIndexLabel_ = new QLabel;
 +  glyphNameLabel_ = new QLabel;
 +  fontNameLabel_ = new QLabel;
 -  glyphScene = new QGraphicsScene;
 -  glyphScene->addItem(new Grid(gridPen, axisPen));
 +  glyphScene_ = new QGraphicsScene;
 +  glyphScene_->addItem(new Grid(gridPen_, axisPen_));
 -  currentGlyphBitmapItem = NULL;
 -  currentGlyphOutlineItem = NULL;
 -  currentGlyphPointsItem = NULL;
 -  currentGlyphPointNumbersItem = NULL;
 +  currentGlyphBitmapItem_ = NULL;
 +  currentGlyphOutlineItem_ = NULL;
 +  currentGlyphPointsItem_ = NULL;
 +  currentGlyphPointNumbersItem_ = NULL;
    drawGlyph();
 -  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"));
 +  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");
+ }
@@ -1022,127 +1048,122 @@ 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(fontWatcher, SIGNAL(fileChanged(const QString&)),
 -          SLOT(watchCurrentFont()));
 -  connect(timer, SIGNAL(timeout()),
 -          SLOT(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);
+ }
  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_);
+ }
@@ -1153,80 +1174,74 @@ MainGUI::createStatusBar()
+ }
 -void
 -MainGUI::clearStatusBar()
 -{
 -  statusBar()->clearMessage();
 -  statusBar()->setStyleSheet("");
 -}
+-
+-
  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();
    // make copies and remove existing elements...
 -  QHash<int, int> hmTTHash = hintingModesTrueTypeHash;
 -  if (hmTTHash.contains(engine->ttInterpreterVersionDefault))
 -    hmTTHash.remove(engine->ttInterpreterVersionDefault);
 -  if (hmTTHash.contains(engine->ttInterpreterVersionOther))
 -    hmTTHash.remove(engine->ttInterpreterVersionOther);
 -  if (hmTTHash.contains(engine->ttInterpreterVersionOther1))
 -    hmTTHash.remove(engine->ttInterpreterVersionOther1);
+-
 -  QHash<int, int> hmCFFHash = hintingModesCFFHash;
 -  if (hmCFFHash.contains(engine->cffHintingEngineDefault))
 -    hmCFFHash.remove(engine->cffHintingEngineDefault);
 -  if (hmCFFHash.contains(engine->cffHintingEngineOther))
 -    hmCFFHash.remove(engine->cffHintingEngineOther);
 +  QHash<int, int> hmTTHash = hintingModesTrueTypeHash_;
 +  if (hmTTHash.contains(defaults.ttInterpreterVersionDefault))
 +    hmTTHash.remove(defaults.ttInterpreterVersionDefault);
 +  if (hmTTHash.contains(defaults.ttInterpreterVersionOther))
 +    hmTTHash.remove(defaults.ttInterpreterVersionOther);
 +  if (hmTTHash.contains(defaults.ttInterpreterVersionOther1))
 +    hmTTHash.remove(defaults.ttInterpreterVersionOther1);
++
 +  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[engine->cffHintingEngineDefault];
 -  currentTTInterpreterVersion
 -    = hintingModesTrueTypeHash[engine->ttInterpreterVersionDefault];
 +  currentCFFHintingMode_
 +    = hintingModesCFFHash_[defaults.cffHintingEngineDefault];
 +  currentTTInterpreterVersion_
 +    = hintingModesTrueTypeHash_[defaults.ttInterpreterVersionDefault];
 -  hintingCheckBox->setChecked(true);
 +  hintingCheckBox_->setChecked(true);
 -  antiAliasingComboBoxx->setCurrentIndex(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();

src/ftinspect/maingui.hpp

@@ -94,158 +94,143 @@ private slots:
    void zoom();
  private:
 -  Engine* engine;
 +  Engine* engine_;
++
 +  int currentFontIndex_;
 -  QStringList fontList;
 -  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;
+-
 -  QFileSystemWatcher *fontWatcher;
+-
 -  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;
+-
 -  QTimer *timer;
+-
 -  QVBoxLayout *generalTabLayout;
 -  QVBoxLayout *leftLayout;
 -  QVBoxLayout *rightLayout;
+-
 -  QVector<QRgb> grayColorTable;
 -  QVector<QRgb> monoColorTable;
+-
 -  QWidget *ftinspectWidget;
 -  QWidget *generalTabWidget;
 -  QWidget *leftWidget;
 -  QWidget *rightWidget;
 -  QWidget *mmgxTabWidget;
+-
 -  enum AntiAliasing
 -  {
 -    AntiAliasing_None,
 -    AntiAliasing_Normal,
 -    AntiAliasing_Light,
 -    AntiAliasing_LCD,
 -    AntiAliasing_LCD_BGR,
 -    AntiAliasing_LCD_Vertical,
 -    AntiAliasing_LCD_Vertical_BGR
 -  };
 +  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_;
++
    enum HintingMode
+   {
      HintingMode_TrueType_v35,
@@ -267,15 +252,18 @@ private:
      Units_pt
    };
 +  void showFont();
 +  void syncSettings();
 +  void clearStatusBar();
++
    void createActions();
    void createConnections();
    void createLayout();
    void createMenus();
 -  void clearStatusBar();
    void createStatusBar();
 -  void readSettings();
    void setGraphicsDefaults();
 -  void showFont();
++
 +  void readSettings();
    void writeSettings();
  };

src/ftinspect/meson.build

@@ -21,15 +21,19 @@ qt5_dep = dependency('qt5',
  if qt5_dep.found()
    sources = files([
      'engine/engine.cpp',
 +    'engine/fontfilemanager.cpp',
++
      'rendering/glyphbitmap.cpp',
      'rendering/glyphoutline.cpp',
      'rendering/glyphpointnumbers.cpp',
      'rendering/glyphpoints.cpp',
      'rendering/grid.cpp',
++
      'widgets/qcomboboxx.cpp',
      'widgets/qgraphicsviewx.cpp',
      'widgets/qpushbuttonx.cpp',
      'widgets/qspinboxx.cpp',
++
      'ftinspect.cpp',
      'maingui.cpp',
    ])

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 / lod,
 + 1 / lod),
                          QColor(qRed(p),

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_;
  };

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);
+ }

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_;
  };

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 (;;)
+       {

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_;
  };

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);
+       }

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_;
  };

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,
 , y);
+   }
 -  painter->setPen(axisPen);
 +  painter->setPen(axisPen_);
    painter->drawLine(0, -100,
 , 100);

src/ftinspect/rendering/grid.hpp

@@ -21,8 +21,8 @@ public:
               QWidget* widget);
  private:
 -  QPen gridPen;
 -  QPen axisPen;
 +  QPen gridPen_;
 +  QPen axisPen_;
  };

src/ftinspect/widgets/qgraphicsviewx.cpp


 
 
 QGraphicsViewx::QGraphicsViewx()
-: lastBottomLeftPointInitialized(false)
+: lastBottomLeftPointInitialized_(false)
 {
   // empty
 }

                                  int dy)
 {
   QGraphicsView::scrollContentsBy(dx, dy);
-  lastBottomLeftPoint = viewport()->rect().bottomLeft();
+  lastBottomLeftPoint_ = viewport()->rect().bottomLeft();
 }
 
 

 
   // 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();

   verticalScrollBar()->setValue(static_cast<int>(
                                   verticalPosition
                                   - (currentBottomLeftPoint.y()
-                                     - lastBottomLeftPoint.y())));
+                                     - lastBottomLeftPoint_.y())));
 }
 
 

src/ftinspect/widgets/qgraphicsviewx.hpp

@@ -24,8 +24,8 @@ protected:
                          int dy);
  private:
 -  QPointF lastBottomLeftPoint;
 -  bool lastBottomLeftPointInitialized;
 +  QPointF lastBottomLeftPoint_;
 +  bool lastBottomLeftPointInitialized_;
  };

From:	Charlie Jiang (@cqjjjzr)
Subject:	[Git][freetype/freetype-demos][reorg-maingui] 3 commits: [ftinspect] Move out font file managing/watching out to a new class.
Date:	Wed, 29 Jun 2022 15:00:43 +0000