[Git][freetype/freetype-demos][gsoc-2022-chariri-final] 2 commits: [ftin

Charlie Jiang pushed to branch gsoc-2022-chariri-final at FreeType / FreeType Demo Programs

Commits:

47238404

by Charlie Jiang at 2022-09-04T00:23:30+08:00

[ftinspect] Rewrite `MainGUI`.

Note: This commit compiles, but the main view is removed, so you will get a
blank right panel. The singular view will be added back with major changes
in the next commit.

This commit mainly introduces below changes:

1. The original `MainGUI` contains almost all GUI elements. Most of them are
   taken out to modular components. The current `MainGUI` serves only as
   a skeleton provides coordinate between components, greatly shortened.
   It also provides some auxiliary code such as calling to file chooser.
2. The left panel is moved to `SettingPanel` class. The current
   `settingpanel.[ch]pp` are directly modified from the latest code, so they
   contains some options not implemented in the `Engine`.
   Structural code that is only added accompanying later change is removed,
   such as the comparator mode. Such code will be added back with the
   related feature. However, code for unimplemented options are simply
   commented out.
3. The main part is transformed into a tabbed view. The original code is
   removed. Refactored, it will be added back in the next commit.
4. The navigation buttons (Next/Prev Font/Face/NI) are changed into the new
   triplet-selector, which is a major UI improvement.

* src/ftinspect/maingui.cpp, src/ftinspect/maingui.hpp: As described.

* src/ftinspect/panels/abstracttab.hpp: Add `AbstractTab` which is an
  interface for all tabs listening for font reloading and repainting.

* src/ftinspect/panels/settingpanel.cpp,
  src/ftinspect/panels/settingpanel.hpp:
  As described, this is the left panel. This requires intensive reviewing
  since many bugs had rooted here.

* src/ftinspect/widgets/tripletselector.cpp,
  src/ftinspect/widgets/tripletselector.hpp:
  As described, this is the triplet (Font/Subface/NI) selector.
  This component is also responsible for repopulating triplet information
  and keep up with the font file change (i.e. the
  `FontFileManager::currentFileChanged` event is captured here).

* src/ftinspect/engine/engine.cpp, src/ftinspect/engine/engine.hpp:
  Add `fontValid` and `namedInstanceName` since `TripletSelector` requires
  them. However, they'll subject to change later.

* src/ftinspect/ftinspect.cpp: Remove call to `MainGUI::setDefaults`.

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

14556570

by Charlie Jiang at 2022-09-04T00:23:36+08:00

[ftinspect] Add the `SingularTab` and related widgets.

This introduces the new singular tab. However, because the new tab heavily
depend on the new engine structure, it's current not functional. No bitmap
or outline will be displayed. This would be fixed after the `Engine` was
refactored in the next commit.

The new singular tab has the size and glyph index selector moved out as
modular widgets to be reused.

The new scroll and shortcut behaviours are introduced in this commit, which
depend on scroll events introduced in the custom `QGraphicsViewx`.

The infinity panning of grid is implemented mainly via
`SingularTab::updateGrid` and `Grid::updateRect`.

This commit is introducing new features since it would be unfavorable to
"backport" old version of glyph components, and add those new features in
future commits - this is way too complex.

* src/ftinspect/engine/engine.cpp, src/ftinspect/engine/engine.hpp:
  Add `currentFontNumberOfGlyphs` and `dpi` functions.

* src/ftinspect/widgets/fontsizeselector.cpp,
  src/ftinspect/widgets/fontsizeselector.hpp:
  This is the new font size selector to replace the old size/DPI/zoom boxes.
  This widget is capable of handling wheel and key events delegated from
  other widgets.
  The support for fixed sizes and bitmap-only font is not yet added.

* src/ftinspect/widgets/glyphindexselector.cpp,
  src/ftinspect/widgets/glyphindexselector.hpp:
  This is the new glyph index selector to replace the old navi buttons.
  This selector is aware of index min/max, consists of a group of navi
  buttons, a text box (actually a spin box without buttons) to directly
  input glyph index.

* src/ftinspect/glyphcomponents/graphicsdefault.cpp,
  src/ftinspect/glyphcomponents/graphicsdefault.hpp:
  This struct contains all default graphical settings (mainly for singular
  view, e.g. the grid line color).

* src/ftinspect/maingui.cpp, src/ftinspect/maingui.hpp:
  Add the new tab into the main window.

* src/ftinspect/glyphcomponents/glyphbitmap.cpp,
  src/ftinspect/glyphcomponents/glyphbitmap.hpp:
  This will now delegate rendering to the engine instead of doing rendering
  itself. However, since the rendering part of the `Engine` is not
  implemented, code initializing `image_` is left commented.
  Also add another constructor for initializing directly from a `QImage`.

* src/ftinspect/glyphcomponents/glyphoutline.cpp,
  src/ftinspect/glyphcomponents/glyphoutline.hpp,
  src/ftinspect/glyphcomponents/glyphpointnumbers.cpp,
  src/ftinspect/glyphcomponents/glyphpointnumbers.hpp,
  src/ftinspect/glyphcomponents/glyphpoints.cpp,
  src/ftinspect/glyphcomponents/glyphpoints.hpp:
  Constructors of those items now accept a `FT_Glyph` instead of
  `FT_Outline`. The conversion is done inside the view, and the view won't
  be displayed if the glyph isn't outline glyph.
  This simplifies the code of `SingularTab`.

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

30 changed files:

src/ftinspect/CMakeLists.txt
src/ftinspect/engine/engine.cpp
src/ftinspect/engine/engine.hpp
src/ftinspect/ftinspect.cpp
src/ftinspect/glyphcomponents/glyphbitmap.cpp
src/ftinspect/glyphcomponents/glyphbitmap.hpp
src/ftinspect/glyphcomponents/glyphoutline.cpp
src/ftinspect/glyphcomponents/glyphoutline.hpp
src/ftinspect/glyphcomponents/glyphpointnumbers.cpp
src/ftinspect/glyphcomponents/glyphpointnumbers.hpp
src/ftinspect/glyphcomponents/glyphpoints.cpp
src/ftinspect/glyphcomponents/glyphpoints.hpp
+ src/ftinspect/glyphcomponents/graphicsdefault.cpp
+ src/ftinspect/glyphcomponents/graphicsdefault.hpp
src/ftinspect/glyphcomponents/grid.cpp
src/ftinspect/glyphcomponents/grid.hpp
+ src/ftinspect/maingui.cpp
+ src/ftinspect/maingui.hpp
src/ftinspect/meson.build
+ src/ftinspect/panels/abstracttab.hpp
+ src/ftinspect/panels/settingpanel.cpp
+ src/ftinspect/panels/settingpanel.hpp
+ src/ftinspect/panels/singular.cpp
+ src/ftinspect/panels/singular.hpp
+ src/ftinspect/widgets/fontsizeselector.cpp
+ src/ftinspect/widgets/fontsizeselector.hpp
+ src/ftinspect/widgets/glyphindexselector.cpp
+ src/ftinspect/widgets/glyphindexselector.hpp
+ src/ftinspect/widgets/tripletselector.cpp
+ src/ftinspect/widgets/tripletselector.hpp

Changes:

src/ftinspect/CMakeLists.txt

@@ -28,10 +28,17 @@ add_executable(ftinspect
    "glyphcomponents/glyphpointnumbers.cpp"
    "glyphcomponents/glyphpoints.cpp"
    "glyphcomponents/grid.cpp"
 +  "glyphcomponents/graphicsdefault.cpp"
    "widgets/customwidgets.cpp"
 +  "widgets/tripletselector.cpp"
 +  "widgets/glyphindexselector.cpp"
 +  "widgets/fontsizeselector.cpp"
    "models/customcomboboxmodels.cpp"
++
 +  "panels/settingpanel.cpp"
 +  "panels/singular.cpp"
+ )
  target_link_libraries(ftinspect
    Qt5::Core Qt5::Widgets

src/ftinspect/engine/engine.cpp

@@ -237,6 +237,50 @@ Engine::numberOfNamedInstances(int fontIndex,
+ }
 +QString
 +Engine::namedInstanceName(int fontIndex, long faceIndex, int index)
 +{
 +  if (fontIndex < 0)
 +    return {};
++
 +  FT_Face face;
 +  QString name;
++
 +  // search triplet (fontIndex, faceIndex, index)
 +  FTC_FaceID ftcFaceID = reinterpret_cast<FTC_FaceID>
 +                           (faceIDMap_.value(FaceID(fontIndex,
 +                                                    faceIndex,
 +                                                    index)));
 +  if (ftcFaceID)
 +  {
 +    // found
 +    if (!FTC_Manager_LookupFace(cacheManager_, ftcFaceID, &face))
 +      name = QString("%1 %2")
 +               .arg(face->family_name)
 +               .arg(face->style_name);
 +  }
 +  else
 +  {
 +    // not found; try to load triplet (fontIndex, faceIndex, index)
 +    ftcFaceID = reinterpret_cast<FTC_FaceID>(faceCounter_);
 +    faceIDMap_.insert(FaceID(fontIndex, faceIndex, index),
 +                      faceCounter_++);
++
 +    if (!FTC_Manager_LookupFace(cacheManager_, ftcFaceID, &face))
 +      name = QString("%1 %2")
 +               .arg(face->family_name)
 +               .arg(face->style_name);
 +    else
 +    {
 +      faceIDMap_.remove(FaceID(fontIndex, faceIndex, 0));
 +      faceCounter_--;
 +    }
 +  }
++
 +  return name;
 +}
++
++
  int
  Engine::loadFont(int fontIndex,
                   long faceIndex,
@@ -299,6 +343,7 @@ Engine::loadFont(int fontIndex,
        fontType_ = FontType_TrueType;
+   }
 +  curNumGlyphs_ = numGlyphs;
    return numGlyphs;
+ }
@@ -394,6 +439,14 @@ Engine::numberOfOpenedFonts()
+ }
 +bool
 +Engine::fontValid()
 +{
 +  // TODO: use fallback font
 +  return ftSize_ != NULL;
 +}
++
++
  void
  Engine::openFonts(QStringList fontFileNames)
+ {

src/ftinspect/engine/engine.hpp

@@ -85,13 +85,20 @@ public:
    int numberOfOpenedFonts();
    // (for current fonts)
 +  bool fontValid();
    int currentFontType() const { return fontType_; }
    const QString& currentFamilyName() { return curFamilyName_; }
    const QString& currentStyleName() { return curStyleName_; }
 +  int currentFontNumberOfGlyphs() { return curNumGlyphs_; }
++
    QString glyphName(int glyphIndex);
    long numberOfFaces(int fontIndex);
    int numberOfNamedInstances(int fontIndex,
                               long faceIndex);
 +  QString namedInstanceName(int fontIndex, long faceIndex, int index);
++
 +  // (settings)
 +  int dpi() { return dpi_; }
    //////// Setters (direct or indirect)
@@ -138,6 +145,7 @@ private:
    QString curFamilyName_;
    QString curStyleName_;
 +  int curNumGlyphs_ = -1;
    FT_Library library_;
    FTC_Manager cacheManager_;

src/ftinspect/ftinspect.cpp

@@ -23,7 +23,6 @@ main(int argc,
    Engine engine;
    MainGUI gui(&engine);
 -  gui.setDefaults();
    gui.show();

src/ftinspect/glyphcomponents/glyphbitmap.cpp

@@ -5,47 +5,44 @@
  #include "glyphbitmap.hpp"
 +#include "../engine/engine.hpp"
++
  #include <cmath>
 +#include <utility>
 +#include <qevent.h>
  #include <QPainter>
  #include <QStyleOptionGraphicsItem>
 +#include <freetype/ftbitmap.h>
 -GlyphBitmap::GlyphBitmap(FT_Outline* outline,
 -                         FT_Library lib,
 -                         FT_Pixel_Mode pxlMode,
 -                         const QVector<QRgb>& monoColorTbl,
 -                         const QVector<QRgb>& grayColorTbl)
 -: library_(lib),
 -  pixelMode_(pxlMode),
 -  monoColorTable_(monoColorTbl),
 -  grayColorTable_(grayColorTbl)
 +GlyphBitmap::GlyphBitmap(QImage* image,
 +                         QRect rect)
 +: image_(image),
 +  boundingRect_(rect)
+ {
 -  // make a copy of the outline since we are going to manipulate it
 -  FT_Outline_New(library_,
 -                 static_cast<unsigned int>(outline->n_points),
 -                 outline->n_contours,
 -                 &transformed_);
 -  FT_Outline_Copy(outline, &transformed_);
+-
 -  FT_BBox cbox;
 -  FT_Outline_Get_CBox(outline, &cbox);
+-
 -  cbox.xMin &= ~63;
 -  cbox.yMin &= ~63;
 -  cbox.xMax = (cbox.xMax + 63) & ~63;
 -  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);
+-
 -  boundingRect_.setCoords(cbox.xMin / 64, -cbox.yMax / 64,
 -                  cbox.xMax / 64, -cbox.yMin / 64);
++
 +}
++
++
 +GlyphBitmap::GlyphBitmap(int glyphIndex,
 +                         FT_Glyph glyph,
 +                         Engine* engine)
 +{
 +  QRect bRect;
 +  image_ = NULL; // TODO: refactr Engine
 +  //image_ = engine->renderingEngine()->tryDirectRenderColorLayers(glyphIndex,
 +  //                                                               &bRect, true);
++
 +  //if (!image_)
 +  //  image_ = engine->renderingEngine()->convertGlyphToQImage(glyph, &bRect,
 +  //                                                           true);
 +  boundingRect_ = bRect; // QRect to QRectF
+ }
  GlyphBitmap::~GlyphBitmap()
+ {
 -  FT_Outline_Done(library_, &transformed_);
 +  delete image_;
+ }
  QRectF
@@ -60,40 +57,9 @@ GlyphBitmap::paint(QPainter* painter,
                     const QStyleOptionGraphicsItem* option,
                     QWidget*)
+ {
 -  FT_Bitmap bitmap;
+-
 -  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)
 -    format = QImage::Format_Mono;
+-
 -  QImage image(QSize(width, height), format);
+-
 -  if (pixelMode_ == FT_PIXEL_MODE_MONO)
 -    image.setColorTable(monoColorTable_);
 -  else
 -    image.setColorTable(grayColorTable_);
+-
 -  image.fill(0);
+-
 -  bitmap.rows = static_cast<unsigned int>(height);
 -  bitmap.width = static_cast<unsigned int>(width);
 -  bitmap.buffer = image.bits();
 -  bitmap.pitch = image.bytesPerLine();
 -  bitmap.pixel_mode = pixelMode_;
+-
 -  FT_Error error = FT_Outline_Get_Bitmap(library_,
 -                                         &transformed_,
 -                                         &bitmap);
 -  if (error)
 -  {
 -    // XXX error handling
 +  if (!image_)
      return;
 -  }
+-
++
    // `drawImage' doesn't work as expected:
    // the larger the zoom, the more the pixel rectangle positions
    // deviate from the grid lines
@@ -102,16 +68,16 @@ GlyphBitmap::paint(QPainter* painter,
                       image.convertToFormat(
                         QImage::Format_ARGB32_Premultiplied));
  #else
 -  const qreal lod = option->levelOfDetailFromTransform(
 -                              painter->worldTransform());
 +  const qreal lod = QStyleOptionGraphicsItem::levelOfDetailFromTransform(
 +    painter->worldTransform());
    painter->setPen(Qt::NoPen);
 -  for (int x = 0; x < image.width(); x++)
 -    for (int y = 0; y < image.height(); y++)
 +  for (int x = 0; x < image_->width(); x++)
 +    for (int y = 0; y < image_->height(); y++)
+     {
        // be careful not to lose the alpha channel
 -      QRgb p = image.pixel(x, y);
 +      QRgb p = image_->pixel(x, y);
        painter->fillRect(QRectF(x + boundingRect_.left() - 1 / lod / 2,
                                 y + boundingRect_.top() - 1 / lod / 2,
 + 1 / lod,

src/ftinspect/glyphcomponents/glyphbitmap.hpp

@@ -7,33 +7,34 @@
  #include <QGraphicsItem>
  #include <QPen>
 +#include <QPaintEvent>
 +#include <QWidget>
  #include <ft2build.h>
  #include <freetype/freetype.h>
 +#include <freetype/ftglyph.h>
  #include <freetype/ftoutln.h>
 +class Engine;
++
  class GlyphBitmap
  : public QGraphicsItem
+ {
  public:
 -  GlyphBitmap(FT_Outline* outline,
 -              FT_Library library,
 -              FT_Pixel_Mode pixelMode,
 -              const QVector<QRgb>& monoColorTable,
 -              const QVector<QRgb>& grayColorTable);
 -  ~GlyphBitmap();
 -  QRectF boundingRect() const;
 +  GlyphBitmap(QImage* image,
 +              QRect rect);
 +  GlyphBitmap(int glyphIndex,
 +              FT_Glyph glyph,
 +              Engine* engine);
 +  ~GlyphBitmap() override;
 +  QRectF boundingRect() const override;
    void paint(QPainter* painter,
               const QStyleOptionGraphicsItem* option,
 -             QWidget* widget);
 +             QWidget* widget) override;
  private:
 -  FT_Outline transformed_;
 -  FT_Library library_;
 -  unsigned char pixelMode_;
 -  const QVector<QRgb>& monoColorTable_;
 -  const QVector<QRgb>& grayColorTable_;
 +  QImage* image_ = NULL;
    QRectF boundingRect_;
  };

src/ftinspect/glyphcomponents/glyphoutline.cpp

@@ -87,11 +87,17 @@ static FT_Outline_Funcs outlineFuncs =
  } // extern "C"
 -GlyphOutline::GlyphOutline(const QPen& outlineP,
 -                           FT_Outline* outln)
 -: outlinePen_(outlineP),
 -  outline_(outln)
 +GlyphOutline::GlyphOutline(const QPen& pen,
 +                           FT_Glyph glyph)
 +: outlinePen_(pen)
+ {
 +  if (glyph->format != FT_GLYPH_FORMAT_OUTLINE)
 +  {
 +    outline_ = NULL;
 +    return;
 +  }
 +  outline_ = &reinterpret_cast<FT_OutlineGlyph>(glyph)->outline;
++
    FT_BBox cbox;
    qreal halfPenWidth = outlinePen_.widthF();
@@ -117,6 +123,8 @@ GlyphOutline::paint(QPainter* painter,
                      const QStyleOptionGraphicsItem*,
                      QWidget*)
+ {
 +  if (!outline_)
 +    return;
    painter->setPen(outlinePen_);
    QPainterPath path;

src/ftinspect/glyphcomponents/glyphoutline.hpp

@@ -10,6 +10,7 @@
  #include <ft2build.h>
  #include <freetype/freetype.h>
 +#include <freetype/ftglyph.h>
  #include <freetype/ftoutln.h>
@@ -18,11 +19,11 @@ class GlyphOutline
+ {
  public:
    GlyphOutline(const QPen& pen,
 -               FT_Outline* outline);
 -  QRectF boundingRect() const;
 +               FT_Glyph glyph);
 +  QRectF boundingRect() const override;
    void paint(QPainter* painter,
               const QStyleOptionGraphicsItem* option,
 -             QWidget* widget);
 +             QWidget* widget) override;
  private:
    QPen outlinePen_;

src/ftinspect/glyphcomponents/glyphpointnumbers.cpp

@@ -12,11 +12,17 @@
  GlyphPointNumbers::GlyphPointNumbers(const QPen& onP,
                                       const QPen& offP,
 -                                     FT_Outline* outln)
 +                                     FT_Glyph glyph)
  : onPen_(onP),
 -  offPen_(offP),
 -  outline_(outln)
 +  offPen_(offP)
+ {
 +  if (glyph->format != FT_GLYPH_FORMAT_OUTLINE)
 +  {
 +    outline_ = NULL;
 +    return;
 +  }
 +  outline_ = &reinterpret_cast<FT_OutlineGlyph>(glyph)->outline;
++
    FT_BBox cbox;
    FT_Outline_Get_CBox(outline_, &cbox);
@@ -41,6 +47,8 @@ GlyphPointNumbers::paint(QPainter* painter,
                           const QStyleOptionGraphicsItem* option,
                           QWidget*)
+ {
 +  if (!outline_)
 +    return;
    const qreal lod = option->levelOfDetailFromTransform(
                                painter->worldTransform());

src/ftinspect/glyphcomponents/glyphpointnumbers.hpp

@@ -10,6 +10,7 @@
  #include <ft2build.h>
  #include <freetype/freetype.h>
 +#include <freetype/ftglyph.h>
  #include <freetype/ftoutln.h>
@@ -19,11 +20,11 @@ class GlyphPointNumbers
  public:
    GlyphPointNumbers(const QPen& onPen,
                      const QPen& offPen,
 -                    FT_Outline* outline);
 -  QRectF boundingRect() const;
 +                    FT_Glyph glyph);
 +  QRectF boundingRect() const override;
    void paint(QPainter* painter,
               const QStyleOptionGraphicsItem* option,
 -             QWidget* widget);
 +             QWidget* widget) override;
  private:
    QPen onPen_;

src/ftinspect/glyphcomponents/glyphpoints.cpp

@@ -11,11 +11,17 @@
  GlyphPoints::GlyphPoints(const QPen& onP,
                           const QPen& offP,
 -                         FT_Outline* outln)
 +                         FT_Glyph glyph)
  : onPen_(onP),
 -  offPen_(offP),
 -  outline_(outln)
 +  offPen_(offP)
+ {
 +  if (glyph->format != FT_GLYPH_FORMAT_OUTLINE)
 +  {
 +    outline_ = NULL;
 +    return;
 +  }
 +  outline_ = &reinterpret_cast<FT_OutlineGlyph>(glyph)->outline;
++
    FT_BBox cbox;
    qreal halfPenWidth = qMax(onPen_.widthF(), offPen_.widthF()) / 2;
@@ -41,6 +47,9 @@ GlyphPoints::paint(QPainter* painter,
                     const QStyleOptionGraphicsItem* option,
                     QWidget*)
+ {
 +  if (!outline_)
 +    return;
++
    const qreal lod = option->levelOfDetailFromTransform(
                                painter->worldTransform());

src/ftinspect/glyphcomponents/glyphpoints.hpp

@@ -10,6 +10,7 @@
  #include <ft2build.h>
  #include <freetype/freetype.h>
 +#include <freetype/ftglyph.h>
  #include <freetype/ftoutln.h>
@@ -19,11 +20,11 @@ class GlyphPoints
  public:
    GlyphPoints(const QPen& onPen,
                const QPen& offPen,
 -              FT_Outline* outline);
 -  QRectF boundingRect() const;
 +              FT_Glyph glyph);
 +  QRectF boundingRect() const override;
    void paint(QPainter* painter,
               const QStyleOptionGraphicsItem* option,
 -             QWidget* widget);
 +             QWidget* widget) override;
  private:
    QPen onPen_;

src/ftinspect/glyphcomponents/graphicsdefault.cpp

 +// graphicsdefault.cpp
++
 +// Copyright (C) 2022 by Charlie Jiang.
++
 +#include "graphicsdefault.hpp"
++
 +GraphicsDefault* GraphicsDefault::instance_ = NULL;
++
 +GraphicsDefault::GraphicsDefault()
 +{
 +  // XXX make this user-configurable
++
 +  axisPen.setColor(Qt::black);
 +  axisPen.setWidth(0);
 +  blueZonePen.setColor(QColor(64, 64, 255, 64)); // light blue
 +  blueZonePen.setWidth(0);
 +  // Don't make this solid
 +  gridPen.setColor(QColor(0, 0, 0, 255 - QColor(Qt::lightGray).red()));
 +  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);
++
 +  advanceAuxPen.setColor(QColor(110, 52, 235)); // kind of blue
 +  advanceAuxPen.setWidth(0);
 +  ascDescAuxPen.setColor(QColor(255, 0, 0)); // red
 +  ascDescAuxPen.setWidth(0);
 +}
++
++
 +GraphicsDefault*
 +GraphicsDefault::deafultInstance()
 +{
 +  if (!instance_)
 +    instance_ = new GraphicsDefault;
++
 +  return instance_;
 +}
++
++
 +// end of graphicsdefault.cpp

src/ftinspect/glyphcomponents/graphicsdefault.hpp

 +// graphicsdefault.hpp
++
 +// Copyright (C) 2022 by Charlie Jiang.
++
 +#pragma once
++
 +#include <QVector>
 +#include <QRgb>
 +#include <QPen>
++
 +// This is default graphics objects fed into render functions.
 +struct GraphicsDefault
 +{
 +  QPen axisPen;
 +  QPen blueZonePen;
 +  QPen gridPen;
 +  QPen offPen;
 +  QPen onPen;
 +  QPen outlinePen;
 +  QPen segmentPen;
++
 +  QPen advanceAuxPen;
 +  QPen ascDescAuxPen;
++
 +  GraphicsDefault();
++
 +  static GraphicsDefault* deafultInstance();
++
 +private:
 +  static GraphicsDefault* instance_;
 +};
++
++
 +// end of graphicsdefault.hpp

src/ftinspect/glyphcomponents/grid.cpp

@@ -5,88 +5,131 @@
  #include "grid.hpp"
 +#include "graphicsdefault.hpp"
++
  #include <QPainter>
  #include <QStyleOptionGraphicsItem>
 +#include <QGraphicsWidget>
 +#include <QGraphicsView>
 -Grid::Grid(const QPen& gridP,
 -           const QPen& axisP)
 -: gridPen_(gridP),
 -  axisPen_(axisP)
 +Grid::Grid(QGraphicsView* parentView)
 +:  parentView_(parentView)
+ {
   // empty
 +  updateRect();
+ }
  QRectF
  Grid::boundingRect() const
+ {
 -  // XXX fix size
 +  return rect_;
 +}
++
++
 +void
 +Grid::updateRect()
 +{
 +  auto viewport = parentView_->mapToScene(parentView_->viewport()->geometry())
 +                         .boundingRect()
 +                         .toRect();
 +  int minX = std::min(viewport.left() - 10, -100);
 +  int minY = std::min(viewport.top() - 10, -100);
 +  int maxX = std::max(viewport.right() + 10, 100);
 +  int maxY = std::max(viewport.bottom() + 10, 100);
++
 +  auto newSceneRect = QRectF(QPointF(minX - 20, minY - 20),
 +                             QPointF(maxX + 20, maxY + 20));
 +  if (sceneRect_ != newSceneRect && scene())
 +  {
 +    scene()->setSceneRect(newSceneRect);
 +    sceneRect_ = newSceneRect;
 +  }
    // no need to take care of pen width
 -  return QRectF(-100, -100,
 -                200, 200);
 +  rect_ = QRectF(QPointF(minX, minY),
 +                QPointF(maxX, maxY));
+ }
 -// XXX call this in a `myQDraphicsView::drawBackground' derived method
 -//     to always fill the complete viewport
+-
  void
  Grid::paint(QPainter* painter,
              const QStyleOptionGraphicsItem* option,
 -            QWidget*)
 +            QWidget* widget)
