[Git][freetype/freetype-demos][gsoc-2022-chariri-3] 9 commits: [ftinspec

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

Commits:

a1b171f9

by Charlie Jiang at 2022-08-28T13:29:42+08:00

[ftinspect] Add composite glyphs info tab.

Not tested for nested glyphs.

* src/ftinspect/models/fontinfomodels.cpp,
  src/ftinspect/models/fontinfomodels.hpp:
  Add `CompositeGlyphsInfoModel` as a lazily loaded tree model.

* src/ftinspect/panels/info.cpp, src/ftinspect/panels/info.hpp:
  Implement the `CompositeGlyphsTab` and integrate into the `InfoTab`.

* src/ftinspect/engine/fontinfo.cpp, src/ftinspect/engine/fontinfo.hpp:
  Add `CompositeGlyphInfo` to retrieve composite glyph info from the `glyf`
  table.

* src/ftinspect/maingui.cpp: Connect event for switching to singular.

* src/ftinspect/engine/engine.cpp, src/ftinspect/engine/engine.hpp:
  Add `currentFontHasGlyphName`.

* src/ftinspect/engine/fontfilemanager.cpp,
  src/ftinspect/engine/fontfilemanager.hpp:
  Add getter to check if current font reload is caused by periodic reload of
  symbolic files. Don't reload the composite glyphs in such case.

c93a74f4

by Charlie Jiang at 2022-08-28T13:30:42+08:00

* src/ftinspect/panels/singular.cpp: Adjust initial zoom factor.

3575e6e5

by Charlie Jiang at 2022-08-28T13:39:47+08:00

* src/ftinspect/maingui.cpp: Use min size hint for initial window size.

b49f5ac8

by Charlie Jiang at 2022-08-28T13:41:16+08:00

* src/ftinspect/panels/settingpanel.cpp: Set gamma slider steps.

cc61ce5a

by Charlie Jiang at 2022-08-28T13:43:38+08:00

* src/ftinspect/panels/continuous.cpp: Hide the details pane when...

switching to the singular tab.

0a8df748

by Charlie Jiang at 2022-08-28T14:04:04+08:00

[ftinspect] Add preset settings to comparators view.

* src/ftinspect/panels/comparator.cpp: Set presets based on index.

* src/ftinspect/panels/settingpanel.cpp,
  src/ftinspect/panels/settingpanel.hpp: Add `setDefaultsPreset` values.

212821d5

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

* src/ftinspect/panels/continuous.cpp: Disable kerning for "All Glyphs".

612b5f7c

by Charlie Jiang at 2022-08-28T14:08:21+08:00

* src/ftinspect/maingui.cpp: Stop setting panels' tab bars from being...

shifted right in the comparator view.

1c468180

by Charlie Jiang at 2022-08-28T14:20:52+08:00

[ftinspect] Improve fore/background color setting.

Now they're shown in the comparator view as well, and an indicator for
current color is shown.

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

16 changed files:

src/ftinspect/engine/engine.cpp
src/ftinspect/engine/engine.hpp
src/ftinspect/engine/fontfilemanager.cpp
src/ftinspect/engine/fontfilemanager.hpp
src/ftinspect/engine/fontinfo.cpp
src/ftinspect/engine/fontinfo.hpp
src/ftinspect/maingui.cpp
src/ftinspect/models/fontinfomodels.cpp
src/ftinspect/models/fontinfomodels.hpp
src/ftinspect/panels/comparator.cpp
src/ftinspect/panels/continuous.cpp
src/ftinspect/panels/info.cpp
src/ftinspect/panels/info.hpp
src/ftinspect/panels/settingpanel.cpp
src/ftinspect/panels/settingpanel.hpp
src/ftinspect/panels/singular.cpp

Changes:

src/ftinspect/engine/engine.cpp

@@ -560,6 +560,15 @@ Engine::currentFontFixedSizes()
+ }
 +bool
 +Engine::currentFontHasGlyphName()
 +{
 +  if (!ftFallbackFace_)
 +    return false;
 +  return FT_HAS_GLYPH_NAMES(ftFallbackFace_);
 +}
++
++
  QString
  Engine::glyphName(int index)
+ {

src/ftinspect/engine/engine.hpp

@@ -122,6 +122,7 @@ public:
    const QString& currentFamilyName() { return curFamilyName_; }
    const QString& currentStyleName() { return curStyleName_; }
    int currentFontNumberOfGlyphs() { return curNumGlyphs_; }
 +  bool currentFontHasGlyphName();
    QString glyphName(int glyphIndex);
    long numberOfFaces(int fontIndex);

src/ftinspect/engine/fontfilemanager.cpp

@@ -17,9 +17,9 @@ FontFileManager::FontFileManager()
    watchTimer_->setInterval(1000);
    connect(fontWatcher_, &QFileSystemWatcher::fileChanged,
 -          this, &FontFileManager::onTimerOrWatcherFire);
 +          this, &FontFileManager::onWatcherFire);
    connect(watchTimer_, &QTimer::timeout,
 -          this, &FontFileManager::onTimerOrWatcherFire);
 +          this, &FontFileManager::onTimerFire);
+ }
@@ -137,11 +137,20 @@ FontFileManager::loadFromCommandLine()
  void
 -FontFileManager::onTimerOrWatcherFire()
 +FontFileManager::onWatcherFire()
+ {
    watchTimer_->stop();
    emit currentFileChanged();
+ }
 +void
 +FontFileManager::onTimerFire()
 +{
 +  periodicUpdating_ = true;
 +  onWatcherFire();
 +  periodicUpdating_ = false;
 +}
