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

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

Commits:

38f60d85

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

[ftinspect] Add "Show Grid" check box.

* src/ftinspect/panels/singular.cpp, src/ftinspect/panels/singular.hpp:
  Add "Show Grid" check box, which uses `QGraphicsItem::setVisible`.

* src/ftinspect/rendering/grid.cpp: Remove TODO that has been resolved.

60bb6f09

by Charlie Jiang at 2022-07-14T17:04:02+08:00

[ftinspect] Fix build error on old FreeType verions.

FreeType older than 2.12.0 don't have `FT_GLYPH_FORMAT_SVG`.

* src/ftinspect/panels/singular.cpp: Add conditional compilation.

6f5ac858

by Charlie Jiang at 2022-07-14T17:28:47+08:00

* src/ftinspect/engine/engine.cpp: Fix segfault on Linux.

Honestly I have no idea how this should have been able to run on Windows.

a42eb7f9

by Charlie Jiang at 2022-07-15T14:23:36+08:00

[ftinspect] Fix grid background in dark mode.

* src/ftinspect/panels/singular.cpp: Force white as the background color.
  Set overlay label's foreground color to the correct color.

7b4fb4f7

by Charlie Jiang at 2022-07-15T14:31:57+08:00

[ftinspect] Rewrite the GUI layout of "Continuous View"

We no longer use sub-tabs to switch between "All Glyphs", "Text String" or
other modes, and use a combo box instead. This makes the two major options
clear:

- Render Mode: Normal, Fancy, Stroked etc...
- Text Source: All Glyphs, Text String etc...

Move most code in the original "All Glyphs" sub-tab to `ContinuousTab`, and
add other options. However, they're not implemented yet.

* src/ftinspect/panels/continuous.hpp, src/ftinspect/panels/continuous.cpp:
  As described.

* src/ftinspect/rendering/glyphcontinuous.cpp,
  src/ftinspect/rendering/glyphcontinuous.hpp:
  Add new options as properties. Rename "Mode" to "Source", "SubMode" to
  "Mode".

469443c4

by Charlie Jiang at 2022-07-15T14:53:34+08:00

[ftinspect] Rework on scroll tooltip of "Singular View"

The overlay tooltip explaining scroll operations in the singular view is
annoying and ugly. Move it into a small button on the right-bottom corner..
Only show the tooltip when clicking the button.

* src/ftinspect/panels/singular.cpp, src/ftinspect/panels/singular.hpp:
  As described.

a1c3e64a

by Charlie Jiang at 2022-07-15T16:01:09+08:00

[ftinspect] Move "waterfall" out as a separate option.

"Waterfall" rendering is rather a pattern applied for the whole view instead
of individual characters. Therefore it shouldn't be placed into "Render
Mode" where Fancy/Stroked are placed.

Also squeezes out some horizontal space by rewording labels.

* src/ftinspect/panels/continuous.cpp, src/ftinspect/panels/continuous.hpp:
  As described.

* src/ftinspect/rendering/glyphcontinuous.cpp:
  Make "waterfall" a separate property instead a value in the mode enum.

c09da8bc

by Charlie Jiang at 2022-07-15T18:29:07+08:00

[ftinspect] Let continuous view support non-outline glyphs.

Integrate the rendering infrastructure we built previously into the
`GlyphContinuous`.

TODO: Optimize: Cache `QImage`s because they're expensive to create.

* src/ftinspect/rendering/glyphcontinuous.cpp,
  src/ftinspect/rendering/glyphcontinuous.hpp:
  As described, integrate rendering infrastructures from `Engine`.
  Add better documentation for FreeType objects stored in the class.
  Removed `cloneOutline` since you should never clone an outline alone.
  Renamed some functions.

* src/ftinspect/engine/engine.cpp, src/ftinspect/engine/engine.hpp:
  Split `convertBitmapToQImage` into `convertGlyphToQImage` and
  `convertBitmapToQImage`, add `computeGlyphOffset` and rename
  `glyphToBitmap` to follow the style `convertXXX`.

* src/ftinspect/rendering/glyphbitmap.cpp: Update renamed function ref.

* src/ftinspect/rendering/renderutils.cpp,
  src/ftinspect/rendering/renderutils.hpp: Add `cloneBitmap`.

12 changed files:

src/ftinspect/engine/engine.cpp
src/ftinspect/engine/engine.hpp
src/ftinspect/panels/continuous.cpp
src/ftinspect/panels/continuous.hpp
src/ftinspect/panels/singular.cpp
src/ftinspect/panels/singular.hpp
src/ftinspect/rendering/glyphbitmap.cpp
src/ftinspect/rendering/glyphcontinuous.cpp
src/ftinspect/rendering/glyphcontinuous.hpp
src/ftinspect/rendering/grid.cpp
src/ftinspect/rendering/renderutils.cpp
src/ftinspect/rendering/renderutils.hpp

Changes:

src/ftinspect/engine/engine.cpp

@@ -384,7 +384,10 @@ Engine::glyphName(int index)
    if (index < 0)
      throw std::runtime_error("Invalid glyph index");
 -   if (!FTC_Manager_LookupSize(cacheManager_, &scaler_, &ftSize_))
 +  if (!ftSize_)
 +    return "";
++
 +  if (!FTC_Manager_LookupSize(cacheManager_, &scaler_, &ftSize_))
      return name;
    if (ftSize_ && FT_HAS_GLYPH_NAMES(ftSize_->face))
@@ -409,6 +412,9 @@ Engine::loadGlyph(int glyphIndex)
    if (glyphIndex < 0)
      throw std::runtime_error("Invalid glyph index");
 +  if (curNumGlyphs_ <= 0)
 +    return NULL;
++
    FT_Glyph glyph;
    // the `scaler' object is set up by the
