[Git][freetype/freetype-demos][gsoc-2022-chariri-2] 7 commits: [ftinspec

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

Commits:

bb053ffd

by Charlie Jiang at 2022-07-14T16:08:10+08:00

[ftinspect] Add Fancy submode to "Continuous View"

Fancy mode adds slanting and hori./vert. emboldening to the glyph.

`GlyphContinuous::paintChar` is broken down to better support additional
operations during rendering. Add proper cloning so the glyph and the
outline which are stored in the `GlyphContinuous` class can be safely
modified.

* src/ftinspect/rendering/glyphcontinuous.cpp,
  src/ftinspect/rendering/glyphcontinuous.hpp: As described, refactored and
  supported Fancy mode.

* src/ftinspect/rendering/glyphbitmap.cpp: Edited to match the new
  `renderutils.cpp`.

* src/ftinspect/rendering/renderutils.cpp,
  src/ftinspect/rendering/renderutils.hpp: Broken down
  `transformOutlineToOrigin`, add `cloneOutline` and `cloneGlyph`.

* src/ftinspect/panels/continuous.cpp, src/ftinspect/panels/continuous.hpp:
  Add necessary GUI components and data passing to support fancy mode.

e6c47fa6

by Charlie Jiang at 2022-07-14T16:08:10+08:00

[ftinspect] Support Stroked SubMode in "Continuous Mode"

* src/ftinspect/panels/continuous.cpp, src/ftinspect/panels/continuous.hpp:
  GUI update.

* src/ftinspect/rendering/glyphcontinuous.cpp,
  src/ftinspect/rendering/glyphcontinuous.hpp: Add support.

b1392d6a

by Charlie Jiang at 2022-07-14T16:08:10+08:00

* src/ftinspect/meson.build: Fix meson build.

Fix typo.

ed68c568

by Charlie Jiang at 2022-07-14T16:08:10+08:00

[ftinspect] Fix compilation on GCC.

* src/ftinspect/panels/continuous.hpp, src/ftinspect/panels/continuous.cpp,
  use `std::vector` over `QVector` because the latter requires default
  `constructor`; Fix signedness because of `std::vector`;

* src/ftinspect/models/ttsettingscomboboxmodel.hpp: Fix enum inconsistency.

* src/ftinspect/engine/engine.hpp, src/ftinspect/engine/engine.cpp: Fix
missing include; use `std::vector`;

* src/ftinspect/CMakeLists.txt: Fix MinGW: g++ doesn't need `/utf-8` switch.

f532d57c

by Charlie Jiang at 2022-07-14T16:08:10+08:00

[ftinspect] Remove redundant text on the GUI.

Removed "Count:" indicator showing the display count because it serves
little value. Removed "for Fancy/Stroked" text from the label because
graying out elements is already enough.

* src/ftinspect/panels/continuous.cpp: Remove "Count:" indicator.

* src/ftinspect/widgets/glyphindexselector.cpp: Remove text from label.

1e38831a

by Charlie Jiang at 2022-07-14T16:08:10+08:00

[ftinspect] Support embedded bitmap, refactor rendering.

This commit supported embedded bitmap and more FreeType font types. Singular
rendering widgets are refactored so they're more flexible about glyph and
bitmap types.

Replace `loadOutline` in `Engine` to `loadGlyph` and add other glyph
formats. Move the rasterization from `GlyphBitmap` to `Engine` to decouple
rendering from specific widgets. Engine will produce `QImage` object so
render widgets can be agnostic about glyph type.

Added "Enable Embedded Bitmap" checkbox to the GUI, so one can still force
disable embedded bitmap output. Outline, points and point numbers showing
are hidden when the glyph format isn't outline.

LCD rendering is not yet supported because `convertLCDToARGB` and
`convertLCDVToARGB` are not implemented.

* src/ftinspect/engine/engine.cpp, src/ftinspect/engine/engine.hpp:
  Replace `loadOutline` to `loadGlyph`, and enable non-outline glyph types.
  Add `glyphToBitmap`, `convertBitmapTo8Bpp` and `convertBitmapToQImage`.
  Add necessary setting properties.
  TODO: Move `glyphFormatToName` and CharMap related code out from
  `engine.[ch]pp`.

* src/ftinspect/rendering/glyphbitmap.cpp,
  src/ftinspect/rendering/glyphbitmap.hpp:
  Remove detailed rasterizing code, and use `Engine` to generate `QImage`..

* src/ftinspect/panels/singular.cpp: Use `loadGlyph` instead of
  `loadOutline`, and remove code about pixel mode.

* src/ftinspect/models/ttsettingscomboboxmodel.cpp,
  src/ftinspect/models/ttsettingscomboboxmodel.hpp:
  Make `SimpleComboBoxModel` a template class because the Anti-Aliasing
  setting combo box maps to multiple fields (load flag, render mode and
  RGB/BGR).
  Because Qt disallows template class with Q_OBJECT, we have to use mixin
  instead of inheritance. The new base class is named
  `SimpleComboBoxModelImpl` and subclass delegate function calls to it.
  Those models may subject to refactoring later.

* src/ftinspect/rendering/renderutils.cpp,
  src/ftinspect/rendering/renderutils.hpp:
  Split `computeTransformationToOrigin` out from `transformOutlineToOrigin`.

* src/ftinspect/rendering/glyphoutline.cpp,
  src/ftinspect/rendering/glyphoutline.hpp,
  src/ftinspect/rendering/glyphpoints.cpp,
  src/ftinspect/rendering/glyphpoints.hpp,
  src/ftinspect/rendering/glyphpointnumbers.cpp,
  src/ftinspect/rendering/glyphpointnumbers.hpp:
  Receive `FT_Glyph` instead of `FT_Outline*` as input, but don't preceed if
  the glyph isn't outline-typed.

598ce364

by Charlie Jiang at 2022-07-14T16:08:10+08:00

[ftinspect] Rename `ttsettingscomboboxmodel.[ch]pp`.

Rename them to `customcomboboxmodels.[ch]pp`.

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

25 changed files:

src/ftinspect/CMakeLists.txt
src/ftinspect/engine/engine.cpp
src/ftinspect/engine/engine.hpp
src/ftinspect/meson.build
src/ftinspect/models/ttsettingscomboboxmodel.cpp → src/ftinspect/models/customcomboboxmodels.cpp
src/ftinspect/models/ttsettingscomboboxmodel.hpp → src/ftinspect/models/customcomboboxmodels.hpp
src/ftinspect/panels/continuous.cpp
src/ftinspect/panels/continuous.hpp
src/ftinspect/panels/settingpanel.cpp
src/ftinspect/panels/settingpanel.hpp
src/ftinspect/panels/singular.cpp
src/ftinspect/rendering/glyphbitmap.cpp
src/ftinspect/rendering/glyphbitmap.hpp
src/ftinspect/rendering/glyphcontinuous.cpp
src/ftinspect/rendering/glyphcontinuous.hpp
src/ftinspect/rendering/glyphoutline.cpp
src/ftinspect/rendering/glyphoutline.hpp
src/ftinspect/rendering/glyphpointnumbers.cpp
src/ftinspect/rendering/glyphpointnumbers.hpp
src/ftinspect/rendering/glyphpoints.cpp
src/ftinspect/rendering/glyphpoints.hpp
src/ftinspect/rendering/grid.hpp
src/ftinspect/rendering/renderutils.cpp
src/ftinspect/rendering/renderutils.hpp
src/ftinspect/widgets/glyphindexselector.cpp

Changes:

src/ftinspect/CMakeLists.txt

@@ -4,7 +4,7 @@ set(CMAKE_CXX_STANDARD 11)
  project("ftinspect")
 -if (WIN32)
 +if (MSVC)
    add_compile_options("/utf-8")
  endif ()
@@ -36,7 +36,7 @@ add_executable(ftinspect
    "widgets/glyphindexselector.cpp"
    "widgets/fontsizeselector.cpp"
 -  "models/ttsettingscomboboxmodel.cpp"
 +  "models/customcomboboxmodels.cpp"
    "panels/settingpanel.cpp"
    "panels/singular.cpp"

src/ftinspect/engine/engine.cpp

@@ -5,12 +5,16 @@
  #include "engine.hpp"
 +#include "../rendering/renderutils.hpp"
 +#include "../rendering/graphicsdefault.hpp"
++
  #include <stdexcept>
  #include <stdint.h>
  #include <freetype/ftmodapi.h>
  #include <freetype/ftdriver.h>
  #include <freetype/ftlcdfil.h>
 +#include <freetype/ftbitmap.h>
  /////////////////////////////////////////////////////////////////////////////
@@ -153,7 +157,7 @@ Engine::Engine()
+   {
      // XXX error handling
+   }
+-
++
    queryEngine();
+ }
@@ -309,7 +313,7 @@ Engine::loadFont(int fontIndex,
      curCharMaps_.clear();
      curCharMaps_.reserve(face->num_charmaps);
      for (int i = 0; i < face->num_charmaps; i++)
 -      curCharMaps_.append(CharMapInfo(i, face->charmaps[i]));
 +      curCharMaps_.emplace_back(i, face->charmaps[i]);
+   }
    curNumGlyphs_ = numGlyphs;
@@ -397,8 +401,8 @@ Engine::glyphName(int index)
+ }
 -FT_Outline*
 -Engine::loadOutline(int glyphIndex)
 +FT_Glyph
 +Engine::loadGlyph(int glyphIndex)