++
++
  // end of fontfilemanager.hpp

src/ftinspect/engine/fontfilemanager.hpp

@@ -31,16 +31,21 @@ public:
    void timerStart();
    void loadFromCommandLine();
 +  bool currentReloadDueToPeriodicUpdate() { return periodicUpdating_; }
++
  signals:
    void currentFileChanged();
  private slots:
 -  void onTimerOrWatcherFire();
 +  void onTimerFire();
 +  void onWatcherFire();
  private:
    QList<QFileInfo> fontFileNameList_;
    QFileSystemWatcher* fontWatcher_;
    QTimer* watchTimer_;
++
 +  bool periodicUpdating_ = false;
  };

src/ftinspect/engine/fontinfo.cpp

@@ -571,4 +571,126 @@ SFNTTableInfo::getForAll(Engine* engine,
+ }
 +void
 +CompositeGlyphInfo::get(Engine* engine,
 +                        std::vector<CompositeGlyphInfo>& list)
 +{
 +  list.clear();
 +  engine->reloadFont();
 +  auto face = engine->currentFallbackFtFace();
 +  if (!face || !FT_IS_SFNT(face))
 +  {
 +    if (list.empty())
 +      return;
 +  }
++
 +  // We're not using the FreeType's subglyph APIs, but directly reading from
 +  // the `glyf` table since it's faster
 +  auto head = static_cast<TT_Header*>(FT_Get_Sfnt_Table(face, FT_SFNT_HEAD));
 +  auto maxp
 +    = static_cast<TT_MaxProfile*>(FT_Get_Sfnt_Table(face, FT_SFNT_MAXP));
 +  if (!head || !maxp)
 +    return;
++
 +  FT_ULong locaLength = head->Index_To_Loc_Format ? 4 * maxp->numGlyphs + 4
 +                                                  : 2 * maxp->numGlyphs + 2;
 +  std::unique_ptr<unsigned char[]> locaBufferGuard(
 +    new unsigned char[locaLength]);
 +  auto offset = locaBufferGuard.get();
 +  auto error = FT_Load_Sfnt_Table(face, TTAG_loca, 0, offset, &locaLength);
 +  if (error)
 +    return;
++
 +  FT_ULong glyfLength = 0;
 +  error = FT_Load_Sfnt_Table(face, TTAG_glyf, 0, NULL, &glyfLength);
 +  if (error || !glyfLength)
 +    return;
++
 +  std::unique_ptr<unsigned char[]> glyfBufferGuard(
 +    new unsigned char[glyfLength]);
 +  auto buffer = glyfBufferGuard.get();
 +  error = FT_Load_Sfnt_Table(face, TTAG_glyf, 0, buffer, &glyfLength);
 +  if (error)
 +    return;
++
 +  for (size_t i = 0; i < maxp->numGlyphs; i++)
 +  {
 +    FT_UInt32  loc, end;
 +    if (head->Index_To_Loc_Format)
 +    {
 +      loc = static_cast<FT_UInt32>(offset[4 * i    ]) << 24 |
 +            static_cast<FT_UInt32>(offset[4 * i + 1]) << 16 |
 +            static_cast<FT_UInt32>(offset[4 * i + 2]) << 8  |
 +            static_cast<FT_UInt32>(offset[4 * i + 3])       ;
 +      end = static_cast<FT_UInt32>(offset[4 * i + 4]) << 24 |
 +            static_cast<FT_UInt32>(offset[4 * i + 5]) << 16 |
 +            static_cast<FT_UInt32>(offset[4 * i + 6]) << 8  |
 +            static_cast<FT_UInt32>(offset[4 * i + 7])       ;
 +    }
 +    else
 +    {
 +      loc = static_cast<FT_UInt32>(offset[2 * i    ]) << 9 |
 +            static_cast<FT_UInt32>(offset[2 * i + 1]) << 1 ;
 +      end = static_cast<FT_UInt32>(offset[2 * i + 2]) << 9 |
 +            static_cast<FT_UInt32>(offset[2 * i + 3]) << 1 ;
 +    }
++
 +    if (end > glyfLength)
 +      end = glyfLength;
++
 +    if (loc + 16 > end)
 +      continue;
++
 +    auto len = static_cast<FT_Int16>(buffer[loc] << 8 | buffer[loc + 1]);
 +    loc += 10;  // skip header
 +    if (len >= 0) // not a composite one
 +      continue;
++
 +    std::vector<SubGlyph> subglyphs;
++
 +    while (true)
 +    {
 +      if (loc + 6 > end)
 +        break;
 +      auto flags = static_cast<FT_UInt16>(buffer[loc] << 8 | buffer[loc + 1]);
 +      loc += 2;
 +      auto index = static_cast<FT_UInt16>(buffer[loc] << 8 | buffer[loc + 1]);
 +      loc += 2;
 +      FT_Int16 arg1, arg2;
++
 +      // https://docs.microsoft.com/en-us/typography/opentype/spec/glyf#composite-glyph-description
 +      if (flags & 0x0001)
 +      {
 +        arg1 = static_cast<FT_Int16>(buffer[loc] << 8 | buffer[loc + 1]);
 +        loc += 2;
 +        arg2 = static_cast<FT_Int16>(buffer[loc] << 8 | buffer[loc + 1]);
 +        loc += 2;
 +      }
 +      else
 +      {
 +        arg1 = buffer[loc];
 +        arg2 = buffer[loc + 1];
 +        loc += 2;
 +      }
 +      if (flags & 0x0008)
 +        loc += 2;
 +      else if (flags & 0x0040)
 +        loc += 4;
 +      else if (flags & 0x0080)
 +        loc += 8;
++
 +      subglyphs.emplace_back(index, flags,
 +                             flags & 0x0002 ? SubGlyph::PT_Offset
 +                                            : SubGlyph::PT_Align,
 +                             std::pair<short, short>(arg1, arg2));
++
 +      if (!(flags & 0x0020))
 +        break;
 +    }
++
 +    list.emplace_back(static_cast<int>(i), std::move(subglyphs));
 +  }
 +}
