[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[freetype2-demos] gsoc-2022-chariri-final 85b086c8 3/6: [ftinspect] Refa
|
From: |
Werner Lemberg |
|
Subject: |
[freetype2-demos] gsoc-2022-chariri-final 85b086c8 3/6: [ftinspect] Refactor `Engine`. |
|
Date: |
Fri, 2 Sep 2022 01:19:24 -0400 (EDT) |
branch: gsoc-2022-chariri-final
commit 85b086c8f8de1a6c6bd4998dad5b20c7fb35d3be
Author: Charlie Jiang <w@chariri.moe>
Commit: Charlie Jiang <w@chariri.moe>
[ftinspect] Refactor `Engine`.
This commit decouples `Engine` so it no longer depends on `MainGUI`.
Because of that, a lot of getters and setters are added to `Engine`, and
`MainGUI` call setters in its `applySettings` function, which makes applying
of the settings lazy (only happen when the glyph repaints).
In the later commits, options will be divided into two types: mostly lazy
ones, and a few eager ones which need to be immediately applied, because
they need the cache to be purged.
Some code in `MainGUI` is moved into `Engine`, as well.
Functions in the `Engine` are re-ordered. Constructor is greatly reduced to
`queryEngine`.
* src/ftinspect/engine/engine.cpp, src/ftinspect/engine/engine.hpp:
As described.
* src/ftinspect/maingui.cpp, src/ftinspect/maingui.hpp:
As described.
* src/ftinspect/ftinspect.cpp: Remove dependency of `Engine` against
`MainGUI`.
---
src/ftinspect/engine/engine.cpp | 320 +++++++++++++++++++---------------------
src/ftinspect/engine/engine.hpp | 132 ++++++++++++-----
src/ftinspect/ftinspect.cpp | 6 +-
src/ftinspect/maingui.cpp | 145 ++++++++++--------
src/ftinspect/maingui.hpp | 23 +--
5 files changed, 341 insertions(+), 285 deletions(-)
diff --git a/src/ftinspect/engine/engine.cpp b/src/ftinspect/engine/engine.cpp
index 5b00cf9c..9fd1dcf8 100644
--- a/src/ftinspect/engine/engine.cpp
+++ b/src/ftinspect/engine/engine.cpp
@@ -4,7 +4,6 @@
#include "engine.hpp"
-#include "../maingui.hpp"
#include <stdexcept>
#include <stdint.h>
@@ -77,7 +76,7 @@ faceRequester(FTC_FaceID ftcFaceID,
FT_Pointer requestData,
FT_Face* faceP)
{
- MainGUI* gui = static_cast<MainGUI*>(requestData);
+ Engine* engine = static_cast<Engine*>(requestData);
// `ftcFaceID' is actually an integer
// -> first convert pointer to same-width integer, then discard superfluous
// bits (e.g., on x86_64 where pointers are wider than int)
@@ -88,16 +87,16 @@ faceRequester(FTC_FaceID ftcFaceID,
"Pointer size must be at least the size of int"
" in order to treat FTC_FaceID correctly");
- const FaceID& faceID = gui->engine->faceIDMap.key(val);
+ const FaceID& faceID = engine->faceIDMap.key(val);
// this is the only place where we have to check the validity of the font
// index; note that the validity of both the face and named instance index
// is checked by FreeType itself
if (faceID.fontIndex < 0
- || faceID.fontIndex >= gui->engine->numberOfOpenedFonts())
+ || faceID.fontIndex >= engine->numberOfOpenedFonts())
return FT_Err_Invalid_Argument;
- QString font = gui->engine->fileManager[faceID.fontIndex].filePath();
+ QString font = engine->fileManager[faceID.fontIndex].filePath();
long faceIndex = faceID.faceIndex;
if (faceID.namedInstanceIndex > 0)
@@ -116,10 +115,9 @@ faceRequester(FTC_FaceID ftcFaceID,
//
/////////////////////////////////////////////////////////////////////////////
-Engine::Engine(MainGUI* g)
+Engine::Engine()
: fileManager(this)
{
- gui = g;
ftSize = NULL;
// we reserve value 0 for the `invalid face ID'
faceCounter = 1;
@@ -133,7 +131,7 @@ Engine::Engine(MainGUI* g)
}
error = FTC_Manager_New(library, 0, 0, 0,
- faceRequester, gui, &cacheManager);
+ faceRequester, this, &cacheManager);
if (error)
{
// XXX error handling
@@ -151,98 +149,7 @@ Engine::Engine(MainGUI* g)
// XXX error handling
}
- // query engines and check for alternatives
-
- // CFF
- error = FT_Property_Get(library,
- "cff",
- "hinting-engine",
- &cffHintingEngineDefault);
- if (error)
- {
- // no CFF engine
- cffHintingEngineDefault = -1;
- cffHintingEngineOther = -1;
- }
- else
- {
- int engines[] =
- {
- FT_HINTING_FREETYPE,
- FT_HINTING_ADOBE
- };
-
- int i;
- for (i = 0; i < 2; i++)
- if (cffHintingEngineDefault == engines[i])
- break;
-
- cffHintingEngineOther = engines[(i + 1) % 2];
-
- error = FT_Property_Set(library,
- "cff",
- "hinting-engine",
- &cffHintingEngineOther);
- if (error)
- cffHintingEngineOther = -1;
-
- // reset
- FT_Property_Set(library,
- "cff",
- "hinting-engine",
- &cffHintingEngineDefault);
- }
-
- // TrueType
- error = FT_Property_Get(library,
- "truetype",
- "interpreter-version",
- &ttInterpreterVersionDefault);
- if (error)
- {
- // no TrueType engine
- ttInterpreterVersionDefault = -1;
- ttInterpreterVersionOther = -1;
- ttInterpreterVersionOther1 = -1;
- }
- else
- {
- int interpreters[] =
- {
- TT_INTERPRETER_VERSION_35,
- TT_INTERPRETER_VERSION_38,
- TT_INTERPRETER_VERSION_40
- };
-
- int i;
- for (i = 0; i < 3; i++)
- if (ttInterpreterVersionDefault == interpreters[i])
- break;
-
- ttInterpreterVersionOther = interpreters[(i + 1) % 3];
-
- error = FT_Property_Set(library,
- "truetype",
- "interpreter-version",
- &ttInterpreterVersionOther);
- if (error)
- ttInterpreterVersionOther = -1;
-
- ttInterpreterVersionOther1 = interpreters[(i + 2) % 3];
-
- error = FT_Property_Set(library,
- "truetype",
- "interpreter-version",
- &ttInterpreterVersionOther1);
- if (error)
- ttInterpreterVersionOther1 = -1;
-
- // reset
- FT_Property_Set(library,
- "truetype",
- "interpreter-version",
- &ttInterpreterVersionDefault);
- }
+ queryEngine();
}
@@ -424,20 +331,6 @@ Engine::removeFont(int fontIndex, bool closeFile)
}
-const QString&
-Engine::currentFamilyName()
-{
- return curFamilyName;
-}
-
-
-const QString&
-Engine::currentStyleName()
-{
- return curStyleName;
-}
-
-
QString
Engine::glyphName(int index)
{
@@ -493,107 +386,98 @@ Engine::loadOutline(int glyphIndex)
return &outlineGlyph->outline;
}
+
int
Engine::numberOfOpenedFonts()
{
return fileManager.size();
}
+
void
Engine::openFonts(QStringList fontFileNames)
{
fileManager.append(fontFileNames, true);
}
+
void
-Engine::setCFFHintingMode(int mode)
+Engine::setSizeByPixel(double pixelSize)
+{
+ this->pixelSize = pixelSize;
+ pointSize = pixelSize * 72.0 / dpi;
+ usingPixelSize = true;
+}
+
+void
+Engine::setSizeByPoint(double pointSize)
+{
+ this->pointSize = pointSize;
+ pixelSize = pointSize * dpi / 72.0;
+ usingPixelSize = false;
+}
+
+
+void
+Engine::setLcdFilter(FT_LcdFilter filter)
{
- int index = gui->hintingModesCFFHash.key(mode);
+ FT_Library_SetLcdFilter(library, filter);
+}
+
+void
+Engine::setCFFHintingMode(int mode)
+{
FT_Error error = FT_Property_Set(library,
"cff",
"hinting-engine",
- &index);
+ &mode);
if (!error)
- {
- // reset the cache
- FTC_Manager_Reset(cacheManager);
- }
+ resetCache();
}
void
-Engine::setTTInterpreterVersion(int mode)
+Engine::setTTInterpreterVersion(int version)
{
- int index = gui->hintingModesTrueTypeHash.key(mode);
-
FT_Error error = FT_Property_Set(library,
"truetype",
"interpreter-version",
- &index);
+ &version);
if (!error)
- {
- // reset the cache
- FTC_Manager_Reset(cacheManager);
- }
+ resetCache();
}
void
Engine::update()
{
- // Spinbox value cannot become negative
- dpi = static_cast<unsigned int>(gui->dpiSpinBox->value());
-
- if (gui->unitsComboBox->currentIndex() == MainGUI::Units_px)
- {
- pixelSize = gui->sizeDoubleSpinBox->value();
- pointSize = pixelSize * 72.0 / dpi;
- }
- else
- {
- pointSize = gui->sizeDoubleSpinBox->value();
- pixelSize = pointSize * dpi / 72.0;
- }
-
- doHinting = gui->hintingCheckBox->isChecked();
-
- doAutoHinting = gui->autoHintingCheckBox->isChecked();
- doHorizontalHinting = gui->horizontalHintingCheckBox->isChecked();
- doVerticalHinting = gui->verticalHintingCheckBox->isChecked();
- doBlueZoneHinting = gui->blueZoneHintingCheckBox->isChecked();
- showSegments = gui->segmentDrawingCheckBox->isChecked();
-
- gamma = gui->gammaSlider->value();
-
loadFlags = FT_LOAD_DEFAULT;
if (doAutoHinting)
loadFlags |= FT_LOAD_FORCE_AUTOHINT;
loadFlags |= FT_LOAD_NO_BITMAP; // XXX handle bitmap fonts also
- int index = gui->antiAliasingComboBoxx->currentIndex();
-
if (doHinting)
{
unsigned long target;
- if (index == MainGUI::AntiAliasing_None)
+ if (antiAliasingMode == AntiAliasing_None)
target = FT_LOAD_TARGET_MONO;
else
{
- switch (index)
+ switch (antiAliasingMode)
{
- case MainGUI::AntiAliasing_Light:
+ case AntiAliasing_Light:
target = FT_LOAD_TARGET_LIGHT;
break;
- case MainGUI::AntiAliasing_LCD:
- case MainGUI::AntiAliasing_LCD_BGR:
+ case AntiAliasing_LCD:
+ case AntiAliasing_LCD_BGR:
target = FT_LOAD_TARGET_LCD;
break;
- case MainGUI::AntiAliasing_LCD_Vertical:
- case MainGUI::AntiAliasing_LCD_Vertical_BGR:
+ case AntiAliasing_LCD_Vertical:
+ case AntiAliasing_LCD_Vertical_BGR:
target = FT_LOAD_TARGET_LCD_V;
break;
@@ -608,7 +492,7 @@ Engine::update()
{
loadFlags |= FT_LOAD_NO_HINTING;
- if (index == MainGUI::AntiAliasing_None)
+ if (antiAliasingMode == AntiAliasing_None)
loadFlags |= FT_LOAD_MONOCHROME;
}
@@ -616,7 +500,7 @@ Engine::update()
scaler.pixel = 0; // use 26.6 format
- if (gui->unitsComboBox->currentIndex() == MainGUI::Units_px)
+ if (usingPixelSize)
{
scaler.width = static_cast<unsigned int>(pixelSize * 64.0);
scaler.height = static_cast<unsigned int>(pixelSize * 64.0);
@@ -632,11 +516,113 @@ Engine::update()
}
}
-FontFileManager&
-Engine::fontFileManager()
+
+void
+Engine::resetCache()
{
- return fileManager;
+ // reset the cache
+ FTC_Manager_Reset(cacheManager);
+ ftSize = NULL;
}
+void
+Engine::queryEngine()
+{
+ FT_Error error;
+
+ // query engines and check for alternatives
+
+ // CFF
+ error = FT_Property_Get(library,
+ "cff",
+ "hinting-engine",
+ &defaults.cffHintingEngineDefault);
+ if (error)
+ {
+ // no CFF engine
+ defaults.cffHintingEngineDefault = -1;
+ defaults.cffHintingEngineOther = -1;
+ }
+ else
+ {
+ int engines[] =
+ {
+ FT_HINTING_FREETYPE,
+ FT_HINTING_ADOBE
+ };
+
+ int i;
+ for (i = 0; i < 2; i++)
+ if (defaults.cffHintingEngineDefault == engines[i])
+ break;
+
+ defaults.cffHintingEngineOther = engines[(i + 1) % 2];
+
+ error = FT_Property_Set(library,
+ "cff",
+ "hinting-engine",
+ &defaults.cffHintingEngineOther);
+ if (error)
+ defaults.cffHintingEngineOther = -1;
+
+ // reset
+ FT_Property_Set(library,
+ "cff",
+ "hinting-engine",
+ &defaults.cffHintingEngineDefault);
+ }
+
+ // TrueType
+ error = FT_Property_Get(library,
+ "truetype",
+ "interpreter-version",
+ &defaults.ttInterpreterVersionDefault);
+ if (error)
+ {
+ // no TrueType engine
+ defaults.ttInterpreterVersionDefault = -1;
+ defaults.ttInterpreterVersionOther = -1;
+ defaults.ttInterpreterVersionOther1 = -1;
+ }
+ else
+ {
+ int interpreters[] =
+ {
+ TT_INTERPRETER_VERSION_35,
+ TT_INTERPRETER_VERSION_38,
+ TT_INTERPRETER_VERSION_40
+ };
+
+ int i;
+ for (i = 0; i < 3; i++)
+ if (defaults.ttInterpreterVersionDefault == interpreters[i])
+ break;
+
+ defaults.ttInterpreterVersionOther = interpreters[(i + 1) % 3];
+
+ error = FT_Property_Set(library,
+ "truetype",
+ "interpreter-version",
+ &defaults.ttInterpreterVersionOther);
+ if (error)
+ defaults.ttInterpreterVersionOther = -1;
+
+ defaults.ttInterpreterVersionOther1 = interpreters[(i + 2) % 3];
+
+ error = FT_Property_Set(library,
+ "truetype",
+ "interpreter-version",
+ &defaults.ttInterpreterVersionOther1);
+ if (error)
+ defaults.ttInterpreterVersionOther1 = -1;
+
+ // reset
+ FT_Property_Set(library,
+ "truetype",
+ "interpreter-version",
+ &defaults.ttInterpreterVersionDefault);
+ }
+}
+
// end of engine.cpp
diff --git a/src/ftinspect/engine/engine.hpp b/src/ftinspect/engine/engine.hpp
index 72403e3e..eb7a794e 100644
--- a/src/ftinspect/engine/engine.hpp
+++ b/src/ftinspect/engine/engine.hpp
@@ -14,6 +14,7 @@
#include <freetype/freetype.h>
#include <freetype/ftoutln.h>
#include <freetype/ftcache.h>
+#include <freetype/ftlcdfil.h>
// This structure maps the (font, face, instance) index triplet to abstract
@@ -35,64 +36,103 @@ struct FaceID
bool operator<(const FaceID& other) const;
};
-
-class MainGUI;
-
// FreeType specific data.
class Engine
{
public:
- Engine(MainGUI*);
+ //////// Nested definitions (forward decl)
+
+ // TODO these would be dropped with custom QAbstractItemModel
+ enum AntiAliasing : int;
+ enum FontType : int;
+
+ struct EngineDefaultValues
+ {
+ int cffHintingEngineDefault;
+ int cffHintingEngineOther;
+
+ int ttInterpreterVersionDefault;
+ int ttInterpreterVersionOther;
+ int ttInterpreterVersionOther1;
+ };
+
+ //////// Ctors & Dtors
+
+ Engine();
~Engine();
// Disable copying
Engine(const Engine& other) = delete;
Engine& operator=(const Engine& other) = delete;
- FT_Library ftLibrary() const { return library; }
+ //////// Actions
- const QString& currentFamilyName();
- const QString& currentStyleName();
- QString glyphName(int glyphIndex);
- long numberOfFaces(int fontIndex);
- int numberOfNamedInstances(int fontIndex,
- long faceIndex);
int loadFont(int fontIndex,
long faceIndex,
int namedInstanceIndex); // return number of glyphs
FT_Outline* loadOutline(int glyphIndex);
- int numberOfOpenedFonts();
void openFonts(QStringList fontFileNames);
void removeFont(int fontIndex, bool closeFile = true);
+
+ void update();
+ void resetCache();
+
+ //////// Getters
+
+ FT_Library ftLibrary() const { return library; }
+ FontFileManager& fontFileManager() { return fileManager; }
+ EngineDefaultValues& engineDefaults() { return defaults; }
+
+ int numberOfOpenedFonts();
+ // (for current fonts)
+ int currentFontType() const { return fontType; }
+ const QString& currentFamilyName() { return curFamilyName; }
+ const QString& currentStyleName() { return curStyleName; }
+ QString glyphName(int glyphIndex);
+ long numberOfFaces(int fontIndex);
+ int numberOfNamedInstances(int fontIndex,
+ long faceIndex);
+
+ //////// Setters (direct or indirect)
+
+ void setDPI(int d) { dpi = d; }
+ void setSizeByPixel(double pixelSize);
+ void setSizeByPoint(double pointSize);
+ void setHinting(bool hinting) { doHinting = hinting; }
+ void setAutoHinting(bool autoHinting) { doAutoHinting = autoHinting; }
+ void setHorizontalHinting(bool horHinting)
+ {
+ doHorizontalHinting = horHinting;
+ }
+ void setVerticalHinting(bool verticalHinting)
+ {
+ doVerticalHinting = verticalHinting;
+ }
+ void setBlueZoneHinting(bool blueZoneHinting)
+ {
+ doBlueZoneHinting = blueZoneHinting;
+ }
+ void setShowSegments(bool showSegments) { this->showSegments = showSegments;
}
+ void setGamma(double gamma) { this->gamma = gamma; }
+ void setAntiAliasingMode(AntiAliasing mode) { antiAliasingMode = mode; }
+
+ // Note: These 3 functions now takes actual mode/version from FreeType,
+ // instead of values from enum in MainGUI!
+ void setLcdFilter(FT_LcdFilter filter);
void setCFFHintingMode(int mode);
void setTTInterpreterVersion(int version);
- void update();
- friend class MainGUI;
+ //////// Misc
+
friend FT_Error faceRequester(FTC_FaceID,
FT_Library,
FT_Pointer,
FT_Face*);
- // XXX cover all available modules
- enum FontType
- {
- FontType_CFF,
- FontType_TrueType,
- FontType_Other
- };
-
- // XXX We should prepend '_' to all private member variable so we can create
- // getter without naming conflict... e.g. var named _fontFileManager while
- // getter named fontFileManager
- FontFileManager& fontFileManager();
-
private:
- MainGUI* gui;
-
using FTC_IDType = uintptr_t;
FTC_IDType faceCounter; // a running number used to initialize `faceIDMap'
QMap<FaceID, FTC_IDType> faceIDMap;
@@ -110,15 +150,11 @@ private:
FTC_ScalerRec scaler;
FT_Size ftSize;
- int cffHintingEngineDefault;
- int cffHintingEngineOther;
-
- int ttInterpreterVersionDefault;
- int ttInterpreterVersionOther;
- int ttInterpreterVersionOther1;
+ EngineDefaultValues defaults;
int fontType;
+ bool usingPixelSize = false;
double pointSize;
double pixelSize;
unsigned int dpi;
@@ -129,10 +165,36 @@ private:
bool doVerticalHinting;
bool doBlueZoneHinting;
bool showSegments;
+ AntiAliasing antiAliasingMode;
double gamma;
unsigned long loadFlags;
+
+ void queryEngine();
+
+public:
+
+ /// Actual definition
+
+ enum AntiAliasing : int
+ {
+ AntiAliasing_None,
+ AntiAliasing_Normal,
+ AntiAliasing_Light,
+ AntiAliasing_LCD,
+ AntiAliasing_LCD_BGR,
+ AntiAliasing_LCD_Vertical,
+ AntiAliasing_LCD_Vertical_BGR
+ };
+
+ // XXX cover all available modules
+ enum FontType : int
+ {
+ FontType_CFF,
+ FontType_TrueType,
+ FontType_Other
+ };
};
diff --git a/src/ftinspect/ftinspect.cpp b/src/ftinspect/ftinspect.cpp
index 7ddae30d..91da7809 100644
--- a/src/ftinspect/ftinspect.cpp
+++ b/src/ftinspect/ftinspect.cpp
@@ -21,10 +21,8 @@ main(int argc,
app.setOrganizationName("FreeType");
app.setOrganizationDomain("freetype.org");
- MainGUI gui;
- Engine engine(&gui);
-
- gui.update(&engine);
+ Engine engine;
+ MainGUI gui(&engine);
gui.setDefaults();
gui.show();
diff --git a/src/ftinspect/maingui.cpp b/src/ftinspect/maingui.cpp
index 2b887c77..cc4c09c3 100644
--- a/src/ftinspect/maingui.cpp
+++ b/src/ftinspect/maingui.cpp
@@ -14,10 +14,9 @@
#include <freetype/ftdriver.h>
-MainGUI::MainGUI()
+MainGUI::MainGUI(Engine* engine)
+: engine(engine)
{
- engine = NULL;
-
setGraphicsDefaults();
createLayout();
createConnections();
@@ -37,19 +36,6 @@ MainGUI::~MainGUI()
}
-void
-MainGUI::update(Engine* e)
-{
- if (engine)
- disconnect(&engine->fontFileManager(),
&FontFileManager::currentFileChanged,
- this, &MainGUI::watchCurrentFont);
-
- engine = e;
- connect(&engine->fontFileManager(), &FontFileManager::currentFileChanged,
- this, &MainGUI::watchCurrentFont);
-}
-
-
// overloading
void
@@ -176,6 +162,7 @@ MainGUI::showFont()
else
fontFilenameLabel->clear();
+ applySettings();
currentNumberOfFaces
= engine->numberOfFaces(currentFontIndex);
currentNumberOfNamedInstances
@@ -211,12 +198,45 @@ MainGUI::showFont()
}
+void
+MainGUI::applySettings()
+{
+ // Spinbox value cannot become negative
+ engine->setDPI(static_cast<unsigned int>(dpiSpinBox->value()));
+
+ if (unitsComboBox->currentIndex() == Units_px)
+ engine->setSizeByPixel(sizeDoubleSpinBox->value());
+ else
+ engine->setSizeByPoint(sizeDoubleSpinBox->value());
+
+ engine->setHinting(hintingCheckBox->isChecked());
+ engine->setAutoHinting(autoHintingCheckBox->isChecked());
+ engine->setHorizontalHinting(horizontalHintingCheckBox->isChecked());
+ engine->setVerticalHinting(verticalHintingCheckBox->isChecked());
+ engine->setBlueZoneHinting(blueZoneHintingCheckBox->isChecked());
+ engine->setShowSegments(segmentDrawingCheckBox->isChecked());
+
+ engine->setGamma(gammaSlider->value());
+
+ engine->setAntiAliasingMode(static_cast<Engine::AntiAliasing>(
+ antiAliasingComboBoxx->currentIndex()));
+}
+
+
+void
+MainGUI::clearStatusBar()
+{
+ statusBar()->clearMessage();
+ statusBar()->setStyleSheet("");
+}
+
+
void
MainGUI::checkHinting()
{
if (hintingCheckBox->isChecked())
{
- if (engine->fontType == Engine::FontType_CFF)
+ if (engine->currentFontType() == Engine::FontType_CFF)
{
for (int i = 0; i < hintingModeComboBoxx->count(); i++)
{
@@ -228,7 +248,7 @@ MainGUI::checkHinting()
hintingModeComboBoxx->setCurrentIndex(currentCFFHintingMode);
}
- else if (engine->fontType == Engine::FontType_TrueType)
+ else if (engine->currentFontType() == Engine::FontType_TrueType)
{
for (int i = 0; i < hintingModeComboBoxx->count(); i++)
{
@@ -264,7 +284,7 @@ MainGUI::checkHinting()
blueZoneHintingCheckBox->setEnabled(false);
segmentDrawingCheckBox->setEnabled(false);
- antiAliasingComboBoxx->setItemEnabled(AntiAliasing_Light, false);
+ antiAliasingComboBoxx->setItemEnabled(Engine::AntiAliasing_Light, false);
}
drawGlyph();
@@ -276,14 +296,14 @@ MainGUI::checkHintingMode()
{
int index = hintingModeComboBoxx->currentIndex();
- if (engine->fontType == Engine::FontType_CFF)
+ if (engine->currentFontType() == Engine::FontType_CFF)
{
- engine->setCFFHintingMode(index);
+ engine->setCFFHintingMode(hintingModesCFFHash.key(index));
currentCFFHintingMode = index;
}
- else if (engine->fontType == Engine::FontType_TrueType)
+ else if (engine->currentFontType() == Engine::FontType_TrueType)
{
- engine->setTTInterpreterVersion(index);
+ engine->setTTInterpreterVersion(hintingModesTrueTypeHash.key(index));
currentTTInterpreterVersion = index;
}
@@ -305,12 +325,12 @@ MainGUI::checkAutoHinting()
blueZoneHintingCheckBox->setEnabled(true);
segmentDrawingCheckBox->setEnabled(true);
- antiAliasingComboBoxx->setItemEnabled(AntiAliasing_Light, true);
+ antiAliasingComboBoxx->setItemEnabled(Engine::AntiAliasing_Light, true);
}
else
{
- if (engine->fontType == Engine::FontType_CFF
- || engine->fontType == Engine::FontType_TrueType)
+ if (engine->currentFontType() == Engine::FontType_CFF
+ || engine->currentFontType() == Engine::FontType_TrueType)
{
hintingModeLabel->setEnabled(true);
hintingModeComboBoxx->setEnabled(true);
@@ -321,10 +341,10 @@ MainGUI::checkAutoHinting()
blueZoneHintingCheckBox->setEnabled(false);
segmentDrawingCheckBox->setEnabled(false);
- antiAliasingComboBoxx->setItemEnabled(AntiAliasing_Light, false);
+ antiAliasingComboBoxx->setItemEnabled(Engine::AntiAliasing_Light, false);
- if (antiAliasingComboBoxx->currentIndex() == AntiAliasing_Light)
- antiAliasingComboBoxx->setCurrentIndex(AntiAliasing_Normal);
+ if (antiAliasingComboBoxx->currentIndex() == Engine::AntiAliasing_Light)
+ antiAliasingComboBoxx->setCurrentIndex(Engine::AntiAliasing_Normal);
}
drawGlyph();
@@ -336,9 +356,9 @@ MainGUI::checkAntiAliasing()
{
int index = antiAliasingComboBoxx->currentIndex();
- if (index == AntiAliasing_None
- || index == AntiAliasing_Normal
- || index == AntiAliasing_Light)
+ if (index == Engine::AntiAliasing_None
+ || index == Engine::AntiAliasing_Normal
+ || index == Engine::AntiAliasing_Light)
{
lcdFilterLabel->setEnabled(false);
lcdFilterComboBox->setEnabled(false);
@@ -357,7 +377,7 @@ void
MainGUI::checkLcdFilter()
{
int index = lcdFilterComboBox->currentIndex();
- FT_Library_SetLcdFilter(engine->library, lcdFilterHash.key(index));
+ engine->setLcdFilter(lcdFilterHash.key(index));
}
@@ -656,6 +676,7 @@ MainGUI::drawGlyph()
currentGlyphPointNumbersItem = NULL;
}
+ applySettings();
FT_Outline* outline = engine->loadOutline(currentGlyphIndex);
if (outline)
{
@@ -663,11 +684,11 @@ MainGUI::drawGlyph()
{
// XXX support LCD
FT_Pixel_Mode pixelMode = FT_PIXEL_MODE_GRAY;
- if (antiAliasingComboBoxx->currentIndex() == AntiAliasing_None)
+ if (antiAliasingComboBoxx->currentIndex() == Engine::AntiAliasing_None)
pixelMode = FT_PIXEL_MODE_MONO;
currentGlyphBitmapItem = new GlyphBitmap(outline,
- engine->library,
+ engine->ftLibrary(),
pixelMode,
monoColorTable,
grayColorTable);
@@ -733,19 +754,19 @@ MainGUI::createLayout()
antiAliasingLabel = new QLabel(tr("Anti-Aliasing"));
antiAliasingLabel->setAlignment(Qt::AlignRight);
antiAliasingComboBoxx = new QComboBoxx;
- antiAliasingComboBoxx->insertItem(AntiAliasing_None,
+ antiAliasingComboBoxx->insertItem(Engine::AntiAliasing_None,
tr("None"));
- antiAliasingComboBoxx->insertItem(AntiAliasing_Normal,
+ antiAliasingComboBoxx->insertItem(Engine::AntiAliasing_Normal,
tr("Normal"));
- antiAliasingComboBoxx->insertItem(AntiAliasing_Light,
+ antiAliasingComboBoxx->insertItem(Engine::AntiAliasing_Light,
tr("Light"));
- antiAliasingComboBoxx->insertItem(AntiAliasing_LCD,
+ antiAliasingComboBoxx->insertItem(Engine::AntiAliasing_LCD,
tr("LCD (RGB)"));
- antiAliasingComboBoxx->insertItem(AntiAliasing_LCD_BGR,
+ antiAliasingComboBoxx->insertItem(Engine::AntiAliasing_LCD_BGR,
tr("LCD (BGR)"));
- antiAliasingComboBoxx->insertItem(AntiAliasing_LCD_Vertical,
+ antiAliasingComboBoxx->insertItem(Engine::AntiAliasing_LCD_Vertical,
tr("LCD (vert. RGB)"));
- antiAliasingComboBoxx->insertItem(AntiAliasing_LCD_Vertical_BGR,
+ antiAliasingComboBoxx->insertItem(Engine::AntiAliasing_LCD_Vertical_BGR,
tr("LCD (vert. BGR)"));
antiAliasingLabel->setBuddy(antiAliasingComboBoxx);
@@ -887,7 +908,6 @@ MainGUI::createLayout()
currentGlyphOutlineItem = NULL;
currentGlyphPointsItem = NULL;
currentGlyphPointNumbersItem = NULL;
- drawGlyph();
glyphView = new QGraphicsViewx;
glyphView->setRenderHint(QPainter::Antialiasing, true);
@@ -1094,6 +1114,9 @@ MainGUI::createConnections()
glyphNavigationMapper->setMapping(toP100Buttonx, 100);
glyphNavigationMapper->setMapping(toP1000Buttonx, 1000);
glyphNavigationMapper->setMapping(toEndButtonx, 0x10000);
+
+ connect(&engine->fontFileManager(), &FontFileManager::currentFileChanged,
+ this, &MainGUI::watchCurrentFont);
}
@@ -1141,14 +1164,6 @@ MainGUI::createStatusBar()
}
-void
-MainGUI::clearStatusBar()
-{
- statusBar()->clearMessage();
- statusBar()->setStyleSheet("");
-}
-
-
void
MainGUI::setDefaults()
{
@@ -1165,20 +1180,22 @@ MainGUI::setDefaults()
lcdFilterHash[FT_LCD_FILTER_NONE] = LCDFilter_None;
lcdFilterHash[FT_LCD_FILTER_LEGACY] = LCDFilter_Legacy;
+ Engine::EngineDefaultValues& defaults = engine->engineDefaults();
+
// make copies and remove existing elements...
QHash<int, int> hmTTHash = hintingModesTrueTypeHash;
- if (hmTTHash.contains(engine->ttInterpreterVersionDefault))
- hmTTHash.remove(engine->ttInterpreterVersionDefault);
- if (hmTTHash.contains(engine->ttInterpreterVersionOther))
- hmTTHash.remove(engine->ttInterpreterVersionOther);
- if (hmTTHash.contains(engine->ttInterpreterVersionOther1))
- hmTTHash.remove(engine->ttInterpreterVersionOther1);
+ if (hmTTHash.contains(defaults.ttInterpreterVersionDefault))
+ hmTTHash.remove(defaults.ttInterpreterVersionDefault);
+ if (hmTTHash.contains(defaults.ttInterpreterVersionOther))
+ hmTTHash.remove(defaults.ttInterpreterVersionOther);
+ if (hmTTHash.contains(defaults.ttInterpreterVersionOther1))
+ hmTTHash.remove(defaults.ttInterpreterVersionOther1);
QHash<int, int> hmCFFHash = hintingModesCFFHash;
- if (hmCFFHash.contains(engine->cffHintingEngineDefault))
- hmCFFHash.remove(engine->cffHintingEngineDefault);
- if (hmCFFHash.contains(engine->cffHintingEngineOther))
- hmCFFHash.remove(engine->cffHintingEngineOther);
+ if (hmCFFHash.contains(defaults.cffHintingEngineDefault))
+ hmCFFHash.remove(defaults.cffHintingEngineDefault);
+ if (hmCFFHash.contains(defaults.cffHintingEngineOther))
+ hmCFFHash.remove(defaults.cffHintingEngineOther);
// ... to construct a list of always disabled hinting mode combo box items
hintingModesAlwaysDisabled = hmTTHash.values();
@@ -1195,13 +1212,13 @@ MainGUI::setDefaults()
currentGlyphIndex = 0;
currentCFFHintingMode
- = hintingModesCFFHash[engine->cffHintingEngineDefault];
+ = hintingModesCFFHash[defaults.cffHintingEngineDefault];
currentTTInterpreterVersion
- = hintingModesTrueTypeHash[engine->ttInterpreterVersionDefault];
+ = hintingModesTrueTypeHash[defaults.ttInterpreterVersionDefault];
hintingCheckBox->setChecked(true);
- antiAliasingComboBoxx->setCurrentIndex(AntiAliasing_Normal);
+ antiAliasingComboBoxx->setCurrentIndex(Engine::AntiAliasing_Normal);
lcdFilterComboBox->setCurrentIndex(LCDFilter_Light);
horizontalHintingCheckBox->setChecked(true);
diff --git a/src/ftinspect/maingui.hpp b/src/ftinspect/maingui.hpp
index 9f8b2c20..4a08b51d 100644
--- a/src/ftinspect/maingui.hpp
+++ b/src/ftinspect/maingui.hpp
@@ -52,11 +52,10 @@ class MainGUI
Q_OBJECT
public:
- MainGUI();
+ MainGUI(Engine* engine);
~MainGUI();
void setDefaults();
- void update(Engine*);
friend class Engine;
friend FT_Error faceRequester(FTC_FaceID,
@@ -231,16 +230,7 @@ private:
QWidget *rightWidget;
QWidget *mmgxTabWidget;
- enum AntiAliasing
- {
- AntiAliasing_None,
- AntiAliasing_Normal,
- AntiAliasing_Light,
- AntiAliasing_LCD,
- AntiAliasing_LCD_BGR,
- AntiAliasing_LCD_Vertical,
- AntiAliasing_LCD_Vertical_BGR
- };
+ // TODO these would be dropped with custom QAbstractItemModel
enum HintingMode
{
HintingMode_TrueType_v35,
@@ -262,15 +252,18 @@ private:
Units_pt
};
+ void showFont();
+ void applySettings();
+ void clearStatusBar();
+
void createActions();
void createConnections();
void createLayout();
void createMenus();
- void clearStatusBar();
void createStatusBar();
- void readSettings();
void setGraphicsDefaults();
- void showFont();
+
+ void readSettings();
void writeSettings();
};
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [freetype2-demos] gsoc-2022-chariri-final 85b086c8 3/6: [ftinspect] Refactor `Engine`.,
Werner Lemberg <=