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

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

Commits:

8cc92c54

by Charlie Jiang at 2022-06-30T18:21:36+08:00

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

* src/ftinspect/maingui.hpp, src/ftinspect/maingui.cpp: Move `fontList`,
`fontWatcher` and `timer` and other code related to font file managing to
new class `FontFileManager`.

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

* src/ftinspect/fontfilemanager.hpp, src/ftinspect/fontfilemanager.cpp: New
files.

* src/ftinspect/CMakeLists.txt, src/ftinspect/meson.build: Updated.

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

1f0ead70

by Charlie Jiang at 2022-06-30T18:39:28+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.

5771bdf9

by Charlie Jiang at 2022-06-30T18:39:28+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.

c22559ce

by Charlie Jiang at 2022-06-30T22:28:26+08:00

[ftinspect] Use custom `QAbstractListModel` instead of manually mapping.

In `maingui.cpp`, mapping between `QComboBox` indices and actual FreeType
values was done manually. The enabled statuses of individual ComboBox items
were also maintained in `maingui.cpp`.

In this commit, those code was moved to seperate custom classes implementating
`QAbstractListModel`. All mapping was done there. Statuses was maintained
in the classes as well. By doing this, the reason why some items were disabled
was made more clear and explicit, and adding more items is more easy.

The `QComboBoxx` custom widget was no longer needed since disable flag can be
provided by the custom model by overriding the `flags` function.

`SimpleComboBoxModel` is a basic class for Key-Value-DisplayName mapping.
Other models could extend this class if no complicated mapping (e.g.
`HintingModeComboBoxModel`) is needed.

* src/ftinspect/models/ttsettingscomboboxmodel.cpp,
  src/ftinspect/models/ttsettingscomboboxmodel.cpp: New files.
  `HintingModeComboBoxModel`, `SimpleComboBoxModel`, `LCDFilterComboBoxModel`
  and `AntiAliasingComboBoxModel` is defined here.

* src/ftinspect/engine/engine.cpp, src/ftinspect/engine/engine.hpp:
  `Engine` now accepts "load target" value of certain anti-aliasing mode
  instead of the anti-aliasing enum value. The mapping was moved into
  `AntiAliasingComboBoxModel`.

* src/ftinspect/maingui.cpp, src/ftinspect/maingui.hpp: Move all mappings
  and enabled/disabled statuses to separate models.
  Remove mapping `QHash`es. Use `QComboBox` instead of `QComboBoxx`.

* src/ftinspect/meson.build, src/ftinspect/CMakeLists.txt: Updated.

23 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/models/ttsettingscomboboxmodel.cpp
+ src/ftinspect/models/ttsettingscomboboxmodel.hpp
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"
@@ -31,6 +32,8 @@ add_executable(ftinspect
    "widgets/qgraphicsviewx.cpp"
    "widgets/qpushbuttonx.cpp"
    "widgets/qspinboxx.cpp"
++
 +  "models/ttsettingscomboboxmodel.cpp"
+ )
  target_link_libraries(ftinspect
    Qt5::Core Qt5::Widgets

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)
+ {
 -  int index = gui->hintingModesCFFHash.key(mode);
 +  this->pixelSize_ = pixelSize;
 +  pointSize_ = pixelSize * 72.0 / dpi_;
 +  usingPixelSize_ = true;
 +}
 -  FT_Error error = FT_Property_Set(library,
 +void
 +Engine::setSizeByPoint(double pointSize)
 +{
 +  this->pointSize_ = pointSize;
 +  pixelSize_ = pointSize * dpi_ / 72.0;
 +  usingPixelSize_ = false;
 +}
++
++
 +void
 +Engine::setLcdFilter(FT_LcdFilter filter)
 +{
 +  FT_Library_SetLcdFilter(library_, filter);
 +}
++
++
 +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,95 +457,143 @@ 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)
 +  if (doHinting_)
+   {
 -    pixelSize = gui->sizeDoubleSpinBox->value();
 -    pointSize = pixelSize * 72.0 / dpi;
 +    // TODO Differenate RGB/BGR here?
 +    unsigned long target = antiAliasingTarget_;
 +    loadFlags_ |= target;
+   }
    else