++
++
  // end of fontinfo.cpp

src/ftinspect/engine/fontinfo.hpp

@@ -244,6 +244,86 @@ struct FontFixedSize
  };
 +struct CompositeGlyphInfo
 +{
 +  struct SubGlyph
 +  {
 +    enum PositionType
 +    {
 +      PT_Offset, // Child's points are added with a xy-offset
 +      PT_Align // One point of the child is aligned with one point of the parent
 +    };
 +    unsigned short index;
 +    unsigned short flag;
 +    PositionType positionType;
 +    // For PT_Offset: <deltaX, deltaY>
 +    // For PT_Align:  <childPoint, parentPoint>
 +    std::pair<short, short> position;
++
 +    SubGlyph(unsigned short index,
 +             unsigned short flag,
 +             PositionType positionType,
 +             std::pair<short, short> position)
 +    : index(index),
 +      flag(flag),
 +      positionType(positionType),
 +      position(std::move(position))
 +    { }
++
++
 +    friend bool
 +    operator==(const SubGlyph& lhs,
 +               const SubGlyph& rhs)
 +    {
 +      return lhs.index == rhs.index
 +        && lhs.flag == rhs.flag
 +        && lhs.positionType == rhs.positionType
 +        && lhs.position == rhs.position;
 +    }
++
++
 +    friend bool
 +    operator!=(const SubGlyph& lhs,
 +               const SubGlyph& rhs)
 +    {
 +      return !(lhs == rhs);
 +    }
 +  };
++
++
 +  int index;
 +  std::vector<SubGlyph> subglyphs;
++
++
 +  CompositeGlyphInfo(short index,
 +                     std::vector<SubGlyph> subglyphs)
 +  : index(index),
 +    subglyphs(std::move(subglyphs))
 +  { }
++
++
 +  friend bool
 +  operator==(const CompositeGlyphInfo& lhs,
 +             const CompositeGlyphInfo& rhs)
 +  {
 +    return lhs.index == rhs.index
 +      && lhs.subglyphs == rhs.subglyphs;
 +  }
++
++
 +  friend bool
 +  operator!=(const CompositeGlyphInfo& lhs,
 +             const CompositeGlyphInfo& rhs)
 +  {
 +    return !(lhs == rhs);
 +  }
++
++
 +  // expensive
 +  static void get(Engine* engine, std::vector<CompositeGlyphInfo>& list);
 +};
++
++
  QString* mapSFNTNameIDToName(unsigned short nameID);
  QString* mapTTPlatformIDToName(unsigned short platformID);
  QString* mapTTEncodingIDToName(unsigned short platformID,

src/ftinspect/maingui.cpp

@@ -171,8 +171,9 @@ MainGUI::switchTab()
    auto isComparator = current == comparatorTab_;
    if (isComparator)
 -    tabWidget_->setStyleSheet(QString("QTabWidget::tab-bar {left: %1 px;}")
 -                              .arg(leftWidget_->width()));
 +    tabWidget_->setStyleSheet(
 +      QString("QTabWidget#mainTab::tab-bar {left: %1 px;}")
 +      .arg(leftWidget_->width()));
    else
      tabWidget_->setStyleSheet("");
@@ -271,6 +272,7 @@ MainGUI::createLayout()
    infoTab_ = new InfoTab(this, engine_);
    tabWidget_ = new QTabWidget(this);
 +  tabWidget_->setObjectName("mainTab"); // for stylesheet
    // Note those two list must be in sync
    tabs_.append(singularTab_);
@@ -320,7 +322,8 @@ MainGUI::createLayout()
    ftinspectLayout_->setSizeConstraint(QLayout::SetNoConstraint);
    layout()->setSizeConstraint(QLayout::SetNoConstraint);
 -  resize(1400 * logicalDpiX() / 96, 700 * logicalDpiY() / 96);
 +  resize(ftinspectWidget_->minimumSizeHint().width(),
 +         700 * logicalDpiY() / 96);
    statusBar()->hide(); // remove the extra space
    setCentralWidget(ftinspectWidget_);
@@ -344,6 +347,8 @@ MainGUI::createConnections()
    connect(continuousTab_, &ContinuousTab::switchToSingular,
            this, &MainGUI::switchToSingular);
 +  connect(infoTab_, &InfoTab::switchToSingular,
 +          [&](int index) { switchToSingular(index, -1); });
+ }

src/ftinspect/models/fontinfomodels.cpp

@@ -3,6 +3,7 @@
  // Copyright (C) 2022 by Charlie Jiang.
  #include "fontinfomodels.hpp"
 +#include "../engine/engine.hpp"
  int
  FixedSizeInfoModel::rowCount(const QModelIndex& parent) const
@@ -463,4 +464,219 @@ MMGXAxisInfoModel::headerData(int section,
+ }
 +int
 +CompositeGlyphsInfoModel::rowCount(const QModelIndex& parent) const
 +{
 +  if (!parent.isValid())
 +    return static_cast<int>(glyphs_.size());
 +  auto id = parent.internalId();
 +  if (id < 0 || id >= nodes_.size())
 +    return 0;
 +  auto gid = nodes_[id].glyphIndex;
 +  auto iter = glyphMapper_.find(gid);
 +  if (iter == glyphMapper_.end())
 +    return 0;
 +  if (iter->second > glyphs_.size())
 +    return 0;
 +  return static_cast<int>(glyphs_[iter->second]. subglyphs.size());
 +}