+ {
    update();
@@ -407,13 +411,11 @@ Engine::loadOutline(int glyphIndex)
    FT_Glyph glyph;
 -  // XXX handle bitmap fonts
+-
    // the `scaler' object is set up by the
    // `update' and `loadFont' methods
    if (FTC_ImageCache_LookupScaler(imageCache_,
                                    &scaler_,
 -                                  loadFlags_ | FT_LOAD_NO_BITMAP,
 +                                  loadFlags_,
                                    static_cast<unsigned int>(glyphIndex),
                                    &glyph,
                                    NULL))
@@ -422,21 +424,14 @@ Engine::loadOutline(int glyphIndex)
      return NULL;
+   }
 -  if (glyph->format != FT_GLYPH_FORMAT_OUTLINE)
 -    return NULL;
+-
 -  FT_OutlineGlyph outlineGlyph = reinterpret_cast<FT_OutlineGlyph>(glyph);
+-
 -  return &outlineGlyph->outline;
 +  return glyph;
+ }
  FT_Glyph
  Engine::loadGlyphWithoutUpdate(int glyphIndex)
+ {
 -  // TODO bitmap fonts? color layered fonts?
    FT_Glyph glyph;
 -  imageType_.flags |= FT_LOAD_NO_BITMAP;
    if (FTC_ImageCache_Lookup(imageCache_,
                              &imageType_,
                              glyphIndex,
@@ -451,6 +446,57 @@ Engine::loadGlyphWithoutUpdate(int glyphIndex)
+ }
 +bool
 +Engine::glyphToBitmap(FT_Glyph src,
 +                      FT_Glyph* out)
 +{
 +  if (src->format == FT_GLYPH_FORMAT_BITMAP)
 +  {
 +    *out = src;
 +    return false;
 +  }
 +  if (src->format != FT_GLYPH_FORMAT_OUTLINE)
 +  {
 +    *out = NULL;
 +    return false;
 +    // TODO support SVG
 +  }
++
 +  if (src->format == FT_GLYPH_FORMAT_OUTLINE)
 +  {
 +    FT_Glyph out2 = src;
 +    auto error = FT_Glyph_To_Bitmap(&out2,
 +                                    static_cast<FT_Render_Mode>(renderMode_),
 +                                    nullptr,
 +                                    false);
 +    if (error)
 +    {
 +      *out = NULL;
 +      return false;
 +    }
 +    *out = out2;
 +    return true;
 +  }
++
 +  *out = NULL;
 +  return false;
 +}
++
++
 +FT_Bitmap
 +Engine::convertBitmapTo8Bpp(FT_Bitmap* bitmap)
 +{
 +  FT_Bitmap out;
 +  out.buffer = NULL;
 +  auto error = FT_Bitmap_Convert(library_, bitmap, &out, 1);
 +  if (error)
 +  {
 +    // XXX handling?
 +  }
 +  return out;
 +}
++
++
  int
  Engine::numberOfOpenedFonts()
+ {
@@ -527,19 +573,19 @@ Engine::update()
    loadFlags_ = FT_LOAD_DEFAULT;
    if (doAutoHinting_)
      loadFlags_ |= FT_LOAD_FORCE_AUTOHINT;
 -  loadFlags_ |= FT_LOAD_NO_BITMAP; // XXX handle bitmap fonts also
++
 +  if (!embeddedBitmap_)
 +    loadFlags_ |= FT_LOAD_NO_BITMAP;
    if (doHinting_)
+   {
 -    // TODO Differentiate RGB/BGR here?
 -    unsigned long target = antiAliasingTarget_;
 -    loadFlags_ |= target;
 +    loadFlags_ |= antiAliasingTarget_;
+   }
    else
+   {
      loadFlags_ |= FT_LOAD_NO_HINTING;
 -    if (!antiAliasingEnabled_) // XXX does this hold?
 +    if (!antiAliasingEnabled_)
        loadFlags_ |= FT_LOAD_MONOCHROME;
+   }
@@ -561,7 +607,7 @@ Engine::update()
      scaler_.x_res = dpi_;
      scaler_.y_res = dpi_;
+   }
+-
++
    imageType_.width = static_cast<unsigned int>(pixelSize_);
    imageType_.height = static_cast<unsigned int>(pixelSize_);
    imageType_.flags = static_cast<int>(loadFlags_);
@@ -668,6 +714,149 @@ Engine::queryEngine()
+ }
 +void
 +convertLCDToARGB(FT_Bitmap& bitmap,
 +                 QImage& image,
 +                 bool isBGR)
 +{
 +  // TODO to be implemented
 +}
++
++
 +void
 +convertLCDVToARGB(FT_Bitmap& bitmap,
 +                  QImage& image,
 +                  bool isBGR)
 +{
 +  // TODO to be implemented
 +}
++
++
 +QImage*
 +Engine::convertBitmapToQImage(FT_Glyph src,
 +                              QRect* outRect)
 +{
 +  QImage* result = NULL;
 +  FT_BitmapGlyph bitmapGlyph;
 +  bool ownBitmapGlyph
 +    = glyphToBitmap(src, reinterpret_cast<FT_Glyph*>(&bitmapGlyph));
 +  if (!bitmapGlyph)
 +    return result;
 +  auto& bmap = bitmapGlyph->bitmap;
 +  bool ownBitmap = false;
++
 +  int width = bmap.width;
 +  int height = bmap.rows;
 +  QImage::Format format = QImage::Format_Indexed8; // goto crossing init
++
 +  if (bmap.pixel_mode == FT_PIXEL_MODE_GRAY2
 +      || bmap.pixel_mode == FT_PIXEL_MODE_GRAY4)
 +  {
 +    bmap = convertBitmapTo8Bpp(&bmap);
 +    if (!bmap.buffer)
 +      goto cleanup;
 +    ownBitmap = true;
 +  }
++
 +  if (bmap.pixel_mode == FT_PIXEL_MODE_LCD)
 +    width /= 3;
 +  else if (bmap.pixel_mode == FT_PIXEL_MODE_LCD_V)
 +    height /= 3;
++
 +  if (outRect)
 +  {
 +    outRect->setLeft(bitmapGlyph->left);
 +    outRect->setTop(-bitmapGlyph->top);
 +    outRect->setWidth(width);
 +    outRect->setHeight(height);
 +  }
++
 +  switch (bmap.pixel_mode)
 +  {
 +  case FT_PIXEL_MODE_MONO:
 +    format = QImage::Format_Mono;
 +    break;
 +  case FT_PIXEL_MODE_GRAY:
 +    format = QImage::Format_Indexed8;
 +    break;
 +  case FT_PIXEL_MODE_BGRA:
 +    // XXX "ARGB" here means BGRA due to endianness - may be problematic
 +    // on big-endian machines
 +    format = QImage::Format_ARGB32_Premultiplied;
 +    break;
 +  case FT_PIXEL_MODE_LCD:
 +  case FT_PIXEL_MODE_LCD_V:
 +    format = QImage::Format_ARGB32;
 +    break;
 +  default:
 +    goto cleanup;
 +  }
++
 +  switch (bmap.pixel_mode)
 +  {
 +  case FT_PIXEL_MODE_MONO:
 +  case FT_PIXEL_MODE_GRAY:
 +  case FT_PIXEL_MODE_BGRA:
 +    {
 +      QImage image(bmap.buffer,
 +                   width, height,
 +                   bmap.pitch,
 +                   format);
 +      if (bmap.pixel_mode == FT_PIXEL_MODE_GRAY)
 +        image.setColorTable(GraphicsDefault::deafultInstance()->grayColorTable);
 +      else if (bmap.pixel_mode == FT_PIXEL_MODE_MONO)
 +        image.setColorTable(GraphicsDefault::deafultInstance()->monoColorTable);
 +      result = new QImage(image.copy());
 +      // Don't directly use `image` since we're destroying the image
 +    }
 +    break;
 +  case FT_PIXEL_MODE_LCD:;
 +    result = new QImage(width, height, format);
 +    convertLCDToARGB(bmap, *result, lcdUsesBGR_);
 +    break;
 +  case FT_PIXEL_MODE_LCD_V:;
 +    result = new QImage(width, height, format);
 +    convertLCDVToARGB(bmap, *result, lcdUsesBGR_);
 +    break;
 +  }
++
 +cleanup:
 +  if (ownBitmapGlyph)
 +    FT_Done_Glyph(reinterpret_cast<FT_Glyph>(bitmapGlyph));
 +  if (ownBitmap)
 +    FT_Bitmap_Done(library_, &bmap);
++
 +  return result;
 +}
++
++
 +QHash<FT_Glyph_Format, QString> glyphFormatNamesCache;
 +QHash<FT_Glyph_Format, QString>&
 +glyphFormatNames()
 +{
 +  if (glyphFormatNamesCache.empty())
 +  {
 +    glyphFormatNamesCache[FT_GLYPH_FORMAT_NONE] = "None/Unknown";
 +    glyphFormatNamesCache[FT_GLYPH_FORMAT_COMPOSITE] = "Composite";
 +    glyphFormatNamesCache[FT_GLYPH_FORMAT_BITMAP] = "Bitmap";
 +    glyphFormatNamesCache[FT_GLYPH_FORMAT_OUTLINE] = "Outline";
 +    glyphFormatNamesCache[FT_GLYPH_FORMAT_PLOTTER] = "Plotter";
 +    glyphFormatNamesCache[FT_GLYPH_FORMAT_SVG] = "SVG";
 +  }
 +  return glyphFormatNamesCache;
 +}
++
 +QString*
 +glyphFormatToName(FT_Glyph_Format format)
 +{
 +  auto& names = glyphFormatNames();
 +  auto it = names.find(format);
 +  if (it == names.end())
 +    return &names[FT_GLYPH_FORMAT_NONE];
 +  return &it.value();
 +}
++
++
  QHash<FT_Encoding, QString> encodingNamesCache;
  QHash<FT_Encoding, QString>&
  encodingNames()

src/ftinspect/engine/engine.hpp

@@ -7,8 +7,11 @@
  #include "fontfilemanager.hpp"
 +#include <vector>
  #include <QString>
  #include <QMap>
 +#include <QRect>
 +#include <QImage>
  #include <ft2build.h>
  #include <freetype/freetype.h>
@@ -59,6 +62,10 @@ private:
    static int maxIndexForFaceAndCharMap(FT_CharMap charMap, unsigned max);
  };
 +// Some helper functions.