+ {
 +  auto gb = GraphicsDefault::deafultInstance();
 +  auto br = boundingRect().toRect();
 +  int minX = br.left();
 +  int minY = br.top();
 +  int maxX = br.right();
 +  int maxY = br.bottom();
++
    const qreal lod = option->levelOfDetailFromTransform(
                                painter->worldTransform());
+-
 -  painter->setPen(gridPen_);
+-
 -  // don't mark pixel center with a cross if magnification is too small
 -  if (lod > 20)
 +  if (showGrid_)
+   {
 -    int halfLength = 1;
+-
 -    // cf. QSpinBoxx
 -    if (lod > 640)
 -      halfLength = 6;
 -    else if (lod > 320)
 -      halfLength = 5;
 -    else if (lod > 160)
 -      halfLength = 4;
 -    else if (lod > 80)
 -      halfLength = 3;
 -    else if (lod > 40)
 -      halfLength = 2;
+-
 -    for (qreal x = -100; x < 100; x++)
 -      for (qreal y = -100; y < 100; y++)
 -      {
 -        painter->drawLine(QLineF(x + 0.5, y + 0.5 - halfLength / lod,
 -                                 x + 0.5, y + 0.5 + halfLength / lod));
 -        painter->drawLine(QLineF(x + 0.5 - halfLength / lod, y + 0.5,
 -                                 x + 0.5 + halfLength / lod, y + 0.5));
 -      }
 +    painter->setPen(gb->gridPen);
++
 +    // don't mark pixel center with a cross if magnification is too small
 +    if (lod > 20)
 +    {
 +      int halfLength = 1;
++
 +      // cf. QSpinBoxx
 +      if (lod > 640)
 +        halfLength = 6;
 +      else if (lod > 320)
 +        halfLength = 5;
 +      else if (lod > 160)
 +        halfLength = 4;
 +      else if (lod > 80)
 +        halfLength = 3;
 +      else if (lod > 40)
 +        halfLength = 2;
++
 +      for (qreal x = minX; x < maxX; x++)
 +        for (qreal y = minY; y < maxY; y++)
 +        {
 +          painter->drawLine(QLineF(x + 0.5, y + 0.5 - halfLength / lod,
 +                                   x + 0.5, y + 0.5 + halfLength / lod));
 +          painter->drawLine(QLineF(x + 0.5 - halfLength / lod, y + 0.5,
 +                                   x + 0.5 + halfLength / lod, y + 0.5));
 +        }
 +    }
++
 +    // don't draw grid if magnification is too small
 +    if (lod >= 5)
 +    {
 +      for (int x = minX; x <= maxX; x++)
 +        painter->drawLine(x, minY,
 +                          x, maxY);
 +      for (int y = minY; y <= maxY; y++)
 +        painter->drawLine(minX, y,
 +                          maxX, y);
 +    }
++
 +    painter->setPen(gb->axisPen);
++
 +    painter->drawLine(0, minY,
 +                      0, maxY);
 +    painter->drawLine(minX, 0,
 +                      maxX, 0);
+   }
 -  // don't draw grid if magnification is too small
 -  if (lod >= 5)
 +  if (showAuxLines_)
+   {
 -    // XXX fix size
 -    for (int x = -100; x <= 100; x++)
 -      painter->drawLine(x, -100,
 -                        x, 100);
 -    for (int y = -100; y <= 100; y++)
 -      painter->drawLine(-100, y,
 -                        100, y);
 +    // TODO: impl
+   }
 +}
 -  painter->setPen(axisPen_);
 -  painter->drawLine(0, -100,
 -                    0, 100);
 -  painter->drawLine(-100, 0,
 -                    100, 0);
 +void
 +Grid::setShowGrid(bool showGrid, bool showAuxLines)
 +{
 +  showGrid_ = showGrid;
 +  showAuxLines_ = showAuxLines;
 +  update();
+ }

src/ftinspect/glyphcomponents/grid.hpp

@@ -6,23 +6,30 @@
  #pragma once
  #include <QGraphicsItem>
 +#include <QGraphicsView>
  #include <QPen>
+-
  class Grid
  : public QGraphicsItem
+ {
  public:
 -  Grid(const QPen& gridPen,
 -       const QPen& axisPen);
 -  QRectF boundingRect() const;
 +  Grid(QGraphicsView* parentView);
 +  QRectF boundingRect() const override;
    void paint(QPainter* painter,
               const QStyleOptionGraphicsItem* option,
 -             QWidget* widget);
 +             QWidget* widget) override;
++
 +  void setShowGrid(bool showGrid, bool showAuxLines);
++
 +  void updateRect(); // there's no signal/slots for QGraphicsItem.
  private:
 -  QPen gridPen_;
 -  QPen axisPen_;
 +  QGraphicsView* parentView_;
 +  QRectF rect_;
 +  QRectF sceneRect_;
++
 +  bool showGrid_ = true;
 +  bool showAuxLines_ = false;
  };

src/ftinspect/maingui.cpp

 +// maingui.cpp
++
 +// Copyright (C) 2016-2022 by Werner Lemberg.
++
++
 +#include "maingui.hpp"
++
 +#include <QApplication>
 +#include <QFileDialog>
 +#include <QMessageBox>
 +#include <QSettings>
 +#include <QScrollBar>
 +#include <QStatusBar>
++
++
 +MainGUI::MainGUI(Engine* engine)
 +: engine_(engine)
 +{
 +  createLayout();
 +  createConnections();
 +  createActions();
 +  createMenus();
++
 +  readSettings();
 +  setUnifiedTitleAndToolBarOnMac(true);
++
 +  show();
 +}
++
++
 +MainGUI::~MainGUI()
 +{
 +  // empty
 +}
++
++
 +// overloading
++
 +void
 +MainGUI::closeEvent(QCloseEvent* event)
 +{
 +  writeSettings();
 +  event->accept();
 +}
++
++
 +void
 +MainGUI::keyPressEvent(QKeyEvent* event)
 +{
 +  // Delegate key events to tabs
 +  if (!tabWidget_->currentWidget()->eventFilter(this, event))
 +    QMainWindow::keyPressEvent(event);
 +}
++
++
 +void
 +MainGUI::about()
 +{
 +  QMessageBox::about(
 +    this,
 +    tr("About ftinspect"),
 +    tr("<p>This is <b>ftinspect</b> version %1<br>"
 +       " Copyright %2 2016-2022<br>"
 +       " by Werner Lemberg <tt>&lt;wl@gnu.org&gt;</tt></p>"
 +       ""
 +       "<p><b>ftinspect</b> shows how a font gets rendered"
 +       " by FreeType, allowing control over virtually"
 +       " all rendering parameters.</p>"
 +       ""
 +       "<p>License:"
 +       " <a href=''>FreeType"
 +       " License (FTL)</a> or"
 +       " <a href=''>GNU"
 +       " GPLv2</a></p>")
 +       .arg(QApplication::applicationVersion())
 +       .arg(QChar(0xA9)));
 +}
++
++
 +void
 +MainGUI::aboutQt()
 +{
 +  QApplication::aboutQt();
 +}
++
++
 +void
 +MainGUI::loadFonts()
 +{
 +  QStringList files = QFileDialog::getOpenFileNames(
 +                        this,
 +                        tr("Load one or more fonts"),
 +                        QDir::homePath(),
 +                        "",
 +                        NULL,
 +                        QFileDialog::ReadOnly);
 +  openFonts(files);
 +}
++
++
 +void
 +MainGUI::openFonts(QStringList const& fileNames)
 +{
 +  engine_->openFonts(fileNames);
 +  tripletSelector_->repopulateFonts();
 +}
++
++
 +void
 +MainGUI::onTripletChanged()
 +{
 +  auto state = settingPanel_->blockSignals(true);
 +  settingPanel_->onFontChanged();
 +  settingPanel_->blockSignals(state);
 +  reloadCurrentTabFont();
 +}
++
++
 +void
 +MainGUI::switchTab()
 +{
 +  reloadCurrentTabFont();
 +  lastTab_ = tabWidget_->currentWidget();
 +}
++
++
 +void
 +MainGUI::repaintCurrentTab()
 +{
 +  applySettings();
 +  tabs_[tabWidget_->currentIndex()]->repaintGlyph();
 +}
++
++
 +void
 +MainGUI::reloadCurrentTabFont()
 +{
 +  engine_->resetCache();
 +  applySettings();
 +  auto index = tabWidget_->currentIndex();
 +  if (index >= 0 && static_cast<size_t>(index) < tabs_.size())
 +    tabs_[index]->reloadFont();
 +}
++
++
 +void
 +MainGUI::applySettings()
 +{
 +  settingPanel_->applySettings();
 +  settingPanel_->applyDelayedSettings();
 +}