++
++
 +int
 +CompositeGlyphsInfoModel::columnCount(const QModelIndex& parent) const
 +{
 +  return CGIM_Max;
 +}
++
++
 +QModelIndex
 +CompositeGlyphsInfoModel::index(int row,
 +                                int column,
 +                                const QModelIndex& parent) const
 +{
 +  long long parentIdx = -1;
 +  if (parent.isValid()) // Not top-level
 +    parentIdx = static_cast<long long>(parent.internalId());
 +  if (parentIdx < 0)
 +    parentIdx = -1;
 +  // find existing node by row and parent index, -1 for top-level
 +  auto lookupPair = std::pair<int, long long>(row, parentIdx);
++
 +  auto iter = nodeLookup_.find(lookupPair);
 +  if (iter != nodeLookup_.end())
 +  {
 +    if (iter->second < 0 || static_cast<size_t>(iter->second) >= nodes_.size())
 +      return {};
 +    return createIndex(row, column, iter->second);
 +  }
++
 +  int id = -1;
 +  CompositeGlyphInfo::SubGlyph const* sgInfo = nullptr;
 +  if (!parent.isValid()) // top-level nodes
 +    id = glyphs_[row].index;
 +  else if (parent.internalId() < glyphs_.size())
 +  {
 +    auto& sg = glyphs_[parent.internalId()].subglyphs;
 +    if (row < 0 || static_cast<size_t>(row) >= sg.size())
 +      return {};
 +    id = sg[row].index;
 +    sgInfo = &sg[row];
 +  }
++
 +  if (id < 0)
 +    return {};
++
 +  InfoNode node = {
 +    parentIdx,
 +    row, id,
 +    sgInfo
 +  };
 +  nodes_.push_back(node);
 +  nodeLookup_.emplace(std::pair<int, long long>(row, parentIdx),
 +                      nodes_.size() - 1);
++
 +  return createIndex(row, column, nodes_.size() - 1);
 +}
++
++
 +QModelIndex
 +CompositeGlyphsInfoModel::parent(const QModelIndex& child) const
 +{
 +  if (!child.isValid())
 +    return {};
++
 +  auto id = static_cast<long long>(child.internalId());
 +  if (id < 0 || static_cast<size_t>(id) >= nodes_.size())
 +    return {};
++
 +  auto pid = nodes_[id].parentNodeIndex;
 +  if (pid < 0 || static_cast<size_t>(pid) >= nodes_.size())
 +    return {};
++
 +  auto& p = nodes_[pid];
 +  return createIndex(p.indexInParent, 0, pid);
 +}
++
++
 +QVariant
 +CompositeGlyphsInfoModel::data(const QModelIndex& index,
 +                               int role) const
 +{
 +  if (!index.isValid())
 +    return {};
++
 +  auto id = index.internalId();
 +  if (id >= nodes_.size())
 +    return {};
 +  auto& n = nodes_[id];
 +  auto glyphIdx = n.glyphIndex;
++
 +  if (role == Qt::ToolTipRole && index.column() == CGIM_Position)
 +  {
 +    if (!n.subGlyphInfo)
 +      return {};
 +    auto pos = n.subGlyphInfo->position;
 +    switch (n.subGlyphInfo->positionType)
 +    {
 +    case CompositeGlyphInfo::SubGlyph::PT_Offset:
 +      return QString("Add a offset (%1, %2) to the subglyph's points")
 +          .arg(pos.first)
 +          .arg(pos.second);
 +    case CompositeGlyphInfo::SubGlyph::PT_Align:
 +      return QString("Align parent's point %1 to subglyph's point %2")
 +          .arg(pos.first)
 +          .arg(pos.second);
 +    }
 +    return {};
 +  }
++
 +  if (role != Qt::DisplayRole)
 +    return {};
++
 +  switch (static_cast<Columns>(index.column()))
 +  {
 +  case CGIM_Glyph:
 +    if (engine_->currentFontHasGlyphName())
 +      return QString("%1 <%2>").arg(glyphIdx).arg(engine_->glyphName(glyphIdx));
 +    return QString::number(glyphIdx);
 +  case CGIM_Flag:
 +    if (!n.subGlyphInfo)
 +      return {};
 +    return QString::number(n.subGlyphInfo->flag, 16).rightJustified(4, '0');
 +  case CGIM_Position:
 +  {
 +    if (!n.subGlyphInfo)
 +      return {};
 +    auto pos = n.subGlyphInfo->position;
 +    switch (n.subGlyphInfo->positionType)
 +    {
 +    case CompositeGlyphInfo::SubGlyph::PT_Offset:
 +      return QString("Offset (%1, %2)").arg(pos.first).arg(pos.second);
 +    case CompositeGlyphInfo::SubGlyph::PT_Align:
 +      return QString("Align %1 -> %2").arg(pos.first).arg(pos.second);
 +    }
 +  }
 +  }
++
 +  return {};
 +}
++
++
 +QVariant
 +CompositeGlyphsInfoModel::headerData(int section,
 +                                     Qt::Orientation orientation,
 +                                     int role) const
 +{
 +  if (role != Qt::DisplayRole)
 +    return {};
 +  if (orientation != Qt::Horizontal)
 +    return {};
++
 +  switch (static_cast<Columns>(section))
 +  {
 +  case CGIM_Glyph:
 +    return tr("Glyph");
 +  case CGIM_Flag:
 +    return tr("Flags");
 +  case CGIM_Position:
 +    return tr("Position");
 +  }
 +  return {};
 +}
