[Git][freetype/freetype-demos][gsoc-2022-chariri-3] 2 commits: * src/fti

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

Commits:

3f5ab935

by Charlie Jiang at 2022-08-11T23:50:23+08:00

* src/ftinspect/engine/engine.cpp: Fix missing include.

42cabc80

by Charlie Jiang at 2022-08-14T23:53:56+08:00

[ftinspect] Add "Font Info" tab, and implement "General" tab.

* src/ftinspect/panels/info.cpp, src/ftinspect/panels/info.hpp:
  Add `InfoTab` and implement the "General" subtab.

* src/ftinspect/engine/fontinfo.cpp, src/ftinspect/engine/fontinfo.hpp:
  Add `FontBasicInfo`, `FontTypeEntries` and `FontFixedSize` to retrieve
  font infos.

* src/ftinspect/models/fontinfomodels.cpp,
  src/ftinspect/models/fontinfomodels.hpp:
  Add custom `QAbstractTableModel` to display fixed sizes and char maps.

* src/ftinspect/maingui.cpp, src/ftinspect/maingui.hpp: Included.

* src/ftinspect/engine/engine.cpp, src/ftinspect/engine/engine.hpp:
  Add functions to expose current font index and size object.

* src/ftinspect/engine/charmap.cpp, src/ftinspect/engine/charmap.hpp:
  Add format ID and language ID. Fix the `operator==`.

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

14 changed files:

src/ftinspect/CMakeLists.txt
src/ftinspect/engine/charmap.cpp
src/ftinspect/engine/charmap.hpp
src/ftinspect/engine/engine.cpp
src/ftinspect/engine/engine.hpp
+ src/ftinspect/engine/fontinfo.cpp
+ src/ftinspect/engine/fontinfo.hpp
src/ftinspect/maingui.cpp
src/ftinspect/maingui.hpp
src/ftinspect/meson.build
+ src/ftinspect/models/fontinfomodels.cpp
+ src/ftinspect/models/fontinfomodels.hpp
+ src/ftinspect/panels/info.cpp
+ src/ftinspect/panels/info.hpp

Changes:

src/ftinspect/CMakeLists.txt

