[Git][freetype/freetype-demos][gsoc-2022-chariri-3] [ftinspect] Support

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

Commits:

54761bec

by Charlie Jiang at 2022-08-21T23:19:37+08:00

[ftinspect] Support MM/GX.

Currently the "Reset Default" is problematic due to rounding issue.

* src/ftinspect/panels/settingpanelmmgx.cpp,
  src/ftinspect/panels/settingpanelmmgx.hpp:
  New file, containing the MM/GX setting tab.

* src/ftinspect/panels/settingpanel.cpp,
  src/ftinspect/panels/settingpanel.hpp: Integrate the `SettingPanelMMGX`..

* src/ftinspect/engine/engine.cpp, src/ftinspect/engine/engine.hpp:
  Add `applyMMGXDesignCoords` function, and move all cache resetting code
  to a new function `resetCache`.

* src/ftinspect/engine/mmgx.cpp, src/ftinspect/engine/mmgx.hpp
  Add `isMM` field.

* src/ftinspect/maingui.cpp: Force reset cache when reloading fonts.

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

11 changed files:

src/ftinspect/CMakeLists.txt
src/ftinspect/engine/engine.cpp
src/ftinspect/engine/engine.hpp
src/ftinspect/engine/mmgx.cpp
src/ftinspect/engine/mmgx.hpp
src/ftinspect/maingui.cpp
src/ftinspect/meson.build
src/ftinspect/panels/settingpanel.cpp
src/ftinspect/panels/settingpanel.hpp
+ src/ftinspect/panels/settingpanelmmgx.cpp
+ src/ftinspect/panels/settingpanelmmgx.hpp

Changes:

src/ftinspect/CMakeLists.txt

@@ -48,6 +48,7 @@ add_executable(ftinspect
    "models/fontinfomodels.cpp"
    "panels/settingpanel.cpp"
 +  "panels/settingpanelmmgx.cpp"
    "panels/singular.cpp"
    "panels/continuous.cpp"
    "panels/comparator.cpp"

src/ftinspect/engine/engine.cpp

@@ -16,6 +16,7 @@
  #include <freetype/ftdriver.h>
  #include <freetype/ftlcdfil.h>
  #include <freetype/ftbitmap.h>
 +#include <freetype/ftmm.h>
  /////////////////////////////////////////////////////////////////////////////
@@ -743,12 +744,7 @@ Engine::setCFFHintingMode(int mode)
                                     "hinting-engine",
                                     &mode);
    if (!error)
 -  {
 -    // reset the cache
 -    FTC_Manager_Reset(cacheManager_);
 -    ftFallbackFace_ = NULL;
 -    ftSize_ = NULL;
 -  }
 +    resetCache();
+ }
@@ -760,19 +756,13 @@ Engine::setTTInterpreterVersion(int version)
                                     "interpreter-version",
                                     &version);
    if (!error)
 -  {
 -    // reset the cache
 -    FTC_Manager_Reset(cacheManager_);
 -    ftFallbackFace_ = NULL;
 -    ftSize_ = NULL;
 -  }
 +    resetCache();
+ }
  void
  Engine::setStemDarkening(bool darkening)
+ {
 -  // TODO not working
    FT_Bool noDarkening = !darkening;
    FT_Property_Set(library_,
                    "cff",
@@ -790,10 +780,20 @@ Engine::setStemDarkening(bool darkening)
                    "t1cid",
                    "no-stem-darkening",
                    &noDarkening);
 -  // reset the cache
 -  FTC_Manager_Reset(cacheManager_);
 -  ftFallbackFace_ = NULL;
 -  ftSize_ = NULL;
 +  resetCache();
 +}
++
++
 +void
 +Engine::applyMMGXDesignCoords(FT_Fixed* coords,
 +                              size_t count)
 +{
 +  if (!ftSize_)
 +    return;
 +  if (count >= UINT_MAX)
 +    count = UINT_MAX - 1;
 +  FT_Set_Var_Design_Coordinates(ftSize_->face,
 +                                static_cast<unsigned>(count), coords);
+ }
@@ -866,6 +866,16 @@ Engine::update()
+ }
 +void
 +Engine::resetCache()
 +{
 +  // reset the cache
 +  FTC_Manager_Reset(cacheManager_);
 +  ftFallbackFace_ = NULL;
 +  ftSize_ = NULL;
 +}