++
++
 +int
 +CompositeGlyphsInfoModel::glyphIndexFromIndex(const QModelIndex& idx)
 +{
 +  if (!idx.isValid())
 +    return -1;
++
 +  auto id = idx.internalId();
 +  if (id >= nodes_.size())
 +    return -1;
 +  auto& n = nodes_[id];
 +  return n.glyphIndex;
 +}
++
++
 +void
 +CompositeGlyphsInfoModel::beginModelUpdate()
 +{
 +  beginResetModel();
 +  glyphs_.clear();
 +  nodeLookup_.clear();
 +  nodes_.clear();
 +}
++
++
 +void
 +CompositeGlyphsInfoModel::endModelUpdate()
 +{
 +  glyphMapper_.clear();
 +  for (size_t i = 0; i < glyphs_.size(); i++)
 +    glyphMapper_.emplace(glyphs_[i].index, i);
 +  endResetModel();
 +}
++
++
  // end of fontinfomodels.cpp

src/ftinspect/models/fontinfomodels.hpp

@@ -9,6 +9,7 @@
  #include "../engine/mmgx.hpp"
  #include <vector>
 +#include <unordered_map>
  #include <QAbstractTableModel>
  class FixedSizeInfoModel
@@ -203,4 +204,82 @@ private:
  };
 +struct LookupPairHash
 +{
 +public:
 +  std::size_t
 +  operator()(const std::pair<int, long long>& p) const
 +  {
 +    std::size_t seed = 0x291FEEA8;
 +    seed ^= (seed << 6) + (seed >> 2) + 0x25F3E86D
 +            + static_cast<std::size_t>(p.first);
 +    seed ^= (seed << 6) + (seed >> 2) + 0x436E6B92
 +            + static_cast<std::size_t>(p.second);
 +    return seed;
 +  }
 +};
++
++
 +// A tree model, so much more complicated.
 +class CompositeGlyphsInfoModel : public QAbstractItemModel
 +{
 +  Q_OBJECT
 +public:
 +  // A lazily created info node.
 +  struct InfoNode
 +  {
 +    long long parentNodeIndex;
 +    int indexInParent;
 +    int glyphIndex;
 +    CompositeGlyphInfo::SubGlyph const* subGlyphInfo;
 +  };
++
 +  explicit CompositeGlyphsInfoModel(QObject* parent, Engine* engine)
 +      : QAbstractItemModel(parent), engine_(engine)
 +  {
 +  }
++
 +  ~CompositeGlyphsInfoModel() override = default;
++
 +  int rowCount(const QModelIndex& parent) const override;
 +  int columnCount(const QModelIndex& parent) const override;
 +  QModelIndex index(int row, int column,
 +                    const QModelIndex& parent) const override;
 +  QModelIndex parent(const QModelIndex& child) const override;
 +  QVariant data(const QModelIndex& index, int role) const override;
 +  QVariant headerData(int section, Qt::Orientation orientation,
 +                      int role) const override;
 +  int glyphIndexFromIndex(const QModelIndex& idx);
++
 +  void beginModelUpdate();
 +  void endModelUpdate();
 +  std::vector<CompositeGlyphInfo>& storage() { return glyphs_; }
++
 +  enum Columns : int
 +  {
 +    CGIM_Glyph = 0, // TODO: transformation, scale? consider more flags?
 +    CGIM_Flag = 1,
 +    CGIM_Position = 2,
 +    CGIM_Max
 +  };
++
 +private:
 +  Engine* engine_;
 +  /*
 +   * Take care of 3 types of index:
 +   * 1. Glyph Index in Font File
 +   * 2. Glyph Index in `glyphs_` - often called as "glyph info index"
 +   * 3. Node Index
 +   */
 +  std::vector<CompositeGlyphInfo> glyphs_;
 +  std::unordered_map<int, size_t> glyphMapper_;
 +  // map <row, parentId> to node
 +  // the internal id of `QModelIndex` is the node's index
 +  mutable std::unordered_map<std::pair<int, long long>,
 +                             long long, LookupPairHash>
 +          nodeLookup_;
 +  mutable std::vector<InfoNode> nodes_;
 +};
++
++
  // end of fontinfomodels.hpp

src/ftinspect/panels/comparator.cpp

@@ -98,6 +98,7 @@ ComperatorTab::createLayout()
      auto frame = new QFrame(this);
      auto canvas = new GlyphContinuous(frame, engine_);
      auto settingPanel = new SettingPanel(this, engine_, true);
 +    settingPanel->setDefaultsPreset(i);
      sizeSelector_->installEventFilterForWidget(canvas);

src/ftinspect/panels/continuous.cpp

@@ -161,6 +161,14 @@ ContinuousTab::checkModeSource()
    indexSelector_->setEnabled(src == GlyphContinuous::SRC_AllGlyphs);
    sourceTextEdit_->setEnabled(isText);
    sampleStringSelector_->setEnabled(isText);
++
 +  {
 +    QSignalBlocker blocker(kerningCheckBox_);
 +    kerningCheckBox_->setEnabled(isText);
 +    if (!isText)
 +      kerningCheckBox_->setChecked(false);
 +  }
++
    canvas_->setSource(src);