++
++
 +// XXX distances are specified in pixels,
 +//     making the layout dependent on the output device resolution
 +void
 +MainGUI::createLayout()
 +{
 +  // left side
 +  settingPanel_ = new SettingPanel(this, engine_);
++
 +  leftLayout_ = new QVBoxLayout; // The only point is to set a margin->remove?
 +  leftLayout_->addWidget(settingPanel_);
 +  leftLayout_->setContentsMargins(32, 32, 0, 16);
++
 +  // we don't want to expand the left side horizontally;
 +  // to change the policy we have to use a widget wrapper
 +  leftWidget_ = new QWidget(this);
 +  leftWidget_->setLayout(leftLayout_);
 +  leftWidget_->setMaximumWidth(400);
++
 +  // right side
 +  singularTab_ = new SingularTab(this, engine_);
++
 +  tabWidget_ = new QTabWidget(this);
 +  tabWidget_->setObjectName("mainTab"); // for stylesheet
++
 +  // Note those two list must be in sync
 +  tabs_.push_back(singularTab_);
 +  tabWidget_->addTab(singularTab_, tr("Singular Grid View"));
 +  lastTab_ = singularTab_;
++
 +  tabWidget_->setTabToolTip(0, tr("View single glyph in grid view.\n"
 +                                  "For pixelwise inspection of the glyphs."));
 +  tripletSelector_ = new TripletSelector(this, engine_);
++
 +  rightLayout_ = new QVBoxLayout;
 +  //rightLayout_->addWidget(fontNameLabel_);
 +  rightLayout_->addWidget(tabWidget_); // same for `leftLayout_`: Remove?
 +  rightLayout_->setContentsMargins(16, 32, 32, 16);
++
 +  // for symmetry with the left side use a widget also
 +  rightWidget_ = new QWidget(this);
 +  rightWidget_->setLayout(rightLayout_);
++
 +  // the whole thing
 +  mainPartLayout_ = new QHBoxLayout;
 +  mainPartLayout_->addWidget(leftWidget_);
 +  mainPartLayout_->addWidget(rightWidget_);
++
 +  ftinspectLayout_ = new QVBoxLayout;
 +  ftinspectLayout_->setSpacing(0);
 +  ftinspectLayout_->addLayout(mainPartLayout_);
 +  ftinspectLayout_->addWidget(tripletSelector_);
 +  ftinspectLayout_->setContentsMargins(0, 0, 0, 0);
++
 +  ftinspectWidget_ = new QWidget(this);
 +  ftinspectWidget_->setLayout(ftinspectLayout_);
++
 +  ftinspectLayout_->setSizeConstraint(QLayout::SetNoConstraint);
 +  layout()->setSizeConstraint(QLayout::SetNoConstraint);
 +  resize(ftinspectWidget_->minimumSizeHint().width(),
 +         700 * logicalDpiY() / 96);
++
 +  statusBar()->hide(); // remove the extra space
 +  setCentralWidget(ftinspectWidget_);
 +  setWindowTitle("ftinspect");
 +}
++
++
 +void
 +MainGUI::createConnections()
 +{
 +  connect(settingPanel_, &SettingPanel::fontReloadNeeded,
 +          this, &MainGUI::reloadCurrentTabFont);
 +  connect(settingPanel_, &SettingPanel::repaintNeeded,
 +          this, &MainGUI::repaintCurrentTab);
++
 +  connect(tabWidget_, &QTabWidget::currentChanged,
 +          this, &MainGUI::switchTab);
++
 +  connect(tripletSelector_, &TripletSelector::tripletChanged,
 +          this, &MainGUI::onTripletChanged);
 +}
++
++
 +void
 +MainGUI::createActions()
 +{
 +  loadFontsAct_ = new QAction(tr("&Load Fonts"), this);
 +  loadFontsAct_->setShortcuts(QKeySequence::Open);
 +  connect(loadFontsAct_, &QAction::triggered, this, &MainGUI::loadFonts);
++
 +  closeFontAct_ = new QAction(tr("&Close Font"), this);
 +  closeFontAct_->setShortcuts(QKeySequence::Close);
 +  connect(closeFontAct_, &QAction::triggered,
 +          tripletSelector_, &TripletSelector::closeCurrentFont);
++
 +  exitAct_ = new QAction(tr("E&xit"), this);
 +  exitAct_->setShortcuts(QKeySequence::Quit);
 +  connect(exitAct_, &QAction::triggered, this, &MainGUI::close);
++
 +  aboutAct_ = new QAction(tr("&About"), this);
 +  connect(aboutAct_, &QAction::triggered, this, &MainGUI::about);
++
 +  aboutQtAct_ = new QAction(tr("About &Qt"), this);
 +  connect(aboutQtAct_, &QAction::triggered, this, &MainGUI::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_);
 +}
++
++
 +void
 +MainGUI::readSettings()
 +{
 +  QSettings settings;
 +//  QPoint pos = settings.value("pos", QPoint(200, 200)).toPoint();
 +//  QSize size = settings.value("size", QSize(400, 400)).toSize();
 +//  resize(size);
 +//  move(pos);
 +}
++
++
 +void
 +MainGUI::writeSettings()
 +{
 +  QSettings settings;
 +//  settings.setValue("pos", pos());
 +//  settings.setValue("size", size());
 +}
++
++
 +// end of maingui.cpp

src/ftinspect/maingui.hpp

 +// maingui.hpp
++
 +// Copyright (C) 2016-2022 by Werner Lemberg.
++
++
 +#pragma once
++
 +#include "engine/engine.hpp"
 +#include "widgets/tripletselector.hpp"
 +#include "panels/settingpanel.hpp"
 +#include "panels/abstracttab.hpp"
 +#include "panels/singular.hpp"
++
 +#include <vector>
 +#include <QAction>
 +#include <QCloseEvent>
 +#include <QGridLayout>
 +#include <QDockWidget>
 +#include <QBoxLayout>
 +#include <QLabel>
 +#include <QMainWindow>
 +#include <QMenu>
 +#include <QMenuBar>
 +#include <QTabWidget>
++
++
 +class MainGUI
 +: public QMainWindow
 +{
 +  Q_OBJECT
++
 +public:
 +  MainGUI(Engine* engine);
 +  ~MainGUI() override;
++
 +  friend class Engine;
 +  friend FT_Error faceRequester(FTC_FaceID,
 +                                FT_Library,
 +                                FT_Pointer,
 +                                FT_Face*);
++
 +protected:
 +  void closeEvent(QCloseEvent*) override;
 +  void keyPressEvent(QKeyEvent* event) override;
++
 +private slots:
 +  void about();
 +  void aboutQt();
 +  void repaintCurrentTab();
 +  void reloadCurrentTabFont();
 +  void loadFonts();
 +  void onTripletChanged();
 +  void switchTab();
++
 +private:
 +  Engine* engine_;
++
 +  int currentNumberOfGlyphs_;
++
 +  // layout related stuff
 +  QAction *aboutAct_;
 +  QAction *aboutQtAct_;
 +  QAction *closeFontAct_;
 +  QAction *exitAct_;
 +  QAction *loadFontsAct_;
++
 +  QVBoxLayout *ftinspectLayout_;
 +  QHBoxLayout *mainPartLayout_;
++
 +  QLocale *locale_;
++
 +  QMenu *menuFile_;
 +  QMenu *menuHelp_;
++
 +  TripletSelector* tripletSelector_;
++
 +  QVBoxLayout *leftLayout_;
 +  QVBoxLayout *rightLayout_;
++
 +  QWidget *ftinspectWidget_;
 +  QWidget *leftWidget_;
 +  QWidget *rightWidget_;
++
 +  SettingPanel* settingPanel_;
++
 +  QTabWidget* tabWidget_;
 +  std::vector<AbstractTab*> tabs_;
 +  SingularTab* singularTab_;
 +  QWidget* lastTab_ = NULL;
++
 +  void openFonts(QStringList const& fileNames);
++
 +  void applySettings();
++
 +  void createActions();
 +  void createConnections();
 +  void createLayout();
 +  void createMenus();
++
 +  void readSettings();
 +  void writeSettings();
 +};
++
++
 +// end of maingui.hpp

src/ftinspect/meson.build

@@ -29,11 +29,18 @@ if qt5_dep.found()
      'glyphcomponents/glyphpointnumbers.cpp',
      'glyphcomponents/glyphpoints.cpp',
      'glyphcomponents/grid.cpp',
 +    'glyphcomponents/graphicsdefault.cpp',
      'widgets/customwidgets.cpp',
 +    'widgets/tripletselector.cpp',
 +    'widgets/glyphindexselector.cpp',
 +    'widgets/fontsizeselector.cpp',
      'models/customcomboboxmodels.cpp',
 +    'panels/settingpanel.cpp',
 +    'panels/singular.cpp',
++
      'ftinspect.cpp',
      'maingui.cpp',
      'uihelper.cpp',
@@ -43,8 +50,13 @@ if qt5_dep.found()
      moc_headers: [
        'engine/fontfilemanager.hpp',
        'widgets/customwidgets.hpp',
 +      'widgets/tripletselector.hpp',
 +      'widgets/glyphindexselector.hpp',
 +      'widgets/fontsizeselector.hpp',
        'maingui.hpp',
        'models/customcomboboxmodels.hpp',
 +      'panels/settingpanel.hpp',
 +      'panels/singular.hpp',
      ],
      dependencies: qt5_dep)

src/ftinspect/panels/abstracttab.hpp

 +// abstracttab.hpp
++
 +// Copyright (C) 2022 by Charlie Jiang.
++
 +#pragma once
++
 +// This is an pure abstract interface for a ftinspect "tab".
 +// The interface itself does not inherit from `QWidget`, but should be used as
 +// the second base class.
 +class AbstractTab
 +{
 +public:
 +  virtual ~AbstractTab() = default; // must be `virtual` for `dynamic_cast`
++
 +  virtual void repaintGlyph() = 0;
 +  virtual void reloadFont() = 0;
 +};
++
++
 +// end of abstracttab.hpp

src/ftinspect/panels/settingpanel.cpp

 +// settingpanel.cpp
++
 +// Copyright (C) 2022 by Charlie Jiang.
++
 +#include "settingpanel.hpp"
++
 +#include "../uihelper.hpp"
++
 +#include <QColorDialog>
++
 +// for `FT_DEBUG_AUTOFIT`
 +#include <freetype/config/ftoption.h>
++
 +SettingPanel::SettingPanel(QWidget* parent,
 +                           Engine* engine)
 +: QWidget(parent),
 +  engine_(engine)
 +{
 +#ifdef FT_DEBUG_AUTOFIT
 +  debugMode_ = !comparatorMode_;
 +#else
 +  debugMode_ = false;
 +#endif
 +  createLayout();
 +  setDefaults();
 +  createConnections();
 +  checkAllSettings();
 +}
++
++
 +int
 +SettingPanel::antiAliasingModeIndex()
 +{
 +  return antiAliasingComboBox_->currentIndex();
 +}
++
++
 +bool
 +SettingPanel::kerningEnabled()
 +{
 +  return kerningCheckBox_->isChecked();
 +}
++
++
 +bool
 +SettingPanel::lsbRsbDeltaEnabled()
 +{
 +  return lsbRsbDeltaCheckBox_->isChecked();
 +}
++
++
 +void
 +SettingPanel::populatePalettes()
 +{
 +  // TODO: Impl
 +}
++
++
 +void
 +SettingPanel::checkAllSettings()
 +{
 +  onFontChanged();
 +  checkAntiAliasing();
 +}
++
++
 +void
 +SettingPanel::checkHinting()
 +{
 +  if (hintingCheckBox_->isChecked())
 +  {
 +    // TODO: tricky: disable auto-hinting
 +    checkAutoHinting(); // this will emit repaint
 +  }
 +  else
 +  {
 +    hintingModeLabel_->setEnabled(false);
 +    hintingModeComboBox_->setEnabled(false);
++
 +    autoHintingCheckBox_->setEnabled(false);
 +    if (debugMode_)
 +    {
 +      horizontalHintingCheckBox_->setEnabled(false);
 +      verticalHintingCheckBox_->setEnabled(false);
 +      blueZoneHintingCheckBox_->setEnabled(false);
 +      segmentDrawingCheckBox_->setEnabled(false);
 +    }
++
 +    stemDarkeningCheckBox_->setEnabled(false);
 +    antiAliasingComboBoxModel_->setLightAntiAliasingEnabled(false);
 +    auto aaMode = antiAliasingComboBox_->currentIndex();
 +    if (aaMode == AntiAliasingComboBoxModel::AntiAliasing_Light
 +        || aaMode == AntiAliasingComboBoxModel::AntiAliasing_Light_SubPixel)
 +      antiAliasingComboBox_->setCurrentIndex(
 +        AntiAliasingComboBoxModel::AntiAliasing_Normal);
++
 +    emit repaintNeeded();
 +  }
 +}
++
++
 +void
 +SettingPanel::checkHintingMode()
 +{
 +  //if (!comparatorMode_)
 +  //  applyDelayedSettings();
++
 +  emit fontReloadNeeded();
 +}
++
++
 +void
 +SettingPanel::checkAutoHinting()
 +{
 +  if (autoHintingCheckBox_->isChecked())
 +  {
 +    hintingModeLabel_->setEnabled(false);
 +    hintingModeComboBox_->setEnabled(false);
++
 +    if (debugMode_)
 +    {
 +      horizontalHintingCheckBox_->setEnabled(true);
 +      verticalHintingCheckBox_->setEnabled(true);
 +      blueZoneHintingCheckBox_->setEnabled(true);
 +      segmentDrawingCheckBox_->setEnabled(true);
 +    }
++
 +    antiAliasingComboBoxModel_->setLightAntiAliasingEnabled(true);
 +    auto aaMode = antiAliasingComboBox_->currentIndex();
 +    stemDarkeningCheckBox_->setEnabled(
 +      aaMode == AntiAliasingComboBoxModel::AntiAliasing_Light
 +      || aaMode == AntiAliasingComboBoxModel::AntiAliasing_Light_SubPixel);
 +  }
 +  else
 +  {
 +    if (engine_->currentFontType() == Engine::FontType_CFF
 +        || engine_->currentFontType() == Engine::FontType_TrueType)
 +    {
 +      hintingModeLabel_->setEnabled(true);
 +      hintingModeComboBox_->setEnabled(true);
 +    }
++
 +    if (debugMode_)
 +    {
 +      horizontalHintingCheckBox_->setEnabled(false);
 +      verticalHintingCheckBox_->setEnabled(false);
 +      blueZoneHintingCheckBox_->setEnabled(false);
 +      segmentDrawingCheckBox_->setEnabled(false);
 +    }
++
 +    antiAliasingComboBoxModel_->setLightAntiAliasingEnabled(false);
 +    stemDarkeningCheckBox_->setEnabled(false);
++
 +    auto aaMode = antiAliasingComboBox_->currentIndex();
 +    if (aaMode == AntiAliasingComboBoxModel::AntiAliasing_Light
 +        || aaMode == AntiAliasingComboBoxModel::AntiAliasing_Light_SubPixel)
 +      antiAliasingComboBox_->setCurrentIndex(
 +          AntiAliasingComboBoxModel::AntiAliasing_Normal);
 +  }
 +  emit repaintNeeded();
 +}
++
++
 +void
 +SettingPanel::checkAntiAliasing()
 +{
 +  int index = antiAliasingComboBox_->currentIndex();
 +  auto isMono = index == AntiAliasingComboBoxModel::AntiAliasing_None;
 +  auto isLight
 +    = index == AntiAliasingComboBoxModel::AntiAliasing_Light
 +      || index == AntiAliasingComboBoxModel::AntiAliasing_Light_SubPixel;
 +  auto disableLCD
 +    = index == AntiAliasingComboBoxModel::AntiAliasing_None
 +      || index == AntiAliasingComboBoxModel::AntiAliasing::AntiAliasing_Normal
 +      || isLight;
++
 +  lcdFilterLabel_->setEnabled(!disableLCD);
 +  lcdFilterComboBox_->setEnabled(!disableLCD);
 +  stemDarkeningCheckBox_->setEnabled(isLight);
 +  gammaSlider_->setEnabled(!isMono);
++
 +  emit repaintNeeded();
 +}
++
++
 +void
 +SettingPanel::checkPalette()
 +{
 +  paletteComboBox_->setEnabled(colorLayerCheckBox_->isChecked());
 +  emit repaintNeeded();
 +}
++
++
 +void
 +SettingPanel::checkStemDarkening()
 +{
 +  //if (!comparatorMode_)
 +  //  applyDelayedSettings();
++
 +  emit fontReloadNeeded();
 +}
++
++
 +void
 +SettingPanel::openBackgroundPicker()
 +{
 +  auto result = QColorDialog::getColor(backgroundColor_,
 +                                       this,
 +                                       tr("Background Color"));
 +  if (result.isValid())
 +  {
 +    backgroundColor_ = result;
 +    resetColorBlocks();
 +    emit repaintNeeded();
 +  }
 +}
++
++
 +void
 +SettingPanel::openForegroundPicker()
 +{
 +  auto result = QColorDialog::getColor(foregroundColor_,
 +                                       this,
 +                                       tr("Foreground Color"),
 +                                       QColorDialog::ShowAlphaChannel);
 +  if (result.isValid())
 +  {
 +    foregroundColor_ = result;
 +    resetColorBlocks();
 +    emit repaintNeeded();
 +  }
 +}
++
++
 +void
 +SettingPanel::updateGamma()
 +{
 +  gammaValueLabel_->setText(QString::number(gammaSlider_->value() / 10.0,
 +                           'f',
 +                           1));
 +  emit repaintNeeded();
 +}
++
++
 +void
 +SettingPanel::resetColorBlocks()
 +{
 +  foregroundBlock_->setStyleSheet(
 +    QString("QWidget {background-color: rgba(%1, %2, %3, %4);}")
 +      .arg(foregroundColor_.red())
 +      .arg(foregroundColor_.green())
 +      .arg(foregroundColor_.blue())
 +      .arg(foregroundColor_.alpha()));
 +  backgroundBlock_->setStyleSheet(
 +    QString("QWidget {background-color: rgba(%1, %2, %3, %4);}")
 +      .arg(backgroundColor_.red())
 +      .arg(backgroundColor_.green())
 +      .arg(backgroundColor_.blue())
 +      .arg(backgroundColor_.alpha()));
 +}