++
 +QString* glyphFormatToName(FT_Glyph_Format format);
++
  // FreeType specific data.
  class Engine
@@ -91,11 +98,17 @@ public:
    int loadFont(int fontIndex,
                 long faceIndex,
                 int namedInstanceIndex); // return number of glyphs
 -  FT_Outline* loadOutline(int glyphIndex);
 +  FT_Glyph loadGlyph(int glyphIndex);
    // Sometimes the engine is already updated, and we want to be faster
    FT_Glyph loadGlyphWithoutUpdate(int glyphIndex);
 +  // Return `true` if you need to free `out`
 +  // `out` will be set to NULL in cases of error
 +  bool glyphToBitmap(FT_Glyph src, FT_Glyph* out);
 +  FT_Bitmap convertBitmapTo8Bpp(FT_Bitmap* bitmap);
 +  QImage* convertBitmapToQImage(FT_Glyph src, QRect* outRect);
++
    // reload current triplet, but with updated settings, useful for updating
    // `ftSize_` only
    void reloadFont();
@@ -121,11 +134,11 @@ public:
    unsigned glyphIndexFromCharCode(int code, int charMapIndex);
    FT_Size_Metrics const& currentFontMetrics();
 -  QVector<CharMapInfo>& currentFontCharMaps() { return curCharMaps_; }
 +  std::vector<CharMapInfo>& currentFontCharMaps() { return curCharMaps_; }
    FontFileManager& fontFileManager() { return fontFileManager_; }
    EngineDefaultValues& engineDefaults() { return engineDefaults_; }
    bool antiAliasingEnabled() { return antiAliasingEnabled_; }
+-
 +  bool embeddedBitmapEnabled() { return embeddedBitmap_; }
    //////// Setters (direct or indirect)
@@ -149,7 +162,10 @@ public:
    void setShowSegments(bool showSegments) { showSegments_ = showSegments; }
    void setGamma(double gamma) { gamma_ = gamma; }
    void setAntiAliasingTarget(int target) { antiAliasingTarget_ = target; }
 +  void setRenderMode(int mode) { renderMode_ = mode; }
    void setAntiAliasingEnabled(bool enabled) { antiAliasingEnabled_ = enabled; }
 +  void setEmbeddedBitmap(bool force) { embeddedBitmap_ = force; }
 +  void setLCDUsesBGR(bool isBGR) { lcdUsesBGR_ = isBGR; }
    // Note: These 3 functions now takes actual mode/version from FreeType,
    // instead of values from enum in MainGUI!
@@ -174,7 +190,7 @@ private:
    QString curFamilyName_;
    QString curStyleName_;
    int curNumGlyphs_ = -1;
 -  QVector<CharMapInfo> curCharMaps_;
 +  std::vector<CharMapInfo> curCharMaps_;
    FT_Library library_;
    FTC_Manager cacheManager_;
@@ -202,10 +218,12 @@ private:
    bool doVerticalHinting_;
    bool doBlueZoneHinting_;
    bool showSegments_;
 +  bool embeddedBitmap_;
    int antiAliasingTarget_;
 +  bool lcdUsesBGR_;
 +  int renderMode_;
    double gamma_;
+-
    unsigned long loadFlags_;
    void queryEngine();

src/ftinspect/meson.build

@@ -35,7 +35,7 @@ if qt5_dep.found()
      'widgets/glyphindexselector.cpp',
      'widgets/fontsizeselector.cpp',
 -    'models/ttsettingscomboboxmodel.cpp',
 +    'models/customcomboboxmodels.cpp',
      'panels/settingpanel.cpp',
      'panels/singular.cpp',
@@ -52,7 +52,7 @@ if qt5_dep.found()
        'widgets/customwidgets.hpp',
        'widgets/glyphindexselector.hpp',
        'widgets/fontsizeselector.hpp',
 -      'widgets/glyphcontinuous.hpp',
 +      'rendering/glyphcontinuous.hpp',
        'models/ttsettingscomboboxmodel.hpp',
        'panels/settingpanel.hpp',
        'panels/singular.hpp',

src/ftinspect/models/ttsettingscomboboxmodel.cpp → src/ftinspect/models/customcomboboxmodels.cpp

@@ -190,48 +190,6 @@ HintingModeComboBoxModel::setCurrentEngineType(HintingEngineType type)
+ }
 -/////////////////////////////////////////////////////////////////////////////
 -//
 -// SimpleComboBoxModel
 -//
 -/////////////////////////////////////////////////////////////////////////////
+-
+-
 -SimpleComboBoxModel::SimpleComboBoxModel(QObject* parent)
 -: QAbstractListModel(parent)
 -{
 -}
+-
+-
 -int
 -SimpleComboBoxModel::rowCount(const QModelIndex& parent) const
 -{
 -  return items_.size();
 -}
+-
+-
 -QVariant
 -SimpleComboBoxModel::data(const QModelIndex& index, int role) const
 -{
 -  if (role != Qt::DisplayRole)
 -    return QVariant {};
+-
 -  int r = index.row();
 -  if (r < 0 || r >= items_.size())
 -    return QVariant {};
 -  return items_[r].displayName;
 -}
+-
+-
 -int
 -SimpleComboBoxModel::indexToValue(int index)
 -{
 -  if (index < 0 || index >= items_.size())
 -    return -1;
 -  return items_[index].value;
 -}