+   {
 -    pointSize = gui->sizeDoubleSpinBox->value();
 -    pixelSize = pointSize * dpi / 72.0;
 +    loadFlags_ |= FT_LOAD_NO_HINTING;
++
 +    if (antiAliasingTarget_ == FT_LOAD_TARGET_MONO)
 +      loadFlags_ |= FT_LOAD_MONOCHROME;
+   }
 -  doHinting = gui->hintingCheckBox->isChecked();
 +  // XXX handle color fonts also
 -  doAutoHinting = gui->autoHintingCheckBox->isChecked();
 -  doHorizontalHinting = gui->horizontalHintingCheckBox->isChecked();
 -  doVerticalHinting = gui->verticalHintingCheckBox->isChecked();
 -  doBlueZoneHinting = gui->blueZoneHintingCheckBox->isChecked();
 -  showSegments = gui->segmentDrawingCheckBox->isChecked();
 +  scaler_.pixel = 0; // use 26.6 format
 -  gamma = gui->gammaSlider->value();
 +  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;
 +  }
 +  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_;
 +  }
 +}
 -  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();
 +void
 +Engine::queryEngine()
 +{
 +  FT_Error error;
 -  if (doHinting)
 -  {
 -    unsigned long target;
 +  // query engines and check for alternatives
 -    if (index == MainGUI::AntiAliasing_None)
 -      target = FT_LOAD_TARGET_MONO;
 -    else
 +  // 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[] =
+     {
 -      switch (index)
 -      {
 -      case MainGUI::AntiAliasing_Light:
 -        target = FT_LOAD_TARGET_LIGHT;
 -        break;
 +      FT_HINTING_FREETYPE,
 +      FT_HINTING_ADOBE
 +    };
 -      case MainGUI::AntiAliasing_LCD:
 -      case MainGUI::AntiAliasing_LCD_BGR:
 -        target = FT_LOAD_TARGET_LCD;
 +    int i;
 +    for (i = 0; i < 2; i++)
 +      if (engineDefaults_.cffHintingEngineDefault == engines[i])
          break;
 -      case MainGUI::AntiAliasing_LCD_Vertical:
 -      case MainGUI::AntiAliasing_LCD_Vertical_BGR:
 -        target = FT_LOAD_TARGET_LCD_V;
 -        break;
 +    engineDefaults_.cffHintingEngineOther = engines[(i + 1) % 2];
 -      default:
 -        target = FT_LOAD_TARGET_NORMAL;
 -      }
 -    }
 +    error = FT_Property_Set(library_,
 +                            "cff",
 +                            "hinting-engine",
 +                            &engineDefaults_.cffHintingEngineOther);
 +    if (error)
 +      engineDefaults_.cffHintingEngineOther = -1;
 -    loadFlags |= target;
 +    // 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
+   {
 -    loadFlags |= FT_LOAD_NO_HINTING;
 +    int interpreters[] =
 +    {
 +      TT_INTERPRETER_VERSION_35,
 +      TT_INTERPRETER_VERSION_38,
 +      TT_INTERPRETER_VERSION_40
 +    };
 -    if (index == MainGUI::AntiAliasing_None)
 -      loadFlags |= FT_LOAD_MONOCHROME;
 -  }
 +    int i;
 +    for (i = 0; i < 3; i++)
 +      if (engineDefaults_.ttInterpreterVersionDefault == interpreters[i])
 +        break;
 -  // XXX handle color fonts also
 +    engineDefaults_.ttInterpreterVersionOther = interpreters[(i + 1) % 3];
 -  scaler.pixel = 0; // use 26.6 format
 +    error = FT_Property_Set(library_,
 +                            "truetype",
 +                            "interpreter-version",
 +                            &engineDefaults_.ttInterpreterVersionOther);
 +    if (error)
 +      engineDefaults_.ttInterpreterVersionOther = -1;
 -  if (gui->unitsComboBox->currentIndex() == MainGUI::Units_px)
 -  {
 -    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;
 +    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,151 @@ struct FaceID
    bool operator<(const FaceID& other) const;
  };
+-
 -class MainGUI;
+-
  // FreeType specific data.
  class Engine
+ {
  public:
 -  Engine(MainGUI*);
 +  //////// Nested definitions (forward decl)
 +  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 setAntiAliasingTarget(int target) { antiAliasingTarget_ = target; }
++
 +  // 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_;
 +  int antiAliasingTarget_;
 -  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
++
 +  // 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,81 @@ 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_->setAntiAliasingTarget(antiAliasingComboBoxModel_->indexToValue(
 +    antiAliasingComboBox_->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++)
 -      {
 -        if (hintingModesCFFHash.key(i, -1) != -1)
 -          hintingModeComboBoxx->setItemEnabled(i, true);
 -        else
 -          hintingModeComboBoxx->setItemEnabled(i, false);
 -      }
+-
 -      hintingModeComboBoxx->setCurrentIndex(currentCFFHintingMode);
 +      hintingModeComboBoxModel_->setCurrentEngineType(
 +        HintingModeComboBoxModel::HintingEngineType_CFF);
 +      hintingModeComboBox_->setCurrentIndex(currentCFFHintingMode_);
+     }
 -    else if (engine->fontType == Engine::FontType_TrueType)
 +    else if (engine_->currentFontType() == Engine::FontType_TrueType)
+     {
 -      for (int i = 0; i < hintingModeComboBoxx->count(); i++)
 -      {
 -        if (hintingModesTrueTypeHash.key(i, -1) != -1)
 -          hintingModeComboBoxx->setItemEnabled(i, true);
 -        else
 -          hintingModeComboBoxx->setItemEnabled(i, false);
 -      }
+-
 -      hintingModeComboBoxx->setCurrentIndex(currentTTInterpreterVersion);
 +      hintingModeComboBoxModel_->setCurrentEngineType(
 +        HintingModeComboBoxModel::HintingEngineType_TrueType);
 +      hintingModeComboBox_->setCurrentIndex(currentTTInterpreterVersion_);
+     }
      else
+     {
 -      hintingModeLabel->setEnabled(false);
 -      hintingModeComboBoxx->setEnabled(false);
 +      hintingModeLabel_->setEnabled(false);
 +      hintingModeComboBox_->setEnabled(false);
+     }
 -    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);