@@ -447,7 +453,7 @@ Engine::loadGlyphWithoutUpdate(int glyphIndex)
  bool
 -Engine::glyphToBitmap(FT_Glyph src,
 +Engine::convertGlyphToBitmapGlyph(FT_Glyph src,
                        FT_Glyph* out)
+ {
    if (src->format == FT_GLYPH_FORMAT_BITMAP)
@@ -733,16 +739,11 @@ convertLCDVToARGB(FT_Bitmap& bitmap,
  QImage*
 -Engine::convertBitmapToQImage(FT_Glyph src,
 -                              QRect* outRect)
 +Engine::convertBitmapToQImage(FT_Bitmap* src)
+ {
    QImage* result = NULL;
 -  FT_BitmapGlyph bitmapGlyph;
 -  bool ownBitmapGlyph
 -    = glyphToBitmap(src, reinterpret_cast<FT_Glyph*>(&bitmapGlyph));
 -  if (!bitmapGlyph)
 -    return result;
 -  auto& bmap = bitmapGlyph->bitmap;
++
 +  auto& bmap = *src;
    bool ownBitmap = false;
    int width = bmap.width;
@@ -763,14 +764,6 @@ Engine::convertBitmapToQImage(FT_Glyph src,
    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:
@@ -821,8 +814,6 @@ Engine::convertBitmapToQImage(FT_Glyph src,
+   }
  cleanup:
 -  if (ownBitmapGlyph)
 -    FT_Done_Glyph(reinterpret_cast<FT_Glyph>(bitmapGlyph));
    if (ownBitmap)
      FT_Bitmap_Done(library_, &bmap);
@@ -830,6 +821,56 @@ cleanup:
+ }
 +QImage*
 +Engine::convertGlyphToQImage(FT_Glyph src, QRect* outRect)
 +{
 +  FT_BitmapGlyph bitmapGlyph;
 +  bool ownBitmapGlyph
 +    = convertGlyphToBitmapGlyph(src, reinterpret_cast<FT_Glyph*>(&bitmapGlyph));
 +  if (!bitmapGlyph)
 +    return NULL;
++
 +  auto result = convertBitmapToQImage(&bitmapGlyph->bitmap);
++
 +  if (result && outRect)
 +  {
 +    outRect->setLeft(bitmapGlyph->left);
 +    outRect->setTop(-bitmapGlyph->top);
 +    outRect->setWidth(bitmapGlyph->bitmap.width);
 +    outRect->setHeight(bitmapGlyph->bitmap.rows);
 +  }
++
 +  if (ownBitmapGlyph)
 +    FT_Done_Glyph(reinterpret_cast<FT_Glyph>(bitmapGlyph));
++
 +  return result;
 +}
++
++
 +QPoint
 +Engine::computeGlyphOffset(FT_Glyph glyph)
 +{
 +  if (glyph->format == FT_GLYPH_FORMAT_OUTLINE)
 +  {
 +    FT_BBox cbox;
 +    FT_Outline_Get_CBox(&reinterpret_cast<FT_OutlineGlyph>(glyph)->outline,
 +                        &cbox);
 +    cbox.xMin &= ~63;
 +    cbox.yMin &= ~63;
 +    cbox.xMax = (cbox.xMax + 63) & ~63;
 +    cbox.yMax = (cbox.yMax + 63) & ~63;
 +    return { cbox.xMin / 64, -cbox.yMax / 64 };
 +  }
 +  if (glyph->format == FT_GLYPH_FORMAT_BITMAP)
 +  {
 +    auto bg = reinterpret_cast<FT_BitmapGlyph>(glyph);
 +    return { bg->left, -bg->top };
 +  }
++
 +  return {};
 +}
++
++
  QHash<FT_Glyph_Format, QString> glyphFormatNamesCache;
  QHash<FT_Glyph_Format, QString>&
  glyphFormatNames()
@@ -841,7 +882,9 @@ glyphFormatNames()
      glyphFormatNamesCache[FT_GLYPH_FORMAT_BITMAP] = "Bitmap";
      glyphFormatNamesCache[FT_GLYPH_FORMAT_OUTLINE] = "Outline";
      glyphFormatNamesCache[FT_GLYPH_FORMAT_PLOTTER] = "Plotter";
 +#if FREETYPE_MINOR >= 12
      glyphFormatNamesCache[FT_GLYPH_FORMAT_SVG] = "SVG";
 +#endif
+   }
    return glyphFormatNamesCache;
+ }

src/ftinspect/engine/engine.hpp

@@ -105,9 +105,11 @@ public:
    // 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);
 +  bool convertGlyphToBitmapGlyph(FT_Glyph src, FT_Glyph* out);
    FT_Bitmap convertBitmapTo8Bpp(FT_Bitmap* bitmap);
 -  QImage* convertBitmapToQImage(FT_Glyph src, QRect* outRect);
 +  QImage* convertBitmapToQImage(FT_Bitmap* src);
 +  QImage* convertGlyphToQImage(FT_Glyph src, QRect* outRect);
 +  QPoint computeGlyphOffset(FT_Glyph glyph);
    // reload current triplet, but with updated settings, useful for updating
    // `ftSize_` only

src/ftinspect/panels/continuous.cpp

@@ -13,6 +13,14 @@ ContinuousTab::ContinuousTab(QWidget* parent,
  : QWidget(parent), engine_(engine)
+ {
    createLayout();
++
 +  std::vector<CharMapInfo> tempCharMaps;
 +  setCharMaps(tempCharMaps); // pass in an empty one
++
 +  checkMode();
 +  checkSource();
 +  setDefaults();
++
    createConnections();
+ }
@@ -22,7 +30,7 @@ ContinuousTab::repaintGlyph()
+ {
    sizeSelector_->applyToEngine(engine_);
 -  updateFromCurrentSubTab();
 +  syncSettings();
    canvas_->repaint();
+ }
@@ -31,181 +39,36 @@ void
  ContinuousTab::reloadFont()
+ {
    currentGlyphCount_ = engine_->currentFontNumberOfGlyphs();
 -  updateCurrentSubTab();
 +  setGlyphCount(qBound(0, currentGlyphCount_, INT_MAX));
 +  setCharMaps(engine_->currentFontCharMaps());
    repaintGlyph();
+ }
  void
 -ContinuousTab::changeTab()
 -{
 -  updateCurrentSubTab();
 -  repaintGlyph();
 -}
+-
+-
 -void
 -ContinuousTab::wheelNavigate(int steps)
 -{
 -  if (tabWidget_->currentIndex() == AllGlyphs)
 -    allGlyphsTab_->setGlyphBeginindex(allGlyphsTab_->glyphBeginindex()
 -                                      + steps);
 -}
+-
+-
 -void
 -ContinuousTab::wheelResize(int steps)
 -{
 -  sizeSelector_->handleWheelResizeBySteps(steps);
 -}
+-
+-
 -void
 -ContinuousTab::createLayout()
 -{
 -  canvas_ = new GlyphContinuous(this, engine_);
 -  sizeSelector_ = new FontSizeSelector(this);
 -  allGlyphsTab_ = new ContinousAllGlyphsTab(this);
+-
 -  tabWidget_ = new QTabWidget(this);
 -  tabWidget_->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
 -  // Must be in sync with `Tabs` enum.
 -  tabWidget_->addTab(allGlyphsTab_, tr("All Glyphs"));
+-
 -  mainLayout_ = new QVBoxLayout;
 -  mainLayout_->addWidget(canvas_);
 -  mainLayout_->addWidget(sizeSelector_);
 -  mainLayout_->addWidget(tabWidget_);
+-
 -  setLayout(mainLayout_);
 -}
+-
+-
 -void
 -ContinuousTab::createConnections()
 -{
 -  connect(tabWidget_, &QTabWidget::currentChanged,
 -          this, &ContinuousTab::changeTab);
+-
 -  connect(allGlyphsTab_, &ContinousAllGlyphsTab::changed,
 -          this, &ContinuousTab::repaintGlyph);
+-
 -  connect(sizeSelector_, &FontSizeSelector::valueChanged,
 -          this, &ContinuousTab::repaintGlyph);
+-
 -  connect(canvas_, &GlyphContinuous::wheelResize,
 -          this, &ContinuousTab::wheelResize);
 -  connect(canvas_, &GlyphContinuous::wheelNavigate,
 -          this, &ContinuousTab::wheelNavigate);
 -  connect(canvas_, &GlyphContinuous::displayingCountUpdated,
 -          allGlyphsTab_, &ContinousAllGlyphsTab::setDisplayingCount);
 -}
+-
+-
 -void
 -ContinuousTab::updateCurrentSubTab()
 +ContinuousTab::syncSettings()
+ {
 -  switch (tabWidget_->currentIndex())
 -  {
 -  case AllGlyphs:
 -    allGlyphsTab_->setGlyphCount(qBound(0,
 -                                        currentGlyphCount_,
 -                                        INT_MAX));
 -    allGlyphsTab_->setCharMaps(engine_->currentFontCharMaps());
 -    break;
 -  }
 -}
+-
+-
 -void
 -ContinuousTab::updateFromCurrentSubTab()
 -{
 -  switch (tabWidget_->currentIndex())
 -  {
 -  case AllGlyphs:
 -    canvas_->setMode(GlyphContinuous::AllGlyphs);
 -    canvas_->setSubModeAllGlyphs(allGlyphsTab_->subMode());
 -    // Begin index is selected from All Glyphs subtab,
 -    // and Limit index is calculated by All Glyphs subtab
 -    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;
 -  }
 -}
+-
+-
 -ContinousAllGlyphsTab::ContinousAllGlyphsTab(QWidget* parent)
 -: QWidget(parent)
 -{
 -  createLayout();
+-
 -  std::vector<CharMapInfo> tempCharMaps;
 -  setCharMaps(tempCharMaps); // pass in an empty one
+-
 -  checkSubMode();
 -  setDefaults();
 -  createConnections();
 -}
+-
+-
 -int
 -ContinousAllGlyphsTab::glyphBeginindex()
 -{
 -  return indexSelector_->currentIndex();
 +  auto mode = static_cast<GlyphContinuous::Mode>(modeSelector_->currentIndex());
 +  auto src
 +    = static_cast<GlyphContinuous::Source>(sourceSelector_->currentIndex());
 +  canvas_->setMode(mode);
 +  canvas_->setSource(src);
 +  canvas_->setBeginIndex(indexSelector_->currentIndex());
 +  canvas_->setLimitIndex(glyphLimitIndex_);
 +  canvas_->setCharMapIndex(charMapIndex()); // Not directly from the combo box
++
 +  canvas_->setFancyParams(xEmboldeningSpinBox_->value(),
 +                          yEmboldeningSpinBox_->value(),
 +                          slantSpinBox_->value());
 +  canvas_->setStrokeRadius(strokeRadiusSpinBox_->value());
 +  canvas_->setRotation(rotationSpinBox_->value());
 +  canvas_->setWaterfall(waterfallCheckBox_->isChecked());
 +  canvas_->setVertical(verticalCheckBox_->isChecked());
+ }
  int
 -ContinousAllGlyphsTab::glyphLimitIndex()
 -{
 -  return glyphLimitIndex_;
 -}
+-
+-
 -GlyphContinuous::SubModeAllGlyphs
 -ContinousAllGlyphsTab::subMode()
 -{
 -  return static_cast<GlyphContinuous::SubModeAllGlyphs>(
 -           modeSelector_->currentIndex());
 -}
+-
+-
 -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()
 +ContinuousTab::charMapIndex()
+ {
    auto index = charMapSelector_->currentIndex() - 1;
    if (index <= -1)
@@ -217,30 +80,30 @@ ContinousAllGlyphsTab::charMapIndex()
  void
 -ContinousAllGlyphsTab::setGlyphBeginindex(int index)
 +ContinuousTab::setGlyphCount(int count)
+ {
 -  indexSelector_->setCurrentIndex(index);
 +  currentGlyphCount_ = count;
 +  updateLimitIndex();
+ }
  void
 -ContinousAllGlyphsTab::setGlyphCount(int count)
 +ContinuousTab::setDisplayingCount(int count)
+ {
 -  currentGlyphCount_ = count;
 -  updateLimitIndex();
 +  indexSelector_->setShowingCount(count);
+ }
  void
 -ContinousAllGlyphsTab::setDisplayingCount(int count)
 +ContinuousTab::setGlyphBeginindex(int index)
+ {
 -  indexSelector_->setShowingCount(count);
 +  indexSelector_->setCurrentIndex(index);
+ }
  #define EncodingRole (Qt::UserRole + 10)
  void
 -ContinousAllGlyphsTab::setCharMaps(std::vector<CharMapInfo>& charMaps)
 +ContinuousTab::setCharMaps(std::vector<CharMapInfo>& charMaps)
+ {
    charMaps_ = charMaps;
    int oldIndex = charMapSelector_->currentIndex();
@@ -287,7 +150,7 @@ ContinousAllGlyphsTab::setCharMaps(std::vector<CharMapInfo>& charMaps)
  void
 -ContinousAllGlyphsTab::updateLimitIndex()
 +ContinuousTab::updateLimitIndex()
+ {
    if (charMapSelector_->currentIndex() <= 0)
      glyphLimitIndex_ = currentGlyphCount_;
@@ -299,49 +162,127 @@ ContinousAllGlyphsTab::updateLimitIndex()
  void
 -ContinousAllGlyphsTab::checkSubMode()
 +ContinuousTab::checkMode()
+ {
 -  auto isFancy = subMode() == GlyphContinuous::AG_Fancy;
 -  auto isStroked = subMode() == GlyphContinuous::AG_Stroked;
 +  auto isFancy = modeSelector_->currentIndex() == GlyphContinuous::M_Fancy;
 +  auto isStroked = modeSelector_->currentIndex() == GlyphContinuous::M_Stroked;
    xEmboldeningSpinBox_->setEnabled(isFancy);
    yEmboldeningSpinBox_->setEnabled(isFancy);
    slantSpinBox_->setEnabled(isFancy);
    strokeRadiusSpinBox_->setEnabled(isStroked);
 -  emit changed();
 +  repaintGlyph();
+ }
  void
 -ContinousAllGlyphsTab::createLayout()
 +ContinuousTab::checkSource()
+ {
 +  auto src
 +      = static_cast<GlyphContinuous::Source>(sourceSelector_->currentIndex());
 +  auto isText = src == GlyphContinuous::SRC_TextString
 +                || src == GlyphContinuous::SRC_TextStringRepeated;
 +  indexSelector_->setEnabled(src == GlyphContinuous::SRC_AllGlyphs);
 +  sourceTextEdit_->setEnabled(isText);
 +  verticalCheckBox_->setEnabled(isText);
++
 +  repaintGlyph();
 +}
++
++
 +void
 +ContinuousTab::charMapChanged()
 +{
 +  int newIndex = charMapSelector_->currentIndex();
 +  if (newIndex != lastCharMapIndex_)
 +  {
 +    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);
 +    else
 +      setGlyphBeginindex(0x20);
 +  }
 +  updateLimitIndex();
++
 +  repaintGlyph();
++
 +  lastCharMapIndex_ = newIndex;
 +}
++
++
 +void
 +ContinuousTab::sourceTextChanged()
 +{
 +  canvas_->setSourceText(sourceTextEdit_->toPlainText());
 +  repaintGlyph();
 +}
++
++
 +void
 +ContinuousTab::wheelNavigate(int steps)
 +{
 +  if (sourceSelector_->currentIndex() == GlyphContinuous::SRC_AllGlyphs)
 +    setGlyphBeginindex(indexSelector_->currentIndex() + steps);
 +}
++
++
 +void
 +ContinuousTab::wheelResize(int steps)
 +{
 +  sizeSelector_->handleWheelResizeBySteps(steps);
 +}
++
++
 +void
 +ContinuousTab::createLayout()
 +{
 +  canvas_ = new GlyphContinuous(this, engine_);
 +  sizeSelector_ = new FontSizeSelector(this);
++
    indexSelector_ = new GlyphIndexSelector(this);
    indexSelector_->setSingleMode(false);
    indexSelector_->setNumberRenderer([this](int index)
                                      { return formatIndex(index); });
 +  sourceTextEdit_ = new QPlainTextEdit(
 +      tr("The quick brown fox jumps over the lazy dog."), this);
    modeSelector_ = new QComboBox(this);
    charMapSelector_ = new QComboBox(this);
 +  sourceSelector_ = new QComboBox(this);
    // Note: in sync with the enum!!
 -  modeSelector_->insertItem(GlyphContinuous::AG_AllGlyphs, tr("All Glyphs"));
 -  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);
 +  modeSelector_->insertItem(GlyphContinuous::M_Normal, tr("Normal"));
 +  modeSelector_->insertItem(GlyphContinuous::M_Fancy, tr("Fancy"));
 +  modeSelector_->insertItem(GlyphContinuous::M_Stroked, tr("Stroked"));
 +  modeSelector_->setCurrentIndex(GlyphContinuous::M_Normal);
++
 +  // Note: in sync with the enum!!
 +  sourceSelector_->insertItem(GlyphContinuous::SRC_AllGlyphs,
 +                              tr("All Glyphs"));
 +  sourceSelector_->insertItem(GlyphContinuous::SRC_TextString,
 +                              tr("Text String"));
 +  sourceSelector_->insertItem(GlyphContinuous::SRC_TextStringRepeated,
 +                              tr("Text String (Repeated)"));
++
 +  verticalCheckBox_ = new QCheckBox(tr("Vertical Layout"), this);
 +  waterfallCheckBox_ = new QCheckBox(tr("Waterfall"), this);
    modeLabel_ = new QLabel(tr("Mode:"), this);
 +  sourceLabel_ = new QLabel(tr("Text Source:"), this);
    charMapLabel_ = new QLabel(tr("Char Map:"), this);
 -  xEmboldeningLabel_ = new QLabel(tr("Hori. Embolding:"), this);
 -  yEmboldeningLabel_ = new QLabel(tr("Vert. Embolding:"), this);
 +  xEmboldeningLabel_ = new QLabel(tr("Horz. Emb.:"), this);
 +  yEmboldeningLabel_ = new QLabel(tr("Vert. Emb.:"), this);
    slantLabel_ = new QLabel(tr("Slanting:"), this);
    strokeRadiusLabel_ = new QLabel(tr("Stroke Radius:"), this);
 +  rotationLabel_ = new QLabel(tr("Rotation:"), this);
    xEmboldeningSpinBox_ = new QDoubleSpinBox(this);
    yEmboldeningSpinBox_ = new QDoubleSpinBox(this);
    slantSpinBox_ = new QDoubleSpinBox(this);
    strokeRadiusSpinBox_ = new QDoubleSpinBox(this);
 +  rotationSpinBox_ = new QDoubleSpinBox(this);
    xEmboldeningSpinBox_->setSingleStep(0.005);
    xEmboldeningSpinBox_->setMinimum(-0.1);
@@ -355,93 +296,111 @@ ContinousAllGlyphsTab::createLayout()
    strokeRadiusSpinBox_->setSingleStep(0.005);
    strokeRadiusSpinBox_->setMinimum(0);
    strokeRadiusSpinBox_->setMaximum(0.05);
 +  rotationSpinBox_->setSingleStep(5);
 +  rotationSpinBox_->setMinimum(-180);
 +  rotationSpinBox_->setMaximum(180);
++
 +  bottomLayout_ = new QGridLayout;
 +  bottomLayout_->addWidget(sourceLabel_, 0, 0);
 +  bottomLayout_->addWidget(modeLabel_, 1, 0);
 +  bottomLayout_->addWidget(charMapLabel_, 2, 0);
 +  bottomLayout_->addWidget(sourceSelector_, 0, 1);
 +  bottomLayout_->addWidget(modeSelector_, 1, 1);
 +  bottomLayout_->addWidget(charMapSelector_, 2, 1);
++
 +  bottomLayout_->addWidget(xEmboldeningLabel_, 1, 2);
 +  bottomLayout_->addWidget(yEmboldeningLabel_, 2, 2);
 +  bottomLayout_->addWidget(slantLabel_, 3, 2);
 +  bottomLayout_->addWidget(strokeRadiusLabel_, 3, 0);
 +  bottomLayout_->addWidget(rotationLabel_, 0, 2);
++
 +  bottomLayout_->addWidget(xEmboldeningSpinBox_, 1, 3);
 +  bottomLayout_->addWidget(yEmboldeningSpinBox_, 2, 3);
 +  bottomLayout_->addWidget(slantSpinBox_, 3, 3);
 +  bottomLayout_->addWidget(strokeRadiusSpinBox_, 3, 1);
 +  bottomLayout_->addWidget(rotationSpinBox_, 0, 3);
++
 +  bottomLayout_->addWidget(indexSelector_, 0, 4, 1, 1);
 +  bottomLayout_->addWidget(sourceTextEdit_, 1, 4, 3, 3);
 +  bottomLayout_->addWidget(waterfallCheckBox_, 0, 5);
 +  bottomLayout_->addWidget(verticalCheckBox_, 0, 6);
++
 +  bottomLayout_->setColumnStretch(4, 1);
++
 +  mainLayout_ = new QVBoxLayout;
 +  mainLayout_->addWidget(canvas_);
 +  mainLayout_->addWidget(sizeSelector_);
 +  mainLayout_->addLayout(bottomLayout_);
 -  layout_ = new QGridLayout;
 -  layout_->addWidget(indexSelector_, 0, 0, 1, 2);
 -  layout_->addWidget(modeLabel_, 1, 0);
 -  layout_->addWidget(charMapLabel_, 2, 0);
 -  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_);
 +  setLayout(mainLayout_);
+ }
++
  void
 -ContinousAllGlyphsTab::createConnections()
 +ContinuousTab::createConnections()
+ {
 +  connect(sizeSelector_, &FontSizeSelector::valueChanged,
 +          this, &ContinuousTab::repaintGlyph);
++
 +  connect(canvas_, &GlyphContinuous::wheelResize,
 +          this, &ContinuousTab::wheelResize);
 +  connect(canvas_, &GlyphContinuous::wheelNavigate,
 +          this, &ContinuousTab::wheelNavigate);
 +  connect(canvas_, &GlyphContinuous::displayingCountUpdated,
 +          this, &ContinuousTab::setDisplayingCount);
++
    connect(indexSelector_, &GlyphIndexSelector::currentIndexChanged,
 -          this, &ContinousAllGlyphsTab::changed);
 +          this, &ContinuousTab::repaintGlyph);
    connect(modeSelector_, QOverload<int>::of(&QComboBox::currentIndexChanged),
 -          this, &ContinousAllGlyphsTab::checkSubMode);
 +          this, &ContinuousTab::checkMode);
    connect(charMapSelector_, QOverload<int>::of(&QComboBox::currentIndexChanged),
 -          this, &ContinousAllGlyphsTab::charMapChanged);
 +          this, &ContinuousTab::charMapChanged);
 +  connect(sourceSelector_, QOverload<int>::of(&QComboBox::currentIndexChanged),
 +          this, &ContinuousTab::checkSource);
    connect(xEmboldeningSpinBox_,
            QOverload<double>::of(&QDoubleSpinBox::valueChanged),
 -          this, &ContinousAllGlyphsTab::changed);
 +          this, &ContinuousTab::repaintGlyph);
    connect(yEmboldeningSpinBox_,
            QOverload<double>::of(&QDoubleSpinBox::valueChanged),
 -          this, &ContinousAllGlyphsTab::changed);
 +          this, &ContinuousTab::repaintGlyph);
    connect(slantSpinBox_,
            QOverload<double>::of(&QDoubleSpinBox::valueChanged),
 -          this, &ContinousAllGlyphsTab::changed);
 +          this, &ContinuousTab::repaintGlyph);
    connect(strokeRadiusSpinBox_,
            QOverload<double>::of(&QDoubleSpinBox::valueChanged),
 -          this, &ContinousAllGlyphsTab::changed);
 -}