+-
+-
  /////////////////////////////////////////////////////////////////////////////
  //
  // LCDFilterComboBoxModel
@@ -240,7 +198,7 @@ SimpleComboBoxModel::indexToValue(int index)
  LCDFilterComboBoxModel::LCDFilterComboBoxModel(QObject* parent)
 -: SimpleComboBoxModel(parent)
 +: QAbstractListModel(parent)
+ {
    items_[LCDFilter_Default] = {
      FT_LCD_FILTER_DEFAULT,
@@ -269,34 +227,34 @@ LCDFilterComboBoxModel::LCDFilterComboBoxModel(QObject* parent)
  AntiAliasingComboBoxModel::AntiAliasingComboBoxModel(QObject* parent)
 -: SimpleComboBoxModel(parent)
 +: QAbstractListModel(parent)
+ {
    items_[AntiAliasing_None] = {
 -    FT_LOAD_TARGET_MONO,
 +    {FT_LOAD_TARGET_MONO, FT_RENDER_MODE_MONO, false},
      "None"
    };
    items_[AntiAliasing_Normal] = {
 -    FT_LOAD_TARGET_NORMAL,
 +    {FT_LOAD_TARGET_NORMAL, FT_RENDER_MODE_NORMAL, false},
      "Normal"
    };
    items_[AntiAliasing_Light] = {
 -    FT_LOAD_TARGET_LIGHT,
 +    {FT_LOAD_TARGET_LIGHT, FT_RENDER_MODE_LIGHT, false},
      "Light"
    };
    items_[AntiAliasing_LCD] = {
 -    FT_LOAD_TARGET_LCD,
 +    {FT_LOAD_TARGET_LCD, FT_RENDER_MODE_LCD, false},
      "LCD (RGB)"
    };
    items_[AntiAliasing_LCD_BGR] = {
 -    FT_LOAD_TARGET_LCD,
 +    {FT_LOAD_TARGET_LCD, FT_RENDER_MODE_LCD, true},
      "LCD (BGR)"
    };
    items_[AntiAliasing_LCD_Vertical] = {
 -    FT_LOAD_TARGET_LCD_V,
 +    {FT_LOAD_TARGET_LCD_V, FT_RENDER_MODE_LCD_V, false},
      "LCD (vert. RGB)"
    };
    items_[AntiAliasing_LCD_Vertical_BGR] = {
 -    FT_LOAD_TARGET_LCD_V, // XXX Bug: No difference between RGB and BGR?
 +    {FT_LOAD_TARGET_LCD_V, FT_RENDER_MODE_LCD_V, true},
      "LCD (vert. BGR)"
    };
@@ -312,7 +270,7 @@ AntiAliasingComboBoxModel::data(const QModelIndex& index,
      if (index.row() == AntiAliasing_Light && !lightAntiAliasingEnabled_)
        return QApplication::palette().color(QPalette::Disabled,
                                             QPalette::Text);
 -  return SimpleComboBoxModel::data(index, role);
 +  return SimpleComboBoxModelImpl::data(index, role);
+ }

src/ftinspect/models/ttsettingscomboboxmodel.hpp → src/ftinspect/models/customcomboboxmodels.hpp

@@ -71,25 +71,47 @@ public:
  // A simple key-displayName-value model for QComboBox.
 -class SimpleComboBoxModel
 -: public QAbstractListModel
 +template <class T>
 +class SimpleComboBoxModelImpl
+ {
 -  Q_OBJECT
  public:
    struct ComboBoxItem
+   {
 -    int value;
 +    T value;
      QString displayName;
    };
 -  explicit SimpleComboBoxModel(QObject* parent);
 -  ~SimpleComboBoxModel() override = default;
 +  SimpleComboBoxModelImpl() {}
 +  virtual ~SimpleComboBoxModelImpl() = default;
 -  int rowCount(const QModelIndex& parent) const;
 -  QVariant data(const QModelIndex& index,
 -                int role) const;
 +  virtual int
 +  rowCount(const QModelIndex& parent) const
 +  {
 +    return items_.size();
 +  }
 -  int indexToValue(int index);
++
 +  virtual QVariant
 +  data(const QModelIndex& index,
 +                int role) const
 +  {
 +    if (role != Qt::DisplayRole)
 +      return QVariant{};
++
 +    int r = index.row();
 +    if (r < 0 || r >= items_.size())
 +      return QVariant{};
 +    return items_[r].displayName;
 +  }
++
++
 +  virtual T
 +  indexToValue(int index)
 +  {
 +    if (index < 0 || index >= items_.size())
 +      return T();
 +    return items_[index].value;
 +  }
  protected:
    QHash<int, ComboBoxItem> items_;
@@ -97,7 +119,8 @@ protected:
  class LCDFilterComboBoxModel
 -: public SimpleComboBoxModel
 +: public QAbstractListModel,
 +  public SimpleComboBoxModelImpl<int>
+ {
    Q_OBJECT
  public:
@@ -108,11 +131,26 @@ public:
      QString displayName;
    };
++
    explicit LCDFilterComboBoxModel(QObject* parent);
    virtual ~LCDFilterComboBoxModel() = default;
++
 +  int rowCount(const QModelIndex& parent) const override
 +  {
 +    return SimpleComboBoxModelImpl::rowCount(parent);
 +  }
++
++
 +  QVariant
 +  data(const QModelIndex& index,
 +       int role) const override
 +  {
 +    return SimpleComboBoxModelImpl::data(index, role);
 +  }
++
  public:
 -  enum LCDFilter
 +  enum LCDFilter : int
+   {
      LCDFilter_Default,
      LCDFilter_Light,
@@ -122,8 +160,18 @@ public:
  };
 +struct AASetting
 +{
 +  // No default value for braced init - No C++14, what a pain!
 +  int loadFlag;
 +  int renderMode;
 +  bool isBGR;
 +};
++
++
  class AntiAliasingComboBoxModel
 -: public SimpleComboBoxModel
 +: public QAbstractListModel,
 +  public SimpleComboBoxModelImpl<AASetting>
+ {
    Q_OBJECT
  public:
@@ -136,6 +184,13 @@ public:
                  int role) const;
    Qt::ItemFlags flags(const QModelIndex& index) const;
++
 +  int rowCount(const QModelIndex& parent) const override
 +  {
 +    return SimpleComboBoxModelImpl::rowCount(parent);
 +  }
++
++
    void setLightAntiAliasingEnabled(bool enabled)
+   {
      lightAntiAliasingEnabled_ = enabled;

src/ftinspect/panels/continuous.cpp

@@ -130,6 +130,11 @@ ContinuousTab::updateFromCurrentSubTab()
      canvas_->setBeginIndex(allGlyphsTab_->glyphBeginindex());
      canvas_->setLimitIndex(allGlyphsTab_->glyphLimitIndex());
      canvas_->setCharMapIndex(allGlyphsTab_->charMapIndex());
++
 +    canvas_->setFancyParams(allGlyphsTab_->xEmboldening(),
 +                            allGlyphsTab_->yEmboldening(),
 +                            allGlyphsTab_->slanting());
 +    canvas_->setStrokeRadius(allGlyphsTab_->strokeRadius());
      break;
+   }
+ }
@@ -140,9 +145,11 @@ ContinousAllGlyphsTab::ContinousAllGlyphsTab(QWidget* parent)
+ {
    createLayout();
 -  QVector<CharMapInfo> tempCharMaps;
 +  std::vector<CharMapInfo> tempCharMaps;
    setCharMaps(tempCharMaps); // pass in an empty one
 +  checkSubMode();
 +  setDefaults();
    createConnections();
+ }
@@ -169,13 +176,41 @@ ContinousAllGlyphsTab::subMode()
+ }
 +double
 +ContinousAllGlyphsTab::xEmboldening()
 +{
 +  return xEmboldeningSpinBox_->value();
 +}
++
++
 +double
 +ContinousAllGlyphsTab::yEmboldening()
 +{
 +  return yEmboldeningSpinBox_->value();
 +}
++
++
 +double
 +ContinousAllGlyphsTab::slanting()
 +{
 +  return slantSpinBox_->value();
 +}
++
++
 +double
 +ContinousAllGlyphsTab::strokeRadius()
 +{
 +  return strokeRadiusSpinBox_->value();
 +}
++
++
  int
  ContinousAllGlyphsTab::charMapIndex()
+ {
    auto index = charMapSelector_->currentIndex() - 1;
    if (index <= -1)
      return -1;
 -  if (index >= charMaps_.size())
 +  if (static_cast<unsigned>(index) >= charMaps_.size())
      return -1;
    return index;
+ }
@@ -205,7 +240,7 @@ ContinousAllGlyphsTab::setDisplayingCount(int count)
  #define EncodingRole (Qt::UserRole + 10)
  void
 -ContinousAllGlyphsTab::setCharMaps(QVector<CharMapInfo>& charMaps)
 +ContinousAllGlyphsTab::setCharMaps(std::vector<CharMapInfo>& charMaps)
+ {
    charMaps_ = charMaps;
    int oldIndex = charMapSelector_->currentIndex();
@@ -263,6 +298,20 @@ ContinousAllGlyphsTab::updateLimitIndex()
+ }
 +void
 +ContinousAllGlyphsTab::checkSubMode()
 +{
 +  auto isFancy = subMode() == GlyphContinuous::AG_Fancy;
 +  auto isStroked = subMode() == GlyphContinuous::AG_Stroked;
 +  xEmboldeningSpinBox_->setEnabled(isFancy);
 +  yEmboldeningSpinBox_->setEnabled(isFancy);
 +  slantSpinBox_->setEnabled(isFancy);
 +  strokeRadiusSpinBox_->setEnabled(isStroked);
++
 +  emit changed();
 +}
++
++
  void
  ContinousAllGlyphsTab::createLayout()
+ {
@@ -276,13 +325,36 @@ ContinousAllGlyphsTab::createLayout()
    // Note: in sync with the enum!!
    modeSelector_->insertItem(GlyphContinuous::AG_AllGlyphs, tr("All Glyphs"));
 -  modeSelector_->insertItem(GlyphContinuous::AG_Fancy, tr("Fancy"));
 +  modeSelector_->insertItem(GlyphContinuous::AG_Fancy,
 +                            tr("Fancy (Embolding & Slanting)"));
    modeSelector_->insertItem(GlyphContinuous::AG_Stroked, tr("Stroked"));
    modeSelector_->insertItem(GlyphContinuous::AG_Waterfall, tr("Waterfall"));
    modeSelector_->setCurrentIndex(GlyphContinuous::AG_AllGlyphs);
    modeLabel_ = new QLabel(tr("Mode:"), this);
    charMapLabel_ = new QLabel(tr("Char Map:"), this);
 +  xEmboldeningLabel_ = new QLabel(tr("Hori. Embolding:"), this);
 +  yEmboldeningLabel_ = new QLabel(tr("Vert. Embolding:"), this);
 +  slantLabel_ = new QLabel(tr("Slanting:"), this);
 +  strokeRadiusLabel_ = new QLabel(tr("Stroke Radius:"), this);
++
 +  xEmboldeningSpinBox_ = new QDoubleSpinBox(this);
 +  yEmboldeningSpinBox_ = new QDoubleSpinBox(this);
 +  slantSpinBox_ = new QDoubleSpinBox(this);
 +  strokeRadiusSpinBox_ = new QDoubleSpinBox(this);
++
 +  xEmboldeningSpinBox_->setSingleStep(0.005);
 +  xEmboldeningSpinBox_->setMinimum(-0.1);
 +  xEmboldeningSpinBox_->setMaximum(0.1);
 +  yEmboldeningSpinBox_->setSingleStep(0.005);
 +  yEmboldeningSpinBox_->setMinimum(-0.1);
 +  yEmboldeningSpinBox_->setMaximum(0.1);
 +  slantSpinBox_->setSingleStep(0.02);
 +  slantSpinBox_->setMinimum(-1);
 +  slantSpinBox_->setMaximum(1);
 +  strokeRadiusSpinBox_->setSingleStep(0.005);
 +  strokeRadiusSpinBox_->setMinimum(0);
 +  strokeRadiusSpinBox_->setMaximum(0.05);
    layout_ = new QGridLayout;
    layout_->addWidget(indexSelector_, 0, 0, 1, 2);
@@ -291,7 +363,17 @@ ContinousAllGlyphsTab::createLayout()
    layout_->addWidget(modeSelector_, 1, 1);
    layout_->addWidget(charMapSelector_, 2, 1);
 +  layout_->addWidget(xEmboldeningLabel_, 1, 2);
 +  layout_->addWidget(yEmboldeningLabel_, 2, 2);
 +  layout_->addWidget(slantLabel_, 3, 2);
 +  layout_->addWidget(strokeRadiusLabel_, 3, 0);
 +  layout_->addWidget(xEmboldeningSpinBox_, 1, 3);
 +  layout_->addWidget(yEmboldeningSpinBox_, 2, 3);
 +  layout_->addWidget(slantSpinBox_, 3, 3);
 +  layout_->addWidget(strokeRadiusSpinBox_, 3, 1);
++
    layout_->setColumnStretch(1, 1);
 +  layout_->setColumnStretch(3, 1);
    setLayout(layout_);
+ }
@@ -302,9 +384,22 @@ ContinousAllGlyphsTab::createConnections()
    connect(indexSelector_, &GlyphIndexSelector::currentIndexChanged,
            this, &ContinousAllGlyphsTab::changed);
    connect(modeSelector_, QOverload<int>::of(&QComboBox::currentIndexChanged),
 -          this, &ContinousAllGlyphsTab::changed);
 +          this, &ContinousAllGlyphsTab::checkSubMode);
    connect(charMapSelector_, QOverload<int>::of(&QComboBox::currentIndexChanged),
            this, &ContinousAllGlyphsTab::charMapChanged);
++
 +  connect(xEmboldeningSpinBox_,
 +          QOverload<double>::of(&QDoubleSpinBox::valueChanged),
 +          this, &ContinousAllGlyphsTab::changed);
 +  connect(yEmboldeningSpinBox_,
 +          QOverload<double>::of(&QDoubleSpinBox::valueChanged),
 +          this, &ContinousAllGlyphsTab::changed);
 +  connect(slantSpinBox_,
 +          QOverload<double>::of(&QDoubleSpinBox::valueChanged),
 +          this, &ContinousAllGlyphsTab::changed);
 +  connect(strokeRadiusSpinBox_,
 +          QOverload<double>::of(&QDoubleSpinBox::valueChanged),
 +          this, &ContinousAllGlyphsTab::changed);
+ }
@@ -324,7 +419,8 @@ ContinousAllGlyphsTab::charMapChanged()
    int newIndex = charMapSelector_->currentIndex();
    if (newIndex != lastCharMapIndex_)