+   {
@@ -548,7 +556,12 @@ ContinuousTab::createConnections()
    sizeSelector_->installEventFilterForWidget(this);
    connect(glyphDetails_, &GlyphDetails::switchToSingular,
 -          [&] (int index) { switchToSingular(index, -1); });
 +          [&] (int index)
 +          {
 +            switchToSingular(index, -1);
 +            if (glyphDetailsWidget_->isFloating())
 +              glyphDetailsWidget_->hide();
 +          });
+ }

src/ftinspect/panels/info.cpp

@@ -22,6 +22,7 @@ InfoTab::InfoTab(QWidget* parent,
  : QWidget(parent), engine_(engine)
+ {
    createLayout();
 +  createConnections();
+ }
@@ -40,17 +41,19 @@ InfoTab::createLayout()
    sfntTab_ = new SFNTInfoTab(this, engine_);
    postScriptTab_ = new PostScriptInfoTab(this, engine_);
    mmgxTab_ = new MMGXInfoTab(this, engine_);
 +  compositeGlyphsTab_ = new CompositeGlyphsTab(this, engine_);
    tab_ = new QTabWidget(this);
    tab_->addTab(generalTab_, tr("General"));
    tab_->addTab(sfntTab_, tr("SFNT"));
    tab_->addTab(postScriptTab_, tr("PostScript"));
    tab_->addTab(mmgxTab_, tr("MM/GX"));
 +  tab_->addTab(compositeGlyphsTab_, tr("Composite Glyphs"));
    tabs_.append(generalTab_);
    tabs_.append(sfntTab_);
    tabs_.append(postScriptTab_);
 -  tabs_.append(mmgxTab_);
 +  tabs_.append(compositeGlyphsTab_);
    layout_ = new QHBoxLayout;
    layout_->addWidget(tab_);
@@ -59,6 +62,14 @@ InfoTab::createLayout()
+ }
 +void
 +InfoTab::createConnections()
 +{
 +  connect(compositeGlyphsTab_, &CompositeGlyphsTab::switchToSingular,
 +          this, &InfoTab::switchToSingular);
 +}
++
++
  GeneralInfoTab::GeneralInfoTab(QWidget* parent,
                                 Engine* engine)
  : QWidget(parent), engine_(engine)
@@ -919,4 +930,89 @@ MMGXInfoTab::createLayout()
+ }
 +CompositeGlyphsTab::CompositeGlyphsTab(QWidget* parent,
 +                                       Engine* engine)
 +: QWidget(parent), engine_(engine)
 +{
 +  createLayout();
 +  createConnections();
 +}
++
++
 +void
 +CompositeGlyphsTab::reloadFont()
 +{
 +  if (engine_->fontFileManager().currentReloadDueToPeriodicUpdate())
 +    return;
 +  forceReloadFont();
 +}
++
++
 +void
 +CompositeGlyphsTab::createLayout()
 +{
 +  compositeGlyphCountPromptLabel_ = new QLabel(tr("Composite Glyphs Count:"));
 +  compositeGlyphCountLabel_ = new QLabel(this);
 +  forceRefreshButton_ = new QPushButton(tr("Force Refresh"), this);
 +  compositeTreeView_ = new QTreeView(this);
++
 +  compositeModel_ = new CompositeGlyphsInfoModel(this, engine_);
 +  compositeTreeView_->setModel(compositeModel_);
++
 +  forceRefreshButton_->setToolTip(tr(
 +    "Force refresh the tree view.\n"
 +    "Note that periodic reloading of fonts loaded from symbolic links won't\n"
 +    "trigger automatically refreshing, so you need to manually reload."));
++
 +  // Layouting
 +  countLayout_ = new QHBoxLayout;
 +  countLayout_->addWidget(compositeGlyphCountPromptLabel_);
 +  countLayout_->addWidget(compositeGlyphCountLabel_);
 +  countLayout_->addWidget(forceRefreshButton_);
 +  countLayout_->addStretch(1);
++
 +  mainLayout_ = new QVBoxLayout;
 +  mainLayout_->addLayout(countLayout_);
 +  mainLayout_->addWidget(compositeTreeView_);
++
 +  setLayout(mainLayout_);
 +}
++
++
 +void
 +CompositeGlyphsTab::createConnections()
 +{
 +  connect(forceRefreshButton_, &QPushButton::clicked,
 +          this, &CompositeGlyphsTab::forceReloadFont);
 +  connect(compositeTreeView_, &QTreeView::doubleClicked,
 +          this, &CompositeGlyphsTab::treeRowDoubleClicked);
 +}
++
++
 +void
 +CompositeGlyphsTab::forceReloadFont()
 +{
 +  std::vector<CompositeGlyphInfo> list;
 +  CompositeGlyphInfo::get(engine_, list);
 +  if (list == compositeModel_->storage())
 +    return;
 +  compositeModel_->beginModelUpdate();
 +  compositeModel_->storage() = list;
 +  compositeModel_->endModelUpdate();
++
 +  compositeGlyphCountLabel_->setText(
 +    QString::number(compositeModel_->storage().size()));
 +}
++
++
 +void
 +CompositeGlyphsTab::treeRowDoubleClicked(const QModelIndex& idx)
 +{
 +  auto gidx = compositeModel_->glyphIndexFromIndex(idx);
 +  if (gidx < 0)
 +    return;
 +  emit switchToSingular(gidx);
 +}
++
++
  // end of info.cpp

src/ftinspect/panels/info.hpp

@@ -20,13 +20,14 @@
  #include <QLabel>
  #include <QGroupBox>
  #include <QTableView>
 -#include <QStackedLayout>
 +#include <QTreeView>
  class Engine;
  class GeneralInfoTab;
  class SFNTInfoTab;
  class PostScriptInfoTab;
  class MMGXInfoTab;
 +class CompositeGlyphsTab;
  class InfoTab
  : public QWidget, public AbstractTab