+-
 -    autoHintingCheckBox->setEnabled(false);
 -    horizontalHintingCheckBox->setEnabled(false);
 -    verticalHintingCheckBox->setEnabled(false);
 -    blueZoneHintingCheckBox->setEnabled(false);
 -    segmentDrawingCheckBox->setEnabled(false);
+-
 -    antiAliasingComboBoxx->setItemEnabled(AntiAliasing_Light, false);
 +    hintingModeLabel_->setEnabled(false);
 +    hintingModeComboBox_->setEnabled(false);
++
 +    autoHintingCheckBox_->setEnabled(false);
 +    horizontalHintingCheckBox_->setEnabled(false);
 +    verticalHintingCheckBox_->setEnabled(false);
 +    blueZoneHintingCheckBox_->setEnabled(false);
 +    segmentDrawingCheckBox_->setEnabled(false);
++
 +    antiAliasingComboBoxModel_->setLightAntiAliasingEnabled(false);
 +    if (antiAliasingComboBox_->currentIndex()
 +      == AntiAliasingComboBoxModel::AntiAliasing_Light)
 +      antiAliasingComboBox_->setCurrentIndex(
 +        AntiAliasingComboBoxModel::AntiAliasing_Normal);
+   }
    drawGlyph();
@@ -281,17 +294,19 @@ MainGUI::checkHinting()
  void
  MainGUI::checkHintingMode()
+ {
 -  int index = hintingModeComboBoxx->currentIndex();
 +  int index = hintingModeComboBox_->currentIndex();
 -  if (engine->fontType == Engine::FontType_CFF)
 +  if (engine_->currentFontType() == Engine::FontType_CFF)
+   {
 -    engine->setCFFHintingMode(index);
 -    currentCFFHintingMode = index;
 +    engine_->setCFFHintingMode(
 +      hintingModeComboBoxModel_->indexToCFFMode(index));
 +    currentCFFHintingMode_ = index;
+   }
 -  else if (engine->fontType == Engine::FontType_TrueType)
 +  else if (engine_->currentFontType() == Engine::FontType_TrueType)
+   {
 -    engine->setTTInterpreterVersion(index);
 -    currentTTInterpreterVersion = index;
 +    engine_->setTTInterpreterVersion(
 +      hintingModeComboBoxModel_->indexToTTInterpreterVersion(index));
 +    currentTTInterpreterVersion_ = index;
+   }
    // this enforces reloading of the font
@@ -302,36 +317,38 @@ MainGUI::checkHintingMode()
  void
  MainGUI::checkAutoHinting()
+ {
 -  if (autoHintingCheckBox->isChecked())
 +  if (autoHintingCheckBox_->isChecked())
+   {
 -    hintingModeLabel->setEnabled(false);
 -    hintingModeComboBoxx->setEnabled(false);
 +    hintingModeLabel_->setEnabled(false);
 +    hintingModeComboBox_->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);
 +    antiAliasingComboBoxModel_->setLightAntiAliasingEnabled(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);
 +      hintingModeComboBox_->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);
 +    antiAliasingComboBoxModel_->setLightAntiAliasingEnabled(false);
 -    if (antiAliasingComboBoxx->currentIndex() == AntiAliasing_Light)
 -      antiAliasingComboBoxx->setCurrentIndex(AntiAliasing_Normal);
 +    if (antiAliasingComboBox_->currentIndex()
 +        == AntiAliasingComboBoxModel::AntiAliasing_Light)
 +      antiAliasingComboBox_->setCurrentIndex(
 +          AntiAliasingComboBoxModel::AntiAliasing_Normal);
+   }
    drawGlyph();
@@ -341,19 +358,19 @@ MainGUI::checkAutoHinting()
  void
  MainGUI::checkAntiAliasing()