+-
+-
 -QString
 -ContinousAllGlyphsTab::formatIndex(int index)
 -{
 -  if (charMapSelector_->currentIndex() <= 0) // glyph order
 -    return QString::number(index);
 -  return charMaps_[charMapSelector_->currentIndex() - 1]
 -           .stringifyIndexShort(index);
 -}
+-
+-
 -void
 -ContinousAllGlyphsTab::charMapChanged()
 -{
 -  int newIndex = charMapSelector_->currentIndex();
 -  if (newIndex != lastCharMapIndex_)
 -  {
 -    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);
 -    else
 -      setGlyphBeginindex(0x20);
 -  }
 -  updateLimitIndex();
+-
 -  emit changed();
 +          this, &ContinuousTab::repaintGlyph);
 +  connect(rotationSpinBox_,
 +          QOverload<double>::of(&QDoubleSpinBox::valueChanged),
 +          this, &ContinuousTab::repaintGlyph);
 -  lastCharMapIndex_ = newIndex;
 +  connect(waterfallCheckBox_, &QCheckBox::clicked,
 +          this, &ContinuousTab::repaintGlyph);
 +  connect(verticalCheckBox_, &QCheckBox::clicked,
 +          this, &ContinuousTab::repaintGlyph);
 +  connect(sourceTextEdit_, &QPlainTextEdit::textChanged,
 +          this, &ContinuousTab::sourceTextChanged);