@@ -39,19 +40,24 @@ public:
    void repaintGlyph() override {}
    void reloadFont() override;
 +signals:
 +  void switchToSingular(int glyphIndex);
++
  private:
    Engine* engine_;
    QVector<AbstractTab*> tabs_;
 -  GeneralInfoTab*    generalTab_;
 -  SFNTInfoTab*       sfntTab_;
 -  PostScriptInfoTab* postScriptTab_;
 -  MMGXInfoTab*       mmgxTab_;
 +  GeneralInfoTab*     generalTab_;
 +  SFNTInfoTab*        sfntTab_;
 +  PostScriptInfoTab*  postScriptTab_;
 +  MMGXInfoTab*        mmgxTab_;
 +  CompositeGlyphsTab* compositeGlyphsTab_;
    QTabWidget* tab_;
    QHBoxLayout* layout_;
    void createLayout();
 +  void createConnections();
  };
@@ -285,4 +291,37 @@ private:
  };
 +class CompositeGlyphsTab
 +: public QWidget, public AbstractTab
 +{
 +  Q_OBJECT
 +public:
 +  CompositeGlyphsTab(QWidget* parent, Engine* engine);
 +  ~CompositeGlyphsTab() override = default;
++
 +  void repaintGlyph() override {}
 +  void reloadFont() override;
++
 +signals:
 +  void switchToSingular(int glyphIndex);
++
 +private:
 +  Engine* engine_;
++
 +  LabelPair(compositeGlyphCount)
 +  QPushButton* forceRefreshButton_;
 +  QTreeView* compositeTreeView_;
 +  CompositeGlyphsInfoModel* compositeModel_;
++
 +  QHBoxLayout* countLayout_;
 +  QVBoxLayout* mainLayout_;
++
 +  void createLayout();
 +  void createConnections();
++
 +  void forceReloadFont();
 +  void treeRowDoubleClicked(const QModelIndex& idx);
 +};
++
++
  // end of info.hpp

src/ftinspect/panels/settingpanel.cpp

@@ -49,6 +49,30 @@ SettingPanel::lsbRsbDeltaEnabled()
+ }
 +void
 +SettingPanel::setDefaultsPreset(int preset)
 +{
 +  if (preset < 0)
 +    preset = 0;
 +  preset %= 3;
 +  switch (preset)
 +  {
 +  case 0:
 +    hintingCheckBox_->setChecked(true);
 +    autoHintingCheckBox_->setChecked(false);
 +    break;
 +  case 1:
 +    hintingCheckBox_->setChecked(true);
 +    autoHintingCheckBox_->setChecked(true);
 +    break;
 +  case 2:
 +    hintingCheckBox_->setChecked(false);
 +    autoHintingCheckBox_->setChecked(false);
 +    break;
 +  }
 +}
++
++
  void
  SettingPanel::checkAllSettings()
+ {
@@ -174,6 +198,7 @@ SettingPanel::openBackgroundPicker()
    if (result.isValid())
+   {
      backgroundColor_ = result;
 +    resetColorBlocks();
      emit repaintNeeded();
+   }
+ }
@@ -189,6 +214,7 @@ SettingPanel::openForegroundPicker()
    if (result.isValid())
+   {
      foregroundColor_ = result;
 +    resetColorBlocks();
      emit repaintNeeded();
+   }
+ }
@@ -204,6 +230,24 @@ SettingPanel::updateGamma()
+ }
 +void
 +SettingPanel::resetColorBlocks()
 +{
 +  foregroundBlock_->setStyleSheet(
 +    QString("QWidget {background-color: rgba(%1, %2, %3, %4);}")
 +      .arg(foregroundColor_.red())
 +      .arg(foregroundColor_.blue())
 +      .arg(foregroundColor_.green())
 +      .arg(foregroundColor_.alpha()));
 +  backgroundBlock_->setStyleSheet(
 +    QString("QWidget {background-color: rgba(%1, %2, %3, %4);}")
 +      .arg(backgroundColor_.red())
 +      .arg(backgroundColor_.blue())
 +      .arg(backgroundColor_.green())
 +      .arg(backgroundColor_.alpha()));
 +}
++
++
  void
  SettingPanel::checkHintingMode()
+ {
@@ -427,13 +471,10 @@ SettingPanel::createConnections()
              this, &SettingPanel::repaintNeeded);
+   }
 -  if (!comparatorMode_)
 -  {
 -    connect(backgroundButton_, &QPushButton::clicked,
 -            this, &SettingPanel::openBackgroundPicker);
 -    connect(foregroundButton_, &QPushButton::clicked,
 -            this, &SettingPanel::openForegroundPicker);
 -  }
 +  connect(backgroundButton_, &QPushButton::clicked,
 +          this, &SettingPanel::openBackgroundPicker);
 +  connect(foregroundButton_, &QPushButton::clicked,
 +          this, &SettingPanel::openForegroundPicker);
    connect(mmgxPanel_, &SettingPanelMMGX::mmgxCoordsChanged,
            this, &SettingPanel::fontReloadNeeded);