+ {
 -  int index = antiAliasingComboBoxx->currentIndex();
 +  int index = antiAliasingComboBox_->currentIndex();
 -  if (index == AntiAliasing_None
 -      || index == AntiAliasing_Normal
 -      || index == AntiAliasing_Light)
 +  if (index == AntiAliasingComboBoxModel::AntiAliasing_None
 +      || index == AntiAliasingComboBoxModel::AntiAliasing::AntiAliasing_Normal
 +      || index == AntiAliasingComboBoxModel::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 +380,19 @@ MainGUI::checkAntiAliasing()
  void
  MainGUI::checkLcdFilter()
+ {
 -  int index = lcdFilterComboBox->currentIndex();
 -  FT_Library_SetLcdFilter(engine->library, lcdFilterHash.key(index));
 +  int index = lcdFilterComboBox_->currentIndex();
 +  engine_->setLcdFilter(static_cast<FT_LcdFilter>(
 +    lcdFilterComboboxModel_->indexToValue(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 +401,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 +425,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 +446,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 +472,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 +498,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 +524,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 +537,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 +550,10 @@ MainGUI::nextFont()
  void
  MainGUI::previousFace()
+ {
 -  if (currentFaceIndex > 0)
 +  if (currentFaceIndex_ > 0)
+   {
 -    currentFaceIndex--;
 -    currentNamedInstanceIndex = 0;
 +    currentFaceIndex_--;
 +    currentNamedInstanceIndex_ = 0;
      showFont();
+   }
+ }
@@ -544,10 +562,10 @@ MainGUI::previousFace()
  void
  MainGUI::nextFace()
+ {
 -  if (currentFaceIndex < currentNumberOfFaces - 1)
 +  if (currentFaceIndex_ < currentNumberOfFaces_ - 1)
+   {
 -    currentFaceIndex++;
 -    currentNamedInstanceIndex = 0;
 +    currentFaceIndex_++;
 +    currentNamedInstanceIndex_ = 0;
      showFont();
+   }
+ }
@@ -556,9 +574,9 @@ MainGUI::nextFace()
  void
  MainGUI::previousNamedInstance()
+ {
 -  if (currentNamedInstanceIndex > 0)
 +  if (currentNamedInstanceIndex_ > 0)
+   {
 -    currentNamedInstanceIndex--;
 +    currentNamedInstanceIndex_--;
      showFont();
+   }
+ }
@@ -567,9 +585,9 @@ MainGUI::previousNamedInstance()
  void
  MainGUI::nextNamedInstance()
+ {
 -  if (currentNamedInstanceIndex < currentNumberOfNamedInstances - 1)
 +  if (currentNamedInstanceIndex_ < currentNumberOfNamedInstances_ - 1)
+   {
 -    currentNamedInstanceIndex++;
 +    currentNamedInstanceIndex_++;
      showFont();
+   }
+ }
@@ -578,7 +596,7 @@ MainGUI::nextNamedInstance()
  void
  MainGUI::zoom()
+ {
 -  int scale = zoomSpinBox->value();
 +  int scale = zoomSpinBox_->value();
    QTransform transform;
    transform.scale(scale, scale);
@@ -589,7 +607,7 @@ MainGUI::zoom()
    qreal shift = 0.5 / scale;
    transform.translate(shift, shift);
 -  glyphView->setTransform(transform);
 +  glyphView_->setTransform(transform);
+ }
@@ -598,28 +616,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 +646,83 @@ 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 (antiAliasingComboBox_->currentIndex()
 +          == AntiAliasingComboBoxModel::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 +732,290 @@ void
  MainGUI::createLayout()
+ {
    // left side
 -  fontFilenameLabel = new QLabel;
+-
 -  hintingCheckBox = new QCheckBox(tr("Hinting"));
+-
 -  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,
 -                                   tr("TrueType v38"));
 -  hintingModeComboBoxx->insertItem(HintingMode_TrueType_v40,
 -                                   tr("TrueType v40"));
 -  hintingModeComboBoxx->insertItem(HintingMode_CFF_FreeType,
 -                                   tr("CFF (FreeType)"));
 -  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,
 -                                    tr("None"));
 -  antiAliasingComboBoxx->insertItem(AntiAliasing_Normal,
 -                                    tr("Normal"));
 -  antiAliasingComboBoxx->insertItem(AntiAliasing_Light,
 -                                    tr("Light"));
 -  antiAliasingComboBoxx->insertItem(AntiAliasing_LCD,
 -                                    tr("LCD (RGB)"));
 -  antiAliasingComboBoxx->insertItem(AntiAliasing_LCD_BGR,
 -                                    tr("LCD (BGR)"));
 -  antiAliasingComboBoxx->insertItem(AntiAliasing_LCD_Vertical,
 -                                    tr("LCD (vert. RGB)"));
 -  antiAliasingComboBoxx->insertItem(AntiAliasing_LCD_Vertical_BGR,
 -                                    tr("LCD (vert. BGR)"));
 -  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);
 +  fontFilenameLabel_ = new QLabel;
++
 +  hintingCheckBox_ = new QCheckBox(tr("Hinting"));
++
 +  hintingModeLabel_ = new QLabel(tr("Hinting Mode"));
 +  hintingModeLabel_->setAlignment(Qt::AlignRight);
++
 +  hintingModeComboBoxModel_ = new HintingModeComboBoxModel;
 +  hintingModeComboBox_ = new QComboBox;
 +  hintingModeComboBox_->setModel(hintingModeComboBoxModel_);
 +  hintingModeLabel_->setBuddy(hintingModeComboBox_);
++
 +  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);
++
 +  antiAliasingComboBoxModel_ = new AntiAliasingComboBoxModel;
 +  antiAliasingComboBox_ = new QComboBox;
 +  antiAliasingComboBox_->setModel(antiAliasingComboBoxModel_);
 +  antiAliasingLabel_->setBuddy(antiAliasingComboBox_);
++
 +  lcdFilterLabel_ = new QLabel(tr("LCD Filter"));
 +  lcdFilterLabel_->setAlignment(Qt::AlignRight);
++
 +  lcdFilterComboboxModel_ = new LCDFilterComboBoxModel;
 +  lcdFilterComboBox_ = new QComboBox;
 +  lcdFilterComboBox_->setModel(lcdFilterComboboxModel_);
 +  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 = hintingModeComboBox_->minimumSizeHint().width();
 +  width = qMax(antiAliasingComboBox_->minimumSizeHint().width(), width);
 +  width = qMax(lcdFilterComboBox_->minimumSizeHint().width(), width);
 +  hintingModeComboBox_->setMinimumWidth(width);
 +  antiAliasingComboBox_->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(hintingModeComboBox_);
++
 +  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(antiAliasingComboBox_);
++
 +  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 +1023,122 @@ MainGUI::createLayout()
  void
  MainGUI::createConnections()
+ {
 -  connect(hintingCheckBox, SIGNAL(clicked()),
 +  connect(hintingCheckBox_, SIGNAL(clicked()),
            SLOT(checkHinting()));
 -  connect(hintingModeComboBoxx, SIGNAL(currentIndexChanged(int)),
 +  connect(hintingModeComboBox_, SIGNAL(currentIndexChanged(int)),
            SLOT(checkHintingMode()));
 -  connect(antiAliasingComboBoxx, SIGNAL(currentIndexChanged(int)),
 +  connect(antiAliasingComboBox_, 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 +1149,49 @@ 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;
+-
 -  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;
+-
 -  // 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);
+-
 -  // ... to construct a list of always disabled hinting mode combo box items
 -  hintingModesAlwaysDisabled = hmTTHash.values();
 -  hintingModesAlwaysDisabled += hmCFFHash.values();
+-
 -  for (int i = 0; i < hintingModesAlwaysDisabled.size(); i++)
 -    hintingModeComboBoxx->setItemEnabled(hintingModesAlwaysDisabled[i],
 -                                         false);
 +  Engine::EngineDefaultValues& defaults = engine_->engineDefaults();
 -  // the next four values always non-negative
 -  currentFontIndex = 0;
 -  currentFaceIndex = 0;
 -  currentNamedInstanceIndex = 0;
 -  currentGlyphIndex = 0;
+-
 -  currentCFFHintingMode
 -    = hintingModesCFFHash[engine->cffHintingEngineDefault];
 -  currentTTInterpreterVersion
 -    = hintingModesTrueTypeHash[engine->ttInterpreterVersionDefault];
+-
 -  hintingCheckBox->setChecked(true);
+-
 -  antiAliasingComboBoxx->setCurrentIndex(AntiAliasing_Normal);
 -  lcdFilterComboBox->setCurrentIndex(LCDFilter_Light);
 +  hintingModeComboBoxModel_->setSupportedModes(
 +    { defaults.ttInterpreterVersionDefault,
 +      defaults.ttInterpreterVersionOther,
 +      defaults.ttInterpreterVersionOther1 },
 +    { defaults.cffHintingEngineDefault,
 +      defaults.cffHintingEngineOther });
 -  horizontalHintingCheckBox->setChecked(true);
 -  verticalHintingCheckBox->setChecked(true);
 -  blueZoneHintingCheckBox->setChecked(true);
+-
 -  showBitmapCheckBox->setChecked(true);
 -  showOutlinesCheckBox->setChecked(true);
+-
 -  gammaSlider->setValue(18); // 1.8
 -  sizeDoubleSpinBox->setValue(20);
 -  dpiSpinBox->setValue(96);
 -  zoomSpinBox->setValue(20);
 +  // the next four values always non-negative
 +  currentFontIndex_ = 0;
 +  currentFaceIndex_ = 0;
 +  currentNamedInstanceIndex_ = 0;
 +  currentGlyphIndex_ = 0;
++
 +  currentCFFHintingMode_
 +    = hintingModeComboBoxModel_->cffModeToIndex(
 +    defaults.cffHintingEngineDefault);
 +  currentTTInterpreterVersion_
 +    = hintingModeComboBoxModel_->ttInterpreterVersionToIndex(
 +        defaults.ttInterpreterVersionDefault);
++
 +  hintingCheckBox_->setChecked(true);
++
 +  antiAliasingComboBox_->setCurrentIndex(
 +    AntiAliasingComboBoxModel::AntiAliasing_Normal);
 +  lcdFilterComboBox_->setCurrentIndex(
 +    LCDFilterComboBoxModel::LCDFilter_Light);
++
 +  horizontalHintingCheckBox_->setChecked(true);
 +  verticalHintingCheckBox_->setChecked(true);
 +  blueZoneHintingCheckBox_->setChecked(true);
++
 +  showBitmapCheckBox_->setChecked(true);
 +  showOutlinesCheckBox_->setChecked(true);
++
 +  gammaSlider_->setValue(18); // 1.8
 +  sizeDoubleSpinBox_->setValue(20);
 +  dpiSpinBox_->setValue(96);
 +  zoomSpinBox_->setValue(20);
    checkHinting();
    checkHintingMode();

src/ftinspect/maingui.hpp

@@ -14,6 +14,7 @@
  #include "widgets/qgraphicsviewx.hpp"
  #include "widgets/qpushbuttonx.hpp"
  #include "widgets/qspinboxx.hpp"
 +#include "models/ttsettingscomboboxmodel.hpp"
  #include <QAction>
  #include <QCheckBox>
@@ -94,188 +95,161 @@ 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_;
++
 +  AntiAliasingComboBoxModel* antiAliasingComboBoxModel_;
 +  HintingModeComboBoxModel* hintingModeComboBoxModel_;
 +  LCDFilterComboBoxModel* lcdFilterComboboxModel_;
++
 +  QComboBox *antiAliasingComboBox_;
 +  QComboBox *hintingModeComboBox_;
 +  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
 -  };
 -  enum HintingMode
 -  {
 -    HintingMode_TrueType_v35,
 -    HintingMode_TrueType_v38,
 -    HintingMode_TrueType_v40,
 -    HintingMode_CFF_FreeType,
 -    HintingMode_CFF_Adobe
 -  };
 -  enum LCDFilter
 -  {
 -    LCDFilter_Default,
 -    LCDFilter_Light,
 -    LCDFilter_None,
 -    LCDFilter_Legacy
 -  };
 +  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 Units
+   {
      Units_px,
      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,18 +21,24 @@ 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',
++
 +    'models/ttsettingscomboboxmodel.cpp',
++
      'ftinspect.cpp',
      'maingui.cpp',
 -  ])
 +])
    moc_files = qt5.preprocess(
      moc_headers: [
@@ -41,6 +47,7 @@ if qt5_dep.found()
        'widgets/qpushbuttonx.hpp',
        'widgets/qspinboxx.hpp',
        'maingui.hpp',
 +      'models/ttsettingscomboboxmodel.cpp',
      ],
      dependencies: qt5_dep)

src/ftinspect/models/ttsettingscomboboxmodel.cpp

 +// ttsettingscomboboxmodel.cpp
++
 +// Copyright (C) 2022 by Charlie Jiang.
++
++
 +#include "ttsettingscomboboxmodel.hpp"
++
 +#include <QApplication>
 +#include <QPalette>
 +#include <freetype/ftdriver.h>
 +#include <freetype/ftlcdfil.h>
++
++
 +/////////////////////////////////////////////////////////////////////////////
 +//
 +// HintingModeComboBoxModel
 +//
 +/////////////////////////////////////////////////////////////////////////////
++
 +HintingModeComboBoxModel::HintingModeComboBoxModel()
 +{
 +  items_[HintingMode_TrueType_v35] = {
 +    HintingEngineType_TrueType,
 +    HintingMode_TrueType_v35,
 +    TT_INTERPRETER_VERSION_35,
 +    false, false,
 +    "TrueType v35"
 +  };
 +  items_[HintingMode_TrueType_v38] = {
 +    HintingEngineType_TrueType,
 +    HintingMode_TrueType_v38,
 +    TT_INTERPRETER_VERSION_38,
 +    false, false,
 +    "TrueType v38"
 +  };
 +  items_[HintingMode_TrueType_v40] = {
 +    HintingEngineType_TrueType,
 +    HintingMode_TrueType_v40,
 +    TT_INTERPRETER_VERSION_40,
 +    false, false,
 +    "TrueType v40"
 +  };
++
 +  items_[HintingMode_CFF_FreeType] = {
 +    HintingEngineType_CFF,
 +    HintingMode_CFF_FreeType,
 +    FT_HINTING_FREETYPE,
 +    false, false,
 +    "CFF (FreeType)"
 +  };
 +  items_[HintingMode_CFF_Adobe] = {
 +    HintingEngineType_CFF,
 +    HintingMode_CFF_Adobe,
 +    FT_HINTING_ADOBE,
 +    false, false,
 +    "CFF (Adobe)"
 +  };
 +}
++
++
 +int
 +HintingModeComboBoxModel::rowCount(const QModelIndex& parent) const
 +{
 +  return items_.size();
 +}
++
++
 +QVariant
 +HintingModeComboBoxModel::data(const QModelIndex& index,
 +  int role) const
 +{
 +  int r = index.row();
 +  if (r < 0 || r >= items_.size())
 +    return QVariant {};
 +  HintingModeItem const& item = items_[r];
++
 +  switch (role)
 +  {
 +  case Qt::DisplayRole:
 +    return item.displayName;
 +  case Qt::ForegroundRole:
 +    if (item.enabled && item.supported)
 +      return QVariant {};
 +    else
 +      return QApplication::palette().color(QPalette::Disabled,
 +                                           QPalette::Text);
 +  default:
 +    return QVariant {};
 +  }
 +}
++
++
 +Qt::ItemFlags
 +HintingModeComboBoxModel::flags(const QModelIndex& index) const
 +{
 +  int r = index.row();
 +  if (r < 0 || r >= items_.size())
 +    return Qt::ItemFlags {}; // not selectable, not enabled
 +  HintingModeItem const& item = items_[r];
++
 +  if (item.enabled && item.supported)
 +    return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
++
 +  return Qt::ItemFlags {};
 +}
++
++
 +int
 +HintingModeComboBoxModel::indexToValueForType(int index,
 +                                              HintingEngineType type) const
 +{
 +  if (index < 0 || index >= items_.size())
 +    return -1;
 +  HintingModeItem const& item = items_[index];
 +  if (!item.supported || !item.enabled || item.type != type)
 +    return -1;
 +  return item.value;
 +}
++
++
 +int
 +HintingModeComboBoxModel::valueToIndexForType(int value,
 +                                              HintingEngineType type) const
 +{
 +  for (auto it = items_.begin();
 +       it != items_.end();
 +       ++it)
 +  {
 +    if (it->type == type && it->value == value)
 +      return it->key;
 +  }
 +  return -1;
 +}
++
++
 +int
 +HintingModeComboBoxModel::indexToTTInterpreterVersion(int index) const
 +{
 +  return indexToValueForType(index, HintingEngineType_TrueType);
 +}
++
++
 +int
 +HintingModeComboBoxModel::indexToCFFMode(int index) const
 +{
 +  return indexToValueForType(index, HintingEngineType_CFF);
 +}
++
++
 +int
 +HintingModeComboBoxModel::cffModeToIndex(int mode) const
 +{
 +  return valueToIndexForType(mode, HintingEngineType_CFF);
 +}
++
++
 +int
 +HintingModeComboBoxModel::ttInterpreterVersionToIndex(int version) const
 +{
 +  return valueToIndexForType(version, HintingEngineType_TrueType);
 +}
++
++
 +void
 +HintingModeComboBoxModel::setSupportedModes(QList<int> supportedTTIVersions,
 +                                            QList<int> supportedCFFModes)
 +{
 +  for (auto it = items_.begin();
 +       it != items_.end();
 +       ++it)
 +  {
 +    if (it->type == HintingEngineType_TrueType)
 +      it->supported = supportedTTIVersions.contains(it->value);
 +    else if (it->type == HintingEngineType_CFF)
 +      it->supported = supportedCFFModes.contains(it->value);
 +    else
 +      it->supported = false;
 +  }
 +}
++
++
 +void
 +HintingModeComboBoxModel::setCurrentEngineType(HintingEngineType type)
 +{
 +  for (auto it = items_.begin();
 +       it != items_.end();
 +       ++it)
 +    it->enabled = it->supported && it->type == type;
 +}
++
++
 +/////////////////////////////////////////////////////////////////////////////
 +//
 +// SimpleComboBoxModel
 +//
 +/////////////////////////////////////////////////////////////////////////////
++
++
 +int
 +SimpleComboBoxModel::rowCount(const QModelIndex& parent) const
 +{
 +  return items_.size();
 +}
++
++
 +QVariant
 +SimpleComboBoxModel::data(const QModelIndex& index, int role) const
 +{
 +  if (role != Qt::DisplayRole)
 +    return QVariant {};
++
 +  int r = index.row();
 +  if (r < 0 || r >= items_.size())
 +    return QVariant {};
 +  return items_[r].displayName;
 +}
++
++
 +int
 +SimpleComboBoxModel::indexToValue(int index)
 +{
 +  if (index < 0 || index >= items_.size())
 +    return -1;
 +  return items_[index].value;
 +}
++
++
 +/////////////////////////////////////////////////////////////////////////////
 +//
 +// LCDFilterComboBoxModel
 +//
 +/////////////////////////////////////////////////////////////////////////////
++
++
 +LCDFilterComboBoxModel::LCDFilterComboBoxModel()
 +{
 +  items_[LCDFilter_Default] = {
 +    FT_LCD_FILTER_DEFAULT,
 +    "Default"
 +  };
 +  items_[LCDFilter_Light] = {
 +    FT_LCD_FILTER_LIGHT,
 +    "Light"
 +  };
 +  items_[LCDFilter_None] = {
 +    FT_LCD_FILTER_NONE,
 +    "None"
 +  };
 +  items_[LCDFilter_Legacy] = {
 +    FT_LCD_FILTER_LEGACY,
 +    "Legacy"
 +  };
 +}
++
++
 +/////////////////////////////////////////////////////////////////////////////
 +//
 +// AntiAliasingComboBoxModel
 +//
 +/////////////////////////////////////////////////////////////////////////////
++
++
 +AntiAliasingComboBoxModel::AntiAliasingComboBoxModel()
 +{
 +  items_[AntiAliasing_None] = {
 +    FT_LOAD_TARGET_MONO,
 +    "None"
 +  };
 +  items_[AntiAliasing_Normal] = {
 +    FT_LOAD_TARGET_NORMAL,
 +    "Normal"
 +  };
 +  items_[AntiAliasing_Light] = {
 +    FT_LOAD_TARGET_LIGHT,
 +    "Light"
 +  };
 +  items_[AntiAliasing_LCD] = {
 +    FT_LOAD_TARGET_LCD,
 +    "LCD (RGB)"
 +  };
 +  items_[AntiAliasing_LCD_BGR] = {
 +    FT_LOAD_TARGET_LCD,
 +    "LCD (BGR)"
 +  };
 +  items_[AntiAliasing_LCD_Vertical] = {
 +    FT_LOAD_TARGET_LCD_V,
 +    "LCD (vert. RGB)"
 +  };
 +  items_[AntiAliasing_LCD_Vertical_BGR] = {
 +    FT_LOAD_TARGET_LCD_V, // XXX Bug: No difference between RGB and BGR?
 +    "LCD (vert. BGR)"
 +  };
++
 +  lightAntiAliasingEnabled_ = true;
 +}
++
++
 +QVariant
 +AntiAliasingComboBoxModel::data(const QModelIndex& index,
 +                                int role) const
 +{
 +  if (role == Qt::ForegroundRole)
 +    if (index.row() == AntiAliasing_Light && !lightAntiAliasingEnabled_)
 +      return QApplication::palette().color(QPalette::Disabled,
 +                                           QPalette::Text);
 +  return SimpleComboBoxModel::data(index, role);
 +}
++
++
 +Qt::ItemFlags
 +AntiAliasingComboBoxModel::flags(const QModelIndex& index) const
 +{
 +  if (index.row() == AntiAliasing_Light && !lightAntiAliasingEnabled_)
 +    return Qt::ItemFlags {};
 +  return Qt::ItemIsSelectable | Qt::ItemIsEnabled;
 +}
++
++
 +// end of ttsettingscomboboxmodel.cpp

src/ftinspect/models/ttsettingscomboboxmodel.hpp

 +// ttsettingscomboboxmodel.hpp
++
 +// Copyright (C) 2022 by Charlie Jiang.
++
++
 +#pragma once
++
 +#include <QAbstractListModel>
 +#include <QHash>
++
 +class HintingModeComboBoxModel
 +: public QAbstractListModel
 +{
 +  Q_OBJECT
 +public:
 +  enum HintingEngineType : int;
 +  enum HintingMode : int;
 +  struct HintingModeItem
 +  {
 +    HintingEngineType type;
 +    HintingMode key;
 +    int value;
 +    bool enabled;
 +    bool supported;
 +    QString displayName;
 +  };
++
 +  HintingModeComboBoxModel();
 +  ~HintingModeComboBoxModel() = default;
++
 +  int rowCount(const QModelIndex& parent) const;
 +  QVariant data(const QModelIndex& index,
 +                int role) const;
 +  Qt::ItemFlags flags(const QModelIndex& index) const;
++
 +  int indexToTTInterpreterVersion(int index) const;
 +  int indexToCFFMode(int index) const;
 +  int cffModeToIndex(int mode) const;
 +  int ttInterpreterVersionToIndex(int version) const;
++
 +  void setSupportedModes(QList<int> supportedTTIVersions,
 +                         QList<int> supportedCFFModes);
 +  void setCurrentEngineType(HintingEngineType type);
++
 +private:
 +  QHash<int, HintingModeItem> items_;
++
 +  int indexToValueForType(int index,
 +                          HintingEngineType type) const;
 +  int valueToIndexForType(int value,
 +                          HintingEngineType type) const;
++
 +public:
 +  // Note: Ensure related funcs are also changed when
 +  // these enums are changed!
 +  enum HintingEngineType
 +  {
 +    HintingEngineType_TrueType,
 +    HintingEngineType_CFF
 +  };
++
 +  enum HintingMode
 +  {
 +    HintingMode_TrueType_v35 = 0,
 +    HintingMode_TrueType_v38,
 +    HintingMode_TrueType_v40,
 +    HintingMode_CFF_FreeType,
 +    HintingMode_CFF_Adobe
 +  };
 +};
++
++
 +// A simple key-displayName-value model for QComboBox.
 +class SimpleComboBoxModel
 +: public QAbstractListModel
 +{
 +  Q_OBJECT
 +public:
 +  struct ComboBoxItem
 +  {
 +    int value;
 +    QString displayName;
 +  };
++
 +  SimpleComboBoxModel() {}
 +  ~SimpleComboBoxModel() = default;
++
 +  int rowCount(const QModelIndex& parent) const;
 +  QVariant data(const QModelIndex& index,
 +                int role) const;
++
 +  int indexToValue(int index);
++
 +protected:
 +  QHash<int, ComboBoxItem> items_;
 +};
++
++
 +class LCDFilterComboBoxModel
 +: public SimpleComboBoxModel
 +{
 +public:
 +  enum LCDFilter : int;
 +  struct LCDFilterItem
 +  {
 +    int value;
 +    QString displayName;
 +  };
++
 +  LCDFilterComboBoxModel();
 +  ~LCDFilterComboBoxModel() = default;
++
 +public:
 +  enum LCDFilter
 +  {
 +    LCDFilter_Default,
 +    LCDFilter_Light,
 +    LCDFilter_None,
 +    LCDFilter_Legacy
 +  };
 +};
++
++
 +class AntiAliasingComboBoxModel
 +: public SimpleComboBoxModel
 +{
 +public:
 +  enum AntiAliasing : int;
++
 +  AntiAliasingComboBoxModel();
 +  ~AntiAliasingComboBoxModel() = default;
++
 +  QVariant data(const QModelIndex& index,
 +                int role) const;
 +  Qt::ItemFlags flags(const QModelIndex& index) const;
++
 +  void setLightAntiAliasingEnabled(bool enabled)
 +  {
 +    lightAntiAliasingEnabled_ = enabled;
 +  }
++
 +private:
 +  bool lightAntiAliasingEnabled_;
++
 +public:
 +  enum AntiAliasing
 +  {
 +    AntiAliasing_None,
 +    AntiAliasing_Normal,
 +    AntiAliasing_Light,
 +    AntiAliasing_LCD,
 +    AntiAliasing_LCD_BGR,
 +    AntiAliasing_LCD_Vertical,
 +    AntiAliasing_LCD_Vertical_BGR
 +  };
 +};
++
++
 +// end of ttsettingscomboboxmodel.hpp

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


From:	Charlie Jiang (@cqjjjzr)
Subject:	[Git][freetype/freetype-demos][reorg-maingui] 4 commits: [ftinspect] Move out font file managing/watching out to a new class.
Date:	Thu, 30 Jun 2022 15:21:18 +0000