++
++
 +void
 +SettingPanel::onFontChanged()
 +{
 +  auto blockState = blockSignals(signalsBlocked());
++
 +  if (engine_->currentFontType() == Engine::FontType_CFF)
 +  {
 +    hintingModeComboBoxModel_->setCurrentEngineType(
 +      HintingModeComboBoxModel::HintingEngineType_CFF, false);
 +    hintingModeComboBox_->setCurrentIndex(currentCFFHintingMode_);
 +  }
 +  else if (engine_->currentFontType() == Engine::FontType_TrueType)
 +  {
 +    // TODO: tricky
 +    hintingModeComboBoxModel_->setCurrentEngineType(
 +      HintingModeComboBoxModel::HintingEngineType_TrueType, false);
 +    hintingModeComboBox_->setCurrentIndex(currentTTInterpreterVersion_);
 +  }
 +  else
 +  {
 +    hintingModeLabel_->setEnabled(false);
 +    hintingModeComboBox_->setEnabled(false);
 +  }
++
 +  checkHinting();
++
 +  //engine_->reloadFont();
 +  //auto hasColor = engine_->currentFontHasColorLayers();
 +  //colorLayerCheckBox_->setEnabled(hasColor);
 +  //if (!hasColor)
 +  //  colorLayerCheckBox_->setChecked(false);
 +  populatePalettes();
 +  //mmgxPanel_->reloadFont();
 +  blockSignals(blockState);
++
 +  // Place this after `blockSignals` to let the signals emitted normally
 +  //auto bmapOnly = engine_->currentFontBitmapOnly();
 +  //embeddedBitmapCheckBox_->setEnabled(
 +  //  !bmapOnly && engine_->currentFontHasEmbeddedBitmap());
 +  //if (bmapOnly)
 +  //  embeddedBitmapCheckBox_->setChecked(true);
 +}
++
++
 +void
 +SettingPanel::applySettings()
 +{
 +  engine_->setLcdFilter(
 +    static_cast<FT_LcdFilter>(lcdFilterComboboxModel_->indexToValue(
 +      lcdFilterComboBox_->currentIndex())));
++
 +  auto aaSettings = antiAliasingComboBoxModel_->indexToValue(
 +    antiAliasingComboBox_->currentIndex());
 +  engine_->setAntiAliasingTarget(aaSettings.loadFlag);
 +  //engine_->setRenderMode(aaSettings.renderMode);
++
 +  //engine_->setAntiAliasingEnabled(antiAliasingComboBox_->currentIndex()
 +  //  != AntiAliasingComboBoxModel::AntiAliasing_None);
 +  engine_->setHinting(hintingCheckBox_->isChecked());
 +  engine_->setAutoHinting(autoHintingCheckBox_->isChecked());
++
 +  if (debugMode_)
 +  {
 +    engine_->setHorizontalHinting(horizontalHintingCheckBox_->isChecked());
 +    engine_->setVerticalHinting(verticalHintingCheckBox_->isChecked());
 +    engine_->setBlueZoneHinting(blueZoneHintingCheckBox_->isChecked());
 +    engine_->setShowSegments(segmentDrawingCheckBox_->isChecked());
 +  }
++
 +  engine_->setGamma(gammaSlider_->value() / 10.0);
++
 +  //engine_->setEmbeddedBitmap(embeddedBitmapCheckBox_->isChecked());
 +  //engine_->setPaletteIndex(paletteComboBox_->currentIndex());
++
 +  //engine_->setUseColorLayer(colorLayerCheckBox_->isChecked());
 +  //engine_->setLCDUsesBGR(aaSettings.isBGR);
 +  //engine_->setLCDSubPixelPositioning(
 +  //  antiAliasingComboBox_->currentIndex()
 +  //    == AntiAliasingComboBoxModel::AntiAliasing_Light_SubPixel);
++
 +  //engine_->renderingEngine()->setForeground(foregroundColor_.rgba());
 +  //engine_->renderingEngine()->setBackground(backgroundColor_.rgba());
 +  //mmgxPanel_->applySettings();
 +}
++
++
 +void
 +SettingPanel::applyDelayedSettings()
 +{
 +  // This must not be combined into `applySettings`:
 +  // those engine manipulations will reset the whole cache!!
 +  // Therefore must only be called when the selection of the combo box actually
 +  // changes a.k.a. QComboBox::activate.
++
 +  int index = hintingModeComboBox_->currentIndex();
++
 +  if (engine_->currentFontType() == Engine::FontType_CFF)
 +  {
 +    engine_->setCFFHintingMode(
 +      hintingModeComboBoxModel_->indexToCFFMode(index));
 +    if (index >= 0)
 +      currentCFFHintingMode_ = index;
 +  }
 +  else if (engine_->currentFontType() == Engine::FontType_TrueType)
 +  {
 +    engine_->setTTInterpreterVersion(
 +      hintingModeComboBoxModel_->indexToTTInterpreterVersion(index));
 +    if (index >= 0)
 +      currentTTInterpreterVersion_ = index;
 +  }
++
 +  //engine_->setStemDarkening(stemDarkeningCheckBox_->isChecked());
 +}
++
++
 +void
 +SettingPanel::createLayout()
 +{
 +  hintingCheckBox_ = new QCheckBox(tr("Hinting"), this);
++
 +  hintingModeLabel_ = new QLabel(tr("Hinting Mode"), this);
 +  hintingModeLabel_->setAlignment(Qt::AlignRight);
++
 +  hintingModeComboBoxModel_ = new HintingModeComboBoxModel(this);
 +  hintingModeComboBox_ = new QComboBox(this);
 +  hintingModeComboBox_->setModel(hintingModeComboBoxModel_);
 +  hintingModeLabel_->setBuddy(hintingModeComboBox_);
++
 +  autoHintingCheckBox_ = new QCheckBox(tr("Auto-Hinting"), this);
 +  stemDarkeningCheckBox_ = new QCheckBox(tr("Stem Darkening"), this);
++
 +  if (debugMode_)
 +  {
 +    horizontalHintingCheckBox_ = new QCheckBox(tr("Horizontal Hinting"), this);
 +    verticalHintingCheckBox_ = new QCheckBox(tr("Vertical Hinting"), this);
 +    blueZoneHintingCheckBox_ = new QCheckBox(tr("Blue-Zone Hinting"), this);
 +    segmentDrawingCheckBox_ = new QCheckBox(tr("Segment Drawing"), this);
 +  }
++
 +  embeddedBitmapCheckBox_ = new QCheckBox(tr("Enable Embedded Bitmap"), this);
 +  colorLayerCheckBox_ = new QCheckBox(tr("Enable Color Layer"), this);
++
 +  antiAliasingLabel_ = new QLabel(tr("Anti-Aliasing"), this);
 +  antiAliasingLabel_->setAlignment(Qt::AlignRight);
++
 +  antiAliasingComboBoxModel_ = new AntiAliasingComboBoxModel(this);
 +  antiAliasingComboBox_ = new QComboBox(this);
 +  antiAliasingComboBox_->setModel(antiAliasingComboBoxModel_);
 +  antiAliasingLabel_->setBuddy(antiAliasingComboBox_);
++
 +  lcdFilterLabel_ = new QLabel(tr("LCD Filter"), this);
 +  lcdFilterLabel_->setAlignment(Qt::AlignRight);
++
 +  lcdFilterComboboxModel_ = new LCDFilterComboBoxModel(this);
 +  lcdFilterComboBox_ = new QComboBox(this);
 +  lcdFilterComboBox_->setModel(lcdFilterComboboxModel_);
 +  lcdFilterLabel_->setBuddy(lcdFilterComboBox_);
++
 +  paletteLabel_ = new QLabel(tr("Palette: "), this);
++
 +  paletteComboBox_ = new QComboBox(this);
 +  paletteLabel_->setBuddy(paletteComboBox_);
++
 +  gammaLabel_ = new QLabel(tr("Gamma"), this);
 +  gammaLabel_->setAlignment(Qt::AlignRight);
 +  gammaSlider_ = new QSlider(Qt::Horizontal, this);
 +  gammaSlider_->setRange(3, 30); // in 1/10th
 +  gammaSlider_->setTickPosition(QSlider::TicksBelow);
 +  gammaSlider_->setTickInterval(5);
 +  gammaSlider_->setPageStep(1);
 +  gammaSlider_->setSingleStep(1);
 +  gammaLabel_->setBuddy(gammaSlider_);
 +  gammaValueLabel_ = new QLabel(this);
++
 +  // TODO: MM/GX
 +  mmgxPanel_ = new QWidget(this);
++
 +  backgroundButton_ = new QPushButton(tr("Background"), this);
 +  foregroundButton_ = new QPushButton(tr("Foreground"), this);
++
 +  backgroundBlock_ = new QFrame(this);
 +  backgroundBlock_->setFrameStyle(QFrame::Box);
 +  backgroundBlock_->setLineWidth(1);
 +  backgroundBlock_->setFixedWidth(18);
++
 +  foregroundBlock_ = new QFrame(this);
 +  foregroundBlock_->setFrameStyle(QFrame::Box);
 +  foregroundBlock_->setLineWidth(1);
 +  foregroundBlock_->setFixedWidth(18);
++
 +  generalTab_ = new QWidget(this);
++
 +  generalTab_->setSizePolicy(QSizePolicy::MinimumExpanding,
 +                             QSizePolicy::MinimumExpanding);
++
 +  tab_ = new QTabWidget(this);
 +  tab_->setSizePolicy(QSizePolicy::MinimumExpanding,
 +                      QSizePolicy::MinimumExpanding);
++
 +  // Tooltips
 +  hintingCheckBox_->setToolTip(tr("Enable hinting a.k.a. grid-fitting."));
 +  hintingModeComboBox_->setToolTip(
 +    tr("Modes not available for current font type will be disabled. No "
 +       "effect when auto-hinting is enabled"));
 +  autoHintingCheckBox_->setToolTip(tr("Enable FreeType Auto-Hinter."));
 +  if (debugMode_)
 +  {
 +    horizontalHintingCheckBox_->setToolTip(tr("(auto-hinter debug option)"));
 +    verticalHintingCheckBox_  ->setToolTip(tr("(auto-hinter debug option)"));
 +    blueZoneHintingCheckBox_  ->setToolTip(tr("(auto-hinter debug option)"));
 +    segmentDrawingCheckBox_   ->setToolTip(tr("(auto-hinter debug option)"));
 +  }
 +  antiAliasingComboBox_->setToolTip(tr("Select anti-aliasing mode."));
 +  lcdFilterComboBox_->setToolTip(
 +    tr("Select LCD filter (only valid when LCD AA is enabled)."));
 +  embeddedBitmapCheckBox_->setToolTip(tr(
 +    "Enable embedded bitmap strikes (force enabled for bitmap-only fonts)."));
 +  stemDarkeningCheckBox_->setToolTip(
 +    tr("Enable stem darkening (only valid for auto-hinter with gamma "
 +       "correction enabled and with Light AA modes)."));
 +  gammaSlider_->setToolTip("Gamma correction value.");
 +  colorLayerCheckBox_->setToolTip(tr("Enable color layer rendering."));
 +  paletteComboBox_->setToolTip(tr("Select color layer palette (only valid when "
 +                                  "any palette exists in the font)."));
 +  backgroundButton_->setToolTip(tr("Set canvas background color."));
 +  foregroundButton_->setToolTip(tr("Set text color."));
++
 +  // Layouting
 +  if (debugMode_)
 +  {
 +    debugLayout_ = new QVBoxLayout;
 +    debugLayout_->setContentsMargins(20, 0, 0, 0);
 +    debugLayout_->addWidget(horizontalHintingCheckBox_);
 +    debugLayout_->addWidget(verticalHintingCheckBox_);
 +    debugLayout_->addWidget(blueZoneHintingCheckBox_);
 +    debugLayout_->addWidget(segmentDrawingCheckBox_);
 +  }
++
 +  gammaLayout_ = new QHBoxLayout;
 +  gammaLayout_->addWidget(gammaLabel_);
 +  gammaLayout_->addWidget(gammaSlider_);
 +  gammaLayout_->addWidget(gammaValueLabel_);
++
 +  colorPickerLayout_ = new QHBoxLayout;
 +  colorPickerLayout_->addWidget(backgroundBlock_);
 +  colorPickerLayout_->addWidget(backgroundButton_, 1);
 +  colorPickerLayout_->addWidget(foregroundButton_, 1);
 +  colorPickerLayout_->addWidget(foregroundBlock_);
++
 +  createLayoutNormal();
 +  // TODO: Comparator mode.
++
 +  mainLayout_ = new QVBoxLayout;
 +  mainLayout_->addWidget(tab_);
 +  setLayout(mainLayout_);
 +  mainLayout_->setContentsMargins(0, 0, 0, 0);
 +  setContentsMargins(0, 0, 0, 0);
 +}
++
++
 +void
 +SettingPanel::createLayoutNormal()
 +{
 +  generalTabLayout_ = new QGridLayout;
++
 +  gridLayout2ColAddWidget(generalTabLayout_, hintingCheckBox_);
 +  gridLayout2ColAddWidget(generalTabLayout_,
 +                          hintingModeLabel_, hintingModeComboBox_);
 +  gridLayout2ColAddWidget(generalTabLayout_, autoHintingCheckBox_);
++
 +  if (debugMode_)
 +    gridLayout2ColAddLayout(generalTabLayout_, debugLayout_);
++
 +  gridLayout2ColAddItem(generalTabLayout_,
 +                        new QSpacerItem(0, 20, QSizePolicy::Minimum,
 +                                        QSizePolicy::MinimumExpanding));
++
 +  gridLayout2ColAddWidget(generalTabLayout_,
 +                          antiAliasingLabel_, antiAliasingComboBox_);
 +  gridLayout2ColAddWidget(generalTabLayout_,
 +                          lcdFilterLabel_, lcdFilterComboBox_);
++
 +  gridLayout2ColAddItem(generalTabLayout_,
 +                        new QSpacerItem(0, 20, QSizePolicy::Minimum,
 +                                        QSizePolicy::MinimumExpanding));
++
 +  gridLayout2ColAddLayout(generalTabLayout_, colorPickerLayout_);
 +  gridLayout2ColAddLayout(generalTabLayout_, gammaLayout_);
 +  gridLayout2ColAddWidget(generalTabLayout_, stemDarkeningCheckBox_);
 +  gridLayout2ColAddWidget(generalTabLayout_, embeddedBitmapCheckBox_);
 +  gridLayout2ColAddWidget(generalTabLayout_, colorLayerCheckBox_);
 +  gridLayout2ColAddWidget(generalTabLayout_,
 +                          paletteLabel_, paletteComboBox_);
++
 +  gridLayout2ColAddItem(generalTabLayout_,
 +                        new QSpacerItem(0, 20, QSizePolicy::Minimum,
 +                                        QSizePolicy::MinimumExpanding));
++
 +  generalTabLayout_->setColumnStretch(1, 1);
 +  generalTab_->setLayout(generalTabLayout_);
++
 +  tab_->addTab(generalTab_, tr("General"));
 +  tab_->addTab(mmgxPanel_, tr("MM/GX"));
++
 +  tab_->setTabToolTip(0, tr("General settings."));
 +  tab_->setTabToolTip(1, tr("MM/GX axis parameters."));
 +}
++
++
 +void
 +SettingPanel::createConnections()
 +{
 +  // use `qOverload` here to prevent ambiguity.
 +  connect(hintingModeComboBox_,
 +          QOverload<int>::of(&QComboBox::currentIndexChanged),
 +          this, &SettingPanel::checkHintingMode);
 +  connect(antiAliasingComboBox_,
 +          QOverload<int>::of(&QComboBox::currentIndexChanged),
 +          this, &SettingPanel::checkAntiAliasing);
 +  connect(lcdFilterComboBox_,
 +          QOverload<int>::of(&QComboBox::currentIndexChanged),
 +          this, &SettingPanel::repaintNeeded);
 +  connect(paletteComboBox_,
 +          QOverload<int>::of(&QComboBox::currentIndexChanged),
 +          this, &SettingPanel::repaintNeeded);
++
 +  connect(gammaSlider_, &QSlider::valueChanged,
 +          this, &SettingPanel::updateGamma);
++
 +  connect(hintingCheckBox_, &QCheckBox::clicked,
 +          this, &SettingPanel::checkHinting);
++
 +  if (debugMode_)
 +  {
 +    connect(horizontalHintingCheckBox_, &QCheckBox::clicked,
 +            this, &SettingPanel::repaintNeeded);
 +    connect(verticalHintingCheckBox_, &QCheckBox::clicked,
 +            this, &SettingPanel::repaintNeeded);
 +    connect(blueZoneHintingCheckBox_, &QCheckBox::clicked,
 +            this, &SettingPanel::repaintNeeded);
 +    connect(segmentDrawingCheckBox_, &QCheckBox::clicked,
 +            this, &SettingPanel::repaintNeeded);
 +  }
++
 +  connect(autoHintingCheckBox_, &QCheckBox::clicked,
 +          this, &SettingPanel::checkAutoHinting);
 +  connect(embeddedBitmapCheckBox_, &QCheckBox::clicked,
 +          this, &SettingPanel::fontReloadNeeded);
 +  connect(stemDarkeningCheckBox_, &QCheckBox::clicked,
 +          this, &SettingPanel::checkStemDarkening);
 +  connect(colorLayerCheckBox_, &QCheckBox::clicked,
 +          this, &SettingPanel::checkPalette);
++
 +  connect(backgroundButton_, &QPushButton::clicked,
 +          this, &SettingPanel::openBackgroundPicker);
 +  connect(foregroundButton_, &QPushButton::clicked,
 +          this, &SettingPanel::openForegroundPicker);
 +}