++
++
  void
  Engine::queryEngine()
+ {

src/ftinspect/engine/engine.hpp

@@ -122,6 +122,7 @@ public:
    void removeFont(int fontIndex, bool closeFile = true);
    void update();
 +  void resetCache();
    //////// Getters
@@ -210,7 +211,9 @@ public:
    void setLcdFilter(FT_LcdFilter filter);
    void setCFFHintingMode(int mode);
    void setTTInterpreterVersion(int version);
++
    void setStemDarkening(bool darkening);
 +  void applyMMGXDesignCoords(FT_Fixed* coords, size_t count);
    void setForeground(QRgb foreground);
    void setBackground(QRgb background);

src/ftinspect/engine/mmgx.cpp

@@ -48,6 +48,7 @@ MMGXAxisInfo::get(Engine* engine,
      info.minimum = axis.minimum / 65536.0;
      info.def = axis.def / 65536.0;
      info.tag = axis.tag;
 +    info.isMM = state == MMGXState::MM;
      unsigned int flags = 0;
      FT_Get_Var_Axis_Flags(mm, i, &flags);
@@ -78,5 +79,5 @@ MMGXAxisInfo::get(Engine* engine,
    return state;
+ }
 -// end of mmgx.cpp
 +// end of mmgx.cpp

src/ftinspect/engine/mmgx.hpp

@@ -26,6 +26,7 @@ struct MMGXAxisInfo
    double def;
    bool hidden;
 +  bool isMM;
    static MMGXState get(Engine* engine, std::vector<MMGXAxisInfo>& infos);
@@ -39,7 +40,8 @@ struct MMGXAxisInfo
        && lhs.minimum == rhs.minimum
        && lhs.maximum == rhs.maximum
        && lhs.def == rhs.def
 -      && lhs.hidden == rhs.hidden;
 +      && lhs.hidden == rhs.hidden
 +      && lhs.isMM == rhs.isMM;
+   }

src/ftinspect/maingui.cpp


 void
 MainGUI::reloadCurrentTabFont()
 {
+  engine_->resetCache();
   syncSettings();
   tabs_[tabWidget_->currentIndex()]->reloadFont();
 }

src/ftinspect/meson.build

@@ -48,6 +48,7 @@ if qt5_dep.found()
      'models/fontinfomodels.cpp',
      'panels/settingpanel.cpp',
 +    'panels/settingpanelmmgx.cpp',
      'panels/singular.cpp',
      'panels/continuous.cpp',
      'panels/comparator.cpp',
@@ -72,6 +73,7 @@ if qt5_dep.found()
        'models/customcomboboxmodels.hpp',
        'models/fontinfomodels.hpp',
        'panels/settingpanel.hpp',
 +      'panels/settingpanelmmgx.hpp',
        'panels/singular.hpp',
        'panels/continuous.hpp',
        'panels/comparator.hpp',

src/ftinspect/panels/settingpanel.cpp

@@ -111,6 +111,7 @@ SettingPanel::onFontChanged()
+   }
    populatePalettes();
 +  mmgxPanel_->reloadFont();
    blockSignals(blockState);
+ }
@@ -364,6 +365,7 @@ SettingPanel::syncSettings()
    engine_->setForeground(foregroundColor_.rgba());
    engine_->setBackground(backgroundColor_.rgba());
 +  mmgxPanel_->syncSettings();
+ }
@@ -426,6 +428,9 @@ SettingPanel::createConnections()
      connect(foregroundButton_, &QPushButton::clicked,
              this, &SettingPanel::openForegroundPicker);
+   }
++
 +  connect(mmgxPanel_, &SettingPanelMMGX::mmgxCoordsChanged,
 +          this, &SettingPanel::fontReloadNeeded);
+ }
@@ -510,6 +515,8 @@ SettingPanel::createLayout()
    gammaLabel_->setBuddy(gammaSlider_);
    gammaValueLabel_ = new QLabel(this);
 +  mmgxPanel_ = new SettingPanelMMGX(this, engine_);
++
    if (!comparatorMode_)
+   {
      backgroundButton_ = new QPushButton(tr("Background"), this);
@@ -517,7 +524,6 @@ SettingPanel::createLayout()
+   }
    generalTab_ = new QWidget(this);
 -  mmgxTab_ = new QWidget(this);
    generalTab_->setSizePolicy(QSizePolicy::MinimumExpanding,
                               QSizePolicy::MinimumExpanding);