+   {
 -    if (newIndex <= 0 || charMaps_.size() <= newIndex - 1)
 +    if (newIndex <= 0
 +        || charMaps_.size() <= static_cast<unsigned>(newIndex - 1))
        setGlyphBeginindex(0);
      else if (charMaps_[newIndex - 1].maxIndex <= 20)
        setGlyphBeginindex(charMaps_[newIndex - 1].maxIndex - 1);
@@ -339,4 +435,14 @@ ContinousAllGlyphsTab::charMapChanged()
+ }
 +void
 +ContinousAllGlyphsTab::setDefaults()
 +{
 +  xEmboldeningSpinBox_->setValue(0.04);
 +  yEmboldeningSpinBox_->setValue(0.04);
 +  slantSpinBox_->setValue(0.22);
 +  strokeRadiusSpinBox_->setValue(0.02);
 +}
++
++
  // end of continuous.cpp

src/ftinspect/panels/continuous.hpp

@@ -12,10 +12,10 @@
  #include "../rendering/glyphcontinuous.hpp"
  #include "../engine/engine.hpp"
 +#include <vector>
  #include <QWidget>
  #include <QLabel>
  #include <QComboBox>
 -#include <QVector>
  #include <QGridLayout>
  #include <QBoxLayout>
@@ -79,6 +79,10 @@ public:
    int glyphBeginindex();
    int glyphLimitIndex();
    GlyphContinuous::SubModeAllGlyphs subMode();
 +  double xEmboldening();
 +  double yEmboldening();
 +  double slanting();
 +  double strokeRadius();
    // -1: Glyph order, otherwise the char map index in the original list
    int charMapIndex();
@@ -88,10 +92,12 @@ public:
    void setGlyphCount(int count);
    void setDisplayingCount(int count);
 -  void setCharMaps(QVector<CharMapInfo>& charMaps);
 +  void setCharMaps(std::vector<CharMapInfo>& charMaps);
    // This doesn't trigger either.
    void updateLimitIndex();
 +  void checkSubMode();