++
++
 +void
 +SettingPanel::setDefaults()
 +{
 +  Engine::EngineDefaultValues& defaults = engine_->engineDefaults();
++
 +  hintingModeComboBoxModel_->setSupportedModes(
 +    { defaults.ttInterpreterVersionDefault,
 +      defaults.ttInterpreterVersionOther,
 +      defaults.ttInterpreterVersionOther1 },
 +    { defaults.cffHintingEngineDefault,
 +      defaults.cffHintingEngineOther });
++
 +  currentCFFHintingMode_
 +    = hintingModeComboBoxModel_->cffModeToIndex(
 +    defaults.cffHintingEngineDefault);
 +  currentTTInterpreterVersion_
 +    = hintingModeComboBoxModel_->ttInterpreterVersionToIndex(
 +        defaults.ttInterpreterVersionDefault);
++
 +  hintingCheckBox_->setChecked(true);
++
 +  antiAliasingComboBox_->setCurrentIndex(
 +    AntiAliasingComboBoxModel::AntiAliasing_Normal);
 +  lcdFilterComboBox_->setCurrentIndex(
 +    LCDFilterComboBoxModel::LCDFilter_Light);
++
 +  if (debugMode_)
 +  {
 +    horizontalHintingCheckBox_->setChecked(true);
 +    verticalHintingCheckBox_->setChecked(true);
 +    blueZoneHintingCheckBox_->setChecked(true);
 +    embeddedBitmapCheckBox_->setChecked(false);
 +  }
++
 +  colorLayerCheckBox_->setChecked(true);
 +  paletteComboBox_->setEnabled(false);
++
 +  // These need to be set even in Comperator mode.
 +  backgroundColor_ = Qt::white;
 +  foregroundColor_ = Qt::black;
 +  resetColorBlocks();
++
 +  gammaSlider_->setValue(18); // 1.8
 +  updateGamma();
 +}
++
++
 +// end of settingpanel.cpp

src/ftinspect/panels/settingpanel.hpp

 +// settingpanel.hpp
++
 +// Copyright (C) 2022 by Charlie Jiang.
++
 +#pragma once
++
 +#include "../engine/engine.hpp"
 +#include "../models/customcomboboxmodels.hpp"
++
 +#include <QWidget>
 +#include <QTabWidget>
 +#include <QLabel>
 +#include <QComboBox>
 +#include <QCheckBox>
 +#include <QGridLayout>
 +#include <QBoxLayout>
 +#include <QPushButton>
++
 +class SettingPanel
 +: public QWidget
 +{
 +  Q_OBJECT
 +public:
 +  SettingPanel(QWidget* parent, Engine* engine);
 +  ~SettingPanel() override = default;
++
 +  void onFontChanged();
 +  void applySettings();
 +  /*
 +   * When in comparator mode, this is needed to sync the hinting modes when
 +   * reloading the font.
 +   */
 +  void applyDelayedSettings();
++
 +  //////// Getters/Setters
++
 +  int antiAliasingModeIndex();
 +  bool kerningEnabled();
 +  bool lsbRsbDeltaEnabled();
++
 +signals:
 +  void fontReloadNeeded();
 +  void repaintNeeded();
++
 +private:
 +  Engine* engine_;
++
 +  int currentCFFHintingMode_;
 +  int currentTTInterpreterVersion_;
++
 +  bool debugMode_ = false;
++
 +  QTabWidget* tab_;
++
 +  QWidget* generalTab_;
 +  QWidget* hintingRenderingTab_;
 +  //SettingPanelMMGX* mmgxPanel_;
 +  QWidget* mmgxPanel_;
++
 +  QLabel* gammaLabel_;
 +  QLabel* gammaValueLabel_;
 +  QLabel* antiAliasingLabel_;
 +  QLabel* hintingModeLabel_;
 +  QLabel* lcdFilterLabel_;
 +  QLabel* paletteLabel_;
++
 +  QCheckBox* hintingCheckBox_;
 +  QCheckBox* horizontalHintingCheckBox_;
 +  QCheckBox* verticalHintingCheckBox_;
 +  QCheckBox* blueZoneHintingCheckBox_;
 +  QCheckBox* segmentDrawingCheckBox_;
 +  QCheckBox* autoHintingCheckBox_;
 +  QCheckBox* stemDarkeningCheckBox_;
 +  QCheckBox* embeddedBitmapCheckBox_;
 +  QCheckBox* colorLayerCheckBox_;
 +  QCheckBox* kerningCheckBox_;
 +  QCheckBox* lsbRsbDeltaCheckBox_;
++
 +  AntiAliasingComboBoxModel* antiAliasingComboBoxModel_;
 +  HintingModeComboBoxModel* hintingModeComboBoxModel_;
 +  LCDFilterComboBoxModel* lcdFilterComboboxModel_;
++
 +  QComboBox* hintingModeComboBox_;
 +  QComboBox* antiAliasingComboBox_;
 +  QComboBox* lcdFilterComboBox_;
 +  QComboBox* paletteComboBox_;
++
 +  QSlider* gammaSlider_;
++
 +  QPushButton* backgroundButton_;
 +  QPushButton* foregroundButton_;
 +  QFrame* backgroundBlock_;
 +  QFrame* foregroundBlock_;
++
 +  QVBoxLayout* mainLayout_;
 +  QGridLayout* generalTabLayout_;
 +  QGridLayout* hintingRenderingTabLayout_;
 +  QVBoxLayout* debugLayout_;
 +  QHBoxLayout* gammaLayout_;
 +  QHBoxLayout* colorPickerLayout_;
++
 +  QColor backgroundColor_;
 +  QColor foregroundColor_;
++
 +  //////// Initializing funcs
++
 +  void createConnections();
 +  void createLayout();
 +  void createLayoutNormal();
 +  void setDefaults();
++
 +  //////// Other funcs
++
 +  void populatePalettes();
++
 +  void checkAllSettings();
 +  void checkHinting();
 +  void checkHintingMode();
 +  void checkAutoHinting();
 +  void checkAntiAliasing();
 +  void checkPalette();
 +  void checkStemDarkening();
++
 +  void openBackgroundPicker();
 +  void openForegroundPicker();
 +  void updateGamma();
 +  void resetColorBlocks();
 +};
++
++
 +// end of settingpanel.hpp

src/ftinspect/panels/singular.cpp

 +// singular.cpp
++
 +// Copyright (C) 2022 by Charlie Jiang.
++
 +#include "singular.hpp"
++
 +#include <QSizePolicy>
 +#include <QToolTip>
 +#include <QWheelEvent>
++
++
 +SingularTab::SingularTab(QWidget* parent, Engine* engine)
 +: QWidget(parent), engine_(engine),
 +  graphicsDefault_(GraphicsDefault::deafultInstance())
 +{
 +  createLayout();
 +  createConnections();
++
 +  currentGlyphIndex_ = 0;
 +  setDefaults();
 +  checkShowPoints();
 +}
++
++
 +SingularTab::~SingularTab()
 +{
 +  delete gridItem_;
 +  gridItem_ = NULL;
 +}
++
++
 +void
 +SingularTab::setGlyphIndex(int index)
 +{
 +  // only adjust current glyph index if we have a valid font
 +  if (currentGlyphCount_ <= 0)
 +    return;
++
 +  currentGlyphIndex_ = qBound(0, index, currentGlyphCount_ - 1);
++
 +  QString upperHex = QString::number(currentGlyphIndex_, 16).toUpper();
 +  glyphIndexLabel_->setText(
 +      QString("%1 (0x%2)").arg(currentGlyphIndex_).arg(upperHex));
 +  glyphNameLabel_->setText(engine_->glyphName(currentGlyphIndex_));
++
 +  drawGlyph();
 +}
++
++
 +void
 +SingularTab::drawGlyph()
 +{
 +  // the call to `engine->loadOutline' updates FreeType's load flags
++
 +  if (!engine_)
 +    return;
++
 +  if (currentGlyphBitmapItem_)
 +  {
 +    glyphScene_->removeItem(currentGlyphBitmapItem_);
 +    delete currentGlyphBitmapItem_;
++
 +    currentGlyphBitmapItem_ = NULL;
 +  }
++
 +  if (currentGlyphOutlineItem_)
 +  {
 +    glyphScene_->removeItem(currentGlyphOutlineItem_);
 +    delete currentGlyphOutlineItem_;
++
 +    currentGlyphOutlineItem_ = NULL;
 +  }
++
 +  if (currentGlyphPointsItem_)
 +  {
 +    glyphScene_->removeItem(currentGlyphPointsItem_);
 +    delete currentGlyphPointsItem_;
++
 +    currentGlyphPointsItem_ = NULL;
 +  }
++
 +  if (currentGlyphPointNumbersItem_)
 +  {
 +    glyphScene_->removeItem(currentGlyphPointNumbersItem_);
 +    delete currentGlyphPointNumbersItem_;
++
 +    currentGlyphPointNumbersItem_ = NULL;
 +  }
++
 +  // TODO refactor engine.
 +  //glyphView_->setBackgroundBrush(
 +  //  QColor(engine_->renderingEngine()->background()));
++
 +  applySettings();
 +  FT_Glyph glyph = NULL; // TODO: refactor engine!
 +  //FT_Glyph glyph = engine_->loadGlyph(currentGlyphIndex_);
 +  if (glyph)
 +  {
 +    if (showBitmapCheckBox_->isChecked())
 +    {
 +      currentGlyphBitmapItem_
 +        = new GlyphBitmap(currentGlyphIndex_,
 +                          glyph,
 +                          engine_);
 +      currentGlyphBitmapItem_->setZValue(-1);
 +      glyphScene_->addItem(currentGlyphBitmapItem_);
 +    }
++
 +    if (showOutlinesCheckBox_->isChecked())
 +    {
 +      currentGlyphOutlineItem_ = new GlyphOutline(graphicsDefault_->outlinePen,
 +                                                  glyph);
 +      currentGlyphOutlineItem_->setZValue(1);
 +      glyphScene_->addItem(currentGlyphOutlineItem_);
 +    }
++
 +    if (showPointsCheckBox_->isChecked())
 +    {
 +      currentGlyphPointsItem_ = new GlyphPoints(graphicsDefault_->onPen,
 +                                                graphicsDefault_->offPen,
 +                                                glyph);
 +      currentGlyphPointsItem_->setZValue(1);
 +      glyphScene_->addItem(currentGlyphPointsItem_);
++
 +      if (showPointNumbersCheckBox_->isChecked())
 +      {
 +        currentGlyphPointNumbersItem_
 +          = new GlyphPointNumbers(graphicsDefault_->onPen,
 +                                  graphicsDefault_->offPen,
 +                                  glyph);
 +        currentGlyphPointNumbersItem_->setZValue(1);
 +        glyphScene_->addItem(currentGlyphPointNumbersItem_);
 +      }
 +    }
 +  }
++
 +  glyphScene_->update();
 +}
++
++
 +void
 +SingularTab::checkShowPoints()
 +{
 +  if (showPointsCheckBox_->isChecked())
 +    showPointNumbersCheckBox_->setEnabled(true);
 +  else
 +    showPointNumbersCheckBox_->setEnabled(false);
 +  drawGlyph();
 +}
++
++
 +void
 +SingularTab::zoom()
 +{
 +  int scale = static_cast<int>(sizeSelector_->zoomFactor());
++
 +  QTransform transform;
 +  transform.scale(scale, scale);
++
 +  // we want horizontal and vertical 1px lines displayed with full pixels;
 +  // we thus have to shift the coordinate system accordingly, using a value
 +  // that represents 0.5px (i.e., half the 1px line width) after the scaling
 +  qreal shift = 0.5 / scale;
 +  transform.translate(shift, shift);
++
 +  glyphView_->setTransform(transform);
 +  updateGrid();
 +}
++
++
 +void
 +SingularTab::backToCenter()
 +{
 +  glyphView_->centerOn(0, 0);
 +  if (currentGlyphBitmapItem_)
 +    glyphView_->ensureVisible(currentGlyphBitmapItem_);
 +  else if (currentGlyphPointsItem_)
 +    glyphView_->ensureVisible(currentGlyphPointsItem_);
++
 +  updateGrid();
 +}
++
++
 +void
 +SingularTab::updateGrid()
 +{
 +  if (gridItem_)
 +    gridItem_->updateRect();
 +}
++
++
 +void
 +SingularTab::wheelZoom(QWheelEvent* event)
 +{
 +  int numSteps = event->angleDelta().y() / 120;
 +  sizeSelector_->handleWheelZoomBySteps(numSteps);
 +  // TODO: Zoom relative to viewport left-bottom?
 +}
++
++
 +void
 +SingularTab::wheelResize(QWheelEvent* event)
 +{
 +  sizeSelector_->handleWheelResizeFromGrid(event);
 +}
++
++
 +void
 +SingularTab::setGridVisible()
 +{
 +  gridItem_->setShowGrid(showGridCheckBox_->isChecked(),
 +                         showAuxLinesCheckBox_->isChecked());
 +}
++
++
 +void
 +SingularTab::showToolTip()
 +{
 +  QToolTip::showText(mapToGlobal(helpButton_->pos()),
 +                     tr("Scroll: Grid Up/Down\n"
 +                        "Alt + Scroll: Grid Left/Right\n"
 +                        "Ctrl + Scroll: Adjust Zoom (Relative to cursor)\n"
 +                        "Shift + Scroll: Adjust Font Size\n"
 +                        "Shift + Plus/Minus: Adjust Font Size\n"
 +                        "Shift + 0: Reset Font Size to Default"),
 +                     helpButton_);
 +}
++
++
 +bool
 +SingularTab::eventFilter(QObject* watched,
 +                         QEvent* event)
 +{
 +  if (event->type() == QEvent::KeyPress)
 +  {
 +    auto keyEvent = dynamic_cast<QKeyEvent*>(event);
 +    if (sizeSelector_->handleKeyEvent(keyEvent))
 +      return true;
 +  }
 +  return false;
 +}
++
++
 +void
 +SingularTab::resizeEvent(QResizeEvent* event)
 +{
 +  QWidget::resizeEvent(event);
++
 +  // Tricky part: when loading, this method will be called twice. Only at the
 +  // second time the initial layouting is done, thus the result of `centerOn`
 +  // can be valid.
 +  // We want to only center the midpoint of the size when the program starts up
 +  // so we use a counter to track the status.
 +  if (initialPositionSetCount_ <= 0)
 +    return;
 +  initialPositionSetCount_--;
++
 +  // The code below mainly:
 +  // 1. Center the grid on the the center point of the ppem x ppem bbox.
 +  // 2. Adjust the viewport zoom to fit the ppem x ppem bbox
 +  updateGeometry();
 +  auto size = sizeSelector_->selectedSize();
 +  auto unit = sizeSelector_->selectedUnit();
 +  if (unit == FontSizeSelector::Units_pt)
 +  {
 +    sizeSelector_->applyToEngine(engine_);
 +    auto dpi = engine_->dpi();
 +    size = size * dpi / 72.0;
 +  }
 +  glyphView_->centerOn(size / 2, -size / 2);
++
 +  auto viewSize = glyphView_->size();
 +  auto minViewSide = std::min(viewSize.height(), viewSize.width());
 +  sizeSelector_->setZoomFactor(static_cast<int>(minViewSide / size * 0.7));
 +}
++
++
 +void
 +SingularTab::createLayout()
 +{
 +  glyphScene_ = new QGraphicsScene(this);
++
 +  currentGlyphBitmapItem_ = NULL;
 +  currentGlyphOutlineItem_ = NULL;
 +  currentGlyphPointsItem_ = NULL;
 +  currentGlyphPointNumbersItem_ = NULL;
++
 +  glyphView_ = new QGraphicsViewx(this);
 +  glyphView_->setRenderHint(QPainter::Antialiasing, true);
 +  glyphView_->setAcceptDrops(false);
 +  glyphView_->setDragMode(QGraphicsView::ScrollHandDrag);
 +  glyphView_->setOptimizationFlags(QGraphicsView::DontSavePainterState);
 +  glyphView_->setViewportUpdateMode(QGraphicsView::SmartViewportUpdate);
 +  glyphView_->setTransformationAnchor(QGraphicsView::AnchorUnderMouse);
 +  glyphView_->setScene(glyphScene_);
 +  glyphView_->setBackgroundBrush(Qt::white);
++
 +  gridItem_ = new Grid(glyphView_);
 +  glyphScene_->addItem(gridItem_);
++
 +  // Don't use QGraphicsTextItem: We want this hint to be anchored at the
 +  // top-left corner.
 +  auto overlayFont = font();
 +  overlayFont.setPixelSize(24);
++
 +  glyphIndexLabel_ = new QLabel(glyphView_);
 +  glyphNameLabel_ = new QLabel(glyphView_);
 +  glyphIndexLabel_->setFont(overlayFont);
 +  glyphNameLabel_->setFont(overlayFont);
 +  glyphIndexLabel_->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum);
 +  glyphNameLabel_->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum);
 +  glyphIndexLabel_->setAttribute(Qt::WA_TransparentForMouseEvents, true);
 +  glyphNameLabel_->setAttribute(Qt::WA_TransparentForMouseEvents, true);
++
 +  glyphIndexLabel_->setStyleSheet("QLabel { color : black; }");
 +  glyphNameLabel_->setStyleSheet("QLabel { color : black; }");
++
 +  indexSelector_ = new GlyphIndexSelector(this);
 +  indexSelector_->setSingleMode(true);
++
 +  sizeSelector_ = new FontSizeSelector(this, false, false);
++
 +  centerGridButton_ = new QPushButton("Go Back to Grid Center", this);
 +  helpButton_ = new QPushButton("?", this);
 +  helpButton_->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Maximum);
++
 +  showBitmapCheckBox_ = new QCheckBox(tr("Show Bitmap"), this);
 +  showPointsCheckBox_ = new QCheckBox(tr("Show Points"), this);
 +  showPointNumbersCheckBox_ = new QCheckBox(tr("Show Point Numbers"), this);
 +  showOutlinesCheckBox_ = new QCheckBox(tr("Show Outlines"), this);
 +  showGridCheckBox_ = new QCheckBox(tr("Show Grid"), this);
 +  showAuxLinesCheckBox_ = new QCheckBox(tr("Show Aux. Lines"), this);
++
 +  // Tooltips
 +  centerGridButton_->setToolTip(tr(
 +    "Move the viewport so the origin point is at the center of the view."));
 +  showBitmapCheckBox_->setToolTip(tr("Show glyph bitmap."));
 +  showPointsCheckBox_->setToolTip(
 +    tr("Show control points (only valid when the glyph is an outline glyph)."));
 +  showPointNumbersCheckBox_->setToolTip(
 +    tr("Show point numbers (only available when points are shown)."));
 +  showOutlinesCheckBox_->setToolTip(tr("Show (vector) outline (only valid when "
 +                                       "the glyph is an outline glyph)."));
 +  showGridCheckBox_->setToolTip(tr("Show grid lines (x axis: baseline)."));
 +  showBitmapCheckBox_->setToolTip(
 +    tr("Show auxiliary lines (blue: y-advance; red: ascender/descender)."));
 +  helpButton_->setToolTip(tr("View scroll help"));