@@ -25,6 +25,7 @@ add_executable(ftinspect
    "engine/charmap.cpp"
    "engine/paletteinfo.cpp"
    "engine/stringrenderer.cpp"
 +  "engine/fontinfo.cpp"
    "rendering/glyphbitmap.cpp"
    "rendering/glyphoutline.cpp"
@@ -42,11 +43,13 @@ add_executable(ftinspect
    "widgets/charmapcombobox.cpp"
    "models/customcomboboxmodels.cpp"
 +  "models/fontinfomodels.cpp"
    "panels/settingpanel.cpp"
    "panels/singular.cpp"
    "panels/continuous.cpp"
    "panels/comparator.cpp"
 +  "panels/info.cpp"
    "panels/glyphdetails.cpp"
+ )
  target_link_libraries(ftinspect

src/ftinspect/engine/charmap.cpp

@@ -5,6 +5,8 @@
  #include "charmap.hpp"
  #include <QHash>
 +#include <freetype/freetype.h>
 +#include <freetype/tttables.h>
  QHash<FT_Encoding, QString> encodingNamesCache;
  QHash<FT_Encoding, QString>&
@@ -37,7 +39,10 @@ encodingNames()
  CharMapInfo::CharMapInfo(int index, FT_CharMap cmap)
  : index(index), ptr(cmap),
    encoding(cmap->encoding),
 -  platformID(cmap->platform_id), encodingID(cmap->encoding_id),
 +  platformID(cmap->platform_id),
 +  encodingID(cmap->encoding_id),
 +  formatID(FT_Get_CMap_Format(cmap)),
 +  languageID(FT_Get_CMap_Language_ID(cmap)),
    maxIndex(-1)
+ {
    auto& names = encodingNames();

src/ftinspect/engine/charmap.hpp

@@ -19,6 +19,8 @@ struct CharMapInfo
    FT_Encoding encoding;
    unsigned short platformID;
    unsigned short encodingID;
 +  long formatID;
 +  unsigned long languageID;
    QString* encodingName;
    // Actually this shouldn't go here, but for convenience...
@@ -33,7 +35,13 @@ struct CharMapInfo
    friend bool
    operator==(const CharMapInfo& lhs, const CharMapInfo& rhs)
+   {
 -    return lhs.index == rhs.index && lhs.encoding == rhs.encoding;
 +    // omitting `ptr` by design!
 +    return lhs.index == rhs.index
 +           && lhs.encoding == rhs.encoding
 +           && lhs.platformID == rhs.platformID
 +           && lhs.encodingID == rhs.encodingID
 +           && lhs.formatID == rhs.formatID
 +           && lhs.languageID == rhs.languageID;
+   }

src/ftinspect/engine/engine.cpp

@@ -9,6 +9,7 @@
  #include "../rendering/graphicsdefault.hpp"
  #include <stdexcept>
 +#include <cmath>
  #include <stdint.h>
  #include <freetype/ftmodapi.h>
@@ -282,6 +283,7 @@ Engine::loadFont(int fontIndex,
    update();
 +  curFontIndex_ = fontIndex;
    auto id = FaceID(fontIndex, faceIndex, namedInstanceIndex);
    // search triplet (fontIndex, faceIndex, namedInstanceIndex)
@@ -912,26 +914,26 @@ Engine::calculateForegroundTable()
    // Yes I know this is horribly slow, but we're only calculating the table once
    // and can use it for all rendering if the color and gamma isn't changing.
 -  double br = pow(qRed(backgroundColor_) / 255.0, gamma_);
 -  double bg = pow(qGreen(backgroundColor_) / 255.0, gamma_);
 -  double bb = pow(qBlue(backgroundColor_) / 255.0, gamma_);
 +  double br = std::pow(qRed(backgroundColor_) / 255.0, gamma_);
 +  double bg = std::pow(qGreen(backgroundColor_) / 255.0, gamma_);
 +  double bb = std::pow(qBlue(backgroundColor_) / 255.0, gamma_);
    double invGamma = 1 / gamma_;
    for (int i = 0; i <= 0xFF; i++)
+   {
      double foreAlpha = i * qAlpha(foregroundColor_) / 255.0 / 255.0;
      double backAlpha = 1 - foreAlpha;
 -    double r = pow(qRed(foregroundColor_) / 255.0, gamma_);
 -    double g = pow(qGreen(foregroundColor_) / 255.0, gamma_);
 -    double b = pow(qBlue(foregroundColor_) / 255.0, gamma_);
 +    double r = std::pow(qRed(foregroundColor_) / 255.0, gamma_);
 +    double g = std::pow(qGreen(foregroundColor_) / 255.0, gamma_);
 +    double b = std::pow(qBlue(foregroundColor_) / 255.0, gamma_);
      r = br * backAlpha + r * foreAlpha;
      g = bg * backAlpha + g * foreAlpha;
      b = bb * backAlpha + b * foreAlpha;
 -    r = pow(r, invGamma);
 -    g = pow(g, invGamma);
 -    b = pow(b, invGamma);
 +    r = std::pow(r, invGamma);
 +    g = std::pow(g, invGamma);
 +    b = std::pow(b, invGamma);
      foregroundTable_[i]
          = qRgba(static_cast<int>(r * 255),

src/ftinspect/engine/engine.hpp

@@ -129,6 +129,8 @@ public:
    double pointSize() { return pointSize_; }
    int numberOfOpenedFonts();
 +  int currentFontIndex() { return curFontIndex_; }
 +  FT_Size currentFtSize() { return ftSize_; }
    int currentFontType() const { return fontType_; }
    const QString& currentFamilyName() { return curFamilyName_; }
    const QString& currentStyleName() { return curStyleName_; }
@@ -215,6 +217,7 @@ private:
    FontFileManager fontFileManager_;
 +  int curFontIndex_ = -1;
    QString curFamilyName_;
    QString curStyleName_;
    int curNumGlyphs_ = -1;

src/ftinspect/engine/fontinfo.cpp

 +// fontinfo.cpp
++
 +// Copyright (C) 2022 by Charlie Jiang.
++
 +#include "fontinfo.hpp"
++
 +#include "engine.hpp"
++
 +#include <freetype/ftmodapi.h>
 +#include <freetype/tttables.h>
++
++
 +FontBasicInfo
 +FontBasicInfo::get(Engine* engine)
 +{
 +  auto fontIndex = engine->currentFontIndex();
 +  if (fontIndex < 0)
 +    return {};
 +  FontBasicInfo result;
 +  result.numFaces = engine->numberOfFaces(fontIndex);
++
 +  engine->reloadFont();
 +  auto size = engine->currentFtSize();
 +  if (!size)
 +    return result;
++
 +  auto face = size->face;
 +  if (face->family_name)
 +    result.familyName = QString(face->family_name);
 +  if (face->style_name)
 +    result.styleName = QString(face->style_name);
++
 +  auto psName = FT_Get_Postscript_Name(face);
 +  if (psName)
 +    result.postscriptName = QString(psName);
++
 +  auto head = static_cast<TT_Header*>(FT_Get_Sfnt_Table(face, FT_SFNT_HEAD));
 +  if (head)
 +  {
 +    uint64_t createdTimestamp
 +      = head->Created[1] | static_cast<uint64_t>(head->Created[0]) << 32;
 +    uint64_t modifiedTimestamp
 +      = head->Modified[1] | static_cast<uint64_t>(head->Modified[0]) << 32;
++
 +    result.createdTime
 +      = QDateTime::fromSecsSinceEpoch(createdTimestamp, Qt::OffsetFromUTC)
 +          .addSecs(-2082844800);
 +    result.modifiedTime
 +      = QDateTime::fromSecsSinceEpoch(modifiedTimestamp, Qt::OffsetFromUTC)
 +          .addSecs(-2082844800);
++
 +    auto revDouble = head->Font_Revision / 65536.0;
 +    if (head->Font_Revision & 0xFFC0)
 +      result.revision = QString::number(revDouble, 'g', 4);
 +    else
 +      result.revision = QString::number(revDouble, 'g', 2);
 +  }
++
 +  return result;
 +}
++
++
 +FontTypeEntries
 +FontTypeEntries::get(Engine* engine)
 +{
 +  engine->reloadFont();
 +  auto size = engine->currentFtSize();
 +  if (!size)
 +    return {};
++
 +  auto face = size->face;
++
 +  FontTypeEntries result = {};
 +  result.driverName = QString(FT_FACE_DRIVER_NAME(face));
 +  result.sfnt = FT_IS_SFNT(face);
 +  result.scalable = FT_IS_SCALABLE(face);
 +  if (result.scalable)
 +    result.mmgx = FT_HAS_MULTIPLE_MASTERS(face);
 +  else
 +    result.mmgx = false;
 +  result.fixedSizes = FT_HAS_FIXED_SIZES(face);
 +  result.hasHorizontal = FT_HAS_HORIZONTAL(face);
 +  result.hasVertical = FT_HAS_VERTICAL(face);
 +  result.fixedWidth = FT_IS_FIXED_WIDTH(face);
 +  result.glyphNames = FT_HAS_GLYPH_NAMES(face);
++
 +  if (result.scalable)
 +  {
 +    result.emSize = face->units_per_EM;
 +    result.globalBBox = face->bbox;
 +    result.ascender = face->ascender;
 +    result.descender = face->descender;
 +    result.height = face->height;
 +    result.maxAdvanceWidth = face->max_advance_width;
 +    result.maxAdvanceHeight = face->max_advance_height;
 +    result.underlinePos = face->underline_position;
 +    result.underlineThickness = face->underline_thickness;
 +  }
++
 +  return result;
 +}
++
++
 +bool
 +FontFixedSize::get(Engine* engine,
 +                   std::vector<FontFixedSize>& list,
 +                   const std::function<void()>& onUpdateNeeded)
 +{
 +  engine->reloadFont();
 +  auto size = engine->currentFtSize();
 +  if (!size)
 +  {
 +    if (list.empty())
 +      return false;
++
 +    onUpdateNeeded();
 +    list.clear();
 +    return true;
 +  }
++
 +  auto face = size->face;
 +  auto changed = false;
 +  if (list.size() != static_cast<size_t>(face->num_fixed_sizes))
 +  {
 +    changed = true;
 +    onUpdateNeeded();
 +    list.resize(face->num_fixed_sizes);
 +  }
++
 +  for (int i = 0; i < face->num_fixed_sizes; ++i)
 +  {
 +    FontFixedSize ffs = {};
 +    auto bSize = face->available_sizes + i;
 +    ffs.height = bSize->height;
 +    ffs.width  = bSize->width;
 +    ffs.size   = bSize->size / 64.0;
 +    ffs.xPpem  = bSize->x_ppem / 64.0;
 +    ffs.yPpem  = bSize->y_ppem / 64.0;
 +    if (ffs != list[i])
 +    {
++
 +      if (!changed)
 +      {
 +        onUpdateNeeded();
 +        changed = true;
 +      }
++
 +      list[i] = ffs;
 +    }
 +  }
++
 +  return changed;
 +}
++
++
 +// end of fontinfo.cpp

src/ftinspect/engine/fontinfo.hpp

 +// fontinfo.hpp
++
 +// Copyright (C) 2022 by Charlie Jiang.
++
 +#pragma once
++
 +#include <QDateTime>
 +#include <QString>
 +#include <freetype/freetype.h>
++
 +class Engine;
++
 +struct SFNTNameTable
 +{
++
 +};
++
 +struct FontBasicInfo
 +{
 +  int numFaces = -1;
 +  QString familyName;
 +  QString styleName;
 +  QString postscriptName;
 +  QDateTime createdTime;
 +  QDateTime modifiedTime;
 +  QString revision;
 +  QString copyright;
 +  QString trademark;
 +  QString manufacturer;
++
 +  static FontBasicInfo get(Engine* engine);
++
++
 +  // Oh, we have no C++20 :(
 +  friend bool
 +  operator==(const FontBasicInfo& lhs,
 +             const FontBasicInfo& rhs)
 +  {
 +    return lhs.numFaces == rhs.numFaces
 +      && lhs.familyName == rhs.familyName
 +      && lhs.styleName == rhs.styleName
 +      && lhs.postscriptName == rhs.postscriptName
 +      && lhs.createdTime == rhs.createdTime
 +      && lhs.modifiedTime == rhs.modifiedTime
 +      && lhs.revision == rhs.revision
 +      && lhs.copyright == rhs.copyright
 +      && lhs.trademark == rhs.trademark
 +      && lhs.manufacturer == rhs.manufacturer;
 +  }
++
++
 +  friend bool
 +  operator!=(const FontBasicInfo& lhs,
 +             const FontBasicInfo& rhs)
 +  {
 +    return !(lhs == rhs);
 +  }
 +};
++
++
 +struct FontTypeEntries
 +{
 +  QString driverName;
 +  bool sfnt          : 1;
 +  bool scalable      : 1;
 +  bool mmgx          : 1;
 +  bool fixedSizes    : 1;
 +  bool hasHorizontal : 1;
 +  bool hasVertical   : 1;
 +  bool fixedWidth    : 1;
 +  bool glyphNames    : 1;
++
 +  int emSize;
 +  FT_BBox globalBBox;
 +  int ascender;
 +  int descender;
 +  int height;
 +  int maxAdvanceWidth;
 +  int maxAdvanceHeight;
 +  int underlinePos;
 +  int underlineThickness;
++
 +  static FontTypeEntries get(Engine* engine);
++
++
 +  // Oh, we have no C++20 :(
 +  friend bool
 +  operator==(const FontTypeEntries& lhs,
 +             const FontTypeEntries& rhs)
 +  {
 +    return lhs.driverName == rhs.driverName
 +      && lhs.sfnt == rhs.sfnt
 +      && lhs.scalable == rhs.scalable
 +      && lhs.mmgx == rhs.mmgx
 +      && lhs.fixedSizes == rhs.fixedSizes
 +      && lhs.hasHorizontal == rhs.hasHorizontal
 +      && lhs.hasVertical == rhs.hasVertical
 +      && lhs.fixedWidth == rhs.fixedWidth
 +      && lhs.glyphNames == rhs.glyphNames
 +      && lhs.emSize == rhs.emSize
 +      && lhs.globalBBox.xMax == rhs.globalBBox.xMax
 +      && lhs.globalBBox.xMin == rhs.globalBBox.xMin
 +      && lhs.globalBBox.yMax == rhs.globalBBox.yMax
 +      && lhs.globalBBox.yMin == rhs.globalBBox.yMin
 +      && lhs.ascender == rhs.ascender
 +      && lhs.descender == rhs.descender
 +      && lhs.height == rhs.height
 +      && lhs.maxAdvanceWidth == rhs.maxAdvanceWidth
 +      && lhs.maxAdvanceHeight == rhs.maxAdvanceHeight
 +      && lhs.underlinePos == rhs.underlinePos
 +      && lhs.underlineThickness == rhs.underlineThickness;
 +  }
++
++
 +  friend bool
 +  operator!=(const FontTypeEntries& lhs,
 +             const FontTypeEntries& rhs)
 +  {
 +    return !(lhs == rhs);
 +  }
 +};
++
++
 +struct FontFixedSize
 +{
 +  short height;
 +  short width;
 +  double size;
 +  double xPpem;
 +  double yPpem;
++
++
 +  // Returns that if the list is updated
 +  // Using a callback because Qt needs `beginResetModel` to be called **before**
 +  // the internal storage updates.
 +  static bool get(Engine* engine,
 +                  std::vector<FontFixedSize>& list,
 +                  const std::function<void()>& onUpdateNeeded);
++
++
 +  friend bool
 +  operator==(const FontFixedSize& lhs,
 +             const FontFixedSize& rhs)
 +  {
 +    return lhs.height == rhs.height
 +      && lhs.width == rhs.width
 +      && lhs.size == rhs.size
 +      && lhs.xPpem == rhs.xPpem
 +      && lhs.yPpem == rhs.yPpem;
 +  }
++
++
 +  friend bool
 +  operator!=(const FontFixedSize& lhs,
 +             const FontFixedSize& rhs)
 +  {
 +    return !(lhs == rhs);
 +  }
 +};
++
++
 +// end of fontinfo.hpp

src/ftinspect/maingui.cpp

@@ -240,6 +240,7 @@ MainGUI::createLayout()
    continuousTab_ = new ContinuousTab(this, engine_,
                                       glyphDetailsDockWidget_, glyphDetails_);
    comparatorTab_ = new ComperatorTab(this, engine_);
 +  infoTab_ = new InfoTab(this, engine_);
    tabWidget_ = new QTabWidget(this);
@@ -250,6 +251,8 @@ MainGUI::createLayout()
    tabWidget_->addTab(continuousTab_, tr("Continuous View"));
    tabs_.append(comparatorTab_);
    tabWidget_->addTab(comparatorTab_, tr("Comparator View"));
 +  tabs_.append(infoTab_);
 +  tabWidget_->addTab(infoTab_, tr("Font Info"));
    tripletSelector_ = new TripletSelector(this, engine_);

src/ftinspect/maingui.hpp

@@ -11,6 +11,7 @@
  #include "panels/singular.hpp"
  #include "panels/continuous.hpp"
  #include "panels/comparator.hpp"
 +#include "panels/info.hpp"
  #include "panels/glyphdetails.hpp"
  #include <QAction>
@@ -112,6 +113,7 @@ private:
    SingularTab* singularTab_;
    ContinuousTab* continuousTab_;
    ComperatorTab* comparatorTab_;
 +  InfoTab* infoTab_;
    QDockWidget* glyphDetailsDockWidget_;
    GlyphDetails* glyphDetails_;

src/ftinspect/meson.build

@@ -26,6 +26,7 @@ if qt5_dep.found()
      'engine/charmap.cpp',
      'engine/paletteinfo.cpp',
      'engine/stringrenderer.cpp',
 +    'engine/fontinfo.cpp',
      'rendering/glyphbitmap.cpp',
      'rendering/glyphoutline.cpp',
@@ -42,12 +43,14 @@ if qt5_dep.found()
      'widgets/charmapcombobox.cpp',
      'models/customcomboboxmodels.cpp',
 +    'models/fontinfomodels.cpp',
      'panels/settingpanel.cpp',
      'panels/singular.cpp',
      'panels/continuous.cpp',
      'panels/comparator.cpp',
      'panels/glyphdetails.cpp',
 +    'panels/info.cpp',
      'ftinspect.cpp',
      'maingui.cpp',
@@ -65,11 +68,13 @@ if qt5_dep.found()
        'rendering/glyphbitmap.hpp',
        'rendering/glyphcontinuous.hpp',
        'models/customcomboboxmodels.hpp',
 +      'models/fontinfomodels.hpp',
        'panels/settingpanel.hpp',
        'panels/singular.hpp',
        'panels/continuous.hpp',
        'panels/comparator.hpp',
        'panels/glyphdetails.hpp',
 +      'panels/info.hpp',
        'maingui.hpp',
      ],
      dependencies: qt5_dep)

src/ftinspect/models/fontinfomodels.cpp

 +// fontinfomodels.cpp
++
 +// Copyright (C) 2022 by Charlie Jiang.
++
 +#include "fontinfomodels.hpp"
++
 +int
 +FixedSizeInfoModel::rowCount(const QModelIndex& parent) const
 +{
 +  if (parent.isValid())
 +    return 0;
 +  return static_cast<int>(storage_.size());
 +}
++
++
 +int
 +FixedSizeInfoModel::columnCount(const QModelIndex& parent) const
 +{
 +  if (parent.isValid())
 +    return 0;
 +  return FSIM_Max;
 +}
++
++
 +QVariant
 +FixedSizeInfoModel::data(const QModelIndex& index,
 +                          int role) const
 +{
 +  if (index.row() < 0 || index.column() < 0)
 +    return {};
 +  auto r = static_cast<size_t>(index.row());
 +  if (role != Qt::DisplayRole || r > storage_.size())
 +    return {};
++
 +  auto& obj = storage_[r];
 +  switch (static_cast<Columns>(index.column()))
 +  {
 +  case FSIM_Index:
 +    return index.row();
 +  case FSIM_Height:
 +    return obj.height;
 +  case FSIM_Width:
 +    return obj.width;
 +  case FSIM_Size:
 +    return obj.size;
 +  case FSIM_XPpem:
 +    return obj.xPpem;
 +  case FSIM_YPpem:
 +    return obj.yPpem;
 +  }
++
 +  return {};
 +}
++
++
 +QVariant
 +FixedSizeInfoModel::headerData(int section,
 +                                Qt::Orientation orientation,
 +                                int role) const
 +{
 +  if (role != Qt::DisplayRole || orientation != Qt::Horizontal)
 +    return {};
++
 +  switch (static_cast<Columns>(section))
 +  {
 +  case FSIM_Index:
 +    return tr("#");
 +  case FSIM_Height:
 +    return tr("Height");
 +  case FSIM_Width:
 +    return tr("Width");
 +  case FSIM_Size:
 +    return tr("Size");
 +  case FSIM_XPpem:
 +    return tr("X ppem");
 +  case FSIM_YPpem:
 +    return tr("Y ppem");
 +  }
++
 +  return {};
 +}
++
++
 +int
 +CharMapInfoModel::rowCount(const QModelIndex& parent) const
 +{
 +  if (parent.isValid())
 +    return 0;
 +  return static_cast<int>(storage_.size());
 +}
++
++
 +int
 +CharMapInfoModel::columnCount(const QModelIndex& parent) const
 +{
 +  if (parent.isValid())
 +    return 0;
 +  return CMIM_Max;
 +}
++
++
 +QVariant
 +CharMapInfoModel::data(const QModelIndex& index,
 +                       int role) const
 +{
 +  // TODO reduce duplication
 +  if (index.row() < 0 || index.column() < 0)
 +    return {};
 +  auto r = static_cast<size_t>(index.row());
 +  if (role != Qt::DisplayRole || r > storage_.size())
 +    return {};
++
 +  auto& obj = storage_[r];
 +  switch (static_cast<Columns>(index.column()))
 +  {
 +  case CMIM_Index:
 +    return index.row();
 +  case CMIM_Encoding:
 +    return *obj.encodingName;
 +  case CMIM_PlatformID:
 +    return obj.platformID;
 +  case CMIM_EncodingID:
 +    return obj.encodingID;
 +  case CMIM_FormatID:
 +    return obj.formatID;
 +  case CMIM_LanguageID:
 +    return static_cast<unsigned long long>(obj.languageID);
 +  case CMIM_MaxIndex:
 +    return obj.maxIndex;
 +  }
++
 +  return {};
 +}
++
++
 +QVariant
 +CharMapInfoModel::headerData(int section,
 +                             Qt::Orientation orientation,
 +                             int role) const
 +{
 +  if (role != Qt::DisplayRole || orientation != Qt::Horizontal)
 +    return {};
++
 +  switch (static_cast<Columns>(section))
 +  {
 +  case CMIM_Index:
 +    return "#";
 +  case CMIM_Encoding:
 +    return "Encoding";
 +  case CMIM_PlatformID:
 +    return "Platform ID";
 +  case CMIM_EncodingID:
 +    return "Encoding ID";
 +  case CMIM_FormatID:
 +    return "Format ID";
 +  case CMIM_LanguageID:
 +    return "Language ID";
 +  case CMIM_MaxIndex:
 +    return "Max Code Point";
 +  }
++
 +  return {};
 +}
++
++
 +// end of fontinfomodels.cpp

src/ftinspect/models/fontinfomodels.hpp

 +// fontinfomodels.hpp
++
 +// Copyright (C) 2022 by Charlie Jiang.
++
 +#pragma once
++
 +#include "../engine/fontinfo.hpp"
 +#include "../engine/charmap.hpp"
++
 +#include <vector>
 +#include <QAbstractTableModel>
++
 +class FixedSizeInfoModel
 +: public QAbstractTableModel
 +{
 +  Q_OBJECT
 +public:
 +  explicit FixedSizeInfoModel(QObject* parent) : QAbstractTableModel(parent) {}
 +  ~FixedSizeInfoModel() override = default;
++
 +  int rowCount(const QModelIndex& parent) const override;
 +  int columnCount(const QModelIndex& parent) const override;
 +  QVariant data(const QModelIndex& index,
 +                int role) const override;
 +  QVariant headerData(int section,
 +                      Qt::Orientation orientation,
 +                      int role) const override;
++
 +  // Since we need to call `beginResetModel` right before updating, and need to
 +  // call `endResetModel` after the internal storage is changed
 +  // The model should be updated on-demand, and the internal storage is updated
 +  // from `FontFixedSize::get`, we provide a callback for `get` to ensure the
 +  // `beginResetModel` is called before the storage is changed,
 +  // and the caller is responsible to call `endResetModel` according to `get`'s
 +  // return value.
 +  void beginModelUpdate() { beginResetModel(); }
 +  void endModelUpdate() { endResetModel(); }
 +  std::vector<FontFixedSize>& storage() { return storage_; }
++
 +  enum Columns : int
 +  {
 +    FSIM_Index  = 0,
 +    FSIM_Height = 1,
 +    FSIM_Width  = 2,
 +    FSIM_Size   = 3,
 +    FSIM_XPpem  = 4,
 +    FSIM_YPpem  = 5,
 +    FSIM_Max
 +  };
++
 +private:
 +  // Don't let the item count exceed INT_MAX!
 +  std::vector<FontFixedSize> storage_;
 +};
++
++
 +class CharMapInfoModel
 +: public QAbstractTableModel
 +{
 +  Q_OBJECT
 +public:
 +  explicit CharMapInfoModel(QObject* parent) : QAbstractTableModel(parent) {}
 +  ~CharMapInfoModel() override = default;
++
 +  int rowCount(const QModelIndex& parent) const override;
 +  int columnCount(const QModelIndex& parent) const override;
 +  QVariant data(const QModelIndex& index,
 +                int role) const override;
 +  QVariant headerData(int section,
 +                      Qt::Orientation orientation,
 +                      int role) const override;
++
 +  // Same to `FixedSizeInfoModel`
 +  void beginModelUpdate() { beginResetModel(); }
 +  void endModelUpdate() { endResetModel(); }
 +  std::vector<CharMapInfo>& storage() { return storage_; }
++
 +  enum Columns : int
 +  {
 +    CMIM_Index      = 0,
 +    CMIM_Encoding   = 1,
 +    CMIM_PlatformID = 2,
 +    CMIM_EncodingID = 3,
 +    CMIM_FormatID   = 4,
 +    CMIM_LanguageID = 5,
 +    CMIM_MaxIndex   = 6,
 +    CMIM_Max
 +  };
++
 +private:
 +  // Don't let the item count exceed INT_MAX!
 +  std::vector<CharMapInfo> storage_;
 +};
++
++
 +// end of fontinfomodels.hpp

src/ftinspect/panels/info.cpp

 +// info.cpp
++
 +// Copyright (C) 2022 by Charlie Jiang.
++
 +#include "info.hpp"
++
 +#include "../uihelper.hpp"
 +#include "../engine/engine.hpp"
++
 +#include <QStringList>
 +#include <QHeaderView>
++
 +InfoTab::InfoTab(QWidget* parent,
 +                 Engine* engine)
 +: QWidget(parent), engine_(engine)
 +{
 +  createLayout();
 +}
++
++
 +void
 +InfoTab::reloadFont()
 +{
 +  for (auto tab : tabs_)
 +    tab->reloadFont();
 +}
++
++
 +void
 +InfoTab::createLayout()
 +{
 +  generalTab_ = new GeneralInfoTab(this, engine_);
 +  sfntTab_ = new SFNTInfoTab(this, engine_);
 +  postScriptTab_ = new PostScriptInfoTab(this, engine_);
 +  mmgxTab_ = new MMGXInfoTab(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"));
++
 +  tabs_.append(generalTab_);
 +  tabs_.append(sfntTab_);
 +  tabs_.append(postScriptTab_);
 +  tabs_.append(mmgxTab_);
++
 +  layout_ = new QHBoxLayout;
 +  layout_->addWidget(tab_);
++
 +  setLayout(layout_);
 +}
++
++
 +GeneralInfoTab::GeneralInfoTab(QWidget* parent,
 +                               Engine* engine)
 +: QWidget(parent), engine_(engine)
 +{
 +  createLayout();
 +}
++
++
 +void
 +GeneralInfoTab::reloadFont()
 +{
 +  auto basicInfo = FontBasicInfo::get(engine_);
 +  // don't update when unnecessary
 +  if (basicInfo != oldFontBasicInfo_)
 +  {
 +    oldFontBasicInfo_ = basicInfo;
 +    if (basicInfo.numFaces < 0)
 +      numFacesLabel_->clear();
 +    else
 +      numFacesLabel_->setText(QString::number(basicInfo.numFaces));
++
 +          familyLabel_->setText(basicInfo.familyName);
 +           styleLabel_->setText(basicInfo.styleName);
 +      postscriptLabel_->setText(basicInfo.postscriptName);
 +        revisionLabel_->setText(basicInfo.revision);
 +       copyrightLabel_->setText(basicInfo.copyright);
 +       trademarkLabel_->setText(basicInfo.trademark);
 +    manufacturerLabel_->setText(basicInfo.manufacturer);
++
 +    createdLabel_->setText(
 +        basicInfo.createdTime.toString("yyyy-MM-dd hh:mm:ss t"));
 +    modifiedLabel_->setText(
 +        basicInfo.modifiedTime.toString("yyyy-MM-dd hh:mm:ss t"));
 +  }
++
 +  auto fontTypeEntries = FontTypeEntries::get(engine_);
++
 +  if (fontTypeEntries != oldFontTypeEntries_)
 +  {
 +    oldFontTypeEntries_ = fontTypeEntries;
 +    QString directionText;
 +    // Don't want to do concat...
 +    if (fontTypeEntries.hasHorizontal && fontTypeEntries.hasVertical)
 +      directionText = "honizontal, vertical";
 +    else if (fontTypeEntries.hasHorizontal)
 +      directionText = "horizontal";
 +    else if (fontTypeEntries.hasVertical)
 +      directionText = "vertical";
++
 +    QStringList types;
 +    if (fontTypeEntries.scalable)
 +      types += "scalable";
 +    if (fontTypeEntries.mmgx)
 +      types += "multiple master";
 +    if (fontTypeEntries.fixedSizes)
 +      types += "fixed sizes";
++
 +    driverNameLabel_->setText(fontTypeEntries.driverName);
 +          sfntLabel_->setText(fontTypeEntries.sfnt ? "yes" : "no");
 +      fontTypeLabel_->setText(types.join(", "));
 +     directionLabel_->setText(directionText);
 +    fixedWidthLabel_->setText(fontTypeEntries.fixedWidth ? "yes" : "no");
 +    glyphNamesLabel_->setText(fontTypeEntries.glyphNames ? "available"
 +                                                           : "unavailable");
++
 +    if (fontTypeEntries.scalable)
 +    {
 +      emSizeLabel_->setText(QString::number(fontTypeEntries.emSize));
 +      bboxLabel_->setText(QString("(%1, %2) : (%3, %4)")
 +                            .arg(fontTypeEntries.globalBBox.xMin)
 +                            .arg(fontTypeEntries.globalBBox.yMin)
 +                            .arg(fontTypeEntries.globalBBox.xMax)
 +                            .arg(fontTypeEntries.globalBBox.yMax));
 +      ascenderLabel_->setText(QString::number(fontTypeEntries.ascender));
 +      descenderLabel_->setText(QString::number(fontTypeEntries.descender));
 +      maxAdvanceWidthLabel_
 +        ->setText(QString::number(fontTypeEntries.maxAdvanceWidth));
 +      maxAdvanceHeightLabel_
 +        ->setText(QString::number(fontTypeEntries.maxAdvanceHeight));
 +      ulPosLabel_
 +        ->setText(QString::number(fontTypeEntries.underlinePos));
 +      ulThicknessLabel_
 +        ->setText(QString::number(fontTypeEntries.underlineThickness));
++
 +      for (auto label : scalableOnlyLabels_)
 +        label->setEnabled(true);
 +    }
 +    else
 +    {
 +      for (auto label : scalableOnlyLabels_)
 +        label->setEnabled(false);
 +    }
 +  }
++
 +  fixedSizesTable_->setEnabled(fontTypeEntries.fixedSizes);
 +  bool reset
 +    = FontFixedSize::get(engine_,
 +                         fixedSizeInfoModel_->storage(),
 +                         [&] { fixedSizeInfoModel_->beginModelUpdate(); });
 +  if (reset)
 +    fixedSizeInfoModel_->endModelUpdate();
++
 +  if (engine_->currentFontCharMaps() != charMapInfoModel_->storage())
 +  {
 +    charMapInfoModel_->beginModelUpdate();
 +    charMapInfoModel_->storage() = engine_->currentFontCharMaps();
 +    charMapInfoModel_->endModelUpdate();
 +  }
 +}
++
++
 +void
 +GeneralInfoTab::createLayout()
 +{
 +      numFacesPromptLabel_  = new QLabel(tr("Num of Faces:"), this);
 +        familyPromptLabel_  = new QLabel(tr("Family Name:"), this);
 +         stylePromptLabel_  = new QLabel(tr("Style Name:"), this);
 +    postscriptPromptLabel_  = new QLabel(tr("PostScript Name:"), this);
 +       createdPromptLabel_  = new QLabel(tr("Created at:"), this);
 +      modifiedPromptLabel_  = new QLabel(tr("Modified at:"), this);
 +      revisionPromptLabel_  = new QLabel(tr("Font Revision:"), this);
 +     copyrightPromptLabel_  = new QLabel(tr("Copyright:"), this);
 +     trademarkPromptLabel_  = new QLabel(tr("Trademark:"), this);
 +  manufacturerPromptLabel_  = new QLabel(tr("Manufacturer:"), this);
++
 +      numFacesLabel_ = new QLabel(this);
 +        familyLabel_ = new QLabel(this);
 +         styleLabel_ = new QLabel(this);
 +    postscriptLabel_ = new QLabel(this);
 +       createdLabel_ = new QLabel(this);
 +      modifiedLabel_ = new QLabel(this);
 +      revisionLabel_ = new QLabel(this);
 +     copyrightLabel_ = new QLabel(this);
 +     trademarkLabel_ = new QLabel(this);
 +  manufacturerLabel_ = new QLabel(this);
++
 +  setLabelSelectable(    numFacesLabel_);
 +  setLabelSelectable(      familyLabel_);
 +  setLabelSelectable(       styleLabel_);
 +  setLabelSelectable(  postscriptLabel_);
 +  setLabelSelectable(     createdLabel_);
 +  setLabelSelectable(    modifiedLabel_);
 +  setLabelSelectable(    revisionLabel_);
 +  setLabelSelectable(   copyrightLabel_);
 +  setLabelSelectable(   trademarkLabel_);
 +  setLabelSelectable(manufacturerLabel_);
++
 +  driverNamePromptLabel_ = new QLabel(tr("Driver:"), this);
 +        sfntPromptLabel_ = new QLabel(tr("SFNT Wrapped:"), this);
 +    fontTypePromptLabel_ = new QLabel(tr("Type:"), this);
 +   directionPromptLabel_ = new QLabel(tr("Direction:"), this);
 +  fixedWidthPromptLabel_ = new QLabel(tr("Fixed Width:"), this);
 +  glyphNamesPromptLabel_ = new QLabel(tr("Glyph Names:"), this);
++
 +  driverNameLabel_ = new QLabel(this);
 +        sfntLabel_ = new QLabel(this);
 +    fontTypeLabel_ = new QLabel(this);
 +   directionLabel_ = new QLabel(this);
 +  fixedWidthLabel_ = new QLabel(this);
 +  glyphNamesLabel_ = new QLabel(this);
++
 +  setLabelSelectable(driverNameLabel_);
 +  setLabelSelectable(      sfntLabel_);
 +  setLabelSelectable(  fontTypeLabel_);
 +  setLabelSelectable( directionLabel_);
 +  setLabelSelectable(fixedWidthLabel_);
 +  setLabelSelectable(glyphNamesLabel_);
++
 +            emSizePromptLabel_ = new QLabel(tr("EM Size:"), this);
 +              bboxPromptLabel_ = new QLabel(tr("Global BBox:"), this);
 +          ascenderPromptLabel_ = new QLabel(tr("Ascender:"), this);
 +         descenderPromptLabel_ = new QLabel(tr("Descender:"), this);
 +   maxAdvanceWidthPromptLabel_ = new QLabel(tr("Max Advance Width:"), this);
 +  maxAdvanceHeightPromptLabel_ = new QLabel(tr("Max Advance Height:"), this);
 +             ulPosPromptLabel_ = new QLabel(tr("Underline Position:"), this);
 +       ulThicknessPromptLabel_ = new QLabel(tr("Underline Thickness:"), this);
++
 +            emSizeLabel_ = new QLabel(this);
 +              bboxLabel_ = new QLabel(this);
 +          ascenderLabel_ = new QLabel(this);
 +         descenderLabel_ = new QLabel(this);
 +   maxAdvanceWidthLabel_ = new QLabel(this);
 +  maxAdvanceHeightLabel_ = new QLabel(this);
 +             ulPosLabel_ = new QLabel(this);
 +       ulThicknessLabel_ = new QLabel(this);
++
 +  setLabelSelectable(          emSizeLabel_);
 +  setLabelSelectable(            bboxLabel_);
 +  setLabelSelectable(        ascenderLabel_);
 +  setLabelSelectable(       descenderLabel_);
 +  setLabelSelectable( maxAdvanceWidthLabel_);
 +  setLabelSelectable(maxAdvanceHeightLabel_);
 +  setLabelSelectable(           ulPosLabel_);
 +  setLabelSelectable(     ulThicknessLabel_);
++
 +  scalableOnlyLabels_.push_back(          emSizePromptLabel_);
 +  scalableOnlyLabels_.push_back(            bboxPromptLabel_);
 +  scalableOnlyLabels_.push_back(        ascenderPromptLabel_);
 +  scalableOnlyLabels_.push_back(       descenderPromptLabel_);
 +  scalableOnlyLabels_.push_back( maxAdvanceWidthPromptLabel_);
 +  scalableOnlyLabels_.push_back(maxAdvanceHeightPromptLabel_);
 +  scalableOnlyLabels_.push_back(           ulPosPromptLabel_);
 +  scalableOnlyLabels_.push_back(     ulThicknessPromptLabel_);
 +  scalableOnlyLabels_.push_back(          emSizeLabel_);
 +  scalableOnlyLabels_.push_back(            bboxLabel_);
 +  scalableOnlyLabels_.push_back(        ascenderLabel_);
 +  scalableOnlyLabels_.push_back(       descenderLabel_);
 +  scalableOnlyLabels_.push_back( maxAdvanceWidthLabel_);
 +  scalableOnlyLabels_.push_back(maxAdvanceHeightLabel_);
 +  scalableOnlyLabels_.push_back(           ulPosLabel_);
 +  scalableOnlyLabels_.push_back(     ulThicknessLabel_);
++
 +        basicGroupBox_ = new QGroupBox(tr("Basic"), this);
 +  typeEntriesGroupBox_ = new QGroupBox(tr("Type Entries"), this);
 +      charMapGroupBox_ = new QGroupBox(tr("CharMaps"), this);
 +  fixedSizesGroupBox_  = new QGroupBox(tr("Fixed Sizes"), this);
++
 +  charMapsTable_ = new QTableView(this);
 +  fixedSizesTable_ = new QTableView(this);
++
 +  charMapInfoModel_ = new CharMapInfoModel(this);
 +  charMapsTable_->setModel(charMapInfoModel_);
 +  auto header = charMapsTable_->verticalHeader();
 +  // This will force the minimal size to be used
 +  header->setDefaultSectionSize(0);
 +  header->setSectionResizeMode(QHeaderView::Fixed);
++
 +  fixedSizeInfoModel_ = new FixedSizeInfoModel(this);
 +  fixedSizesTable_->setModel(fixedSizeInfoModel_);
 +  header = fixedSizesTable_->verticalHeader();
 +  header->setDefaultSectionSize(0);
 +  header->setSectionResizeMode(QHeaderView::Fixed);
++
 +  basicLayout_       = new QGridLayout;
 +  typeEntriesLayout_ = new QGridLayout;
 +  charMapLayout_     = new QHBoxLayout;
 +  fixedSizesLayout_  = new QHBoxLayout;
++
 +#define GL2CRow(l, w) gridLayout2ColAddWidget(l          ,      \
 +                                              w##PromptLabel_,  \
 +                                              w##Label_)
 +#define BasicRow(w) GL2CRow(basicLayout_, w)
 +#define FTERow(w) GL2CRow(typeEntriesLayout_, w)
++
 +  BasicRow(    numFaces);
 +  BasicRow(      family);
 +  BasicRow(       style);
 +  BasicRow(  postscript);
 +  BasicRow(     created);
 +  BasicRow(    modified);
 +  BasicRow(    revision);
 +  BasicRow(   copyright);
 +  BasicRow(   trademark);
 +  BasicRow(manufacturer);
++
 +  FTERow(      driverName);
 +  FTERow(            sfnt);
 +  FTERow(        fontType);
 +  FTERow(       direction);
 +  FTERow(      fixedWidth);
 +  FTERow(      glyphNames);
 +  FTERow(          emSize);
 +  FTERow(            bbox);
 +  FTERow(        ascender);
 +  FTERow(       descender);
 +  FTERow( maxAdvanceWidth);
 +  FTERow(maxAdvanceHeight);
 +  FTERow(           ulPos);
 +  FTERow(     ulThickness);
++
 +  charMapLayout_->addWidget(charMapsTable_);
 +  fixedSizesLayout_->addWidget(fixedSizesTable_);
++
 +        basicGroupBox_ ->setLayout(basicLayout_      );
 +  typeEntriesGroupBox_ ->setLayout(typeEntriesLayout_);
 +      charMapGroupBox_ ->setLayout(charMapLayout_    );
 +  fixedSizesGroupBox_  ->setLayout(fixedSizesLayout_ );
++
 +  leftLayout_ = new QVBoxLayout;
 +  rightLayout_ = new QVBoxLayout;
 +  mainLayout_ = new QHBoxLayout;
++
 +  leftLayout_->addWidget(basicGroupBox_);
 +  leftLayout_->addWidget(typeEntriesGroupBox_);
 +  leftLayout_->addSpacerItem(new QSpacerItem(0, 0,
 +                                             QSizePolicy::Preferred,
 +                                             QSizePolicy::Expanding));
++
 +  rightLayout_->addWidget(charMapGroupBox_);
 +  rightLayout_->addWidget(fixedSizesGroupBox_);
++
 +  mainLayout_->addLayout(leftLayout_);
 +  mainLayout_->addLayout(rightLayout_);
 +  setLayout(mainLayout_);
 +}
++
++
 +SFNTInfoTab::SFNTInfoTab(QWidget* parent,
 +                         Engine* engine)
 +: QWidget(parent), engine_(engine)
 +{
 +}
++
++
 +void
 +SFNTInfoTab::reloadFont()
 +{
 +}
++
++
 +PostScriptInfoTab::PostScriptInfoTab(QWidget* parent,
 +                                     Engine* engine)
 +: QWidget(parent), engine_(engine)
 +{
 +}
++
++
 +void
 +PostScriptInfoTab::reloadFont()
 +{
 +}
++
++
 +MMGXInfoTab::MMGXInfoTab(QWidget* parent,
 +                         Engine* engine)
 +: QWidget(parent), engine_(engine)
 +{
 +}
++
++
 +void
 +MMGXInfoTab::reloadFont()
 +{
 +}
++
++
 +// end of info.cpp

src/ftinspect/panels/info.hpp

 +// info.hpp
++
 +// Copyright (C) 2022 by Charlie Jiang.
++
 +#pragma once
++
 +#include "abstracttab.hpp"
 +#include "../engine/fontinfo.hpp"
 +#include "../models/fontinfomodels.hpp"
++
 +#include <vector>
 +#include <QWidget>
 +#include <QTabWidget>
 +#include <QBoxLayout>
 +#include <QGridLayout>
 +#include <QVector>
 +#include <QLabel>
 +#include <QGroupBox>
 +#include <QTableView>
 +#include <QStackedLayout>
++
 +class Engine;
 +class GeneralInfoTab;
 +class SFNTInfoTab;
 +class PostScriptInfoTab;
 +class MMGXInfoTab;
++
 +class InfoTab
 +: public QWidget, public AbstractTab
 +{
 +  Q_OBJECT
 +public:
 +  InfoTab(QWidget* parent, Engine* engine);
 +  ~InfoTab() override = default;
++
 +  void repaintGlyph() override {}
 +  void reloadFont() override;
++
 +private:
 +  Engine* engine_;
++
 +  QVector<AbstractTab*> tabs_;
 +  GeneralInfoTab*    generalTab_;
 +  SFNTInfoTab*       sfntTab_;
 +  PostScriptInfoTab* postScriptTab_;
 +  MMGXInfoTab*       mmgxTab_;
++
 +  QTabWidget* tab_;
 +  QHBoxLayout* layout_;
++
 +  void createLayout();
 +};
++
++
 +class GeneralInfoTab
 +: public QWidget, public AbstractTab
 +{
 +  Q_OBJECT
 +public:
 +  GeneralInfoTab(QWidget* parent, Engine* engine);
 +  ~GeneralInfoTab() override = default;
++
 +  void repaintGlyph() override {}
 +  void reloadFont() override;
++
 +private:
 +  Engine* engine_;
++
 +#define LabelPair(name) \
 +  QLabel* name##Label_; \
 +  QLabel* name##PromptLabel_;
++
 +  LabelPair(    numFaces)
 +  LabelPair(      family)
 +  LabelPair(       style)
 +  LabelPair(  postscript)
 +  LabelPair(     created)
 +  LabelPair(    modified)
 +  LabelPair(    revision)
 +  LabelPair(   copyright)
 +  LabelPair(   trademark)
 +  LabelPair(manufacturer)
++
 +  LabelPair(driverName)
 +  LabelPair(      sfnt)
 +  LabelPair(  fontType)
 +  LabelPair( direction)
 +  LabelPair(fixedWidth)
 +  LabelPair(glyphNames)
++
 +  LabelPair(          emSize)
 +  LabelPair(            bbox)
 +  LabelPair(        ascender)
 +  LabelPair(       descender)
 +  LabelPair( maxAdvanceWidth)
 +  LabelPair(maxAdvanceHeight)
 +  LabelPair(           ulPos)
 +  LabelPair(     ulThickness)
++
 +  QGroupBox*       basicGroupBox_;
 +  QGroupBox* typeEntriesGroupBox_;
 +  QGroupBox*     charMapGroupBox_;
 +  QGroupBox*  fixedSizesGroupBox_;
++
 +  QTableView*   charMapsTable_;
 +  QTableView* fixedSizesTable_;
++
 +  FixedSizeInfoModel* fixedSizeInfoModel_;
 +  CharMapInfoModel* charMapInfoModel_;
++
 +  QHBoxLayout* mainLayout_;
 +  QVBoxLayout* leftLayout_;
 +  QVBoxLayout* rightLayout_;
 +  QGridLayout* basicLayout_;
 +  QGridLayout* typeEntriesLayout_;
 +  QHBoxLayout* charMapLayout_;
 +  QHBoxLayout* fixedSizesLayout_;
++
 +  std::vector<QLabel*> scalableOnlyLabels_;
++
 +  FontBasicInfo oldFontBasicInfo_ = {};
 +  FontTypeEntries oldFontTypeEntries_ = {};
++
 +  void createLayout();
 +};
++
++
 +class SFNTInfoTab
 +: public QWidget, public AbstractTab
 +{
 +  Q_OBJECT
 +public:
 +  SFNTInfoTab(QWidget* parent, Engine* engine);
 +  ~SFNTInfoTab() override = default;
++
 +  void repaintGlyph() override {}
 +  void reloadFont() override;
++
 +private:
 +  Engine* engine_;
 +};
++
++
 +class PostScriptInfoTab
 +: public QWidget, public AbstractTab
 +{
 +  Q_OBJECT
 +public:
 +  PostScriptInfoTab(QWidget* parent, Engine* engine);
 +  ~PostScriptInfoTab() override = default;
++
 +  void repaintGlyph() override {}
 +  void reloadFont() override;
++
 +private:
 +  Engine* engine_;
 +};
++
++
 +class MMGXInfoTab
 +: public QWidget, public AbstractTab
 +{
 +  Q_OBJECT
 +public:
 +  MMGXInfoTab(QWidget* parent, Engine* engine);
 +  ~MMGXInfoTab() override = default;
++
 +  void repaintGlyph() override {}
 +  void reloadFont() override;
++
 +private:
 +  Engine* engine_;
 +};
++
++
 +// end of info.hpp

From:	Charlie Jiang (@cqjjjzr)
Subject:	[Git][freetype/freetype-demos][gsoc-2022-chariri-3] 2 commits: * src/ftinspect/engine/engine.cpp: Fix missing include.
Date:	Sun, 14 Aug 2022 16:18:04 +0000