[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[freetype2-demos] reorg-maingui 164d062: [ftinspect] Decouple `Engine` f
|
From: |
Werner Lemberg |
|
Subject: |
[freetype2-demos] reorg-maingui 164d062: [ftinspect] Decouple `Engine` from `MainGUI`. |
|
Date: |
Wed, 29 Jun 2022 05:17:02 -0400 (EDT) |
branch: reorg-maingui
commit 164d062edec9b26daceaf48b92c4ae55ece48368
Author: Charlie Jiang <w@chariri.moe>
Commit: Charlie Jiang <w@chariri.moe>
[ftinspect] Decouple `Engine` from `MainGUI`.
Relevant info can be found in #13. This commit removes dependency against
`MainGUI` from `Engine` class. All settings will be explicitly passed via
setters of `Engine`. Also see `MainGUI::syncSettings` and simplified
`Engine::update`.
This commit removes friend relation between the two classes.
TODO: Some GUI components in MainGUI lacks proper connections. When changing
their value, the glyph isn't updated in time.
* src/ftinspect/ftinspect.cpp: No longer need to pass GUI when constructing
`Engine`.
* src/ftinspect/maingui.hpp: Move `AntiAliasing` enum to `Engine` class, add
`syncSettings` function, reorder some functions.
* src/ftinspect/maingui.cpp: Because of the removal of friend relationship,
change all access to private fields of `Engine` to getter/setter call.
Add implementation of `syncSettings`, and make sure it's called before
loading font and rendering. Moving of `AntiAliasing` enum is also taken care
of.
* src/ftinspect/engine/engine.hpp: Removed dependency against `MainGUI`.
Added getters/setters and reordered some functions. The default values
queried from engine are all grouped together into `EngineDefaultValues`
struct.
Added `queryEngine` function (see below).
New `setSizeByPoint` and `setSizeByPoint` lifted the branch to `MainGUI`.
Note: Setters of LCD filter mode, CFF mode and TTI version now accepts the
actual values of FreeType instead of values of enums in `MainGUI` used to
initialize combo boxes.
However, `antiAliasingMode` is still using enum values (but moved into
`Engine`) because it's complex to convert to FreeType value.
* src/ftinspect/engine/engine.cpp: `faceRequester` now use the `Engine`
object instead of `MainGUI` as `requestData`.
Moved code preparing engine default values to the `queryEngine` function.
Moved some single-line getters to the header file to benefit from inlineing.
Simplified `update` function since we no longer need to actively fetch
settings.
`usingPixelSize` is used to determine if pixel or point unit is used. This
flag is updated by `setSizeByPixel` and `setSizeByPoint` functions.
---
src/ftinspect/engine/engine.cpp | 307 +++++++++++++++++++---------------------
src/ftinspect/engine/engine.hpp | 132 ++++++++++++-----
src/ftinspect/ftinspect.cpp | 2 +-
src/ftinspect/maingui.cpp | 123 ++++++++++------
src/ftinspect/maingui.hpp | 21 +--
5 files changed, 327 insertions(+), 258 deletions(-)
diff --git a/src/ftinspect/engine/engine.cpp b/src/ftinspect/engine/engine.cpp
index 0ea434f..fc0998d 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,9 +115,8 @@ faceRequester(FTC_FaceID ftcFaceID,
//
/////////////////////////////////////////////////////////////////////////////
-Engine::Engine(MainGUI* g)
+Engine::Engine()
{
- gui = g;
ftSize = NULL;
// we reserve value 0 for the `invalid face ID'
faceCounter = 1;
@@ -132,7 +130,7 @@ Engine::Engine(MainGUI* g)
}
error = FTC_Manager_New(library, 0, 0, 0,
- faceRequester, gui, &cacheManager);
+ faceRequester, this, &cacheManager);
if (error)
{
// XXX error handling
@@ -150,98 +148,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();
}
@@ -395,6 +302,13 @@ Engine::loadFont(int fontIndex,
}
+void
+Engine::openFonts(QStringList fontFileNames)
+{
+ fileManager.append(fontFileNames);
+}
+
+
void
Engine::removeFont(int fontIndex, bool closeFile)
{
@@ -423,20 +337,6 @@ Engine::removeFont(int fontIndex, bool closeFile)
}
-const QString&
-Engine::currentFamilyName()
-{
- return curFamilyName;
-}
-
-
-const QString&
-Engine::currentStyleName()
-{
- return curStyleName;
-}
-
-
QString
Engine::glyphName(int index)
{
@@ -492,27 +392,45 @@ Engine::loadOutline(int glyphIndex)
return &outlineGlyph->outline;
}
+
int
Engine::numberOfOpenedFonts()
{
return fileManager.size();
}
+
void
-Engine::openFonts(QStringList fontFileNames)
+Engine::setSizeByPixel(double pixelSize)
{
- fileManager.append(fontFileNames);
+ this->pixelSize = pixelSize;
+ pointSize = pixelSize * 72.0 / dpi;
+ usingPixelSize = true;
}
void
-Engine::setCFFHintingMode(int mode)
+Engine::setSizeByPoint(double pointSize)
{
- int index = gui->hintingModesCFFHash.key(mode);
+ this->pointSize = pointSize;
+ pixelSize = pointSize * dpi / 72.0;
+ usingPixelSize = false;
+}
+
+void
+Engine::setLcdFilter(FT_LcdFilter filter)
+{
+ 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
@@ -522,14 +440,12 @@ Engine::setCFFHintingMode(int mode)
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
@@ -541,58 +457,32 @@ Engine::setTTInterpreterVersion(int mode)
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: // TODO Differenate RGB/BGR here?
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;
@@ -607,7 +497,7 @@ Engine::update()
{
loadFlags |= FT_LOAD_NO_HINTING;
- if (index == MainGUI::AntiAliasing_None)
+ if (antiAliasingMode == AntiAliasing_None)
loadFlags |= FT_LOAD_MONOCHROME;
}
@@ -615,7 +505,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);
@@ -631,11 +521,104 @@ Engine::update()
}
}
-FontFileManager&
-Engine::fontFileManager()
+
+void
+Engine::queryEngine()
{
- return fileManager;
-}
+ 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 b529089..a32ad42 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,62 +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;
- const QString& currentFamilyName();
- const QString& currentStyleName();
- QString glyphName(int glyphIndex);
- long numberOfFaces(int fontIndex);
- int numberOfNamedInstances(int fontIndex,
- long faceIndex);
+ //////// Actions
+
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();
+ //////// Getters
+
+ FT_Library ftLibrary() const { return library; }
+ int currentFontType() const { return fontType; }
+ const QString& currentFamilyName() { return curFamilyName; }
+ const QString& currentStyleName() { return curStyleName; }
+ int numberOfOpenedFonts();
+ QString glyphName(int glyphIndex);
+ long numberOfFaces(int fontIndex);
+ int numberOfNamedInstances(int fontIndex,
+ long faceIndex);
+
+ // 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() { return fileManager; }
+ EngineDefaultValues& engineDefaults() { return defaults; }
+
+ //////// 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;
@@ -108,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;
@@ -127,10 +165,36 @@ private:
bool doVerticalHinting;
bool doBlueZoneHinting;
bool showSegments;
+ AntiAliasing antiAliasingMode;
double gamma;
unsigned long loadFlags;
+
+ void queryEngine();
+
+public:
+
+ /// Actual definition
+
+ enum AntiAliasing
+ {
+ 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
+ {
+ FontType_CFF,
+ FontType_TrueType,
+ FontType_Other
+ };
};
diff --git a/src/ftinspect/ftinspect.cpp b/src/ftinspect/ftinspect.cpp
index 7ddae30..17498e5 100644
--- a/src/ftinspect/ftinspect.cpp
+++ b/src/ftinspect/ftinspect.cpp
@@ -22,7 +22,7 @@ main(int argc,
app.setOrganizationDomain("freetype.org");
MainGUI gui;
- Engine engine(&gui);
+ Engine engine;
gui.update(&engine);
gui.setDefaults();
diff --git a/src/ftinspect/maingui.cpp b/src/ftinspect/maingui.cpp
index 2538dc6..5851286 100644
--- a/src/ftinspect/maingui.cpp
+++ b/src/ftinspect/maingui.cpp
@@ -174,6 +174,7 @@ MainGUI::showFont()
else
fontFilenameLabel->clear();
+ syncSettings();
currentNumberOfFaces
= engine->numberOfFaces(currentFontIndex);
currentNumberOfNamedInstances
@@ -209,12 +210,45 @@ MainGUI::showFont()
}
+void
+MainGUI::syncSettings()
+{
+ // 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++)
{
@@ -226,7 +260,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++)
{
@@ -262,7 +296,7 @@ MainGUI::checkHinting()
blueZoneHintingCheckBox->setEnabled(false);
segmentDrawingCheckBox->setEnabled(false);
- antiAliasingComboBoxx->setItemEnabled(AntiAliasing_Light, false);
+ antiAliasingComboBoxx->setItemEnabled(Engine::AntiAliasing_Light, false);
}
drawGlyph();
@@ -274,14 +308,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;
}
@@ -303,12 +337,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);
@@ -319,10 +353,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();
@@ -334,9 +368,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::AntiAliasing_Normal
+ || index == Engine::AntiAliasing_Light)
{
lcdFilterLabel->setEnabled(false);
lcdFilterComboBox->setEnabled(false);
@@ -355,7 +389,7 @@ void
MainGUI::checkLcdFilter()
{
int index = lcdFilterComboBox->currentIndex();
- FT_Library_SetLcdFilter(engine->library, lcdFilterHash.key(index));
+ engine->setLcdFilter(lcdFilterHash.key(index));
}
@@ -654,6 +688,7 @@ MainGUI::drawGlyph()
currentGlyphPointNumbersItem = NULL;
}
+ syncSettings();
FT_Outline* outline = engine->loadOutline(currentGlyphIndex);
if (outline)
{
@@ -661,11 +696,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);
@@ -731,19 +766,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);
@@ -1139,14 +1174,6 @@ MainGUI::createStatusBar()
}
-void
-MainGUI::clearStatusBar()
-{
- statusBar()->clearMessage();
- statusBar()->setStyleSheet("");
-}
-
-
void
MainGUI::setDefaults()
{
@@ -1163,20 +1190,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();
@@ -1193,13 +1222,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 9f8b2c2..c97e6c7 100644
--- a/src/ftinspect/maingui.hpp
+++ b/src/ftinspect/maingui.hpp
@@ -230,17 +230,7 @@ private:
QWidget *leftWidget;
QWidget *rightWidget;
QWidget *mmgxTabWidget;
-
- enum AntiAliasing
- {
- AntiAliasing_None,
- AntiAliasing_Normal,
- AntiAliasing_Light,
- AntiAliasing_LCD,
- AntiAliasing_LCD_BGR,
- AntiAliasing_LCD_Vertical,
- AntiAliasing_LCD_Vertical_BGR
- };
+
enum HintingMode
{
HintingMode_TrueType_v35,
@@ -262,15 +252,18 @@ private:
Units_pt
};
+ void showFont();
+ void syncSettings();
+ 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] reorg-maingui 164d062: [ftinspect] Decouple `Engine` from `MainGUI`.,
Werner Lemberg <=