@@ -602,7 +608,7 @@ SettingPanel::createLayoutNormal()
    generalTab_->setLayout(generalTabLayout_);
    tab_->addTab(generalTab_, tr("General"));
 -  tab_->addTab(mmgxTab_, tr("MM/GX"));
 +  tab_->addTab(mmgxPanel_, tr("MM/GX"));
+ }
@@ -647,7 +653,7 @@ SettingPanel::createLayoutComperator()
    tab_->addTab(hintingRenderingTab_, tr("Hinting && Rendering"));
    tab_->addTab(generalTab_, tr("General"));
 -  tab_->addTab(mmgxTab_, tr("MM/GX"));
 +  tab_->addTab(mmgxPanel_, tr("MM/GX"));
    setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Maximum);
+ }

src/ftinspect/panels/settingpanel.hpp

@@ -4,6 +4,7 @@
  #pragma once
 +#include "settingpanelmmgx.hpp"
  #include "../engine/engine.hpp"
  #include "../models/customcomboboxmodels.hpp"
@@ -76,7 +77,7 @@ private:
    QWidget* generalTab_;
    QWidget* hintingRenderingTab_;
 -  QWidget* mmgxTab_;
 +  SettingPanelMMGX* mmgxPanel_;
    QLabel* gammaLabel_;
    QLabel* gammaValueLabel_;

src/ftinspect/panels/settingpanelmmgx.cpp

 +// settingpanelmmgx.cpp
++
 +// Copyright (C) 2022 by Charlie Jiang.
++
 +#include "settingpanelmmgx.hpp"
++
 +#include <QScrollBar>
++
 +#include "../engine/engine.hpp"
++
 +SettingPanelMMGX::SettingPanelMMGX(QWidget* parent,
 +                                   Engine* engine)
 +: QWidget(parent),
 +  engine_(engine)
 +{
 +  createLayout();
 +  createConnections();
 +}
++
++
 +void
 +SettingPanelMMGX::reloadFont()
 +{
 +  setEnabled(engine_->currentFontMMGXState() != MMGXState::NoMMGX);
 +  if (currentAxes_ == engine_->currentFontMMGXAxes())
 +    return;
++
 +  currentAxes_ = engine_->currentFontMMGXAxes();
++
 +  auto newSize = currentAxes_.size();
 +  auto oldSize = itemWidgets_.size();
 +  auto minSize = std::min(newSize, oldSize);
++
 +  // This won't trigger unexpected updating since signals are blocked
 +  for (size_t i = 0; i < minSize; ++i)
 +    itemWidgets_[i]->updateInfo(currentAxes_[i]);
++
 +  if (newSize < oldSize)
 +  {
 +    for (size_t i = oldSize; i < newSize; ++i)
 +    {
 +      auto w = itemWidgets_[i];
 +      disconnect(w);
 +      listLayout_->removeWidget(w);
 +      delete w;
 +    }
 +    itemWidgets_.resize(newSize);
 +  }
 +  else if (newSize > oldSize)
 +  {
 +    itemWidgets_.resize(newSize);
 +    for (size_t i = oldSize; i < newSize; ++i)
 +    {
 +      auto w = new MMGXSettingItem(this);
 +      itemWidgets_[i] = w;
 +      w->updateInfo(currentAxes_[i]);
 +      listLayout_->addWidget(w);
 +      connect(w, &MMGXSettingItem::valueChanged,
 +              this, &SettingPanelMMGX::itemChanged);
 +    }
 +  }
 +  checkHidden();
 +}
++
++
 +void
 +SettingPanelMMGX::syncSettings()
 +{
 +  engine_->reloadFont();
 +  engine_->applyMMGXDesignCoords(currentValues_.data(),
 +                                 currentValues_.size());
 +}
++
++
 +void
 +SettingPanelMMGX::checkHidden()
 +{
 +  if (itemWidgets_.size() < currentAxes_.size())
 +    return; // This should never happen!
 +  for (int i = 0; static_cast<size_t>(i) < currentAxes_.size(); ++i)
 +    itemWidgets_[i]->setVisible(showHiddenCheckBox_->isChecked()
 +                                || !currentAxes_[i].hidden);
 +}