++
  signals:
    void changed();
@@ -106,16 +112,27 @@ private:
    QLabel* modeLabel_;
    QLabel* charMapLabel_;
 +  QLabel* xEmboldeningLabel_;
 +  QLabel* yEmboldeningLabel_;
 +  QLabel* slantLabel_;
 +  QLabel* strokeRadiusLabel_;
++
 +  QDoubleSpinBox* xEmboldeningSpinBox_;
 +  QDoubleSpinBox* yEmboldeningSpinBox_;
 +  QDoubleSpinBox* slantSpinBox_;
 +  QDoubleSpinBox* strokeRadiusSpinBox_;
    QGridLayout* layout_;
 -  QVector<CharMapInfo> charMaps_;
 +  std::vector<CharMapInfo> charMaps_;
    void createLayout();
    void createConnections();
    QString formatIndex(int index);
    void charMapChanged();
++
 +  void setDefaults();
  };

src/ftinspect/panels/settingpanel.cpp

@@ -172,8 +172,12 @@ SettingPanel::syncSettings()
    engine_->setLcdFilter(
      static_cast<FT_LcdFilter>(lcdFilterComboboxModel_->indexToValue(
        lcdFilterComboBox_->currentIndex())));
 -  engine_->setAntiAliasingTarget(antiAliasingComboBoxModel_->indexToValue(
 -    antiAliasingComboBox_->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());
@@ -184,6 +188,9 @@ SettingPanel::syncSettings()
    engine_->setShowSegments(segmentDrawingCheckBox_->isChecked());
    engine_->setGamma(gammaSlider_->value());
++
 +  engine_->setEmbeddedBitmap(embeddedBitmapCheckBox_->isChecked());
 +  engine_->setLCDUsesBGR(aaSettings.isBGR);
+ }
@@ -218,6 +225,8 @@ SettingPanel::createConnections()
    connect(autoHintingCheckBox_, &QCheckBox::clicked,
            this, &SettingPanel::checkAutoHinting);
 +  connect(embeddedBitmapCheckBox_, &QCheckBox::clicked,
 +          this, &SettingPanel::repaintNeeded);
+ }
@@ -239,6 +248,7 @@ SettingPanel::createLayout()
    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);
    antiAliasingLabel_ = new QLabel(tr("Anti-Aliasing"), this);
    antiAliasingLabel_->setAlignment(Qt::AlignRight);
@@ -329,6 +339,7 @@ SettingPanel::createLayout()
    generalTabLayout_->addSpacing(20); // XXX px
    generalTabLayout_->addStretch(1);
    generalTabLayout_->addLayout(gammaLayout_);
 +  generalTabLayout_->addWidget(embeddedBitmapCheckBox_);
    generalTabLayout_->addSpacing(20); // XXX px
    generalTabLayout_->addStretch(1);
@@ -376,6 +387,7 @@ SettingPanel::setDefaults()
    horizontalHintingCheckBox_->setChecked(true);
    verticalHintingCheckBox_->setChecked(true);
    blueZoneHintingCheckBox_->setChecked(true);
 +  embeddedBitmapCheckBox_->setChecked(false);
    gammaSlider_->setValue(18); // 1.8
+ }

src/ftinspect/panels/settingpanel.hpp

@@ -63,6 +63,7 @@ private:
    QCheckBox* blueZoneHintingCheckBox_;
    QCheckBox* segmentDrawingCheckBox_;
    QCheckBox* autoHintingCheckBox_;
 +  QCheckBox* embeddedBitmapCheckBox_;
    AntiAliasingComboBoxModel* antiAliasingComboBoxModel_;
    HintingModeComboBoxModel* hintingModeComboBoxModel_;

src/ftinspect/panels/singular.cpp

@@ -87,29 +87,21 @@ SingularTab::drawGlyph()
+   }
    syncSettings();
 -  FT_Outline* outline = engine_->loadOutline(currentGlyphIndex_);
 -  if (outline)
 +  FT_Glyph glyph = engine_->loadGlyph(currentGlyphIndex_);
 +  if (glyph)
+   {
      if (showBitmapCheckBox_->isChecked())
+     {
 -      // XXX support LCD
 -      FT_Pixel_Mode pixelMode = FT_PIXEL_MODE_GRAY;
 -      if (!engine_->antiAliasingEnabled())
 -        pixelMode = FT_PIXEL_MODE_MONO;
+-
        currentGlyphBitmapItem_
 -        = new GlyphBitmap(outline,
 -          engine_->ftLibrary(),
 -          pixelMode,
 -          graphicsDefault_->monoColorTable,
 -          graphicsDefault_->grayColorTable);
 +        = new GlyphBitmap(glyph,
 +                          engine_);
        glyphScene_->addItem(currentGlyphBitmapItem_);
+     }
      if (showOutlinesCheckBox_->isChecked())
+     {
        currentGlyphOutlineItem_ = new GlyphOutline(graphicsDefault_->outlinePen,
 -                                                  outline);
 +                                                  glyph);
        glyphScene_->addItem(currentGlyphOutlineItem_);
+     }
@@ -117,7 +109,7 @@ SingularTab::drawGlyph()
+     {
        currentGlyphPointsItem_ = new GlyphPoints(graphicsDefault_->onPen,
                                                  graphicsDefault_->offPen,
 -                                                outline);
 +                                                glyph);
        glyphScene_->addItem(currentGlyphPointsItem_);
        if (showPointNumbersCheckBox_->isChecked())
@@ -125,7 +117,7 @@ SingularTab::drawGlyph()
          currentGlyphPointNumbersItem_
            = new GlyphPointNumbers(graphicsDefault_->onPen,
                                    graphicsDefault_->offPen,
 -                                  outline);
 +                                  glyph);
          glyphScene_->addItem(currentGlyphPointNumbersItem_);
+       }
+     }

src/ftinspect/rendering/glyphbitmap.cpp

@@ -6,33 +6,26 @@
  #include "glyphbitmap.hpp"
  #include "renderutils.hpp"
 +#include "../engine/engine.hpp"
  #include <cmath>
  #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(FT_Glyph glyph,
 +                         Engine* engine)
+ {
 -  // make a copy of the outline since we are going to manipulate it
 -  FT_BBox cbox;
 -  transformed_ = transformOutlineToOrigin(lib, outline, &cbox);
 -  boundingRect_.setCoords(cbox.xMin / 64, -cbox.yMax / 64,
 -                  cbox.xMax / 64, -cbox.yMin / 64);
 +  QRect bRect;
 +  image_ = engine->convertBitmapToQImage(glyph, &bRect);
 +  boundingRect_ = bRect; // QRectF to QRect
+ }
  GlyphBitmap::~GlyphBitmap()
+ {
 -  FT_Outline_Done(library_, &transformed_);
 +  delete image_;
+ }
  QRectF
@@ -47,40 +40,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
@@ -94,11 +56,11 @@ GlyphBitmap::paint(QPainter* painter,
    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,
@@ -108,7 +70,9 @@ GlyphBitmap::paint(QPainter* painter,
                                 qBlue(p),
                                 qAlpha(p)));
+     }
++
  #endif
++
+ }

src/ftinspect/rendering/glyphbitmap.hpp

@@ -10,18 +10,18 @@
  #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(FT_Glyph glyph,
 +              Engine* engine);
    ~GlyphBitmap() override;
    QRectF boundingRect() const override;
    void paint(QPainter* painter,
@@ -29,11 +29,7 @@ public:
               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/rendering/glyphcontinuous.cpp

@@ -4,13 +4,13 @@
  #include "glyphcontinuous.hpp"
 +#include "../engine/engine.hpp"
 +#include "../rendering/renderutils.hpp"
++
  #include <cmath>
  #include <QPainter>
  #include <QWheelEvent>
 -#include "../engine/engine.hpp"
 -#include "../rendering/renderutils.hpp"
+-
  GlyphContinuous::GlyphContinuous(QWidget* parent, Engine* engine)
  : QWidget(parent), engine_(engine)
@@ -18,6 +18,15 @@ GlyphContinuous::GlyphContinuous(QWidget* parent, Engine* engine)
    setAcceptDrops(false);
    setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    graphicsDefault_ = GraphicsDefault::deafultInstance();
++
 +  FT_Stroker_New(engine_->ftLibrary(), &stroker_);
 +}
