[Git][freetype/freetype-demos][reorg-maingui] [ftinspect] Decouple `Engi

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

Commits:

8b9a8e70

by Charlie Jiang at 2022-06-29T17:18: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.

5 changed files:

src/ftinspect/engine/engine.cpp
src/ftinspect/engine/engine.hpp
src/ftinspect/ftinspect.cpp
src/ftinspect/maingui.cpp
src/ftinspect/maingui.hpp

Changes:

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->engine->numberOfOpenedFonts())
 +      || faceID.fontIndex >= engine->numberOfOpenedFonts())
      return FT_Err_Invalid_Argument;
 -  QString font = gui->engine->fileManager[faceID.fontIndex].filePath();
 +  QString font = engine->fileManager[faceID.fontIndex].filePath();
    long faceIndex = faceID.faceIndex;
    if (faceID.namedInstanceIndex > 0)
@@ -116,9 +115,8 @@ faceRequester(FTC_FaceID ftcFaceID,
  //
  /////////////////////////////////////////////////////////////////////////////
 -Engine::Engine(MainGUI* g)
 +Engine::Engine()
+ {
 -  gui = g;
    ftSize = NULL;
    // we reserve value 0 for the `invalid face ID'
    faceCounter = 1;
@@ -132,7 +130,7 @@ Engine::Engine(MainGUI* g)
+   }
    error = FTC_Manager_New(library, 0, 0, 0,
 -                          faceRequester, gui, &cacheManager);
 +                          faceRequester, this, &cacheManager);
    if (error)
+   {
      // XXX error handling
@@ -150,98 +148,7 @@ Engine::Engine(MainGUI* g)
      // 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();
+ }
@@ -423,20 +330,6 @@ Engine::removeFont(int fontIndex, bool closeFile)
+ }
 -const QString&
 -Engine::currentFamilyName()
 -{
 -  return curFamilyName;
 -}
+-
+-
 -const QString&
 -Engine::currentStyleName()
 -{
 -  return curStyleName;
 -}
+-
+-
  QString
  Engine::glyphName(int index)
+ {
@@ -492,27 +385,52 @@ Engine::loadOutline(int glyphIndex)
    return &outlineGlyph->outline;
+ }
++
  int
  Engine::numberOfOpenedFonts()
+ {
    return fileManager.size();
+ }
++
  void
  Engine::openFonts(QStringList fontFileNames)
+ {
    fileManager.append(fontFileNames);
+ }
++
  void
 -Engine::setCFFHintingMode(int mode)
 +Engine::setSizeByPixel(double pixelSize)
 +{
 +  this->pixelSize = pixelSize;
 +  pointSize = pixelSize * 72.0 / dpi;
 +  usingPixelSize = true;
 +}
++
 +void
 +Engine::setSizeByPoint(double pointSize)