+ }
  void
 -ContinousAllGlyphsTab::setDefaults()
 +ContinuousTab::setDefaults()
+ {
    xEmboldeningSpinBox_->setValue(0.04);
    yEmboldeningSpinBox_->setValue(0.04);
    slantSpinBox_->setValue(0.22);
    strokeRadiusSpinBox_->setValue(0.02);
 +  rotationSpinBox_->setValue(0);
 +}
++
++
 +QString
 +ContinuousTab::formatIndex(int index)
 +{
 +  if (charMapSelector_->currentIndex() <= 0) // glyph order
 +    return QString::number(index);
 +  return charMaps_[charMapSelector_->currentIndex() - 1].stringifyIndexShort(
 +      index);
+ }

src/ftinspect/panels/continuous.hpp

@@ -18,8 +18,8 @@
  #include <QComboBox>
  #include <QGridLayout>
  #include <QBoxLayout>
+-
 -class ContinousAllGlyphsTab;
 +#include <QPlainTextEdit>
 +#include <QCheckBox>
  class ContinuousTab
  : public QWidget, public AbstractTab
@@ -31,106 +31,72 @@ public:
    void repaintGlyph() override;
    void reloadFont() override;
+-
 -  // Info about current font (glyph count, charmaps...) is flowed to subtab
 -  // via `updateCurrentSubTab`.
 -  // Settings and parameters (e.g. mode) are flowed from subtab to `this` via
 -  // `updateFromCurrentSubTab`.
 -  // SubTabs can notify `this` via signals, see `createConnections`
 -  void updateCurrentSubTab();
 -  void updateFromCurrentSubTab();