++
++
 +void
 +SettingPanelMMGX::createLayout()
 +{
 +  showHiddenCheckBox_ = new QCheckBox(tr("Show Hidden"), this);
 +  resetDefaultButton_ = new QPushButton(tr("Reset Default"), this);
 +  itemsListWidget_ = new QWidget(this);
 +  scrollArea_ = new UnboundScrollArea(this);
++
 +  scrollArea_->setWidget(itemsListWidget_);
 +  scrollArea_->setWidgetResizable(true);
 +  scrollArea_->setStyleSheet("QScrollArea {background-color:transparent;}");
 +  itemsListWidget_->setStyleSheet("background-color:transparent;");
++
 +  mainLayout_ = new QVBoxLayout;
 +  listLayout_ = new QVBoxLayout;
 +  listWrapperLayout_ = new QVBoxLayout;
++
 +  listLayout_->setContentsMargins(0, 0, 0, 0);
 +  itemsListWidget_->setContentsMargins(0, 0, 0, 0);
++
 +  itemsListWidget_->setLayout(listWrapperLayout_);
++
 +  listWrapperLayout_->addLayout(listLayout_);
 +  listWrapperLayout_->addStretch(1);
++
 +  mainLayout_->addWidget(showHiddenCheckBox_);
 +  mainLayout_->addWidget(resetDefaultButton_);
 +  mainLayout_->addWidget(scrollArea_, 1);
++
 +  setLayout(mainLayout_);
 +}
++
++
 +void
 +SettingPanelMMGX::createConnections()
 +{
 +  connect(showHiddenCheckBox_, &QCheckBox::clicked,
 +          this, &SettingPanelMMGX::checkHidden);
 +  connect(resetDefaultButton_, &QCheckBox::clicked,
 +          this, &SettingPanelMMGX::resetDefaultClicked);
 +}
++
++
 +void
 +SettingPanelMMGX::itemChanged()
 +{
 +  currentValues_.resize(currentAxes_.size());
 +  for (unsigned i = 0; i < currentAxes_.size(); ++i)
 +    currentValues_[i] = itemWidgets_[i]->value();
++
 +  emit mmgxCoordsChanged();
 +}
++
++
 +void
 +SettingPanelMMGX::resetDefaultClicked()
 +{
 +  for (auto w : itemWidgets_)
 +    w->resetDefault();
 +  itemChanged();
 +}
++
++
 +MMGXSettingItem::MMGXSettingItem(QWidget* parent)
 +: QFrame(parent)
 +{
 +  createLayout();
 +  createConnections();
 +}
++
++
 +void
 +MMGXSettingItem::updateInfo(MMGXAxisInfo& info)
 +{
 +  axisInfo_ = info;
 +  if (info.hidden)
 +    nameLabel_->setText("<i>" + info.name + "</i>");
 +  else
 +    nameLabel_->setText(info.name);
++
 +  // To keep things simple, we will use 1/1024 of the span between the min and
 +  // max as one step on the slider.
++
 +  slider_->setMinimum(0);
 +  slider_->setTickInterval(1);
 +  slider_->setMaximum(1024);
++
 +  resetDefault();
 +}
++
++
 +void
 +MMGXSettingItem::resetDefault()
 +{
 +  QSignalBlocker blocker(this);
 +  slider_->setValue(static_cast<int>((axisInfo_.def - axisInfo_.minimum)
 +                                     / (axisInfo_.maximum - axisInfo_.minimum)
 +                                     * 1024));
 +}
++
++
 +void
 +MMGXSettingItem::createLayout()
 +{
 +  nameLabel_ = new QLabel(this);
 +  valueLabel_ = new QLabel(this);
 +  slider_ = new QSlider(this);
 +  slider_->setOrientation(Qt::Horizontal);
++
 +  mainLayout_ = new QGridLayout();
++
 +  mainLayout_->addWidget(nameLabel_, 0, 0);
 +  mainLayout_->addWidget(valueLabel_, 0, 1, 1, 1, Qt::AlignRight);
 +  mainLayout_->addWidget(slider_, 1, 0, 1, 2);
++
 +  mainLayout_->setContentsMargins(4, 4, 4, 4);
 +  setContentsMargins(4, 4, 4, 4);
 +  setLayout(mainLayout_);
 +  setFrameShape(StyledPanel);
 +}