++
++
 +GlyphContinuous::~GlyphContinuous()
 +{
 +  cleanCloned();
 +  FT_Stroker_Done(stroker_);
+ }
@@ -38,12 +47,9 @@ GlyphContinuous::paintEvent(QPaintEvent* event)
        switch (modeAG_)
+       {
        case AG_AllGlyphs:
 -        paintAGAllGlyphs(&painter);
 -        break;
 -        // TODO more modes
        case AG_Fancy:
 -        break;
        case AG_Stroked:
 +        paintAG(&painter);
          break;
        case AG_Waterfall:
          break;
@@ -71,19 +77,114 @@ GlyphContinuous::wheelEvent(QWheelEvent* event)
  void
 -GlyphContinuous::paintAGAllGlyphs(QPainter* painter)
 +GlyphContinuous::paintAG(QPainter* painter)
+ {
 +  if (modeAG_ == AG_Stroked)
 +  {
 +    auto radius = static_cast<FT_Fixed>(metrics_.y_ppem * 64 * strokeRadius_);
 +    FT_Stroker_Set(stroker_, radius,
 +                   FT_STROKER_LINECAP_ROUND,
 +                   FT_STROKER_LINEJOIN_ROUND,
 +                   0);
 +  }
++
    for (int i = beginIndex_; i < limitIndex_; i++)
+   {
      unsigned index = i;
      if (charMapIndex_ >= 0)
        index = engine_->glyphIndexFromCharCode(i, charMapIndex_);
 -    if (!paintChar(painter, index))
 +    if (!loadGlyph(index))
 +      break;
++
 +    // All Glyphs need no tranformation, and Waterfall isn't handled here.
 +    switch (modeAG_)
 +    {
 +    case AG_Fancy:
 +      transformGlyphAGFancy();
 +      break;
 +    case AG_Stroked:
 +      transformGlyphAGStroked();
        break;
 +    default:;
 +    }
++
 +    if (!paintChar(painter))
 +      break;
 +    cleanCloned();
      displayingCount_++;
+   }
 +  cleanCloned();
 +}
++
++
 +void
 +GlyphContinuous::transformGlyphAGFancy()
 +{
 +  // adopted from ftview.c:289
 +  /***************************************************************/
 +  /*                                                             */
 +  /*  2*2 affine transformation matrix, 16.16 fixed float format */
 +  /*                                                             */
 +  /*  Shear matrix:                                              */
 +  /*                                                             */
 +  /*         | x' |     | 1  k |   | x |          x' = x + ky    */
 +  /*         |    |  =  |      | * |   |   <==>                  */
 +  /*         | y' |     | 0  1 |   | y |          y' = y         */
 +  /*                                                             */
 +  /*        outline'     shear    outline                        */
 +  /*                                                             */
 +  /***************************************************************/
++
 +  FT_Matrix shear;
 +  FT_Pos xstr, ystr;
++
 +  shear.xx = 1 << 16;
 +  shear.xy = static_cast<FT_Fixed>(slant_ * (1 << 16));
 +  shear.yx = 0;
 +  shear.yy = 1 << 16;
++
 +  xstr = (FT_Pos)(metrics_.y_ppem * 64 * boldX_);
 +  ystr = (FT_Pos)(metrics_.y_ppem * 64 * boldY_);
++
 +  if (!isGlyphCloned_)
 +    cloneGlyph();
++
 +  if (glyph_->format != FT_GLYPH_FORMAT_OUTLINE)
 +    return; // TODO suuport non-outline: code below all depend on `outline_`!
++
 +  FT_Outline_Transform(&outline_, &shear);
 +  FT_Outline_EmboldenXY(&outline_, xstr, ystr);
++
 +  if (glyph_->advance.x)
 +    glyph_->advance.x += xstr;
++
 +  if (glyph_->advance.y)
 +    glyph_->advance.y += ystr;
++
 +  //glyph_->metrics.width += xstr;
 +  //glyph_->metrics.height += ystr;
 +  //glyph_->metrics.horiAdvance += xstr;
 +  //glyph_->metrics.vertAdvance += ystr;
 +}
++
++
 +void
 +GlyphContinuous::transformGlyphAGStroked()
 +{
 +  //if (!isGlyphCloned_)
 +    //cloneGlyph();
 +  // Well, now here only outline glyph is supported.
 +  if (glyph_->format != FT_GLYPH_FORMAT_OUTLINE)
 +    return;
 +  auto error = FT_Glyph_Stroke(&glyph_, stroker_, 0);
 +  if (!error)
 +  {
 +    isGlyphCloned_ = true;
 +    isOutlineCloned_ = false;
 +    outline_ = reinterpret_cast<FT_OutlineGlyph>(glyph_)->outline;
 +  }
+ }
@@ -101,16 +202,11 @@ GlyphContinuous::prePaint()
  bool
 -GlyphContinuous::paintChar(QPainter* painter,
 -                           int index)
 +GlyphContinuous::paintChar(QPainter* painter)
+ {
 -  auto glyph = engine_->loadGlyphWithoutUpdate(index);
 -  if (!glyph)
 -    return false;
+-
    // ftview.c:557
 -  int width = glyph->advance.x ? glyph->advance.x >> 16
 -                               : metrics_.y_ppem / 2;
 +  int width = glyph_->advance.x ? glyph_->advance.x >> 16
 +                                : metrics_.y_ppem / 2;
    if (!checkFitX(x_ + width))
+   {
@@ -122,7 +218,7 @@ GlyphContinuous::paintChar(QPainter* painter,
+   }
    x_++; // extra space
 -  if (glyph->advance.x == 0)
 +  if (glyph_->advance.x == 0)
+   {
      // Draw a red square to indicate
        painter->fillRect(x_, y_ - width, width, width,
@@ -136,15 +232,15 @@ GlyphContinuous::paintChar(QPainter* painter,
    // First translate the outline
 -  if (glyph->format != FT_GLYPH_FORMAT_OUTLINE)
 +  if (glyph_->format != FT_GLYPH_FORMAT_OUTLINE)
      return true; // XXX only outline is supported - need to impl others later
    FT_BBox cbox;
    // Don't forget to free this when returning
 -  auto outline = transformOutlineToOrigin(
 -                   engine_->ftLibrary(),
 -                   &reinterpret_cast<FT_OutlineGlyph>(glyph)->outline,
 -                   &cbox);
 +  if (!isOutlineCloned_ && !isGlyphCloned_)
 +    cloneOutline();
++
 +  transformOutlineToOrigin(&outline_, &cbox);
    auto outlineWidth = (cbox.xMax - cbox.xMin) / 64;
    auto outlineHeight = (cbox.yMax - cbox.yMin) / 64;
@@ -175,12 +271,11 @@ GlyphContinuous::paintChar(QPainter* painter,
    bitmap.pixel_mode = aaEnabled ? FT_PIXEL_MODE_GRAY : FT_PIXEL_MODE_MONO;
    FT_Error error = FT_Outline_Get_Bitmap(engine_->ftLibrary(),
 -                                         &outline,
 +                                         &outline_,
                                           &bitmap);
    if (error)
+   {
      // XXX error handling
 -    FT_Outline_Done(engine_->ftLibrary(), &outline);
      return true;
+   }
@@ -189,12 +284,59 @@ GlyphContinuous::paintChar(QPainter* painter,
        image.convertToFormat(QImage::Format_ARGB32_Premultiplied));
    x_ += width;
++
 +  return true;
 +}
++
 -  FT_Outline_Done(engine_->ftLibrary(), &outline);
 +bool
 +GlyphContinuous::loadGlyph(int index)
 +{
 +  glyph_ = engine_->loadGlyphWithoutUpdate(index);
 +  isGlyphCloned_ = false;
 +  if (!glyph_)
 +    return false;
 +  if (glyph_->format == FT_GLYPH_FORMAT_OUTLINE)
 +  {
 +    isOutlineCloned_ = false;
 +    outline_ = reinterpret_cast<FT_OutlineGlyph>(glyph_)->outline;
 +  }
    return true;
+ }
 +void
 +GlyphContinuous::cloneGlyph()
 +{
 +  glyph_ = ::cloneGlyph(glyph_);
 +  isGlyphCloned_ = true;
 +}
++
++
 +void
 +GlyphContinuous::cloneOutline()
 +{
 +  outline_ = ::cloneOutline(engine_->ftLibrary(), &outline_);
 +  isOutlineCloned_ = true;
 +}
++
++
 +void
 +GlyphContinuous::cleanCloned()
 +{
 +  if (isGlyphCloned_)
 +  {
 +    FT_Done_Glyph(glyph_);
 +    isGlyphCloned_ = false;
 +  }
 +  if (isOutlineCloned_)
 +  {
 +    FT_Outline_Done(engine_->ftLibrary(), &outline_);
 +    isOutlineCloned_ = false;
 +  }
 +}
++
++
  bool
  GlyphContinuous::checkFitX(int x)
+ {

src/ftinspect/rendering/glyphcontinuous.hpp

@@ -7,6 +7,9 @@
  #include "graphicsdefault.hpp"
  #include <QWidget>
  #include <freetype/freetype.h>
 +#include <freetype/ftglyph.h>
 +#include <freetype/ftoutln.h>
 +#include <freetype/ftstroke.h>
  class Engine;
  class GlyphContinuous
@@ -15,7 +18,7 @@ class GlyphContinuous
    Q_OBJECT
  public:
    GlyphContinuous(QWidget* parent, Engine* engine);
 -  ~GlyphContinuous() override = default;
 +  ~GlyphContinuous() override;
    enum Mode : int
+   {
@@ -39,6 +42,13 @@ public:
    void setCharMapIndex(int index) { charMapIndex_ = index; }
    void setMode(Mode mode) { mode_ = mode; }
    void setSubModeAllGlyphs(SubModeAllGlyphs modeAg) { modeAG_ = modeAg; }
 +  void setFancyParams(double boldX, double boldY, double slant)
 +  {
 +    boldX_ = boldX;
 +    boldY_ = boldY;
 +    slant_ = slant;
 +  }
 +  void setStrokeRadius(double radius) { strokeRadius_ = radius; }
  signals:
    void wheelNavigate(int steps);
@@ -53,21 +63,36 @@ private:
    Engine* engine_;
    GraphicsDefault* graphicsDefault_;
 +  Mode mode_ = AllGlyphs;
 +  SubModeAllGlyphs modeAG_ = AG_AllGlyphs;
    int beginIndex_;
    int limitIndex_;
    int charMapIndex_;
 -  Mode mode_ = AllGlyphs;
 -  SubModeAllGlyphs modeAG_ = AG_AllGlyphs;
 +  double boldX_, boldY_, slant_;
 +  double strokeRadius_;
    int displayingCount_ = 0;
    FT_Size_Metrics metrics_;
    int x_ = 0, y_ = 0;
    int stepY_ = 0;
 +  FT_Glyph glyph_;
 +  FT_Outline outline_;
 +  // when glyph is cloned, outline is factually also cloned
 +  // but `isOutlineCloned` won't be set!
 +  bool isGlyphCloned_ = false, isOutlineCloned_ = false;
++
 +  FT_Stroker stroker_;
 -  void paintAGAllGlyphs(QPainter* painter);
 +  void paintAG(QPainter* painter);
 +  void transformGlyphAGFancy();
 +  void transformGlyphAGStroked();
    void prePaint();
    // return if there's enough space to paint the current char
 -  bool paintChar(QPainter* painter, int index);
 +  bool paintChar(QPainter* painter);
 +  bool loadGlyph(int index);
 +  void cloneGlyph();
 +  void cloneOutline();
 +  void cleanCloned();
    bool checkFitX(int x);
    bool checkFitY(int y);

src/ftinspect/rendering/glyphoutline.cpp

@@ -88,10 +88,16 @@ static FT_Outline_Funcs outlineFuncs =
  GlyphOutline::GlyphOutline(const QPen& pen,
 -                           FT_Outline* outline)
 -: outlinePen_(pen),
 -  outline_(outline)
 +                           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/rendering/glyphoutline.hpp

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

src/ftinspect/rendering/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/rendering/glyphpointnumbers.hpp

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

src/ftinspect/rendering/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/rendering/glyphpoints.hpp

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

src/ftinspect/rendering/grid.hpp

@@ -6,6 +6,7 @@
  #pragma once
  #include <QGraphicsItem>
 +#include <QGraphicsView>
  #include <QPen>
  class Grid

src/ftinspect/rendering/renderutils.cpp

@@ -5,16 +5,43 @@
  #include "renderutils.hpp"
  FT_Outline
 -transformOutlineToOrigin(FT_Library library,
 -                         FT_Outline* outline,
 -                         FT_BBox* outControlBox)
 +cloneOutline(FT_Library library,
 +             FT_Outline* src)
+ {
    FT_Outline transformed;
 -  FT_Outline_New(library,
 -                 static_cast<unsigned int>(outline->n_points),
 -                 outline->n_contours, &transformed);
 -  FT_Outline_Copy(outline, &transformed);
 +  FT_Outline_New(library, static_cast<unsigned int>(src->n_points),
 +                 src->n_contours, &transformed);
 +  FT_Outline_Copy(src, &transformed);
 +  return transformed;
 +}
++
++
 +FT_Glyph
 +cloneGlyph(FT_Glyph src)
 +{
 +  FT_Glyph target = NULL;
 +  FT_Glyph_Copy(src, &target);
 +  return target;
 +}
++
 +void
 +transformOutlineToOrigin(FT_Outline* outline,
 +                         FT_BBox* outControlBox)
 +{
 +  FT_Pos x, y;
 +  computeTransformationToOrigin(outline,
 +                                &x, &y,
 +                                outControlBox);
 +  FT_Outline_Translate(outline, x, y);
 +}
++
++
 +void computeTransformationToOrigin(FT_Outline* outline,
 +                                   FT_Pos* outXOffset,
 +                                   FT_Pos* outYOffset,
 +                                   FT_BBox* outControlBox)
 +{
    FT_BBox cbox;
    FT_Outline_Get_CBox(outline, &cbox);
@@ -23,11 +50,12 @@ transformOutlineToOrigin(FT_Library library,
    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);
+-
 +  if (outXOffset)
 +    *outXOffset = -cbox.xMin;
 +  if (outYOffset)
 +    *outYOffset = -cbox.yMin;
    if (outControlBox)
      *outControlBox = cbox;
 -  return transformed;
+ }

src/ftinspect/rendering/renderutils.hpp

@@ -4,12 +4,20 @@
  #pragma once
 +#include <freetype/ftglyph.h>
  #include <freetype/ftoutln.h>
  // The constructed `outline` must be freed by the caller
 -FT_Outline transformOutlineToOrigin(FT_Library library,
 -                                    FT_Outline* outline,
 -                                    FT_BBox* outControlBox);
 +FT_Outline cloneOutline(FT_Library library, FT_Outline* src);
 +FT_Glyph cloneGlyph(FT_Glyph src);
++
 +void transformOutlineToOrigin(FT_Outline* outline,
 +                              FT_BBox* outControlBox);
++
 +void computeTransformationToOrigin(FT_Outline* outline,
 +                                   FT_Pos* outXOffset,
 +                                   FT_Pos* outYOffset,
 +                                   FT_BBox* outControlBox);
  // end of renderutils.hpp

src/ftinspect/widgets/glyphindexselector.cpp

@@ -111,12 +111,11 @@ GlyphIndexSelector::updateLabel()
                             .arg(numberRenderer_(indexSpinBox_->maximum())));
    else
      indexLabel_->setText(
 -      QString("%1~%2\nCount: %3\nLimit: %4")
 +      QString("%1~%2\nLimit: %4")
          .arg(numberRenderer_(indexSpinBox_->value()))
          .arg(numberRenderer_(
            qBound(indexSpinBox_->value(),
                   indexSpinBox_->value() + showingCount_ - 1, INT_MAX)))
 -        .arg(showingCount_)
          .arg(numberRenderer_(indexSpinBox_->maximum())));
+ }
@@ -142,7 +141,7 @@ GlyphIndexSelector::createLayout()
    indexSpinBox_->setFixedWidth(80);
    indexSpinBox_->setWrapping(false);
 -  indexLabel_ = new QLabel("0\nCount: 0\nLimit: 0");
 +  indexLabel_ = new QLabel("0\nLimit: 0");
    indexLabel_->setMinimumWidth(200);
    setButtonNarrowest(toStartButton_);

From:	Charlie Jiang (@cqjjjzr)
Subject:	[Git][freetype/freetype-demos][gsoc-2022-chariri-2] 7 commits: [ftinspect] Add Fancy submode to "Continuous View"
Date:	Thu, 14 Jul 2022 08:08:49 +0000