+-
 -private slots:
 -  void changeTab();
 -  void wheelNavigate(int steps);
 -  void wheelResize(int steps);
+-
 -private:
 -  Engine* engine_;
+-
 -  int currentGlyphCount_;
 -  GlyphContinuous* canvas_;
+-
 -  FontSizeSelector* sizeSelector_;
+-
 -  QTabWidget* tabWidget_;
 -  ContinousAllGlyphsTab* allGlyphsTab_;
+-
 -  enum Tabs
 -  {
 -    AllGlyphs = 0
 -  };
+-
 -  QVBoxLayout* mainLayout_;
+-
 -  void createLayout();
 -  void createConnections();
 -};
+-
+-
 -class ContinousAllGlyphsTab
 -: public QWidget
 -{
 -  Q_OBJECT
 -public:
 -  explicit ContinousAllGlyphsTab(QWidget* parent);
 -  ~ContinousAllGlyphsTab() override = default;
+-
 -  int glyphBeginindex();
 -  int glyphLimitIndex();
 -  GlyphContinuous::SubModeAllGlyphs subMode();
 -  double xEmboldening();
 -  double yEmboldening();
 -  double slanting();
 -  double strokeRadius();
 +  void syncSettings();
    // -1: Glyph order, otherwise the char map index in the original list
    int charMapIndex();
 -  void setGlyphBeginindex(int index);
    // This doesn't trigger immediate repaint
    void setGlyphCount(int count);
    void setDisplayingCount(int count);
 +  void setGlyphBeginindex(int index);
    void setCharMaps(std::vector<CharMapInfo>& charMaps);
    // This doesn't trigger either.
    void updateLimitIndex();
 +  void checkMode();
 +  void checkSource();
 +  void charMapChanged();
 +  void sourceTextChanged();
 -  void checkSubMode();
+-
 -signals:
 -  void changed();
 +private slots:
 +  void wheelNavigate(int steps);
 +  void wheelResize(int steps);
  private:
 -  int lastCharMapIndex_ = 0;
 +  Engine* engine_;
++
    int currentGlyphCount_;
 +  int lastCharMapIndex_ = 0;
    int glyphLimitIndex_ = 0;
 -  GlyphIndexSelector* indexSelector_;
 +  GlyphContinuous* canvas_;
 +  FontSizeSelector* sizeSelector_;
++
    QComboBox* modeSelector_;
 +  QComboBox* sourceSelector_;
    QComboBox* charMapSelector_;
    QLabel* modeLabel_;
 +  QLabel* sourceLabel_;
    QLabel* charMapLabel_;
    QLabel* xEmboldeningLabel_;
    QLabel* yEmboldeningLabel_;
    QLabel* slantLabel_;
    QLabel* strokeRadiusLabel_;
 +  QLabel* rotationLabel_;
    QDoubleSpinBox* xEmboldeningSpinBox_;
    QDoubleSpinBox* yEmboldeningSpinBox_;
    QDoubleSpinBox* slantSpinBox_;
    QDoubleSpinBox* strokeRadiusSpinBox_;
 +  QDoubleSpinBox* rotationSpinBox_;
++
 +  QCheckBox* verticalCheckBox_;
 +  QCheckBox* waterfallCheckBox_;
 -  QGridLayout* layout_;
 +  GlyphIndexSelector* indexSelector_;
 +  QPlainTextEdit* sourceTextEdit_;
    std::vector<CharMapInfo> charMaps_;
 +  QGridLayout* bottomLayout_;
 +  QVBoxLayout* mainLayout_;
++
    void createLayout();
    void createConnections();
    QString formatIndex(int index);
 -  void charMapChanged();
    void setDefaults();
  };

src/ftinspect/panels/singular.cpp

@@ -5,6 +5,7 @@
  #include "singular.hpp"
  #include <QSizePolicy>
 +#include <QToolTip>
  #include <QWheelEvent>
@@ -197,6 +198,25 @@ SingularTab::wheelResize(QWheelEvent* event)
+ }
 +void
 +SingularTab::setGridVisible()
 +{
 +  gridItem_->setVisible(showGridCheckBox_->isChecked());
 +}
++
++
 +void
 +SingularTab::showToolTip()
 +{
 +  QToolTip::showText(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"),
 +                     helpButton_);
 +}
++
++
  void
  SingularTab::createLayout()