++
 +  // Layouting
 +  indexHelpLayout_ = new QHBoxLayout;
 +  indexHelpLayout_->addWidget(indexSelector_, 1);
 +  indexHelpLayout_->addWidget(helpButton_);
++
 +  sizeLayout_ = new QHBoxLayout;
 +  sizeLayout_->addStretch(2);
 +  sizeLayout_->addWidget(sizeSelector_, 4);
 +  sizeLayout_->addStretch(1);
 +  sizeLayout_->addWidget(centerGridButton_);
 +  sizeLayout_->addStretch(2);
++
 +  checkBoxesLayout_ = new QHBoxLayout;
 +  checkBoxesLayout_->setSpacing(10);
 +  checkBoxesLayout_->addWidget(showBitmapCheckBox_);
 +  checkBoxesLayout_->addWidget(showPointsCheckBox_);
 +  checkBoxesLayout_->addWidget(showPointNumbersCheckBox_);
 +  checkBoxesLayout_->addWidget(showOutlinesCheckBox_);
 +  checkBoxesLayout_->addWidget(showGridCheckBox_);
 +  checkBoxesLayout_->addWidget(showAuxLinesCheckBox_);
++
 +  glyphOverlayIndexLayout_ = new QHBoxLayout;
 +  glyphOverlayIndexLayout_->addWidget(glyphIndexLabel_);
 +  glyphOverlayIndexLayout_->addWidget(glyphNameLabel_);
 +  glyphOverlayLayout_ = new QGridLayout; // use a grid layout to align
 +  glyphOverlayLayout_->addLayout(glyphOverlayIndexLayout_, 0, 1,
 +                                 Qt::AlignTop | Qt::AlignRight);
 +  glyphView_->setLayout(glyphOverlayLayout_);
++
 +  mainLayout_ = new QVBoxLayout;
 +  mainLayout_->addWidget(glyphView_);
 +  mainLayout_->addLayout(indexHelpLayout_);
 +  mainLayout_->addSpacing(10);
 +  mainLayout_->addLayout(sizeLayout_);
 +  mainLayout_->addLayout(checkBoxesLayout_);
 +  mainLayout_->addSpacing(10);
++
 +  setLayout(mainLayout_);
 +}
++
++
 +void
 +SingularTab::createConnections()
 +{
 +  connect(sizeSelector_, &FontSizeSelector::valueChanged,
 +          this, &SingularTab::repaintGlyph);
 +  connect(indexSelector_, &GlyphIndexSelector::currentIndexChanged,
 +          this, &SingularTab::setGlyphIndex);
++
 +  connect(glyphView_, &QGraphicsViewx::shiftWheelEvent,
 +          this, &SingularTab::wheelResize);
 +  connect(glyphView_, &QGraphicsViewx::ctrlWheelEvent,
 +          this, &SingularTab::wheelZoom);
 +  // Use `updateGrid` to support infinite panning.
 +  connect(glyphView_->horizontalScrollBar(), &QScrollBar::valueChanged,
 +          this, &SingularTab::updateGrid);
 +  connect(glyphView_->verticalScrollBar(), &QScrollBar::valueChanged,
 +          this, &SingularTab::updateGrid);
++
 +  connect(centerGridButton_, &QPushButton::clicked,
 +          this, &SingularTab::backToCenter);
 +  connect(helpButton_, &QPushButton::clicked,
 +          this, &SingularTab::showToolTip);
++
 +  connect(showBitmapCheckBox_, &QCheckBox::clicked,
 +          this, &SingularTab::drawGlyph);
 +  connect(showPointsCheckBox_, &QCheckBox::clicked,
 +          this, &SingularTab::checkShowPoints);
 +  connect(showPointNumbersCheckBox_, &QCheckBox::clicked,
 +          this, &SingularTab::drawGlyph);
 +  connect(showOutlinesCheckBox_, &QCheckBox::clicked,
 +          this, &SingularTab::drawGlyph);
 +  connect(showGridCheckBox_, &QCheckBox::clicked,
 +          this, &SingularTab::setGridVisible);
 +  connect(showAuxLinesCheckBox_, &QCheckBox::clicked,
 +          this, &SingularTab::setGridVisible);
++
 +  sizeSelector_->installEventFilterForWidget(glyphView_);
 +  sizeSelector_->installEventFilterForWidget(this);
 +}
++
++
 +void
 +SingularTab::repaintGlyph()
 +{
 +  zoom();
 +  drawGlyph();
 +}
++
++
 +void
 +SingularTab::reloadFont()
 +{
 +  currentGlyphCount_ = engine_->currentFontNumberOfGlyphs();
 +  indexSelector_->setMinMax(0, currentGlyphCount_);
 +  {
 +    QSignalBlocker blocker(sizeSelector_);
 +    sizeSelector_->reloadFromFont(engine_);
 +  }
 +  drawGlyph();
 +}
++
++
 +void
 +SingularTab::setCurrentGlyphAndSize(int glyphIndex,
 +                                    double sizePoint)
 +{
 +  if (sizePoint >= 0)
 +    sizeSelector_->setSizePoint(sizePoint);
 +  indexSelector_->setCurrentIndex(glyphIndex); // this will auto trigger update
 +}
++
++
 +int
 +SingularTab::currentGlyph()
 +{
 +  return indexSelector_->currentIndex();
 +}
++
++
 +void
 +SingularTab::applySettings()
 +{
 +  sizeSelector_->applyToEngine(engine_);
 +}
++
++
 +void
 +SingularTab::setDefaults()
 +{
 +  currentGlyphIndex_ = 0;
++
 +  showBitmapCheckBox_->setChecked(true);
 +  showOutlinesCheckBox_->setChecked(true);
 +  showGridCheckBox_->setChecked(true);
 +  showAuxLinesCheckBox_->setChecked(true);
 +  gridItem_->setShowGrid(true, true);
++
 +  indexSelector_->setCurrentIndex(indexSelector_->currentIndex(), true);
 +  zoom();
 +}
++
++
 +// end of singular.cpp

src/ftinspect/panels/singular.hpp

 +// singular.hpp
++
 +// Copyright (C) 2022 by Charlie Jiang.
++
 +#pragma once
++
 +#include "abstracttab.hpp"
 +#include "../widgets/customwidgets.hpp"
 +#include "../widgets/glyphindexselector.hpp"
 +#include "../widgets/fontsizeselector.hpp"
 +#include "../glyphcomponents/glyphbitmap.hpp"
 +#include "../glyphcomponents/glyphoutline.hpp"
 +#include "../glyphcomponents/glyphpointnumbers.hpp"
 +#include "../glyphcomponents/glyphpoints.hpp"
 +#include "../glyphcomponents/grid.hpp"
 +#include "../glyphcomponents/graphicsdefault.hpp"
 +#include "../engine/engine.hpp"
 +#include "../models/customcomboboxmodels.hpp"
++
 +#include <QWidget>
 +#include <QPushButton>
 +#include <QSpinBox>
 +#include <QGraphicsScene>
 +#include <QGraphicsView>
 +#include <QScrollBar>
 +#include <QLabel>
 +#include <QComboBox>
 +#include <QPen>
 +#include <QCheckBox>
 +#include <QVector>
 +#include <QGridLayout>
 +#include <QBoxLayout>
++
 +class SingularTab
 +: public QWidget, public AbstractTab
 +{
 +  Q_OBJECT
 +public:
 +  SingularTab(QWidget* parent, Engine* engine);
 +  ~SingularTab() override;
++
 +  void repaintGlyph() override;
 +  void reloadFont() override;
 +  // when sizePoint <= 0, the size remains unchanged.
 +  void setCurrentGlyphAndSize(int glyphIndex, double sizePoint);
 +  int currentGlyph();
++
 +private slots:
 +  void setGlyphIndex(int);
 +  void drawGlyph();
++
 +  void checkShowPoints();
++
 +  void zoom();
 +  void backToCenter();
 +  void wheelZoom(QWheelEvent* event);
 +  void wheelResize(QWheelEvent* event);
 +  void setGridVisible();
 +  void showToolTip();
++
 +protected:
 +  bool eventFilter(QObject* watched, QEvent* event) override;
 +  void resizeEvent(QResizeEvent* event) override;
++
 +private:
 +  int currentGlyphIndex_;
 +  int currentGlyphCount_;
++
 +  Engine* engine_;
++
 +  QGraphicsScene* glyphScene_;
 +  QGraphicsViewx* glyphView_;
++
 +  GlyphOutline* currentGlyphOutlineItem_;
 +  GlyphPoints* currentGlyphPointsItem_;
 +  GlyphPointNumbers* currentGlyphPointNumbersItem_;
 +  GlyphBitmap* currentGlyphBitmapItem_;
 +  Grid* gridItem_ = NULL;
++
 +  GlyphIndexSelector* indexSelector_;
 +  FontSizeSelector* sizeSelector_;
 +  QPushButton* centerGridButton_;
 +  QPushButton* helpButton_;
++
 +  QLabel* glyphIndexLabel_;
 +  QLabel* glyphNameLabel_;
++
 +  QCheckBox* showBitmapCheckBox_;
 +  QCheckBox* showOutlinesCheckBox_;
 +  QCheckBox* showPointNumbersCheckBox_;
 +  QCheckBox* showPointsCheckBox_;
 +  QCheckBox* showGridCheckBox_;
 +  QCheckBox* showAuxLinesCheckBox_;
++
 +  QVBoxLayout* mainLayout_;
 +  QHBoxLayout* checkBoxesLayout_;
 +  QHBoxLayout* indexHelpLayout_;
 +  QHBoxLayout* sizeLayout_;
 +  QGridLayout* glyphOverlayLayout_;
 +  QHBoxLayout* glyphOverlayIndexLayout_;
++
 +  GraphicsDefault* graphicsDefault_;
++
 +  int initialPositionSetCount_ = 2; // see `resizeEvent`
++
 +  void createLayout();
 +  void createConnections();
++
 +  void updateGrid();
 +  void applySettings();
 +  void setDefaults();
 +};
++
 +// end of singular.hpp

src/ftinspect/widgets/fontsizeselector.cpp

 +// fontsizeselector.cpp
++
 +// Copyright (C) 2022 by Charlie Jiang.
++
 +#include "fontsizeselector.hpp"
++
 +#include "../engine/engine.hpp"
++
 +#include <algorithm>
++
 +FontSizeSelector::FontSizeSelector(QWidget* parent,
 +                                   bool zoomNewLine,
 +                                   bool continuousView)
 +: QWidget(parent), continuousView_(continuousView)
 +{
 +  createLayout(zoomNewLine);
 +  createConnections();
 +  setDefaults();
 +}
++
++
 +double
 +FontSizeSelector::selectedSize()
 +{
 +  return sizeDoubleSpinBox_->value();
 +}
++
++
 +FontSizeSelector::Units
 +FontSizeSelector::selectedUnit()
 +{
 +  return static_cast<Units>(unitsComboBox_->currentIndex());
 +}
++
++
 +double
 +FontSizeSelector::zoomFactor()
 +{
 +  if (continuousView_)
 +    return zoomSpinBox_->value();
 +  return static_cast<int>(zoomSpinBox_->value());
 +}
++
++
 +void
 +FontSizeSelector::setSizePixel(int sizePixel)
 +{
 +  sizeDoubleSpinBox_->setValue(sizePixel);
 +  unitsComboBox_->setCurrentIndex(Units_px);
 +}
++
++
 +void
 +FontSizeSelector::setSizePoint(double sizePoint)
 +{
 +  sizeDoubleSpinBox_->setValue(sizePoint);
 +  unitsComboBox_->setCurrentIndex(Units_pt);
 +}
++
++
 +void
 +FontSizeSelector::setZoomFactor(double zoomFactor)
 +{
 +  if (continuousView_)
 +    zoomSpinBox_->setValue(zoomFactor);
 +  zoomSpinBox_->setValue(static_cast<int>(zoomFactor));
 +}
++
++
 +void
 +FontSizeSelector::reloadFromFont(Engine* engine)
 +{
 +  // TODO: update available sizes.
 +  checkFixedSizeAndEmit();
 +}
++
++
 +void
 +FontSizeSelector::applyToEngine(Engine* engine)
 +{
 +  // Spinbox value cannot become negative
 +  engine->setDPI(dpiSpinBox_->value());
++
 +  if (unitsComboBox_->currentIndex() == Units_px)
 +    engine->setSizeByPixel(sizeDoubleSpinBox_->value());
 +  else
 +    engine->setSizeByPoint(sizeDoubleSpinBox_->value());
 +}
++
++
 +void
 +FontSizeSelector::handleWheelResizeBySteps(int steps)
 +{
 +  double sizeAfter = sizeDoubleSpinBox_->value()
 +                       + steps * sizeDoubleSpinBox_->singleStep();
 +  sizeAfter = std::max(sizeDoubleSpinBox_->minimum(),
 +                       std::min(sizeAfter, sizeDoubleSpinBox_->maximum()));
 +  sizeDoubleSpinBox_->setValue(sizeAfter);
 +}
++
++
 +void
 +FontSizeSelector::handleWheelZoomBySteps(int steps)
 +{
 +  double zoomAfter = zoomSpinBox_->value()
 +                     + steps * zoomSpinBox_->singleStep();
 +  zoomAfter = std::max(zoomSpinBox_->minimum(),
 +                       std::min(zoomAfter, zoomSpinBox_->maximum()));
 +  zoomSpinBox_->setValue(zoomAfter);
 +}
++
++
 +void
 +FontSizeSelector::handleWheelResizeFromGrid(QWheelEvent* event)
 +{
 +  int numSteps = event->angleDelta().y() / 120;
 +  handleWheelResizeBySteps(numSteps);
 +}
++
++
 +bool
 +FontSizeSelector::handleKeyEvent(QKeyEvent const* keyEvent)
 +{
 +  if (!keyEvent)
 +    return false;
 +  auto modifiers = keyEvent->modifiers();
 +  auto key = keyEvent->key();
 +  if ((modifiers == Qt::ShiftModifier
 +       || modifiers == (Qt::ShiftModifier | Qt::KeypadModifier))
 +      && (key == Qt::Key_Plus
 +          || key == Qt::Key_Minus
 +          || key == Qt::Key_Underscore
 +          || key == Qt::Key_Equal
 +          || key == Qt::Key_ParenRight))
 +  {
 +    if (key == Qt::Key_Plus || key == Qt::Key_Equal)
 +      handleWheelResizeBySteps(1);
 +    else if (key == Qt::Key_Minus
 +             || key == Qt::Key_Underscore)
 +      handleWheelResizeBySteps(-1);
 +    else if (key == Qt::Key_ParenRight)
 +      setDefaults(true);
 +    return true;
 +  }
 +  return false;
 +}
++
++
 +void
 +FontSizeSelector::installEventFilterForWidget(QWidget* widget)
 +{
 +  widget->installEventFilter(this);
 +}
++
++
 +bool
 +FontSizeSelector::eventFilter(QObject* watched,
 +                              QEvent* event)
 +{
 +  if (event->type() == QEvent::KeyPress)
 +  {
 +    auto keyEvent = dynamic_cast<QKeyEvent*>(event);
 +    if (handleKeyEvent(keyEvent))
 +      return true;
 +  }
 +  return QWidget::eventFilter(watched, event);
 +}
++
++
 +void
 +FontSizeSelector::checkUnits()
 +{
 +  int index = unitsComboBox_->currentIndex();
++
 +  if (index == Units_px)
 +  {
 +    dpiLabel_->setEnabled(false);
 +    dpiSpinBox_->setEnabled(false);
 +    sizeDoubleSpinBox_->setSingleStep(1);
++
 +    QSignalBlocker blocker(sizeDoubleSpinBox_);
 +    sizeDoubleSpinBox_->setValue(qRound(sizeDoubleSpinBox_->value()));
 +  }
 +  else
 +  {
 +    dpiLabel_->setEnabled(true);
 +    dpiSpinBox_->setEnabled(true);
 +    sizeDoubleSpinBox_->setSingleStep(0.5);
 +  }
++
 +  emit valueChanged();
 +}
++
++
 +void
 +FontSizeSelector::createLayout(bool zoomNewLine)
 +{
 +  sizeLabel_ = new QLabel(tr("Size "), this);
 +  sizeLabel_->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
 +  sizeDoubleSpinBox_ = new QDoubleSpinBox(this);
 +  sizeDoubleSpinBox_->setAlignment(Qt::AlignRight);
 +  sizeDoubleSpinBox_->setDecimals(1);
 +  sizeDoubleSpinBox_->setRange(1, 500);
 +  sizeLabel_->setBuddy(sizeDoubleSpinBox_);
++
 +  unitsComboBox_ = new QComboBox(this);
 +  unitsComboBox_->insertItem(Units_px, "px");
 +  unitsComboBox_->insertItem(Units_pt, "pt");
++
 +  dpiLabel_ = new QLabel(tr("DPI "), this);
 +  dpiLabel_->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
 +  dpiSpinBox_ = new QSpinBox(this);
 +  dpiSpinBox_->setAlignment(Qt::AlignRight);
 +  dpiSpinBox_->setRange(10, 600);
 +  dpiLabel_->setBuddy(dpiSpinBox_);
++
 +  zoomLabel_ = new QLabel(tr("Zoom Factor "), this);
 +  zoomLabel_->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
 +  zoomSpinBox_ = new ZoomSpinBox(this, continuousView_);
 +  zoomSpinBox_->setAlignment(Qt::AlignRight);
 +  zoomLabel_->setBuddy(zoomSpinBox_);
++
 +  // Tooltips
 +  sizeDoubleSpinBox_->setToolTip(
 +    tr("Size value (will be limited to available sizes if\nthe current font "
 +       "is not scalable)."));
 +  unitsComboBox_->setToolTip(tr("Unit for the size value (force to pixel if\n"
 +                                "the current font is not scalable)."));
 +  dpiSpinBox_->setToolTip(
 +    tr("DPI for the point size value (only valid when the unit is point)."));
 +  zoomSpinBox_->setToolTip(tr("Adjust zoom."));
++
 +  // Layouting
 +  mainLayout_ = new QVBoxLayout;
 +  upLayout_ = new QHBoxLayout;
 +  upLayout_->addStretch(1);
 +  upLayout_->addWidget(sizeLabel_);
 +  upLayout_->addWidget(sizeDoubleSpinBox_);
 +  upLayout_->addWidget(unitsComboBox_);
 +  upLayout_->addStretch(1);
 +  upLayout_->addWidget(dpiLabel_);
 +  upLayout_->addWidget(dpiSpinBox_);
 +  upLayout_->addStretch(1);
 +  if (!zoomNewLine)
 +  {
 +    upLayout_->addWidget(zoomLabel_);
 +    upLayout_->addWidget(zoomSpinBox_);
 +    upLayout_->addStretch(1);
 +    mainLayout_->addLayout(upLayout_);
 +  }
 +  else
 +  {
 +    downLayout_ = new QHBoxLayout;
 +    downLayout_->addWidget(zoomLabel_);
 +    downLayout_->addWidget(zoomSpinBox_, 1);
 +    mainLayout_->addLayout(upLayout_);
 +    mainLayout_->addLayout(downLayout_);
 +  }
++
 +  setLayout(mainLayout_);
 +  setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
 +}