@@ -518,16 +559,25 @@ SettingPanel::createLayout()
    gammaSlider_->setRange(0, 30); // in 1/10th
    gammaSlider_->setTickPosition(QSlider::TicksBelow);
    gammaSlider_->setTickInterval(5);
 +  gammaSlider_->setPageStep(1);
 +  gammaSlider_->setSingleStep(1);
    gammaLabel_->setBuddy(gammaSlider_);
    gammaValueLabel_ = new QLabel(this);
    mmgxPanel_ = new SettingPanelMMGX(this, engine_);
 -  if (!comparatorMode_)
 -  {
 -    backgroundButton_ = new QPushButton(tr("Background"), this);
 -    foregroundButton_ = new QPushButton(tr("Foreground"), this);
 -  }
 +  backgroundButton_ = new QPushButton(tr("Background"), this);
 +  foregroundButton_ = new QPushButton(tr("Foreground"), this);
++
 +  backgroundBlock_ = new QFrame(this);
 +  backgroundBlock_->setFrameStyle(QFrame::Box);
 +  backgroundBlock_->setLineWidth(1);
 +  backgroundBlock_->setFixedWidth(18);
++
 +  foregroundBlock_ = new QFrame(this);
 +  foregroundBlock_->setFrameStyle(QFrame::Box);
 +  foregroundBlock_->setLineWidth(1);
 +  foregroundBlock_->setFixedWidth(18);
    generalTab_ = new QWidget(this);
@@ -571,11 +621,8 @@ SettingPanel::createLayout()
        tr("Enable LSB/RSB delta positioning (only valid when hinting is "
           "enabled)."));
+   }
 -  if (!comparatorMode_)
 -  {
 -    backgroundButton_->setToolTip(tr("Set canvas background color."));
 -    foregroundButton_->setToolTip(tr("Set text color."));
 -  }
 +  backgroundButton_->setToolTip(tr("Set canvas background color."));
 +  foregroundButton_->setToolTip(tr("Set text color."));
    // Layouting
    if (debugMode_)
@@ -593,6 +640,12 @@ SettingPanel::createLayout()
    gammaLayout_->addWidget(gammaSlider_);
    gammaLayout_->addWidget(gammaValueLabel_);
 +  colorPickerLayout_ = new QHBoxLayout;
 +  colorPickerLayout_->addWidget(backgroundBlock_);
 +  colorPickerLayout_->addWidget(backgroundButton_, 1);
 +  colorPickerLayout_->addWidget(foregroundButton_, 1);
 +  colorPickerLayout_->addWidget(foregroundBlock_);
++
    if (comparatorMode_)
      createLayoutComperator();
    else
@@ -632,12 +685,7 @@ SettingPanel::createLayoutNormal()
                          new QSpacerItem(0, 20, QSizePolicy::Minimum,
                                          QSizePolicy::MinimumExpanding));
 -  colorPickerLayout_ = new QHBoxLayout;
 -  colorPickerLayout_->addWidget(backgroundButton_, 1);
 -  colorPickerLayout_->addWidget(foregroundButton_, 1);
 -  generalTabLayout_->addLayout(colorPickerLayout_,
 -                               generalTabLayout_->rowCount(), 0, 1, 2);
+-
 +  gridLayout2ColAddLayout(generalTabLayout_, colorPickerLayout_);
    gridLayout2ColAddLayout(generalTabLayout_, gammaLayout_);
    gridLayout2ColAddWidget(generalTabLayout_, stemDarkeningCheckBox_);
    gridLayout2ColAddWidget(generalTabLayout_, embeddedBitmapCheckBox_);
@@ -686,6 +734,7 @@ SettingPanel::createLayoutComperator()
    gridLayout2ColAddWidget(hintingRenderingTabLayout_, stemDarkeningCheckBox_);
    // General
 +  gridLayout2ColAddLayout(generalTabLayout_, colorPickerLayout_);
    gridLayout2ColAddWidget(generalTabLayout_, embeddedBitmapCheckBox_);
    gridLayout2ColAddWidget(generalTabLayout_, colorLayerCheckBox_);
    gridLayout2ColAddWidget(generalTabLayout_,
@@ -755,6 +804,7 @@ SettingPanel::setDefaults()
    // These need to be set even in Comperator mode.
    backgroundColor_ = Qt::white;
    foregroundColor_ = Qt::black;
 +  resetColorBlocks();
    gammaSlider_->setValue(18); // 1.8
    updateGamma();

src/ftinspect/panels/settingpanel.hpp

@@ -38,6 +38,7 @@ public:
    int antiAliasingModeIndex();
    bool kerningEnabled();
    bool lsbRsbDeltaEnabled();
 +  void setDefaultsPreset(int preset);
  signals:
    void fontReloadNeeded();
@@ -111,6 +112,8 @@ private:
    QPushButton* backgroundButton_;
    QPushButton* foregroundButton_;
 +  QFrame* backgroundBlock_;
 +  QFrame* foregroundBlock_;
    QVBoxLayout* mainLayout_;
    QGridLayout* generalTabLayout_;
@@ -135,6 +138,7 @@ private:
    void openBackgroundPicker();
    void openForegroundPicker();
    void updateGamma();
 +  void resetColorBlocks();
  };

src/ftinspect/panels/singular.cpp

@@ -276,7 +276,7 @@ SingularTab::resizeEvent(QResizeEvent* event)
    auto viewSize = glyphView_->size();
    auto minViewSide = std::min(viewSize.height(), viewSize.width());
 -  zoomSpinBox_->setValue(static_cast<int>(minViewSide / size * 0.9));
 +  zoomSpinBox_->setValue(static_cast<int>(minViewSide / size * 0.7));
+ }

From:	Charlie Jiang (@cqjjjzr)
Subject:	[Git][freetype/freetype-demos][gsoc-2022-chariri-3] 9 commits: [ftinspect] Add composite glyphs info tab.
Date:	Sun, 28 Aug 2022 06:22:00 +0000