+ {
@@ -215,6 +235,7 @@ SingularTab::createLayout()
    glyphView_->setViewportUpdateMode(QGraphicsView::SmartViewportUpdate);
    glyphView_->setTransformationAnchor(QGraphicsView::AnchorUnderMouse);
    glyphView_->setScene(glyphScene_);
 +  glyphView_->setBackgroundBrush(Qt::white);
    gridItem_ = new Grid(glyphView_, graphicsDefault_->gridPen,
                         graphicsDefault_->axisPen);
@@ -222,26 +243,21 @@ SingularTab::createLayout()
    // Don't use QGraphicsTextItem: We want this hint to be anchored at the
    // top-left corner.
 -  mouseUsageHint_ = new QLabel(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"),
 -                      glyphView_);
 -  auto hintFont = font();
 -  hintFont.setPixelSize(24);
 -  mouseUsageHint_->setFont(hintFont);
 -  mouseUsageHint_->setAttribute(Qt::WA_TransparentForMouseEvents, true);
 +  auto overlayFont = font();
 +  overlayFont.setPixelSize(24);
    glyphIndexLabel_ = new QLabel(glyphView_);
    glyphNameLabel_ = new QLabel(glyphView_);
 -  glyphIndexLabel_->setFont(hintFont);
 -  glyphNameLabel_->setFont(hintFont);
 +  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);
@@ -256,11 +272,18 @@ SingularTab::createLayout()
    zoomLabel_->setBuddy(zoomSpinBox_);
    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);
++
 +  indexHelpLayout_ = new QHBoxLayout;
 +  indexHelpLayout_->addWidget(indexSelector_, 1);
 +  indexHelpLayout_->addWidget(helpButton_);
    sizeLayout_ = new QHBoxLayout;
    sizeLayout_->addStretch(2);
@@ -278,20 +301,19 @@ SingularTab::createLayout()
    checkBoxesLayout_->addWidget(showPointsCheckBox_);
    checkBoxesLayout_->addWidget(showPointNumbersCheckBox_);
    checkBoxesLayout_->addWidget(showOutlinesCheckBox_);
 +  checkBoxesLayout_->addWidget(showGridCheckBox_);
    glyphOverlayIndexLayout_ = new QHBoxLayout;
    glyphOverlayIndexLayout_->addWidget(glyphIndexLabel_);
    glyphOverlayIndexLayout_->addWidget(glyphNameLabel_);
    glyphOverlayLayout_ = new QGridLayout;
 -  glyphOverlayLayout_->addWidget(mouseUsageHint_, 0, 0,
 -                                 Qt::AlignTop | Qt::AlignLeft);
    glyphOverlayLayout_->addLayout(glyphOverlayIndexLayout_, 0, 1,
                                   Qt::AlignTop | Qt::AlignRight);
    glyphView_->setLayout(glyphOverlayLayout_);
    mainLayout_ = new QVBoxLayout;
    mainLayout_->addWidget(glyphView_);
 -  mainLayout_->addWidget(indexSelector_);
 +  mainLayout_->addLayout(indexHelpLayout_);
    mainLayout_->addSpacing(10); // XXX px
    mainLayout_->addLayout(sizeLayout_);
    mainLayout_->addLayout(checkBoxesLayout_);
@@ -322,6 +344,8 @@ SingularTab::createConnections()
    connect(centerGridButton_, &QPushButton::clicked,
            this, &SingularTab::backToCenter);
 +  connect(helpButton_, &QPushButton::clicked,
 +          this, &SingularTab::showToolTip);
    connect(showBitmapCheckBox_, &QCheckBox::clicked,
            this, &SingularTab::drawGlyph);
@@ -331,6 +355,8 @@ SingularTab::createConnections()
            this, &SingularTab::drawGlyph);
    connect(showOutlinesCheckBox_, &QCheckBox::clicked,
            this, &SingularTab::drawGlyph);
 +  connect(showGridCheckBox_, &QCheckBox::clicked,
 +          this, &SingularTab::setGridVisible);
+ }
@@ -365,6 +391,7 @@ SingularTab::setDefaults()
    zoomSpinBox_->setValue(20);
    showBitmapCheckBox_->setChecked(true);
    showOutlinesCheckBox_->setChecked(true);
 +  showGridCheckBox_->setChecked(true);
    indexSelector_->setCurrentIndex(indexSelector_->currentIndex(), true);
    zoom();

src/ftinspect/panels/singular.hpp

@@ -52,6 +52,8 @@ private slots:
    void backToCenter();
    void wheelZoom(QWheelEvent* event);
    void wheelResize(QWheelEvent* event);
 +  void setGridVisible();
 +  void showToolTip();
  private:
    int currentGlyphIndex_;
@@ -67,13 +69,13 @@ private:
    GlyphPointNumbers* currentGlyphPointNumbersItem_;
    GlyphBitmap* currentGlyphBitmapItem_;
    Grid* gridItem_ = NULL;
 -  QLabel* mouseUsageHint_;
    GlyphIndexSelector* indexSelector_;
    FontSizeSelector* sizeSelector_;
    QLabel* zoomLabel_;
    ZoomSpinBox* zoomSpinBox_;
    QPushButton* centerGridButton_;
 +  QPushButton* helpButton_;
    QLabel* glyphIndexLabel_;
    QLabel* glyphNameLabel_;
@@ -82,9 +84,11 @@ private:
    QCheckBox* showOutlinesCheckBox_;
    QCheckBox* showPointNumbersCheckBox_;
    QCheckBox* showPointsCheckBox_;
 +  QCheckBox* showGridCheckBox_;
    QVBoxLayout* mainLayout_;
    QHBoxLayout* checkBoxesLayout_;
 +  QHBoxLayout* indexHelpLayout_;
    QHBoxLayout* sizeLayout_;
    QGridLayout* glyphOverlayLayout_;
    QHBoxLayout* glyphOverlayIndexLayout_;

src/ftinspect/rendering/glyphbitmap.cpp


                          Engine* engine)
 {
   QRect bRect;
-  image_ = engine->convertBitmapToQImage(glyph, &bRect);
+  image_ = engine->convertGlyphToQImage(glyph, &bRect);
   boundingRect_ = bRect; // QRectF to QRect
 }
 

src/ftinspect/rendering/glyphcontinuous.cpp

@@ -11,13 +11,14 @@
  #include <QPainter>
  #include <QWheelEvent>
 +#include <freetype/ftbitmap.h>
++
  GlyphContinuous::GlyphContinuous(QWidget* parent, Engine* engine)
  : QWidget(parent), engine_(engine)