++
++
 +void
 +FontSizeSelector::createConnections()
 +{
 +  connect(sizeDoubleSpinBox_, QOverload<double>::of(&QDoubleSpinBox::valueChanged),
 +          this, &FontSizeSelector::checkFixedSizeAndEmit);
 +  connect(unitsComboBox_, QOverload<int>::of(&QComboBox::currentIndexChanged),
 +          this, &FontSizeSelector::checkUnits);
 +  connect(dpiSpinBox_, QOverload<int>::of(&QSpinBox::valueChanged),
 +          this, &FontSizeSelector::checkFixedSizeAndEmit);
 +  connect(zoomSpinBox_, QOverload<double>::of(&ZoomSpinBox::valueChanged),
 +          this, &FontSizeSelector::valueChanged);
 +}
++
++
 +void
 +FontSizeSelector::setDefaults(bool sizeOnly)
 +{
 +  lastValue_ = 20;
 +  sizeDoubleSpinBox_->setValue(lastValue_);
 +  if (sizeOnly)
 +    return;
 +  dpiSpinBox_->setValue(96);
 +  checkUnits();
 +}
++
++
 +void
 +FontSizeSelector::checkFixedSizeAndEmit()
 +{
 +  // TODO: check fixed sizes, coerce to available sizes.
 +  emit valueChanged();
 +}
++
++
 +// end of fontsizeselector.cpp

src/ftinspect/widgets/fontsizeselector.hpp

 +// fontsizeselector.hpp
++
 +// Copyright (C) 2022 by Charlie Jiang.
++
 +#pragma once
++
 +#include "customwidgets.hpp"
++
 +#include <QComboBox>
 +#include <QDoubleSpinBox>
 +#include <QLabel>
 +#include <QWidget>
 +#include <QBoxLayout>
 +#include <QWheelEvent>
++
 +class Engine;
 +class FontSizeSelector : public QWidget
 +{
 +  Q_OBJECT
++
 +public:
 +  // For the continuous view mode, see `ZoomSpinBox`'s documentation.
 +  FontSizeSelector(QWidget* parent, bool zoomNewLine, bool continuousView);
 +  ~FontSizeSelector() override = default;
++
 +  enum Units : int
 +  {
 +    Units_px,
 +    Units_pt
 +  };
++
 +  //////// Getters
 +  double selectedSize();
 +  Units selectedUnit();
 +  double zoomFactor();
 +  //////// Setters
 +  void setSizePixel(int sizePixel);
 +  void setSizePoint(double sizePoint);
 +  void setZoomFactor(double zoomFactor);
++
 +  void reloadFromFont(Engine* engine);
 +  void applyToEngine(Engine* engine);
 +  void handleWheelResizeBySteps(int steps);
 +  void handleWheelZoomBySteps(int steps);
 +  void handleWheelResizeFromGrid(QWheelEvent* event);
 +  bool handleKeyEvent(QKeyEvent const* keyEvent);
 +  void installEventFilterForWidget(QWidget* widget);
++
 +protected:
 +  bool eventFilter(QObject* watched, QEvent* event) override;
++
 +signals:
 +  void valueChanged();
++
 +private:
 +  QLabel* sizeLabel_;
 +  QLabel* dpiLabel_;
 +  QLabel* zoomLabel_;
++
 +  QDoubleSpinBox* sizeDoubleSpinBox_;
 +  QComboBox* unitsComboBox_;
 +  QSpinBox* dpiSpinBox_;
 +  ZoomSpinBox* zoomSpinBox_;
++
 +  // Sometimes we need to split 2 lines
 +  QHBoxLayout* upLayout_;
 +  QHBoxLayout* downLayout_;
 +  QVBoxLayout* mainLayout_;
++
 +  bool continuousView_;
 +  double lastValue_;
++
 +  void createLayout(bool zoomNewLine);
 +  void createConnections();
 +  void setDefaults(bool sizeOnly = false);
++
 +  void checkUnits();
 +  void checkFixedSizeAndEmit();
 +};
++
++
 +// end of fontsizeselector.hpp

src/ftinspect/widgets/glyphindexselector.cpp

 +// glyphindexselector.cpp
++
 +// Copyright (C) 2022 Charlie Jiang.
++
 +#include "glyphindexselector.hpp"
++
 +#include "../uihelper.hpp"
++
 +#include <climits>
++
 +GlyphIndexSelector::GlyphIndexSelector(QWidget* parent)
 +: QWidget(parent)
 +{
 +  numberRenderer_ = &GlyphIndexSelector::renderNumberDefault;
++
 +  createLayout();
 +  createConnections();
 +  showingCount_ = 0;
 +}
++
++
 +void
 +GlyphIndexSelector::setMinMax(int min,
 +                              int max)
 +{
 +  // Don't emit events during setting
 +  auto eventState = blockSignals(true);
 +  indexSpinBox_->setMinimum(min);
 +  indexSpinBox_->setMaximum(qBound(0, max, INT_MAX));
 +  indexSpinBox_->setValue(qBound(indexSpinBox_->minimum(),
 +                                 indexSpinBox_->value(),
 +                                 indexSpinBox_->maximum()));
 +  blockSignals(eventState);
++
 +  updateLabel();
 +}
++
++
 +void
 +GlyphIndexSelector::setShowingCount(int showingCount)
 +{
 +  showingCount_ = showingCount;
 +  updateLabel();
 +}
++
++
 +void
 +GlyphIndexSelector::setSingleMode(bool singleMode)
 +{
 +  singleMode_ = singleMode;
 +  updateLabel();
 +}
++
++
 +void
 +GlyphIndexSelector::setCurrentIndex(int index, bool forceUpdate)
 +{
 +  // to avoid unnecessary update, if force update is enabled
 +  // then the `setValue` shouldn't trigger update signal from `this`
 +  // but we still need `updateLabel`, so block `this` only
 +  auto state = blockSignals(forceUpdate);
 +  indexSpinBox_->setValue(index);
 +  blockSignals(state);
++
 +  if (forceUpdate)
 +    emit currentIndexChanged(indexSpinBox_->value());
 +}
++
++
 +int
 +GlyphIndexSelector::currentIndex()
 +{
 +  return indexSpinBox_->value();
 +}
++
++
 +void
 +GlyphIndexSelector::setNumberRenderer(std::function<QString(int)> renderer)
 +{
 +  numberRenderer_ = std::move(renderer);
 +}
++
++
 +void
 +GlyphIndexSelector::resizeEvent(QResizeEvent* event)
 +{
 +  QWidget::resizeEvent(event);
 +  auto minimumWidth = minimumSizeHint().width();
 +  if (toEndButton_->isVisible())
 +  {
 +    if (width() < minimumWidth)
 +      navigationWidget_->setVisible(false);
 +  }
 +  else if (navigationWidget_->minimumSizeHint().width() + minimumWidth
 +           <= width())
 +    navigationWidget_->setVisible(true);
 +}
++
++
 +void
 +GlyphIndexSelector::adjustIndex(int delta)
 +{
 +  {
 +    QSignalBlocker blocker(this);
 +    indexSpinBox_->setValue(qBound(indexSpinBox_->minimum(),
 +                                   indexSpinBox_->value() + delta,
 +                                   indexSpinBox_->maximum()));
 +  }
 +  emitValueChanged();
 +}
++
++
 +void
 +GlyphIndexSelector::emitValueChanged()
 +{
 +  emit currentIndexChanged(indexSpinBox_->value());
 +  updateLabel();
 +}
++
++
 +void
 +GlyphIndexSelector::updateLabel()
 +{
 +  if (singleMode_)
 +    indexLabel_->setText(QString("%1\nLimit: %2")
 +                           .arg(numberRenderer_(indexSpinBox_->value()))
 +                           .arg(numberRenderer_(indexSpinBox_->maximum())));
 +  else
 +    indexLabel_->setText(
 +      QString("%1~%2\nLimit: %4")
 +        .arg(numberRenderer_(indexSpinBox_->value()))
 +        .arg(numberRenderer_(
 +          qBound(indexSpinBox_->value(),
 +                 indexSpinBox_->value() + showingCount_ - 1, INT_MAX)))
 +        .arg(numberRenderer_(indexSpinBox_->maximum())));
 +}
++
++
 +void
 +GlyphIndexSelector::createLayout()
 +{
 +  navigationWidget_ = new QWidget(this);
 +  toStartButton_ = new QPushButton("|<", this);
 +  toM1000Button_ = new QPushButton("-1000", this);
 +  toM100Button_ = new QPushButton("-100", this);
 +  toM10Button_ = new QPushButton("-10", this);
 +  toM1Button_ = new QPushButton("-1", this);
 +  toP1Button_ = new QPushButton("+1", this);
 +  toP10Button_ = new QPushButton("+10", this);
 +  toP100Button_ = new QPushButton("+100", this);
 +  toP1000Button_ = new QPushButton("+1000", this);
 +  toEndButton_ = new QPushButton(">|", this);
++
 +  indexSpinBox_ = new QSpinBox(this);
 +  indexSpinBox_->setCorrectionMode(QAbstractSpinBox::CorrectToNearestValue);
 +  indexSpinBox_->setButtonSymbols(QAbstractSpinBox::NoButtons);
 +  indexSpinBox_->setRange(0, 0);
 +  indexSpinBox_->setFixedWidth(80);
 +  indexSpinBox_->setWrapping(false);
 +  indexSpinBox_->setKeyboardTracking(false);
++
 +  indexLabel_ = new QLabel("0\nLimit: 0");
 +  indexLabel_->setMinimumWidth(200);
++
 +  setButtonNarrowest(toStartButton_);
 +  setButtonNarrowest(toM1000Button_);
 +  setButtonNarrowest(toM100Button_);
 +  setButtonNarrowest(toM10Button_);
 +  setButtonNarrowest(toM1Button_);
 +  setButtonNarrowest(toP1Button_);
 +  setButtonNarrowest(toP10Button_);
 +  setButtonNarrowest(toP100Button_);
 +  setButtonNarrowest(toP1000Button_);
 +  setButtonNarrowest(toEndButton_);
++
 +  // Toltips
 +  indexSpinBox_->setToolTip("Current glyph index.");
 +  indexLabel_->setToolTip("Current glyph index/range and the max index.");
++
 +  // Layouting
 +  navigationLayout_ = new QHBoxLayout;
 +  navigationLayout_->setSpacing(0);
 +  navigationLayout_->addWidget(toStartButton_);
 +  navigationLayout_->addWidget(toM1000Button_);
 +  navigationLayout_->addWidget(toM100Button_);
 +  navigationLayout_->addWidget(toM10Button_);
 +  navigationLayout_->addWidget(toM1Button_);
 +  navigationLayout_->addWidget(toP1Button_);
 +  navigationLayout_->addWidget(toP10Button_);
 +  navigationLayout_->addWidget(toP100Button_);
 +  navigationLayout_->addWidget(toP1000Button_);
 +  navigationLayout_->addWidget(toEndButton_);
 +  navigationWidget_->setLayout(navigationLayout_);
++
 +  layout_ = new QHBoxLayout;
 +  layout_->setSpacing(0);
 +  layout_->addStretch(3);
 +  layout_->addWidget(navigationWidget_);
 +  layout_->addStretch(1);
 +  layout_->addWidget(indexSpinBox_);
 +  layout_->addStretch(1);
 +  layout_->addWidget(indexLabel_);
 +  layout_->addStretch(3);
++
 +  setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
 +  setLayout(layout_);
 +}
++
 +void
 +GlyphIndexSelector::createConnections()
 +{
 +  connect(indexSpinBox_, QOverload<int>::of(&QSpinBox::valueChanged),
 +          this, &GlyphIndexSelector::emitValueChanged);
++
 +  glyphNavigationMapper_ = new QSignalMapper(this);
 +  connect(glyphNavigationMapper_, &QSignalMapper::mappedInt,
 +          this, &GlyphIndexSelector::adjustIndex);
++
 +  connect(toStartButton_, &QPushButton::clicked,
 +          glyphNavigationMapper_, QOverload<>::of(&QSignalMapper::map));
 +  connect(toM1000Button_, &QPushButton::clicked,
 +          glyphNavigationMapper_, QOverload<>::of(&QSignalMapper::map));
 +  connect(toM100Button_, &QPushButton::clicked,
 +          glyphNavigationMapper_, QOverload<>::of(&QSignalMapper::map));
 +  connect(toM10Button_, &QPushButton::clicked,
 +          glyphNavigationMapper_, QOverload<>::of(&QSignalMapper::map));
 +  connect(toM1Button_, &QPushButton::clicked,
 +          glyphNavigationMapper_, QOverload<>::of(&QSignalMapper::map));
 +  connect(toP1Button_, &QPushButton::clicked,
 +          glyphNavigationMapper_, QOverload<>::of(&QSignalMapper::map));
 +  connect(toP10Button_, &QPushButton::clicked,
 +          glyphNavigationMapper_, QOverload<>::of(&QSignalMapper::map));
 +  connect(toP100Button_, &QPushButton::clicked,
 +          glyphNavigationMapper_, QOverload<>::of(&QSignalMapper::map));
 +  connect(toP1000Button_, &QPushButton::clicked,
 +          glyphNavigationMapper_, QOverload<>::of(&QSignalMapper::map));
 +  connect(toEndButton_, &QPushButton::clicked,
 +          glyphNavigationMapper_, QOverload<>::of(&QSignalMapper::map));
++
 +  glyphNavigationMapper_->setMapping(toStartButton_, -0x10000);
 +  glyphNavigationMapper_->setMapping(toM1000Button_, -1000);
 +  glyphNavigationMapper_->setMapping(toM100Button_, -100);
 +  glyphNavigationMapper_->setMapping(toM10Button_, -10);
 +  glyphNavigationMapper_->setMapping(toM1Button_, -1);
 +  glyphNavigationMapper_->setMapping(toP1Button_, 1);
 +  glyphNavigationMapper_->setMapping(toP10Button_, 10);
 +  glyphNavigationMapper_->setMapping(toP100Button_, 100);
 +  glyphNavigationMapper_->setMapping(toP1000Button_, 1000);
 +  glyphNavigationMapper_->setMapping(toEndButton_, 0x10000);
 +}
++
++
 +QString
 +GlyphIndexSelector::renderNumberDefault(int i)
 +{
 +  return QString::number(i);
 +}
++
++
 +// end of glyphindexselector.cpp

src/ftinspect/widgets/glyphindexselector.hpp

 +// glyphindexselector.hpp
++
 +// Copyright (C) 2022 by Charlie Jiang.
++
 +#pragma once
++
 +#include <functional>
 +#include <QWidget>
 +#include <QPushButton>
 +#include <QSpinBox>
 +#include <QSignalMapper>
 +#include <QHBoxLayout>
 +#include <QLabel>
++
 +class GlyphIndexSelector
 +: public QWidget
 +{
 +  Q_OBJECT
 +public:
 +  GlyphIndexSelector(QWidget* parent);
 +  ~GlyphIndexSelector() override = default;
++
 +  // Will never trigger repaint!
 +  void setMinMax(int min, int max);
 +  void setShowingCount(int showingCount);
++
 +  // Single mode will display single glyph index instead of a range.
 +  void setSingleMode(bool singleMode);
++
 +  void setCurrentIndex(int index, bool forceUpdate = false);
 +  int currentIndex();
++
 +  void setNumberRenderer(std::function<QString(int)> renderer);
++
 +signals:
 +  void currentIndexChanged(int index);
++
 +protected:
 +  void resizeEvent(QResizeEvent* event) override;
++
 +private:
 +  bool singleMode_ = true;
 +  int showingCount_;
 +  std::function<QString(int)> numberRenderer_;
++
 +  // min, max and current status are held by `indexSpinBox_`
 +  QWidget* navigationWidget_;
 +  QPushButton* toEndButton_;
 +  QPushButton* toM1000Button_;
 +  QPushButton* toM100Button_;
 +  QPushButton* toM10Button_;
 +  QPushButton* toM1Button_;
 +  QPushButton* toP1000Button_;
 +  QPushButton* toP100Button_;
 +  QPushButton* toP10Button_;
 +  QPushButton* toP1Button_;
 +  QPushButton* toStartButton_;
++
 +  QLabel* indexLabel_;
 +  QSpinBox* indexSpinBox_;
++
 +  QHBoxLayout* navigationLayout_;
 +  QHBoxLayout* layout_;
++
 +  QSignalMapper* glyphNavigationMapper_;
++
 +  void createLayout();
 +  void createConnections();
++
 +  void adjustIndex(int delta);
 +  void emitValueChanged();
 +  void updateLabel();
++
 +  static QString renderNumberDefault(int i);
 +};
++
++
 +// end of glyphindexselector.hpp

src/ftinspect/widgets/tripletselector.cpp

 +// tripletselector.cpp
++
 +// Copyright (C) 2022 by Charlie Jiang.
++
 +#include "tripletselector.hpp"
++
 +#include "../engine/engine.hpp"
++
 +#include <functional>