++
++
 +void
 +MMGXSettingItem::createConnections()
 +{
 +  connect(slider_, &QSlider::valueChanged,
 +          this, &MMGXSettingItem::sliderValueChanged);
 +}
++
++
 +void
 +MMGXSettingItem::sliderValueChanged()
 +{
 +  auto value = slider_->value() / 1024.0
 +               * (axisInfo_.maximum - axisInfo_.minimum)
 +               + axisInfo_.minimum;
 +  actualValue_ = static_cast<FT_Fixed>(value * 65536.0);
++
 +  if (axisInfo_.isMM)
 +    actualValue_ = FT_RoundFix(actualValue_);
 +  else
 +  {
 +    double x = actualValue_ / 65536.0 * 100.0;
 +    x += x < 0.0 ? -0.5 : 0.5;
 +    x = static_cast<int>(x);
 +    x = x / 100.0 * 65536.0;
 +    x += x < 0.0 ? -0.5 : 0.5;
++
 +    actualValue_ = static_cast<FT_Fixed>(x);
 +  }
++
 +  valueLabel_->setText(QString::number(actualValue_ / 65536.0));
++
 +  emit valueChanged();
 +}
++
++
 +// end of settingpanelmmgx.cpp

src/ftinspect/panels/settingpanelmmgx.hpp

 +// settingpanelmmgx.hpp
++
 +// Copyright (C) 2022 by Charlie Jiang.
++
 +#pragma once
++
 +#include "../engine/mmgx.hpp"
 +#include "../widgets/customwidgets.hpp"
++
 +#include <QWidget>
 +#include <QGridLayout>
 +#include <QBoxLayout>
 +#include <QCheckBox>
 +#include <QScrollArea>
 +#include <QSlider>
 +#include <QFrame>
 +#include <QLabel>
++
 +#include <freetype/fttypes.h>
++
 +class Engine;
++
 +class MMGXSettingItem;
 +class SettingPanelMMGX
 +: public QWidget
 +{
 +  Q_OBJECT
 +public:
 +  SettingPanelMMGX(QWidget* parent, Engine* engine);
 +  ~SettingPanelMMGX() override = default;
++
 +  void reloadFont();
 +  void syncSettings();
 +  void checkHidden();
 +  std::vector<FT_Fixed>& mmgxCoords() { return currentValues_; }
++
 +signals:
 +  void mmgxCoordsChanged();
++
 +private:
 +  Engine* engine_;
++
 +  QCheckBox* showHiddenCheckBox_;
 +  QPushButton* resetDefaultButton_;
 +  QWidget* itemsListWidget_;
 +  UnboundScrollArea* scrollArea_;
 +  std::vector<MMGXSettingItem*> itemWidgets_;
++
 +  QVBoxLayout* mainLayout_;
 +  QVBoxLayout* listLayout_;
 +  QVBoxLayout* listWrapperLayout_;
++
 +  std::vector<FT_Fixed> currentValues_;
 +  std::vector<MMGXAxisInfo> currentAxes_;
++
 +  void createLayout();
 +  void createConnections();
++
 +  void itemChanged();
 +  void resetDefaultClicked();
 +};
++
++
 +class MMGXSettingItem
 +: public QFrame
 +{
 +  Q_OBJECT
 +public:
 +  MMGXSettingItem(QWidget* parent);
 +  ~MMGXSettingItem() override = default;
++
 +  void updateInfo(MMGXAxisInfo& info);
 +  FT_Fixed value() { return actualValue_; }
 +  void resetDefault();
++
 +signals:
 +  void valueChanged();
++
 +private:
 +  QLabel* nameLabel_;
 +  QLabel* valueLabel_;
 +  QSlider* slider_;
++
 +  QGridLayout* mainLayout_;
++
 +  FT_Fixed actualValue_;
 +  MMGXAxisInfo axisInfo_;
++
 +  void createLayout();
 +  void createConnections();
 +  void sliderValueChanged();
 +};
++
++
 +// end of settingpanelmmgx.hpp

From:	Charlie Jiang (@cqjjjzr)
Subject:	[Git][freetype/freetype-demos][gsoc-2022-chariri-3] [ftinspect] Support MM/GX.
Date:	Sun, 21 Aug 2022 15:19:53 +0000