+ {
    setAcceptDrops(false);
    setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
 -  graphicsDefault_ = GraphicsDefault::deafultInstance();
    FT_Stroker_New(engine_->ftLibrary(), &stroker_);
+ }
@@ -41,21 +42,19 @@ GlyphContinuous::paintEvent(QPaintEvent* event)
+   {
      prePaint();
 -    switch (mode_)
 +    switch (source_)
+     {
 -    case AllGlyphs:
 -      switch (modeAG_)
 +    case SRC_AllGlyphs:
 +      switch (mode_)
+       {
 -      case AG_AllGlyphs:
 -      case AG_Fancy:
 -      case AG_Stroked:
 +      case M_Normal:
 +      case M_Fancy:
 +      case M_Stroked:
          paintAG(&painter);
          break;
 -      case AG_Waterfall:
 -        break;
+       }
        break;
 -    case TextString:
 +    case SRC_TextString:
        break;
+     }
      emit displayingCountUpdated(displayingCount_);
@@ -79,7 +78,7 @@ GlyphContinuous::wheelEvent(QWheelEvent* event)
  void
  GlyphContinuous::paintAG(QPainter* painter)
+ {
 -  if (modeAG_ == AG_Stroked)
 +  if (mode_ == M_Stroked)
+   {
      auto radius = static_cast<FT_Fixed>(metrics_.y_ppem * 64 * strokeRadius_);
      FT_Stroker_Set(stroker_, radius,
@@ -98,13 +97,13 @@ GlyphContinuous::paintAG(QPainter* painter)
        break;
      // All Glyphs need no tranformation, and Waterfall isn't handled here.
 -    switch (modeAG_)
 +    switch (mode_)
+     {
 -    case AG_Fancy:
 -      transformGlyphAGFancy();
 +    case M_Fancy:
 +      transformGlyphFancy();
        break;
 -    case AG_Stroked:
 -      transformGlyphAGStroked();
 +    case M_Stroked:
 +      transformGlyphStroked();
        break;
      default:;
+     }
@@ -120,7 +119,7 @@ GlyphContinuous::paintAG(QPainter* painter)
  void
 -GlyphContinuous::transformGlyphAGFancy()
 +GlyphContinuous::transformGlyphFancy()
+ {
    // adopted from ftview.c:289
    /***************************************************************/
@@ -148,41 +147,52 @@ GlyphContinuous::transformGlyphAGFancy()
    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_->format == FT_GLYPH_FORMAT_OUTLINE)
 +  {
 +    if (!isGlyphCloned_)
 +      cloneGlyph();
 +    FT_Outline_Transform(&outline_, &shear);
 +    if (FT_Outline_EmboldenXY(&outline_, xstr, ystr))
 +    {
 +      // XXX error handling?
 +      return;
 +    }
 -  if (glyph_->advance.x)
 -    glyph_->advance.x += xstr;
 +    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;
 +    if (glyph_->advance.y)
 +      glyph_->advance.y += ystr;
 +  }
 +  else if (glyph_->format == FT_GLYPH_FORMAT_BITMAP)
 +  {
 +    if (!isBitmapCloned_)
 +      cloneBitmap();
 +    xstr &= ~63;
 +    ystr &= ~63;
++
 +    // No shearing support for bitmap
 +    FT_Bitmap_Embolden(engine_->ftLibrary(), &bitmap_,
 +                       xstr, ystr);
 +  }
 +  else
 +    return; // XXX no support for SVG
+ }
  void
 -GlyphContinuous::transformGlyphAGStroked()
 +GlyphContinuous::transformGlyphStroked()
+ {
 -  //if (!isGlyphCloned_)
 -    //cloneGlyph();
 -  // Well, now here only outline glyph is supported.
 +  // Well, here only outline glyph is supported.
    if (glyph_->format != FT_GLYPH_FORMAT_OUTLINE)
      return;
 +  auto oldGlyph = glyph_;
    auto error = FT_Glyph_Stroke(&glyph_, stroker_, 0);
    if (!error)
+   {
 +    if (isGlyphCloned_)
 +      FT_Done_Glyph(oldGlyph);
      isGlyphCloned_ = true;
 -    isOutlineCloned_ = false;
      outline_ = reinterpret_cast<FT_OutlineGlyph>(glyph_)->outline;
+   }
+ }
@@ -230,61 +240,19 @@ GlyphContinuous::paintChar(QPainter* painter)
    // XXX: this is different from what's being done in
    // `ftcommon.c`:FTDemo_Draw_Slot: is this correct??
 -  // First translate the 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
 -  if (!isOutlineCloned_ && !isGlyphCloned_)
 -    cloneOutline();
 +  QImage* image;
 -  transformOutlineToOrigin(&outline_, &cbox);
+-
 -  auto outlineWidth = (cbox.xMax - cbox.xMin) / 64;
 -  auto outlineHeight = (cbox.yMax - cbox.yMin) / 64;
+-
 -  // Then convert to bitmap
 -  FT_Bitmap bitmap;
 -  QImage::Format format = QImage::Format_Indexed8;
 -  auto aaEnabled = engine_->antiAliasingEnabled();
+-
 -  // TODO cover LCD and color
 -  if (!aaEnabled)
 -    format = QImage::Format_Mono;
+-
 -  // TODO optimization: reuse QImage?
 -  QImage image(QSize(outlineWidth, outlineHeight), format);
+-
 -  if (!aaEnabled)
 -    image.setColorTable(graphicsDefault_->monoColorTable);
 +  if (bitmap_.buffer) // Always prefer `bitmap_` since it can be manipulated
 +    image = engine_->convertBitmapToQImage(&bitmap_);
    else
 -    image.setColorTable(graphicsDefault_->grayColorTable);
+-
 -  image.fill(0);
+-
 -  bitmap.rows = static_cast<unsigned int>(outlineHeight);
 -  bitmap.width = static_cast<unsigned int>(outlineWidth);
 -  bitmap.buffer = image.bits();
 -  bitmap.pitch = image.bytesPerLine();
 -  bitmap.pixel_mode = aaEnabled ? FT_PIXEL_MODE_GRAY : FT_PIXEL_MODE_MONO;
+-
 -  FT_Error error = FT_Outline_Get_Bitmap(engine_->ftLibrary(),
 -                                         &outline_,
 -                                         &bitmap);
 -  if (error)
 -  {
 -    // XXX error handling
 -    return true;
 -  }
 +    image = engine_->convertGlyphToQImage(glyph_, NULL);
 +  auto offset = engine_->computeGlyphOffset(glyph_);
 -  painter->drawImage(
 -      QPoint(x_ + cbox.xMin / 64, y_ + (-cbox.yMax / 64)),
 -      image.convertToFormat(QImage::Format_ARGB32_Premultiplied));
 +  painter->drawImage(offset + QPoint(x_, y_),
 +                     *image);
 +  delete image;
    x_ += width;
+-
    return true;
+ }
@@ -292,15 +260,13 @@ GlyphContinuous::paintChar(QPainter* painter)
  bool
  GlyphContinuous::loadGlyph(int index)
+ {
 +  if (isGlyphCloned_)
 +    FT_Done_Glyph(glyph_);
    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;
 -  }
 +  refreshOutlineOrBitmapFromGlyph();
    return true;
+ }
@@ -308,16 +274,57 @@ GlyphContinuous::loadGlyph(int index)
  void
  GlyphContinuous::cloneGlyph()
+ {
 +  if (isGlyphCloned_)
 +    return;
    glyph_ = ::cloneGlyph(glyph_);
 +  refreshOutlineOrBitmapFromGlyph();
    isGlyphCloned_ = true;
+ }
  void
 -GlyphContinuous::cloneOutline()
 +GlyphContinuous::cloneBitmap()
 +{
 +  if (isBitmapCloned_)
 +    return;
 +  bitmap_ = ::cloneBitmap(engine_->ftLibrary(), &bitmap_);
 +  isBitmapCloned_ = true;
 +}
++
++
 +void
 +GlyphContinuous::refreshOutlineOrBitmapFromGlyph()
+ {
 -  outline_ = ::cloneOutline(engine_->ftLibrary(), &outline_);
 -  isOutlineCloned_ = true;
 +  if (glyph_->format == FT_GLYPH_FORMAT_OUTLINE)
 +  {
 +    outline_ = reinterpret_cast<FT_OutlineGlyph>(glyph_)->outline;
++
 +    // Make `bitmap_` invalid
 +    if (isBitmapCloned_)
 +      FT_Bitmap_Done(engine_->ftLibrary(), &bitmap_);
 +    isBitmapCloned_ = false;
 +    bitmap_.buffer = NULL;
 +  }
 +  else if (glyph_->format == FT_GLYPH_FORMAT_BITMAP)
 +  {
 +    // Initialize `bitmap_`
 +    if (isBitmapCloned_)
 +      FT_Bitmap_Done(engine_->ftLibrary(), &bitmap_);
 +    isBitmapCloned_ = false;
 +    bitmap_ = reinterpret_cast<FT_BitmapGlyph>(glyph_)->bitmap;
++
 +    outline_.points = NULL;
 +  }
 +  else
 +  {
 +    // Both invalid.
 +    outline_.points = NULL;
++
 +    if (isBitmapCloned_)
 +      FT_Bitmap_Done(engine_->ftLibrary(), &bitmap_);
 +    isBitmapCloned_ = false;
 +    bitmap_.buffer = NULL;
 +  }
+ }
@@ -326,13 +333,17 @@ GlyphContinuous::cleanCloned()
+ {
    if (isGlyphCloned_)
+   {
 +    if (glyph_->format == FT_GLYPH_FORMAT_BITMAP && !isBitmapCloned_)
 +      bitmap_.buffer = NULL;
++
      FT_Done_Glyph(glyph_);
      isGlyphCloned_ = false;
+   }
 -  if (isOutlineCloned_)
 +  if (isBitmapCloned_)
+   {
 -    FT_Outline_Done(engine_->ftLibrary(), &outline_);
 -    isOutlineCloned_ = false;
 +    FT_Bitmap_Done(engine_->ftLibrary(), &bitmap_);
 +    bitmap_.buffer = NULL;
 +    isBitmapCloned_ = false;
+   }
+ }

src/ftinspect/rendering/glyphcontinuous.hpp

@@ -5,12 +5,17 @@
  #pragma once
  #include "graphicsdefault.hpp"
++
 +#include <utility>
++
  #include <QWidget>
++
  #include <freetype/freetype.h>
  #include <freetype/ftglyph.h>
  #include <freetype/ftoutln.h>
  #include <freetype/ftstroke.h>
++
  class Engine;
  class GlyphContinuous
  : public QWidget
@@ -20,18 +25,18 @@ public:
    GlyphContinuous(QWidget* parent, Engine* engine);
    ~GlyphContinuous() override;
 -  enum Mode : int
 +  enum Source : int
+   {
 -    AllGlyphs,
 -    TextString
 +    SRC_AllGlyphs,
 +    SRC_TextString,
 +    SRC_TextStringRepeated
    };
 -  enum SubModeAllGlyphs : int
 +  enum Mode : int
+   {
 -    AG_AllGlyphs,
 -    AG_Fancy,
 -    AG_Stroked,
 -    AG_Waterfall
 +    M_Normal,
 +    M_Fancy,
 +    M_Stroked
    };
    int displayingCount() { return displayingCount_; }
@@ -40,8 +45,8 @@ public:
    void setBeginIndex(int index) { beginIndex_ = index; }
    void setLimitIndex(int index) { limitIndex_ = index; }
    void setCharMapIndex(int index) { charMapIndex_ = index; }
 +  void setSource(Source mode) { source_ = mode; }
    void setMode(Mode mode) { mode_ = mode; }
 -  void setSubModeAllGlyphs(SubModeAllGlyphs modeAg) { modeAG_ = modeAg; }
    void setFancyParams(double boldX, double boldY, double slant)
+   {
      boldX_ = boldX;
@@ -49,6 +54,10 @@ public:
      slant_ = slant;
+   }
    void setStrokeRadius(double radius) { strokeRadius_ = radius; }
 +  void setRotation(double rotation) { rotation_ = rotation; }
 +  void setVertical(bool vertical) { vertical_ = vertical; }
 +  void setWaterfall(bool waterfall) { waterfall_ = waterfall; }
 +  void setSourceText(QString text) { text_ = std::move(text); }
  signals:
    void wheelNavigate(int steps);
@@ -61,37 +70,52 @@ protected:
  private:
    Engine* engine_;
 -  GraphicsDefault* graphicsDefault_;
 -  Mode mode_ = AllGlyphs;
 -  SubModeAllGlyphs modeAG_ = AG_AllGlyphs;
 +  Source source_ = SRC_AllGlyphs;
 +  Mode mode_ = M_Normal;
    int beginIndex_;
    int limitIndex_;
    int charMapIndex_;
    double boldX_, boldY_, slant_;
    double strokeRadius_;
 +  double rotation_;
 +  bool vertical_;
 +  bool waterfall_;
 +  QString text_;
    int displayingCount_ = 0;
    FT_Size_Metrics metrics_;
    int x_ = 0, y_ = 0;
    int stepY_ = 0;
++
 +  // Pay especially attention to life cycles & ownerships of those objects:
 +  // Note that outline and bitmap can be either invalid, owned by glyph or
 +  // owned by `this`.
 +  // If owned by `this`, then it's safe to do manipulation, and need to cleanup
 +  // If owned by glyph, then must clone to do manipulation, and no cleanup
 +  // In `loadGraph`, these 3 values will all be updated.
 +  // Note that `glyph_` is a pointer, while `outline_` and `bitmap_` are structs
    FT_Glyph glyph_;
 -  FT_Outline outline_;
 +  FT_Outline outline_; // Using outline_->points == NULL to determine validity
 +  FT_Bitmap bitmap_; // Using bitmap_->buffer == NULL to determine validity
    // when glyph is cloned, outline is factually also cloned
 -  // but `isOutlineCloned` won't be set!
 -  bool isGlyphCloned_ = false, isOutlineCloned_ = false;
 +  // never manually clone your outline or you can't easily render it!
 +  bool isGlyphCloned_ = false;
 +  bool isBitmapCloned_ = false;
    FT_Stroker stroker_;
    void paintAG(QPainter* painter);
 -  void transformGlyphAGFancy();
 -  void transformGlyphAGStroked();
 +  void transformGlyphFancy();
 +  void transformGlyphStroked();
    void prePaint();
    // return if there's enough space to paint the current char
    bool paintChar(QPainter* painter);
    bool loadGlyph(int index);
++
    void cloneGlyph();
 -  void cloneOutline();
 +  void cloneBitmap();
 +  void refreshOutlineOrBitmapFromGlyph();
    void cleanCloned();
    bool checkFitX(int x);

src/ftinspect/rendering/grid.cpp

@@ -55,9 +55,6 @@ Grid::updateRect()
+ }
 -// XXX call this in a `myQDraphicsView::drawBackground' derived method
 -//     to always fill the complete viewport