++
 +TripletSelector::TripletSelector(QWidget* parent,
 +                                 Engine* engine)
 +: QWidget(parent),
 +  engine_(engine)
 +{
 +  createLayout();
 +  createConnections();
 +  checkButtons();
 +}
++
++
 +TripletSelector::~TripletSelector()
 +{
 +}
++
++
 +void
 +TripletSelector::repopulateFonts()
 +{
 +  auto oldSize = fontComboBox_->count();
 +  auto oldIndex = fontComboBox_->currentIndex();
++
 +  {
 +    QSignalBlocker blk(fontComboBox_);
 +    QSignalBlocker blk2(faceComboBox_);
 +    QSignalBlocker blk3(niComboBox_);
 +    fontComboBox_->clear();
++
 +    auto& ffm = engine_->fontFileManager();
 +    auto newSize = ffm.size();
 +    for (int i = 0; i < newSize; i++)
 +    {
 +      auto& info = ffm[i];
 +      auto name = info.filePath();
 +      auto displayName = info.fileName();
 +      if (info.isSymbolicLink())
 +        displayName += " [symlink]";
++
 +      fontComboBox_->addItem(displayName, name);
 +    }
++
 +    if (newSize > oldSize)
 +    {
 +      // if we have new fonts, set the current index to the first new one
 +      fontComboBox_->setCurrentIndex(oldSize);
 +    }
 +    else if (newSize < oldSize)
 +    {
 +      if (oldIndex >= newSize)
 +        oldIndex = newSize - 1;
 +      if (oldIndex < 0)
 +        oldIndex = -1;
 +      fontComboBox_->setCurrentIndex(oldIndex);
 +    }
++
 +    // Note no signal will be emitted from any combobox until this block ends
 +  }
++
 +  // This will check buttons & reload the triplet
 +  repopulateFaces();
 +}
++
++
 +void
 +TripletSelector::repopulateFaces(bool fontSwitched)
 +{
 +  // Avoid unnecessary recreating, to reduce interruption of user oper
 +  auto needToRecreate = fontSwitched;
 +  auto oldSize = faceComboBox_->count();
++
 +  auto fontIndex = fontComboBox_->currentIndex();
 +  auto newSize = engine_->numberOfFaces(fontIndex);
++
 +  if (fontIndex < 0 || newSize < 0)
 +  {
 +    // Clear and go
 +    faceComboBox_->clear();
 +    // This will check buttons & reload the triplet
 +    repopulateNamedInstances(fontSwitched);
 +    return;
 +  }
++
 +  if (newSize != oldSize)
 +    needToRecreate = true;
++
 +  std::vector<QString> newFaces;
 +  newFaces.reserve(newSize);
 +  for (long i = 0; i < newSize; i++)
 +  {
 +    newFaces.emplace_back(engine_->namedInstanceName(fontIndex, i, 0));
 +    if (!needToRecreate && newFaces[i] != faceComboBox_->itemData(i))
 +      needToRecreate = true;
 +  }
++
 +  if (!needToRecreate)
 +  {
 +    // no need to refersh the combobox
 +    // This will check buttons & reload the triplet
 +    repopulateNamedInstances(fontSwitched);
 +    return;
 +  }
++
 +  {
 +    QSignalBlocker blk2(faceComboBox_);
 +    QSignalBlocker blk3(niComboBox_);
 +    faceComboBox_->clear();
++
 +    for (long i = 0; i < newSize; i++)
 +    {
 +      auto& name = newFaces[i];
 +      auto displayName = QString("%1: %2").arg(i).arg(name);
 +      faceComboBox_->addItem(displayName, name);
 +    }
++
 +    faceComboBox_->setCurrentIndex(0);
 +    // Note no signal will be emitted from any combobox until this block ends
 +  }
++
 +  // This will check buttons & reload the triplet
 +  repopulateNamedInstances(true);
 +}
++
++
 +void
 +TripletSelector::repopulateNamedInstances(bool fontSwitched)
 +{
 +  // Avoid unnecessary recreating, to reduce interruption of user oper
 +  // Similar to `repopulateFaces`
 +  auto needToRecreate = fontSwitched;
 +  auto oldSize = niComboBox_->count();
++
 +  auto fontIndex = fontComboBox_->currentIndex();
 +  auto faceIndex = faceComboBox_->currentIndex();
 +  auto newSize = engine_->numberOfNamedInstances(fontIndex, faceIndex);
++
 +  if (fontIndex < 0 || faceIndex < 0 || newSize < 0)
 +  {
 +    // Clear and go, don't forget checking buttons and loading triplet
 +    niComboBox_->clear();
 +    checkButtons();
 +    loadTriplet();
 +    return;
 +  }
++
 +  if (newSize != oldSize)
 +    needToRecreate = true;
++
 +  std::vector<QString> newFaces;
 +  newFaces.reserve(newSize);
 +  for (long i = 0; i < newSize; i++)
 +  {
 +    newFaces.emplace_back(engine_->namedInstanceName(fontIndex, faceIndex, i));
 +    if (!needToRecreate && newFaces[i] != niComboBox_->itemData(i))
 +      needToRecreate = true;
 +  }
++
 +  niComboBox_->setEnabled(newSize > 1);
++
 +  if (!needToRecreate)
 +  {
 +    // no need to refersh the combobox
 +    checkButtons();
 +    loadTriplet();
 +    return;
 +  }
++
 +  {
 +    QSignalBlocker blk3(niComboBox_);
 +    niComboBox_->clear();
++
 +    for (long i = 0; i < newSize; i++)
 +    {
 +      auto& name = newFaces[i];
 +      auto displayName = QString("%1: %2").arg(i).arg(name);
 +      if (i == 0)
 +        displayName = "* " + displayName;
 +      niComboBox_->addItem(displayName, name);
 +    }
++
 +    niComboBox_->setCurrentIndex(0);
 +    // Note no signal will be emitted from any combobox until this block ends
 +  }
++
 +  checkButtons();
 +  loadTriplet();
 +}
++
++
 +void
 +TripletSelector::closeCurrentFont()
 +{
 +  auto idx = fontComboBox_->currentIndex();
 +  if (idx < 0)
 +    return;
 +  engine_->fontFileManager().remove(idx);
++
 +  // show next font after deletion, i.e., retain index if possible
 +  int num = engine_->numberOfOpenedFonts();
 +  if (num)
 +  {
 +    if (idx >= num)
 +      idx = num - 1;
 +  }
 +  else
 +    idx = -1;
++
 +  {
 +    // Shut up when repopulating
 +    QSignalBlocker blockerThis(this);
 +    QSignalBlocker blockerComboBox(fontComboBox_);
 +    repopulateFonts();
 +  }
++
 +  if (idx != -1)
 +    faceComboBox_->setCurrentIndex(idx);
 +  updateFont();
 +}
++
++
 +void
 +TripletSelector::updateFont()
 +{
 +  auto idx = fontComboBox_->currentIndex();
 +  auto num = engine_->numberOfOpenedFonts();
 +  if (idx < 0)
 +  {
 +    faceComboBox_->clear();
 +    niComboBox_->clear();
++
 +    checkButtons();
 +    loadTriplet();
 +    return;
 +  }
++
 +  if (num <= 0 || idx >= num)
 +  {
 +    // out of sync: this shouldn't happen
 +    repopulateFonts();
 +    return;
 +  }
++
 +  // This will check buttons & reload the triplet
 +  repopulateFaces();
 +}
++
++
 +void
 +TripletSelector::updateFace()
 +{
 +  auto idx = faceComboBox_->currentIndex();
 +  auto num = engine_->numberOfFaces(fontComboBox_->currentIndex());
++
 +  if (idx >= num)
 +  {
 +    // out of sync
 +    repopulateFaces();
 +    return;
 +  }
++
 +  // This will check buttons & reload the triplet
 +  repopulateNamedInstances();
 +}
++
++
 +void
 +TripletSelector::updateNI()
 +{
 +  auto idx = niComboBox_->currentIndex();
 +  auto num = engine_->numberOfNamedInstances(fontComboBox_->currentIndex(),
 +                                             faceComboBox_->currentIndex());
++
 +  if (idx >= num)
 +  {
 +    // out of sync
 +    repopulateNamedInstances();
 +    return;
 +  }
++
 +  checkButtons();
 +  loadTriplet();
 +}
++
++
 +void
 +TripletSelector::checkButtons()
 +{
 +  fontUpButton_->setEnabled(fontComboBox_->currentIndex() > 0);
 +  fontDownButton_->setEnabled(fontComboBox_->currentIndex()
 +                              < fontComboBox_->count() - 1);
 +  closeFontButton_->setEnabled(faceComboBox_->currentIndex() >= 0);
++
 +  faceUpButton_->setEnabled(faceComboBox_->currentIndex() > 0);
 +  faceDownButton_->setEnabled(faceComboBox_->currentIndex()
 +                              < faceComboBox_->count() - 1);
++
 +  niUpButton_->setEnabled(niComboBox_->currentIndex() > 0);
 +  niDownButton_->setEnabled(niComboBox_->currentIndex()
 +                            < niComboBox_->count() - 1);
 +}
++
++
 +void
 +TripletSelector::watchCurrentFont()
 +{
 +  repopulateFaces(false);
 +}
++
++
 +void
 +TripletSelector::createLayout()
 +{
 +  fontComboBox_ = new QComboBox(this);
 +  faceComboBox_ = new QComboBox(this);
 +  niComboBox_   = new QComboBox(this);
++
 +  fontComboBox_->setPlaceholderText(tr("No font open"));
 +  faceComboBox_->setPlaceholderText(tr("No face available"));
 +  niComboBox_->setPlaceholderText(tr("No named instance available"));
++
 +  closeFontButton_ = new QToolButton(this);
 +  fontUpButton_    = new QToolButton(this);
 +  faceUpButton_    = new QToolButton(this);
 +  niUpButton_      = new QToolButton(this);
 +  fontDownButton_  = new QToolButton(this);
 +  faceDownButton_  = new QToolButton(this);
 +  niDownButton_    = new QToolButton(this);
++
 +  closeFontButton_->setText(tr("Close"));
 +  fontUpButton_   ->setText(tr("\xE2\x86\x91"));
 +  faceUpButton_   ->setText(tr("\xE2\x86\x91"));
 +  niUpButton_     ->setText(tr("\xE2\x86\x91"));
 +  fontDownButton_ ->setText(tr("\xE2\x86\x93"));
 +  faceDownButton_ ->setText(tr("\xE2\x86\x93"));
 +  niDownButton_   ->setText(tr("\xE2\x86\x93"));
++
 +  fontComboBox_   ->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Expanding);
 +  faceComboBox_   ->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Expanding);
 +  niComboBox_     ->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Expanding);
 +  closeFontButton_->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Expanding);
 +  fontUpButton_   ->setFixedSize(30, 30);
 +  faceUpButton_   ->setFixedSize(30, 30);
 +  niUpButton_     ->setFixedSize(30, 30);
 +  fontDownButton_ ->setFixedSize(30, 30);
 +  faceDownButton_ ->setFixedSize(30, 30);
 +  niDownButton_   ->setFixedSize(30, 30);
++
 +  // Tooltips
 +  fontComboBox_->setToolTip(tr("Current font"));
 +  faceComboBox_->setToolTip(tr("Current subfont (face)"));
 +  niComboBox_->setToolTip(
 +    tr("Current named instance (only available for variable fonts)"));
 +  closeFontButton_->setToolTip(tr("Close current font"));
 +  fontUpButton_   ->setToolTip(tr("Previous font"));
 +  faceUpButton_   ->setToolTip(tr("Previous subfont (face)"));
 +  niUpButton_     ->setToolTip(tr("Previous named instance"));
 +  fontDownButton_ ->setToolTip(tr("Next font"));
 +  faceDownButton_ ->setToolTip(tr("Next subfont (face)"));
 +  niDownButton_   ->setToolTip(tr("Next named instance"));
++
 +  // Layouting
 +  layout_ = new QHBoxLayout;
 +  layout_->setSpacing(0);
 +  layout_->setContentsMargins(0, 0, 0, 0);
++
 +  layout_->addWidget(fontComboBox_);
 +  layout_->addWidget(fontUpButton_);
 +  layout_->addWidget(fontDownButton_);
 +  layout_->addWidget(closeFontButton_);
 +  layout_->addWidget(faceComboBox_);
 +  layout_->addWidget(faceUpButton_);
 +  layout_->addWidget(faceDownButton_);
 +  layout_->addWidget(niComboBox_);
 +  layout_->addWidget(niUpButton_);
 +  layout_->addWidget(niDownButton_);
++
 +  setFixedHeight(30);
 +  setLayout(layout_);
 +  layout_->setContentsMargins(0, 0, 0, 0);
 +}
++
++
 +void
 +TripletSelector::createConnections()
 +{
 +  connect(fontComboBox_, QOverload<int>::of(&QComboBox::currentIndexChanged),
 +          this, &TripletSelector::updateFont);
 +  connect(faceComboBox_, QOverload<int>::of(&QComboBox::currentIndexChanged),
 +          this, &TripletSelector::updateFace);
 +  connect(niComboBox_, QOverload<int>::of(&QComboBox::currentIndexChanged),
 +          this, &TripletSelector::updateNI);
++
 +  connect(closeFontButton_, &QToolButton::clicked,
 +          this, &TripletSelector::closeCurrentFont);
 +  connect(fontUpButton_   , &QToolButton::clicked,
 +          this,
 +          std::bind(&TripletSelector::previousComboBoxItem, fontComboBox_));
 +  connect(faceUpButton_   , &QToolButton::clicked,
 +          this,
 +          std::bind(&TripletSelector::previousComboBoxItem, faceComboBox_));
 +  connect(niUpButton_     , &QToolButton::clicked,
 +          this,
 +          std::bind(&TripletSelector::previousComboBoxItem, niComboBox_));
 +  connect(fontDownButton_ , &QToolButton::clicked,
 +          this,
 +          std::bind(&TripletSelector::nextComboBoxItem, fontComboBox_));
 +  connect(faceDownButton_ , &QToolButton::clicked,
 +          this,
 +          std::bind(&TripletSelector::nextComboBoxItem, faceComboBox_));
 +  connect(niDownButton_   , &QToolButton::clicked,
 +          this,
 +          std::bind(&TripletSelector::nextComboBoxItem, niComboBox_));
++
 +  connect(&engine_->fontFileManager(), &FontFileManager::currentFileChanged,
 +          this, &TripletSelector::watchCurrentFont);
 +}
++
++
 +void
 +TripletSelector::loadTriplet()
 +{
 +  // we do lazy computation of FT_Face objects
++
 +  // TODO really?
 +  auto fontIndex = fontComboBox_->currentIndex();
 +  auto faceIndex = faceComboBox_->currentIndex();
 +  auto instanceIndex = niComboBox_->currentIndex();
++
 +  if (fontIndex >= 0 && fontIndex < engine_->numberOfOpenedFonts())
 +  {
 +    QFileInfo& fileInfo = engine_->fontFileManager()[fontIndex];
 +    engine_->fontFileManager().updateWatching(fontIndex);
++
 +    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(fontIndex, false);
 +    }
 +  }
++
 +  engine_->loadFont(fontIndex, faceIndex, instanceIndex);
++
 +  // TODO: This may messes up with bitmap-only fonts.
 +  if (!engine_->fontValid())
 +  {
 +    // 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 (faceIndex >= 0 && faceIndex < engine_->numberOfOpenedFonts())
 +      engine_->fontFileManager().timerStart();
 +  }
++
 +  emit tripletChanged();
 +}
++
++
 +void
 +TripletSelector::nextComboBoxItem(QComboBox* c)
 +{
 +  if (c->currentIndex() < 0 || c->currentIndex() >= c->count() - 1)
 +    return;
 +  // No need to handle further steps, the event handler will take care of these
 +  c->setCurrentIndex(c->currentIndex() + 1);
 +}
++
++
 +void
 +TripletSelector::previousComboBoxItem(QComboBox* c)
 +{
 +  if (c->currentIndex() <= 0)
 +    return;
 +  // No need to handle further steps, the event handler will take care of these
 +  c->setCurrentIndex(c->currentIndex() - 1);
 +}
++
++
 +// end of tripletselector.cpp

src/ftinspect/widgets/tripletselector.hpp

 +// QPushButton.hpp
++
 +// Copyright (C) 2022 by Charlie Jiang.
++
 +#pragma once
++
 +#include <vector>
 +#include <QWidget>
 +#include <QComboBox>
 +#include <QPushButton>
 +#include <QToolButton>
 +#include <QBoxLayout>
++
 +class Engine;
 +class TripletSelector
 +: public QWidget
 +{
 +  Q_OBJECT
++
 +public:
 +  TripletSelector(QWidget* parent,
 +                  Engine* engine);
 +  ~TripletSelector() override;
++
 +  void repopulateFonts();
 +  void closeCurrentFont();
++
 +signals:
 +  void tripletChanged();
++
 +private:
 +  Engine* engine_;
++
 +  QComboBox* fontComboBox_;
 +  QComboBox* faceComboBox_;
 +  QComboBox* niComboBox_;
++
 +  QToolButton* closeFontButton_;
++
 +  QToolButton* fontUpButton_;
 +  QToolButton* fontDownButton_;
 +  QToolButton* faceUpButton_;
 +  QToolButton* faceDownButton_;
 +  QToolButton* niUpButton_;
 +  QToolButton* niDownButton_;
++
 +  QHBoxLayout* layout_;
++
 +  void checkButtons();
 +  void watchCurrentFont();
++
 +  void createLayout();
 +  void createConnections();
++
 +  void repopulateFaces(bool fontSwitched = true);
 +  void repopulateNamedInstances(bool fontSwitched = true);
 +  void updateFont();
 +  void updateFace();
 +  void updateNI();
 +  void loadTriplet();
++
 +  static void nextComboBoxItem(QComboBox* c);
 +  static void previousComboBoxItem(QComboBox* c);
 +};
++
++
 +// end of QPushButton.hpp

From:	Charlie Jiang (@cqjjjzr)
Subject:	[Git][freetype/freetype-demos][gsoc-2022-chariri-final] 2 commits: [ftinspect] Rewrite `MainGUI`.
Date:	Sat, 03 Sep 2022 16:26:04 +0000