+ {
 -  int index = gui->hintingModesCFFHash.key(mode);
 +  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
@@ -522,14 +440,12 @@ Engine::setCFFHintingMode(int mode)
  void
 -Engine::setTTInterpreterVersion(int mode)
 +Engine::setTTInterpreterVersion(int version)
+ {
 -  int index = gui->hintingModesTrueTypeHash.key(mode);
+-
    FT_Error error = FT_Property_Set(library,
                                     "truetype",
                                     "interpreter-version",
 -                                   &index);
 +                                   &version);
    if (!error)
+   {
      // reset the cache
@@ -541,58 +457,32 @@ Engine::setTTInterpreterVersion(int mode)
  void
  Engine::update()
+ {
 -  // Spinbox value cannot become negative
 -  dpi = static_cast<unsigned int>(gui->dpiSpinBox->value());
+-
 -  if (gui->unitsComboBox->currentIndex() == MainGUI::Units_px)
 -  {
 -    pixelSize = gui->sizeDoubleSpinBox->value();
 -    pointSize = pixelSize * 72.0 / dpi;
 -  }
 -  else
 -  {
 -    pointSize = gui->sizeDoubleSpinBox->value();
 -    pixelSize = pointSize * dpi / 72.0;
 -  }
+-
 -  doHinting = gui->hintingCheckBox->isChecked();
+-
 -  doAutoHinting = gui->autoHintingCheckBox->isChecked();
 -  doHorizontalHinting = gui->horizontalHintingCheckBox->isChecked();
 -  doVerticalHinting = gui->verticalHintingCheckBox->isChecked();
 -  doBlueZoneHinting = gui->blueZoneHintingCheckBox->isChecked();
 -  showSegments = gui->segmentDrawingCheckBox->isChecked();
+-
 -  gamma = gui->gammaSlider->value();
+-
    loadFlags = FT_LOAD_DEFAULT;
    if (doAutoHinting)
      loadFlags |= FT_LOAD_FORCE_AUTOHINT;
    loadFlags |= FT_LOAD_NO_BITMAP; // XXX handle bitmap fonts also
 -  int index = gui->antiAliasingComboBoxx->currentIndex();
+-
    if (doHinting)
+   {
      unsigned long target;
 -    if (index == MainGUI::AntiAliasing_None)
 +    if (antiAliasingMode == AntiAliasing_None)
        target = FT_LOAD_TARGET_MONO;
      else
+     {
 -      switch (index)
 +      switch (antiAliasingMode)
+       {
 -      case MainGUI::AntiAliasing_Light:
 +      case AntiAliasing_Light:
          target = FT_LOAD_TARGET_LIGHT;
          break;
 -      case MainGUI::AntiAliasing_LCD:
 -      case MainGUI::AntiAliasing_LCD_BGR:
 +      case AntiAliasing_LCD:
 +      case AntiAliasing_LCD_BGR: // TODO Differenate RGB/BGR here?
          target = FT_LOAD_TARGET_LCD;
          break;
 -      case MainGUI::AntiAliasing_LCD_Vertical:
 -      case MainGUI::AntiAliasing_LCD_Vertical_BGR:
 +      case AntiAliasing_LCD_Vertical:
 +      case AntiAliasing_LCD_Vertical_BGR:
          target = FT_LOAD_TARGET_LCD_V;
          break;
@@ -607,7 +497,7 @@ Engine::update()
+   {
      loadFlags |= FT_LOAD_NO_HINTING;
 -    if (index == MainGUI::AntiAliasing_None)
 +    if (antiAliasingMode == AntiAliasing_None)
        loadFlags |= FT_LOAD_MONOCHROME;
+   }
@@ -615,7 +505,7 @@ Engine::update()
    scaler.pixel = 0; // use 26.6 format
 -  if (gui->unitsComboBox->currentIndex() == MainGUI::Units_px)
 +  if (usingPixelSize)
+   {
      scaler.width = static_cast<unsigned int>(pixelSize * 64.0);
      scaler.height = static_cast<unsigned int>(pixelSize * 64.0);
@@ -631,11 +521,104 @@ Engine::update()
+   }
+ }
 -FontFileManager&
 -Engine::fontFileManager()
++
 +void
 +Engine::queryEngine()
+ {
 -  return fileManager;
 -}
 +  FT_Error error;
++
 +  // query engines and check for alternatives
 +  // CFF
 +  error = FT_Property_Get(library,
 +                          "cff",
 +                          "hinting-engine",
 +                          &defaults.cffHintingEngineDefault);
 +  if (error)
 +  {
 +    // no CFF engine
 +    defaults.cffHintingEngineDefault = -1;
 +    defaults.cffHintingEngineOther = -1;
 +  }
 +  else
 +  {
 +    int engines[] =
 +    {
 +      FT_HINTING_FREETYPE,
 +      FT_HINTING_ADOBE
 +    };
++
 +    int i;
 +    for (i = 0; i < 2; i++)
 +      if (defaults.cffHintingEngineDefault == engines[i])
 +        break;
++
 +    defaults.cffHintingEngineOther = engines[(i + 1) % 2];
++
 +    error = FT_Property_Set(library,
 +                            "cff",
 +                            "hinting-engine",
 +                            &defaults.cffHintingEngineOther);
 +    if (error)
 +      defaults.cffHintingEngineOther = -1;
++
 +    // reset
 +    FT_Property_Set(library,
 +                    "cff",
 +                    "hinting-engine",
 +                    &defaults.cffHintingEngineDefault);
 +  }
++
 +  // TrueType
 +  error = FT_Property_Get(library,
 +                          "truetype",
 +                          "interpreter-version",
 +                          &defaults.ttInterpreterVersionDefault);
 +  if (error)
 +  {
 +    // no TrueType engine
 +    defaults.ttInterpreterVersionDefault = -1;
 +    defaults.ttInterpreterVersionOther = -1;
 +    defaults.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 (defaults.ttInterpreterVersionDefault == interpreters[i])
 +        break;
++
 +    defaults.ttInterpreterVersionOther = interpreters[(i + 1) % 3];
++
 +    error = FT_Property_Set(library,
 +                            "truetype",
 +                            "interpreter-version",
 +                            &defaults.ttInterpreterVersionOther);
 +    if (error)
 +      defaults.ttInterpreterVersionOther = -1;
++
 +    defaults.ttInterpreterVersionOther1 = interpreters[(i + 2) % 3];
++
 +    error = FT_Property_Set(library,
 +                            "truetype",
 +                            "interpreter-version",
 +                            &defaults.ttInterpreterVersionOther1);
 +    if (error)
 +      defaults.ttInterpreterVersionOther1 = -1;
++
 +    // reset
 +    FT_Property_Set(library,
 +                    "truetype",
 +                    "interpreter-version",
 +                    &defaults.ttInterpreterVersionDefault);
 +  }
 +}
  // end of engine.cpp

src/ftinspect/engine/engine.hpp

@@ -14,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
@@ -35,62 +36,103 @@ struct FaceID
    bool operator<(const FaceID& other) const;
  };
+-
 -class MainGUI;
+-
  // FreeType specific data.
  class Engine
+ {
  public:
 -  Engine(MainGUI*);
 +  //////// Nested definitions (forward decl)
++
 +  // TODO these would be dropped with custom QAbstractItemModel
 +  enum AntiAliasing : int;
 +  enum FontType : int;
++
 +  struct EngineDefaultValues
 +  {
 +    int cffHintingEngineDefault;
 +    int cffHintingEngineOther;
++
 +    int ttInterpreterVersionDefault;
 +    int ttInterpreterVersionOther;
 +    int ttInterpreterVersionOther1;
 +  };
++
 +  //////// Ctors & Dtors
++
 +  Engine();
    ~Engine();
    // Disable copying
    Engine(const Engine& other) = delete;
    Engine& operator=(const Engine& other) = delete;
 -  const QString& currentFamilyName();
 -  const QString& currentStyleName();
 -  QString glyphName(int glyphIndex);
 -  long numberOfFaces(int fontIndex);
 -  int numberOfNamedInstances(int fontIndex,
 -                             long faceIndex);
 +  //////// Actions
++
    int loadFont(int fontIndex,
                 long faceIndex,
                 int namedInstanceIndex); // return number of glyphs
    FT_Outline* loadOutline(int glyphIndex);
 -  int numberOfOpenedFonts();
    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 fileManager; }
 +  EngineDefaultValues& engineDefaults() { return defaults; }
++
 +  //////// 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) { this->showSegments = showSegments; }
 +  void setGamma(double gamma) { this->gamma = gamma; }
 +  void setAntiAliasingMode(AntiAliasing mode) { antiAliasingMode = mode; }
++
 +  // Note: These 3 functions now takes actual mode/version from FreeType,
 +  // instead of values from enum in MainGUI!
 +  void setLcdFilter(FT_LcdFilter filter);
    void setCFFHintingMode(int mode);
    void setTTInterpreterVersion(int version);
 -  void update();
 -  friend class MainGUI;
 +  //////// Misc
++
    friend FT_Error faceRequester(FTC_FaceID,
                                  FT_Library,
                                  FT_Pointer,
                                  FT_Face*);
 -  // XXX cover all available modules
 -  enum FontType
 -  {
 -    FontType_CFF,
 -    FontType_TrueType,
 -    FontType_Other
 -  };
+-
 -  // 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();
+-
  private:
 -  MainGUI* gui;
+-
    using FTC_IDType = uintptr_t;
    FTC_IDType faceCounter; // a running number used to initialize `faceIDMap'
    QMap<FaceID, FTC_IDType> faceIDMap;
@@ -108,15 +150,11 @@ private:
    FTC_ScalerRec scaler;
    FT_Size ftSize;
 -  int cffHintingEngineDefault;
 -  int cffHintingEngineOther;
+-
 -  int ttInterpreterVersionDefault;
 -  int ttInterpreterVersionOther;
 -  int ttInterpreterVersionOther1;
 +  EngineDefaultValues defaults;
    int fontType;
 +  bool usingPixelSize = false;
    double pointSize;
    double pixelSize;
    unsigned int dpi;
@@ -127,10 +165,36 @@ private:
    bool doVerticalHinting;
    bool doBlueZoneHinting;
    bool showSegments;
 +  AntiAliasing antiAliasingMode;
    double gamma;
    unsigned long loadFlags;
++
 +  void queryEngine();
++
 +public:
++
 +  /// Actual definition
++
 +  enum AntiAliasing
 +  {
 +    AntiAliasing_None,
 +    AntiAliasing_Normal,
 +    AntiAliasing_Light,
 +    AntiAliasing_LCD,
 +    AntiAliasing_LCD_BGR,
 +    AntiAliasing_LCD_Vertical,
 +    AntiAliasing_LCD_Vertical_BGR
 +  };
++
 +  // XXX cover all available modules
 +  enum FontType
 +  {
 +    FontType_CFF,
 +    FontType_TrueType,
 +    FontType_Other
 +  };
  };

src/ftinspect/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

@@ -174,6 +174,7 @@ MainGUI::showFont()
    else
      fontFilenameLabel->clear();
 +  syncSettings();
    currentNumberOfFaces
      = engine->numberOfFaces(currentFontIndex);
    currentNumberOfNamedInstances
@@ -209,12 +210,45 @@ MainGUI::showFont()
+ }
 +void
 +MainGUI::syncSettings()
 +{
 +  // Spinbox value cannot become negative
 +  engine->setDPI(static_cast<unsigned int>(dpiSpinBox->value()));
++
 +  if (unitsComboBox->currentIndex() == Units_px)
 +    engine->setSizeByPixel(sizeDoubleSpinBox->value());
 +  else
 +    engine->setSizeByPoint(sizeDoubleSpinBox->value());
++
 +  engine->setHinting(hintingCheckBox->isChecked());
 +  engine->setAutoHinting(autoHintingCheckBox->isChecked());
 +  engine->setHorizontalHinting(horizontalHintingCheckBox->isChecked());
 +  engine->setVerticalHinting(verticalHintingCheckBox->isChecked());
 +  engine->setBlueZoneHinting(blueZoneHintingCheckBox->isChecked());
 +  engine->setShowSegments(segmentDrawingCheckBox->isChecked());
++
 +  engine->setGamma(gammaSlider->value());
++
 +  engine->setAntiAliasingMode(static_cast<Engine::AntiAliasing>(
 +      antiAliasingComboBoxx->currentIndex()));
 +}
++
++
 +void
 +MainGUI::clearStatusBar()
 +{
 +  statusBar()->clearMessage();
 +  statusBar()->setStyleSheet("");
 +}
++
++
  void
  MainGUI::checkHinting()
+ {
    if (hintingCheckBox->isChecked())
+   {
 -    if (engine->fontType == Engine::FontType_CFF)
 +    if (engine->currentFontType() == Engine::FontType_CFF)
+     {
        for (int i = 0; i < hintingModeComboBoxx->count(); i++)
+       {
@@ -226,7 +260,7 @@ MainGUI::checkHinting()
        hintingModeComboBoxx->setCurrentIndex(currentCFFHintingMode);
+     }
 -    else if (engine->fontType == Engine::FontType_TrueType)
 +    else if (engine->currentFontType() == Engine::FontType_TrueType)
+     {
        for (int i = 0; i < hintingModeComboBoxx->count(); i++)
+       {
@@ -262,7 +296,7 @@ MainGUI::checkHinting()
      blueZoneHintingCheckBox->setEnabled(false);
      segmentDrawingCheckBox->setEnabled(false);
 -    antiAliasingComboBoxx->setItemEnabled(AntiAliasing_Light, false);
 +    antiAliasingComboBoxx->setItemEnabled(Engine::AntiAliasing_Light, false);
+   }
    drawGlyph();
@@ -274,14 +308,14 @@ MainGUI::checkHintingMode()
+ {
    int index = hintingModeComboBoxx->currentIndex();
 -  if (engine->fontType == Engine::FontType_CFF)
 +  if (engine->currentFontType() == Engine::FontType_CFF)
+   {
 -    engine->setCFFHintingMode(index);
 +    engine->setCFFHintingMode(hintingModesCFFHash.key(index));
      currentCFFHintingMode = index;
+   }
 -  else if (engine->fontType == Engine::FontType_TrueType)
 +  else if (engine->currentFontType() == Engine::FontType_TrueType)
+   {
 -    engine->setTTInterpreterVersion(index);
 +    engine->setTTInterpreterVersion(hintingModesTrueTypeHash.key(index));
      currentTTInterpreterVersion = index;
+   }
@@ -303,12 +337,12 @@ MainGUI::checkAutoHinting()
      blueZoneHintingCheckBox->setEnabled(true);
      segmentDrawingCheckBox->setEnabled(true);
 -    antiAliasingComboBoxx->setItemEnabled(AntiAliasing_Light, true);
 +    antiAliasingComboBoxx->setItemEnabled(Engine::AntiAliasing_Light, true);
+   }
    else
+   {
 -    if (engine->fontType == Engine::FontType_CFF
 -        || engine->fontType == Engine::FontType_TrueType)
 +    if (engine->currentFontType() == Engine::FontType_CFF
 +        || engine->currentFontType() == Engine::FontType_TrueType)
+     {
        hintingModeLabel->setEnabled(true);
        hintingModeComboBoxx->setEnabled(true);
@@ -319,10 +353,10 @@ MainGUI::checkAutoHinting()
      blueZoneHintingCheckBox->setEnabled(false);
      segmentDrawingCheckBox->setEnabled(false);
 -    antiAliasingComboBoxx->setItemEnabled(AntiAliasing_Light, false);
 +    antiAliasingComboBoxx->setItemEnabled(Engine::AntiAliasing_Light, false);
 -    if (antiAliasingComboBoxx->currentIndex() == AntiAliasing_Light)
 -      antiAliasingComboBoxx->setCurrentIndex(AntiAliasing_Normal);
 +    if (antiAliasingComboBoxx->currentIndex() == Engine::AntiAliasing_Light)
 +      antiAliasingComboBoxx->setCurrentIndex(Engine::AntiAliasing_Normal);
+   }
    drawGlyph();
@@ -334,9 +368,9 @@ MainGUI::checkAntiAliasing()
+ {
    int index = antiAliasingComboBoxx->currentIndex();
 -  if (index == AntiAliasing_None
 -      || index == AntiAliasing_Normal
 -      || index == AntiAliasing_Light)
 +  if (index == Engine::AntiAliasing_None
 +      || index == Engine::AntiAliasing::AntiAliasing_Normal
 +      || index == Engine::AntiAliasing_Light)
+   {
      lcdFilterLabel->setEnabled(false);
      lcdFilterComboBox->setEnabled(false);
@@ -355,7 +389,7 @@ void
  MainGUI::checkLcdFilter()
+ {
    int index = lcdFilterComboBox->currentIndex();
 -  FT_Library_SetLcdFilter(engine->library, lcdFilterHash.key(index));
 +  engine->setLcdFilter(lcdFilterHash.key(index));
+ }
@@ -654,6 +688,7 @@ MainGUI::drawGlyph()
      currentGlyphPointNumbersItem = NULL;
+   }
 +  syncSettings();
    FT_Outline* outline = engine->loadOutline(currentGlyphIndex);
    if (outline)
+   {
@@ -661,11 +696,11 @@ MainGUI::drawGlyph()
+     {
        // XXX support LCD
        FT_Pixel_Mode pixelMode = FT_PIXEL_MODE_GRAY;
 -      if (antiAliasingComboBoxx->currentIndex() == AntiAliasing_None)
 +      if (antiAliasingComboBoxx->currentIndex() == Engine::AntiAliasing_None)
          pixelMode = FT_PIXEL_MODE_MONO;
        currentGlyphBitmapItem = new GlyphBitmap(outline,
 -                                               engine->library,
 +                                               engine->ftLibrary(),
                                                 pixelMode,
                                                 monoColorTable,
                                                 grayColorTable);
@@ -731,19 +766,19 @@ MainGUI::createLayout()
    antiAliasingLabel = new QLabel(tr("Anti-Aliasing"));
    antiAliasingLabel->setAlignment(Qt::AlignRight);
    antiAliasingComboBoxx = new QComboBoxx;
 -  antiAliasingComboBoxx->insertItem(AntiAliasing_None,
 +  antiAliasingComboBoxx->insertItem(Engine::AntiAliasing_None,
                                      tr("None"));
 -  antiAliasingComboBoxx->insertItem(AntiAliasing_Normal,
 +  antiAliasingComboBoxx->insertItem(Engine::AntiAliasing_Normal,
                                      tr("Normal"));
 -  antiAliasingComboBoxx->insertItem(AntiAliasing_Light,
 +  antiAliasingComboBoxx->insertItem(Engine::AntiAliasing_Light,
                                      tr("Light"));
 -  antiAliasingComboBoxx->insertItem(AntiAliasing_LCD,
 +  antiAliasingComboBoxx->insertItem(Engine::AntiAliasing_LCD,
                                      tr("LCD (RGB)"));
 -  antiAliasingComboBoxx->insertItem(AntiAliasing_LCD_BGR,
 +  antiAliasingComboBoxx->insertItem(Engine::AntiAliasing_LCD_BGR,
                                      tr("LCD (BGR)"));
 -  antiAliasingComboBoxx->insertItem(AntiAliasing_LCD_Vertical,
 +  antiAliasingComboBoxx->insertItem(Engine::AntiAliasing_LCD_Vertical,
                                      tr("LCD (vert. RGB)"));
 -  antiAliasingComboBoxx->insertItem(AntiAliasing_LCD_Vertical_BGR,
 +  antiAliasingComboBoxx->insertItem(Engine::AntiAliasing_LCD_Vertical_BGR,
                                      tr("LCD (vert. BGR)"));
    antiAliasingLabel->setBuddy(antiAliasingComboBoxx);
@@ -1139,14 +1174,6 @@ MainGUI::createStatusBar()
+ }
 -void
 -MainGUI::clearStatusBar()
 -{
 -  statusBar()->clearMessage();
 -  statusBar()->setStyleSheet("");
 -}
+-
+-
  void
  MainGUI::setDefaults()
+ {
@@ -1163,20 +1190,22 @@ MainGUI::setDefaults()
    lcdFilterHash[FT_LCD_FILTER_NONE] = LCDFilter_None;
    lcdFilterHash[FT_LCD_FILTER_LEGACY] = LCDFilter_Legacy;
 +  Engine::EngineDefaultValues& defaults = engine->engineDefaults();
++
    // make copies and remove existing elements...
    QHash<int, int> hmTTHash = hintingModesTrueTypeHash;
 -  if (hmTTHash.contains(engine->ttInterpreterVersionDefault))
 -    hmTTHash.remove(engine->ttInterpreterVersionDefault);
 -  if (hmTTHash.contains(engine->ttInterpreterVersionOther))
 -    hmTTHash.remove(engine->ttInterpreterVersionOther);
 -  if (hmTTHash.contains(engine->ttInterpreterVersionOther1))
 -    hmTTHash.remove(engine->ttInterpreterVersionOther1);
 +  if (hmTTHash.contains(defaults.ttInterpreterVersionDefault))
 +    hmTTHash.remove(defaults.ttInterpreterVersionDefault);
 +  if (hmTTHash.contains(defaults.ttInterpreterVersionOther))
 +    hmTTHash.remove(defaults.ttInterpreterVersionOther);
 +  if (hmTTHash.contains(defaults.ttInterpreterVersionOther1))
 +    hmTTHash.remove(defaults.ttInterpreterVersionOther1);
    QHash<int, int> hmCFFHash = hintingModesCFFHash;
 -  if (hmCFFHash.contains(engine->cffHintingEngineDefault))
 -    hmCFFHash.remove(engine->cffHintingEngineDefault);
 -  if (hmCFFHash.contains(engine->cffHintingEngineOther))
 -    hmCFFHash.remove(engine->cffHintingEngineOther);
 +  if (hmCFFHash.contains(defaults.cffHintingEngineDefault))
 +    hmCFFHash.remove(defaults.cffHintingEngineDefault);
 +  if (hmCFFHash.contains(defaults.cffHintingEngineOther))
 +    hmCFFHash.remove(defaults.cffHintingEngineOther);
    // ... to construct a list of always disabled hinting mode combo box items
    hintingModesAlwaysDisabled = hmTTHash.values();
@@ -1193,13 +1222,13 @@ MainGUI::setDefaults()
    currentGlyphIndex = 0;
    currentCFFHintingMode
 -    = hintingModesCFFHash[engine->cffHintingEngineDefault];
 +    = hintingModesCFFHash[defaults.cffHintingEngineDefault];
    currentTTInterpreterVersion
 -    = hintingModesTrueTypeHash[engine->ttInterpreterVersionDefault];
 +    = hintingModesTrueTypeHash[defaults.ttInterpreterVersionDefault];
    hintingCheckBox->setChecked(true);
 -  antiAliasingComboBoxx->setCurrentIndex(AntiAliasing_Normal);
 +  antiAliasingComboBoxx->setCurrentIndex(Engine::AntiAliasing_Normal);
    lcdFilterComboBox->setCurrentIndex(LCDFilter_Light);
    horizontalHintingCheckBox->setChecked(true);

src/ftinspect/maingui.hpp

@@ -230,17 +230,7 @@ private:
    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,
@@ -262,15 +252,18 @@ private:
      Units_pt
    };
 +  void showFont();
 +  void syncSettings();
 +  void clearStatusBar();
++
    void createActions();
    void createConnections();
    void createLayout();
    void createMenus();
 -  void clearStatusBar();
    void createStatusBar();
 -  void readSettings();
    void setGraphicsDefaults();
 -  void showFont();
++
 +  void readSettings();
    void writeSettings();
  };

From:	Charlie Jiang (@cqjjjzr)
Subject:	[Git][freetype/freetype-demos][reorg-maingui] [ftinspect] Decouple `Engine` from `MainGUI`.
Date:	Wed, 29 Jun 2022 09:19:05 +0000