+-
  void
  Grid::paint(QPainter* painter,
              const QStyleOptionGraphicsItem* option,

src/ftinspect/rendering/renderutils.cpp

@@ -25,6 +25,19 @@ cloneGlyph(FT_Glyph src)
+ }
 +FT_Bitmap
 +cloneBitmap(FT_Library library,
 +            FT_Bitmap* src)
 +{
 +  FT_Bitmap target = *src;
 +  target.buffer = NULL;
 +  target.palette = NULL;
 +  FT_Bitmap_Init(&target);
 +  FT_Bitmap_Copy(library, src, &target);
 +  return target;
 +}
++
++
  void
  transformOutlineToOrigin(FT_Outline* outline,
                           FT_BBox* outControlBox)

src/ftinspect/rendering/renderutils.hpp

@@ -5,11 +5,13 @@
  #pragma once
  #include <freetype/ftglyph.h>
 +#include <freetype/ftbitmap.h>
  #include <freetype/ftoutln.h>
  // The constructed `outline` must be freed by the caller
  FT_Outline cloneOutline(FT_Library library, FT_Outline* src);
  FT_Glyph cloneGlyph(FT_Glyph src);
 +FT_Bitmap cloneBitmap(FT_Library library, FT_Bitmap* src);
  void transformOutlineToOrigin(FT_Outline* outline,
                                FT_BBox* outControlBox);

From:	Charlie Jiang (@cqjjjzr)
Subject:	[Git][freetype/freetype-demos][gsoc-2022-chariri-2] 8 commits: [ftinspect] Add "Show Grid" check box.
Date:	Fri, 15 Jul 2022 10:36:36 +0000