[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[freetype2-demos] master da068f1 04/41: [ftinspect] Rename all private m
From: |
Werner Lemberg |
Subject: |
[freetype2-demos] master da068f1 04/41: [ftinspect] Rename all private member variables with an underscore suffix. |
Date: |
Mon, 3 Oct 2022 11:27:00 -0400 (EDT) |
branch: master
commit da068f1e652382fb7f1dc6e968a6e73f055dfd1a
Author: Charlie Jiang <w@chariri.moe>
Commit: Werner Lemberg <wl@gnu.org>
[ftinspect] Rename all private member variables with an underscore suffix.
(pure mechnical commit)
* src/ftinspect/**: Renaming. Also some variables with abbreviations
were renamed.
This will enable nicer getter/setters, as discussed in #13.
---
src/ftinspect/engine/engine.cpp | 240 ++---
src/ftinspect/engine/engine.hpp | 82 +-
src/ftinspect/engine/fontfilemanager.cpp | 40 +-
src/ftinspect/engine/fontfilemanager.hpp | 8 +-
src/ftinspect/maingui.cpp | 1204 ++++++++++++-------------
src/ftinspect/maingui.hpp | 250 ++---
src/ftinspect/rendering/glyphbitmap.cpp | 44 +-
src/ftinspect/rendering/glyphbitmap.hpp | 12 +-
src/ftinspect/rendering/glyphoutline.cpp | 16 +-
src/ftinspect/rendering/glyphoutline.hpp | 6 +-
src/ftinspect/rendering/glyphpointnumbers.cpp | 24 +-
src/ftinspect/rendering/glyphpointnumbers.hpp | 8 +-
src/ftinspect/rendering/glyphpoints.cpp | 34 +-
src/ftinspect/rendering/glyphpoints.hpp | 8 +-
src/ftinspect/rendering/grid.cpp | 8 +-
src/ftinspect/rendering/grid.hpp | 4 +-
src/ftinspect/widgets/qgraphicsviewx.cpp | 12 +-
src/ftinspect/widgets/qgraphicsviewx.hpp | 4 +-
18 files changed, 1002 insertions(+), 1002 deletions(-)
diff --git a/src/ftinspect/engine/engine.cpp b/src/ftinspect/engine/engine.cpp
index 9fd1dcf..877015c 100644
--- a/src/ftinspect/engine/engine.cpp
+++ b/src/ftinspect/engine/engine.cpp
@@ -87,7 +87,7 @@ faceRequester(FTC_FaceID ftcFaceID,
"Pointer size must be at least the size of int"
" in order to treat FTC_FaceID correctly");
- const FaceID& faceID = 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
@@ -96,7 +96,7 @@ faceRequester(FTC_FaceID ftcFaceID,
|| faceID.fontIndex >= engine->numberOfOpenedFonts())
return FT_Err_Invalid_Argument;
- QString font = engine->fileManager[faceID.fontIndex].filePath();
+ QString font = engine->fontFileManager_[faceID.fontIndex].filePath();
long faceIndex = faceID.faceIndex;
if (faceID.namedInstanceIndex > 0)
@@ -116,34 +116,34 @@ faceRequester(FTC_FaceID ftcFaceID,
/////////////////////////////////////////////////////////////////////////////
Engine::Engine()
-: fileManager(this)
+: fontFileManager_(this)
{
- ftSize = NULL;
+ ftSize_ = NULL;
// we reserve value 0 for the `invalid face ID'
- faceCounter = 1;
+ faceCounter_ = 1;
FT_Error error;
- error = FT_Init_FreeType(&library);
+ error = FT_Init_FreeType(&library_);
if (error)
{
// XXX error handling
}
- error = FTC_Manager_New(library, 0, 0, 0,
- faceRequester, this, &cacheManager);
+ error = FTC_Manager_New(library_, 0, 0, 0,
+ faceRequester, this, &cacheManager_);
if (error)
{
// XXX error handling
}
- error = FTC_SBitCache_New(cacheManager, &sbitsCache);
+ error = FTC_SBitCache_New(cacheManager_, &sbitsCache_);
if (error)
{
// XXX error handling
}
- error = FTC_ImageCache_New(cacheManager, &imageCache);
+ error = FTC_ImageCache_New(cacheManager_, &imageCache_);
if (error)
{
// XXX error handling
@@ -155,8 +155,8 @@ Engine::Engine()
Engine::~Engine()
{
- FTC_Manager_Done(cacheManager);
- FT_Done_FreeType(library);
+ FTC_Manager_Done(cacheManager_);
+ FT_Done_FreeType(library_);
}
@@ -168,28 +168,28 @@ Engine::numberOfFaces(int fontIndex)
// search triplet (fontIndex, 0, 0)
FTC_FaceID ftcFaceID = reinterpret_cast<FTC_FaceID>
- (faceIDMap.value(FaceID(fontIndex,
+ (faceIDMap_.value(FaceID(fontIndex,
0,
0)));
if (ftcFaceID)
{
// found
- if (!FTC_Manager_LookupFace(cacheManager, ftcFaceID, &face))
+ if (!FTC_Manager_LookupFace(cacheManager_, ftcFaceID, &face))
numFaces = face->num_faces;
}
else
{
// not found; try to load triplet (fontIndex, 0, 0)
- ftcFaceID = reinterpret_cast<FTC_FaceID>(faceCounter);
- faceIDMap.insert(FaceID(fontIndex, 0, 0),
- faceCounter++);
+ ftcFaceID = reinterpret_cast<FTC_FaceID>(faceCounter_);
+ faceIDMap_.insert(FaceID(fontIndex, 0, 0),
+ faceCounter_++);
- if (!FTC_Manager_LookupFace(cacheManager, ftcFaceID, &face))
+ if (!FTC_Manager_LookupFace(cacheManager_, ftcFaceID, &face))
numFaces = face->num_faces;
else
{
- faceIDMap.remove(FaceID(fontIndex, 0, 0));
- faceCounter--;
+ faceIDMap_.remove(FaceID(fontIndex, 0, 0));
+ faceCounter_--;
}
}
@@ -208,28 +208,28 @@ Engine::numberOfNamedInstances(int fontIndex,
// search triplet (fontIndex, faceIndex, 0)
FTC_FaceID ftcFaceID = reinterpret_cast<FTC_FaceID>
- (faceIDMap.value(FaceID(fontIndex,
+ (faceIDMap_.value(FaceID(fontIndex,
faceIndex,
0)));
if (ftcFaceID)
{
// found
- if (!FTC_Manager_LookupFace(cacheManager, ftcFaceID, &face))
+ if (!FTC_Manager_LookupFace(cacheManager_, ftcFaceID, &face))
numNamedInstances = static_cast<int>((face->style_flags >> 16) + 1);
}
else
{
// not found; try to load triplet (fontIndex, faceIndex, 0)
- ftcFaceID = reinterpret_cast<FTC_FaceID>(faceCounter);
- faceIDMap.insert(FaceID(fontIndex, faceIndex, 0),
- faceCounter++);
+ ftcFaceID = reinterpret_cast<FTC_FaceID>(faceCounter_);
+ faceIDMap_.insert(FaceID(fontIndex, faceIndex, 0),
+ faceCounter_++);
- if (!FTC_Manager_LookupFace(cacheManager, ftcFaceID, &face))
+ if (!FTC_Manager_LookupFace(cacheManager_, ftcFaceID, &face))
numNamedInstances = static_cast<int>((face->style_flags >> 16) + 1);
else
{
- faceIDMap.remove(FaceID(fontIndex, faceIndex, 0));
- faceCounter--;
+ faceIDMap_.remove(FaceID(fontIndex, faceIndex, 0));
+ faceCounter_--;
}
}
@@ -243,60 +243,60 @@ Engine::loadFont(int fontIndex,
int namedInstanceIndex)
{
int numGlyphs = -1;
- fontType = FontType_Other;
+ fontType_ = FontType_Other;
update();
// search triplet (fontIndex, faceIndex, namedInstanceIndex)
- scaler.face_id = reinterpret_cast<FTC_FaceID>
- (faceIDMap.value(FaceID(fontIndex,
+ scaler_.face_id = reinterpret_cast<FTC_FaceID>
+ (faceIDMap_.value(FaceID(fontIndex,
faceIndex,
namedInstanceIndex)));
- if (scaler.face_id)
+ if (scaler_.face_id)
{
// found
- if (!FTC_Manager_LookupSize(cacheManager, &scaler, &ftSize))
- numGlyphs = ftSize->face->num_glyphs;
+ if (!FTC_Manager_LookupSize(cacheManager_, &scaler_, &ftSize_))
+ numGlyphs = ftSize_->face->num_glyphs;
}
else
{
// not found; try to load triplet
// (fontIndex, faceIndex, namedInstanceIndex)
- scaler.face_id = reinterpret_cast<FTC_FaceID>(faceCounter);
- faceIDMap.insert(FaceID(fontIndex,
+ scaler_.face_id = reinterpret_cast<FTC_FaceID>(faceCounter_);
+ faceIDMap_.insert(FaceID(fontIndex,
faceIndex,
namedInstanceIndex),
- faceCounter++);
+ faceCounter_++);
- if (!FTC_Manager_LookupSize(cacheManager, &scaler, &ftSize))
- numGlyphs = ftSize->face->num_glyphs;
+ if (!FTC_Manager_LookupSize(cacheManager_, &scaler_, &ftSize_))
+ numGlyphs = ftSize_->face->num_glyphs;
else
{
- faceIDMap.remove(FaceID(fontIndex,
+ faceIDMap_.remove(FaceID(fontIndex,
faceIndex,
namedInstanceIndex));
- faceCounter--;
+ faceCounter_--;
}
}
if (numGlyphs < 0)
{
- ftSize = NULL;
- curFamilyName = QString();
- curStyleName = QString();
+ ftSize_ = NULL;
+ curFamilyName_ = QString();
+ curStyleName_ = QString();
}
else
{
- curFamilyName = QString(ftSize->face->family_name);
- curStyleName = QString(ftSize->face->style_name);
+ curFamilyName_ = QString(ftSize_->face->family_name);
+ curStyleName_ = QString(ftSize_->face->style_name);
- const char* moduleName = FT_FACE_DRIVER_NAME( ftSize->face );
+ const char* moduleName = FT_FACE_DRIVER_NAME( ftSize_->face );
// XXX cover all available modules
if (!strcmp(moduleName, "cff"))
- fontType = FontType_CFF;
+ fontType_ = FontType_CFF;
else if (!strcmp(moduleName, "truetype"))
- fontType = FontType_TrueType;
+ fontType_ = FontType_TrueType;
}
return numGlyphs;
@@ -309,11 +309,11 @@ Engine::removeFont(int fontIndex, bool closeFile)
// we iterate over all triplets that contain the given font index
// and remove them
QMap<FaceID, FTC_IDType>::iterator iter
- = faceIDMap.lowerBound(FaceID(fontIndex, 0, 0));
+ = faceIDMap_.lowerBound(FaceID(fontIndex, 0, 0));
for (;;)
{
- if (iter == faceIDMap.end())
+ if (iter == faceIDMap_.end())
break;
FaceID faceID = iter.key();
@@ -321,13 +321,13 @@ Engine::removeFont(int fontIndex, bool closeFile)
break;
FTC_FaceID ftcFaceID = reinterpret_cast<FTC_FaceID>(iter.value());
- FTC_Manager_RemoveFaceID(cacheManager, ftcFaceID);
+ FTC_Manager_RemoveFaceID(cacheManager_, ftcFaceID);
- iter = faceIDMap.erase(iter);
+ iter = faceIDMap_.erase(iter);
}
if (closeFile)
- fileManager.remove(fontIndex);
+ fontFileManager_.remove(fontIndex);
}
@@ -339,10 +339,10 @@ Engine::glyphName(int index)
if (index < 0)
throw std::runtime_error("Invalid glyph index");
- if (ftSize && FT_HAS_GLYPH_NAMES(ftSize->face))
+ if (ftSize_ && FT_HAS_GLYPH_NAMES(ftSize_->face))
{
char buffer[256];
- if (!FT_Get_Glyph_Name(ftSize->face,
+ if (!FT_Get_Glyph_Name(ftSize_->face,
static_cast<unsigned int>(index),
buffer,
sizeof(buffer)))
@@ -367,9 +367,9 @@ Engine::loadOutline(int glyphIndex)
// the `scaler' object is set up by the
// `update' and `loadFont' methods
- if (FTC_ImageCache_LookupScaler(imageCache,
- &scaler,
- loadFlags | FT_LOAD_NO_BITMAP,
+ if (FTC_ImageCache_LookupScaler(imageCache_,
+ &scaler_,
+ loadFlags_ | FT_LOAD_NO_BITMAP,
static_cast<unsigned int>(glyphIndex),
&glyph,
NULL))
@@ -390,45 +390,45 @@ Engine::loadOutline(int glyphIndex)
int
Engine::numberOfOpenedFonts()
{
- return fileManager.size();
+ return fontFileManager_.size();
}
void
Engine::openFonts(QStringList fontFileNames)
{
- fileManager.append(fontFileNames, true);
+ fontFileManager_.append(fontFileNames, true);
}
void
Engine::setSizeByPixel(double pixelSize)
{
- this->pixelSize = pixelSize;
- pointSize = pixelSize * 72.0 / dpi;
- usingPixelSize = true;
+ 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;
+ this->pointSize_ = pointSize;
+ pixelSize_ = pointSize * dpi_ / 72.0;
+ usingPixelSize_ = false;
}
void
Engine::setLcdFilter(FT_LcdFilter filter)
{
- FT_Library_SetLcdFilter(library, filter);
+ FT_Library_SetLcdFilter(library_, filter);
}
void
Engine::setCFFHintingMode(int mode)
{
- FT_Error error = FT_Property_Set(library,
+ FT_Error error = FT_Property_Set(library_,
"cff",
"hinting-engine",
&mode);
@@ -440,7 +440,7 @@ Engine::setCFFHintingMode(int mode)
void
Engine::setTTInterpreterVersion(int version)
{
- FT_Error error = FT_Property_Set(library,
+ FT_Error error = FT_Property_Set(library_,
"truetype",
"interpreter-version",
&version);
@@ -452,20 +452,20 @@ Engine::setTTInterpreterVersion(int version)
void
Engine::update()
{
- loadFlags = FT_LOAD_DEFAULT;
- if (doAutoHinting)
- loadFlags |= FT_LOAD_FORCE_AUTOHINT;
- loadFlags |= FT_LOAD_NO_BITMAP; // XXX handle bitmap fonts also
+ loadFlags_ = FT_LOAD_DEFAULT;
+ if (doAutoHinting_)
+ loadFlags_ |= FT_LOAD_FORCE_AUTOHINT;
+ loadFlags_ |= FT_LOAD_NO_BITMAP; // XXX handle bitmap fonts also
- if (doHinting)
+ if (doHinting_)
{
unsigned long target;
- if (antiAliasingMode == AntiAliasing_None)
+ if (antiAliasingMode_ == AntiAliasing_None)
target = FT_LOAD_TARGET_MONO;
else
{
- switch (antiAliasingMode)
+ switch (antiAliasingMode_)
{
case AntiAliasing_Light:
target = FT_LOAD_TARGET_LIGHT;
@@ -486,33 +486,33 @@ Engine::update()
}
}
- loadFlags |= target;
+ loadFlags_ |= target;
}
else
{
- loadFlags |= FT_LOAD_NO_HINTING;
+ loadFlags_ |= FT_LOAD_NO_HINTING;
- if (antiAliasingMode == AntiAliasing_None)
- loadFlags |= FT_LOAD_MONOCHROME;
+ if (antiAliasingMode_ == AntiAliasing_None)
+ loadFlags_ |= FT_LOAD_MONOCHROME;
}
// XXX handle color fonts also
- scaler.pixel = 0; // use 26.6 format
+ scaler_.pixel = 0; // use 26.6 format
- if (usingPixelSize)
+ if (usingPixelSize_)
{
- scaler.width = static_cast<unsigned int>(pixelSize * 64.0);
- scaler.height = static_cast<unsigned int>(pixelSize * 64.0);
- scaler.x_res = 0;
- scaler.y_res = 0;
+ scaler_.width = static_cast<unsigned int>(pixelSize_ * 64.0);
+ scaler_.height = static_cast<unsigned int>(pixelSize_ * 64.0);
+ scaler_.x_res = 0;
+ scaler_.y_res = 0;
}
else
{
- scaler.width = static_cast<unsigned int>(pointSize * 64.0);
- scaler.height = static_cast<unsigned int>(pointSize * 64.0);
- scaler.x_res = dpi;
- scaler.y_res = dpi;
+ scaler_.width = static_cast<unsigned int>(pointSize_ * 64.0);
+ scaler_.height = static_cast<unsigned int>(pointSize_ * 64.0);
+ scaler_.x_res = dpi_;
+ scaler_.y_res = dpi_;
}
}
@@ -521,8 +521,8 @@ void
Engine::resetCache()
{
// reset the cache
- FTC_Manager_Reset(cacheManager);
- ftSize = NULL;
+ FTC_Manager_Reset(cacheManager_);
+ ftSize_ = NULL;
}
@@ -534,15 +534,15 @@ Engine::queryEngine()
// query engines and check for alternatives
// CFF
- error = FT_Property_Get(library,
+ error = FT_Property_Get(library_,
"cff",
"hinting-engine",
- &defaults.cffHintingEngineDefault);
+ &engineDefaults_.cffHintingEngineDefault);
if (error)
{
// no CFF engine
- defaults.cffHintingEngineDefault = -1;
- defaults.cffHintingEngineOther = -1;
+ engineDefaults_.cffHintingEngineDefault = -1;
+ engineDefaults_.cffHintingEngineOther = -1;
}
else
{
@@ -554,36 +554,36 @@ Engine::queryEngine()
int i;
for (i = 0; i < 2; i++)
- if (defaults.cffHintingEngineDefault == engines[i])
+ if (engineDefaults_.cffHintingEngineDefault == engines[i])
break;
- defaults.cffHintingEngineOther = engines[(i + 1) % 2];
+ engineDefaults_.cffHintingEngineOther = engines[(i + 1) % 2];
- error = FT_Property_Set(library,
+ error = FT_Property_Set(library_,
"cff",
"hinting-engine",
- &defaults.cffHintingEngineOther);
+ &engineDefaults_.cffHintingEngineOther);
if (error)
- defaults.cffHintingEngineOther = -1;
+ engineDefaults_.cffHintingEngineOther = -1;
// reset
- FT_Property_Set(library,
+ FT_Property_Set(library_,
"cff",
"hinting-engine",
- &defaults.cffHintingEngineDefault);
+ &engineDefaults_.cffHintingEngineDefault);
}
// TrueType
- error = FT_Property_Get(library,
+ error = FT_Property_Get(library_,
"truetype",
"interpreter-version",
- &defaults.ttInterpreterVersionDefault);
+ &engineDefaults_.ttInterpreterVersionDefault);
if (error)
{
// no TrueType engine
- defaults.ttInterpreterVersionDefault = -1;
- defaults.ttInterpreterVersionOther = -1;
- defaults.ttInterpreterVersionOther1 = -1;
+ engineDefaults_.ttInterpreterVersionDefault = -1;
+ engineDefaults_.ttInterpreterVersionOther = -1;
+ engineDefaults_.ttInterpreterVersionOther1 = -1;
}
else
{
@@ -596,32 +596,32 @@ Engine::queryEngine()
int i;
for (i = 0; i < 3; i++)
- if (defaults.ttInterpreterVersionDefault == interpreters[i])
+ if (engineDefaults_.ttInterpreterVersionDefault == interpreters[i])
break;
- defaults.ttInterpreterVersionOther = interpreters[(i + 1) % 3];
+ engineDefaults_.ttInterpreterVersionOther = interpreters[(i + 1) % 3];
- error = FT_Property_Set(library,
+ error = FT_Property_Set(library_,
"truetype",
"interpreter-version",
- &defaults.ttInterpreterVersionOther);
+ &engineDefaults_.ttInterpreterVersionOther);
if (error)
- defaults.ttInterpreterVersionOther = -1;
+ engineDefaults_.ttInterpreterVersionOther = -1;
- defaults.ttInterpreterVersionOther1 = interpreters[(i + 2) % 3];
+ engineDefaults_.ttInterpreterVersionOther1 = interpreters[(i + 2) % 3];
- error = FT_Property_Set(library,
+ error = FT_Property_Set(library_,
"truetype",
"interpreter-version",
- &defaults.ttInterpreterVersionOther1);
+ &engineDefaults_.ttInterpreterVersionOther1);
if (error)
- defaults.ttInterpreterVersionOther1 = -1;
+ engineDefaults_.ttInterpreterVersionOther1 = -1;
// reset
- FT_Property_Set(library,
+ FT_Property_Set(library_,
"truetype",
"interpreter-version",
- &defaults.ttInterpreterVersionDefault);
+ &engineDefaults_.ttInterpreterVersionDefault);
}
}
diff --git a/src/ftinspect/engine/engine.hpp b/src/ftinspect/engine/engine.hpp
index eb7a794..2a7ec24 100644
--- a/src/ftinspect/engine/engine.hpp
+++ b/src/ftinspect/engine/engine.hpp
@@ -81,16 +81,16 @@ public:
//////// Getters
- FT_Library ftLibrary() const { return library; }
- FontFileManager& fontFileManager() { return fileManager; }
- EngineDefaultValues& engineDefaults() { return defaults; }
+ FT_Library ftLibrary() const { return library_; }
+ FontFileManager& fontFileManager() { return fontFileManager_; }
+ EngineDefaultValues& engineDefaults() { return engineDefaults_; }
int numberOfOpenedFonts();
// (for current fonts)
- int currentFontType() const { return fontType; }
- const QString& currentFamilyName() { return curFamilyName; }
- const QString& currentStyleName() { return curStyleName; }
+ 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,
@@ -98,26 +98,26 @@ public:
//////// Setters (direct or indirect)
- void setDPI(int d) { dpi = d; }
+ 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 setHinting(bool hinting) { doHinting_ = hinting; }
+ void setAutoHinting(bool autoHinting) { doAutoHinting_ = autoHinting; }
void setHorizontalHinting(bool horHinting)
{
- doHorizontalHinting = horHinting;
+ doHorizontalHinting_ = horHinting;
}
void setVerticalHinting(bool verticalHinting)
{
- doVerticalHinting = verticalHinting;
+ doVerticalHinting_ = verticalHinting;
}
void setBlueZoneHinting(bool blueZoneHinting)
{
- doBlueZoneHinting = blueZoneHinting;
+ doBlueZoneHinting_ = blueZoneHinting;
}
- void setShowSegments(bool showSegments) { this->showSegments = showSegments;
}
- void setGamma(double gamma) { this->gamma = gamma; }
- void setAntiAliasingMode(AntiAliasing mode) { antiAliasingMode = mode; }
+ void setShowSegments(bool showSegments) { showSegments_ = showSegments; }
+ void setGamma(double gamma) { 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!
@@ -134,42 +134,42 @@ public:
private:
using FTC_IDType = uintptr_t;
- FTC_IDType faceCounter; // a running number used to initialize `faceIDMap'
- QMap<FaceID, FTC_IDType> faceIDMap;
+ FTC_IDType faceCounter_; // a running number used to initialize `faceIDMap'
+ QMap<FaceID, FTC_IDType> faceIDMap_;
- FontFileManager fileManager;
+ FontFileManager fontFileManager_;
- QString curFamilyName;
- QString curStyleName;
+ QString curFamilyName_;
+ QString curStyleName_;
- FT_Library library;
- FTC_Manager cacheManager;
- FTC_ImageCache imageCache;
- FTC_SBitCache sbitsCache;
+ FT_Library library_;
+ FTC_Manager cacheManager_;
+ FTC_ImageCache imageCache_;
+ FTC_SBitCache sbitsCache_;
- FTC_ScalerRec scaler;
- FT_Size ftSize;
+ FTC_ScalerRec scaler_;
+ FT_Size ftSize_;
- EngineDefaultValues defaults;
+ EngineDefaultValues engineDefaults_;
- int fontType;
+ int fontType_;
- bool usingPixelSize = false;
- double pointSize;
- double pixelSize;
- unsigned int dpi;
+ bool usingPixelSize_ = false;
+ double pointSize_;
+ double pixelSize_;
+ unsigned int dpi_;
- bool doHinting;
- bool doAutoHinting;
- bool doHorizontalHinting;
- bool doVerticalHinting;
- bool doBlueZoneHinting;
- bool showSegments;
- AntiAliasing antiAliasingMode;
+ bool doHinting_;
+ bool doAutoHinting_;
+ bool doHorizontalHinting_;
+ bool doVerticalHinting_;
+ bool doBlueZoneHinting_;
+ bool showSegments_;
+ AntiAliasing antiAliasingMode_;
- double gamma;
+ double gamma_;
- unsigned long loadFlags;
+ unsigned long loadFlags_;
void queryEngine();
diff --git a/src/ftinspect/engine/fontfilemanager.cpp
b/src/ftinspect/engine/fontfilemanager.cpp
index 13c5cbd..c995624 100644
--- a/src/ftinspect/engine/fontfilemanager.cpp
+++ b/src/ftinspect/engine/fontfilemanager.cpp
@@ -13,16 +13,16 @@
FontFileManager::FontFileManager(Engine* engine)
-: engine(engine)
+: engine_(engine)
{
- fontWatcher = new QFileSystemWatcher(this);
+ fontWatcher_ = new QFileSystemWatcher(this);
// if the current input file is invalid we retry once a second to load it
- watchTimer = new QTimer;
- watchTimer->setInterval(1000);
+ watchTimer_ = new QTimer;
+ watchTimer_->setInterval(1000);
- connect(fontWatcher, &QFileSystemWatcher::fileChanged,
+ connect(fontWatcher_, &QFileSystemWatcher::fileChanged,
this, &FontFileManager::onWatcherFire);
- connect(watchTimer, &QTimer::timeout,
+ connect(watchTimer_, &QTimer::timeout,
this, &FontFileManager::onTimerFire);
}
@@ -30,7 +30,7 @@ FontFileManager::FontFileManager(Engine* engine)
int
FontFileManager::size()
{
- return fontFileNameList.size();
+ return fontFileNameList_.size();
}
@@ -73,7 +73,7 @@ FontFileManager::append(QStringList const& newFileNames, bool
alertNotExist)
// Uniquify elements
auto absPath = info.absoluteFilePath();
auto existing = false;
- for (auto& existingName : fontFileNameList)
+ for (auto& existingName : fontFileNameList_)
if (existingName.absoluteFilePath() == absPath)
{
existing = true;
@@ -84,7 +84,7 @@ FontFileManager::append(QStringList const& newFileNames, bool
alertNotExist)
if (info.size() >= INT_MAX)
return; // Prevent overflowing
- fontFileNameList.append(info);
+ fontFileNameList_.append(info);
}
if (alertNotExist && !failedFiles.empty())
@@ -116,47 +116,47 @@ FontFileManager::remove(int index)
if (index < 0 || index >= size())
return;
- fontWatcher->removePath(fontFileNameList[index].filePath());
- fontFileNameList.removeAt(index);
+ fontWatcher_->removePath(fontFileNameList_[index].filePath());
+ fontFileNameList_.removeAt(index);
}
QFileInfo&
FontFileManager::operator[](int index)
{
- return fontFileNameList[index];
+ return fontFileNameList_[index];
}
void
FontFileManager::updateWatching(int index)
{
- QFileInfo& fileInfo = fontFileNameList[index];
+ QFileInfo& fileInfo = fontFileNameList_[index];
- auto watching = fontWatcher->files();
+ auto watching = fontWatcher_->files();
if (!watching.empty())
- fontWatcher->removePaths(watching);
+ fontWatcher_->removePaths(watching);
// Qt's file watcher doesn't handle symlinks;
// we thus fall back to polling
if (fileInfo.isSymLink() || !fileInfo.exists())
- watchTimer->start();
+ watchTimer_->start();
else
- fontWatcher->addPath(fileInfo.filePath());
+ fontWatcher_->addPath(fileInfo.filePath());
}
void
FontFileManager::timerStart()
{
- watchTimer->start();
+ watchTimer_->start();
}
void
FontFileManager::onWatcherFire()
{
- watchTimer->stop();
+ watchTimer_->stop();
emit currentFileChanged();
}
@@ -164,7 +164,7 @@ FontFileManager::onWatcherFire()
FT_Error
FontFileManager::validateFontFile(QString const& fileName)
{
- return FT_New_Face(engine->ftLibrary(), fileName.toUtf8(), -1, NULL);
+ return FT_New_Face(engine_->ftLibrary(), fileName.toUtf8(), -1, NULL);
}
diff --git a/src/ftinspect/engine/fontfilemanager.hpp
b/src/ftinspect/engine/fontfilemanager.hpp
index 9391685..a13714e 100644
--- a/src/ftinspect/engine/fontfilemanager.hpp
+++ b/src/ftinspect/engine/fontfilemanager.hpp
@@ -41,10 +41,10 @@ private slots:
void onWatcherFire();
private:
- Engine* engine;
- QList<QFileInfo> fontFileNameList;
- QFileSystemWatcher* fontWatcher;
- QTimer* watchTimer;
+ Engine* engine_;
+ QList<QFileInfo> fontFileNameList_;
+ QFileSystemWatcher* fontWatcher_;
+ QTimer* watchTimer_;
FT_Error validateFontFile(QString const& fileName);
};
diff --git a/src/ftinspect/maingui.cpp b/src/ftinspect/maingui.cpp
index cc4c09c..026b656 100644
--- a/src/ftinspect/maingui.cpp
+++ b/src/ftinspect/maingui.cpp
@@ -15,7 +15,7 @@
MainGUI::MainGUI(Engine* engine)
-: engine(engine)
+: engine_(engine)
{
setGraphicsDefaults();
createLayout();
@@ -80,7 +80,7 @@ MainGUI::aboutQt()
void
MainGUI::loadFonts()
{
- int oldSize = engine->numberOfOpenedFonts();
+ int oldSize = engine_->numberOfOpenedFonts();
QStringList files = QFileDialog::getOpenFileNames(
this,
@@ -90,11 +90,11 @@ MainGUI::loadFonts()
NULL,
QFileDialog::ReadOnly);
- engine->openFonts(files);
+ engine_->openFonts(files);
// if we have new fonts, set the current index to the first new one
- if (oldSize < engine->numberOfOpenedFonts())
- currentFontIndex = oldSize;
+ if (oldSize < engine_->numberOfOpenedFonts())
+ currentFontIndex_ = oldSize;
showFont();
}
@@ -103,20 +103,20 @@ MainGUI::loadFonts()
void
MainGUI::closeFont()
{
- if (currentFontIndex < engine->numberOfOpenedFonts())
+ if (currentFontIndex_ < engine_->numberOfOpenedFonts())
{
- engine->removeFont(currentFontIndex);
+ engine_->removeFont(currentFontIndex_);
}
// show next font after deletion, i.e., retain index if possible
- int num = engine->numberOfOpenedFonts();
+ int num = engine_->numberOfOpenedFonts();
if (num)
{
- if (currentFontIndex >= num)
- currentFontIndex = num - 1;
+ if (currentFontIndex_ >= num)
+ currentFontIndex_ = num - 1;
}
else
- currentFontIndex = 0;
+ currentFontIndex_ = 0;
showFont();
}
@@ -134,12 +134,12 @@ MainGUI::showFont()
{
// we do lazy computation of FT_Face objects
- if (currentFontIndex < engine->numberOfOpenedFonts())
+ if (currentFontIndex_ < engine_->numberOfOpenedFonts())
{
- QFileInfo& fileInfo = engine->fontFileManager()[currentFontIndex];
+ QFileInfo& fileInfo = engine_->fontFileManager()[currentFontIndex_];
QString fontName = fileInfo.fileName();
- engine->fontFileManager().updateWatching(currentFontIndex);
+ engine_->fontFileManager().updateWatching(currentFontIndex_);
if (fileInfo.isSymLink())
{
fontName.prepend("<i>");
@@ -154,39 +154,39 @@ MainGUI::showFont()
// For this reason, we remove the font to enforce a reload.
// However, we're just removing it from the Engine cache,
// not deleting the entry in the font file manager
- engine->removeFont(currentFontIndex, false);
+ engine_->removeFont(currentFontIndex_, false);
}
- fontFilenameLabel->setText(fontName);
+ fontFilenameLabel_->setText(fontName);
}
else
- fontFilenameLabel->clear();
+ fontFilenameLabel_->clear();
applySettings();
- currentNumberOfFaces
- = engine->numberOfFaces(currentFontIndex);
- currentNumberOfNamedInstances
- = engine->numberOfNamedInstances(currentFontIndex,
- currentFaceIndex);
- currentNumberOfGlyphs
- = engine->loadFont(currentFontIndex,
- currentFaceIndex,
- currentNamedInstanceIndex);
-
- if (currentNumberOfGlyphs < 0)
+ currentNumberOfFaces_
+ = engine_->numberOfFaces(currentFontIndex_);
+ currentNumberOfNamedInstances_
+ = engine_->numberOfNamedInstances(currentFontIndex_,
+ currentFaceIndex_);
+ currentNumberOfGlyphs_
+ = engine_->loadFont(currentFontIndex_,
+ currentFaceIndex_,
+ currentNamedInstanceIndex_);
+
+ if (currentNumberOfGlyphs_ < 0)
{
// there might be various reasons why the current
// (file, face, instance) triplet is invalid or missing;
// we thus start our timer to periodically test
// whether the font starts working
- if (currentFontIndex > 0
- && currentFontIndex < engine->numberOfOpenedFonts())
- engine->fontFileManager().timerStart();
+ if (currentFontIndex_ > 0
+ && currentFontIndex_ < engine_->numberOfOpenedFonts())
+ engine_->fontFileManager().timerStart();
}
- fontNameLabel->setText(QString("%1 %2")
- .arg(engine->currentFamilyName())
- .arg(engine->currentStyleName()));
+ fontNameLabel_->setText(QString("%1 %2")
+ .arg(engine_->currentFamilyName())
+ .arg(engine_->currentStyleName()));
checkCurrentFontIndex();
checkCurrentFaceIndex();
@@ -202,24 +202,24 @@ void
MainGUI::applySettings()
{
// Spinbox value cannot become negative
- engine->setDPI(static_cast<unsigned int>(dpiSpinBox->value()));
+ engine_->setDPI(static_cast<unsigned int>(dpiSpinBox_->value()));
- if (unitsComboBox->currentIndex() == Units_px)
- engine->setSizeByPixel(sizeDoubleSpinBox->value());
+ if (unitsComboBox_->currentIndex() == Units_px)
+ engine_->setSizeByPixel(sizeDoubleSpinBox_->value());
else
- engine->setSizeByPoint(sizeDoubleSpinBox->value());
+ 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_->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_->setGamma(gammaSlider_->value());
- engine->setAntiAliasingMode(static_cast<Engine::AntiAliasing>(
- antiAliasingComboBoxx->currentIndex()));
+ engine_->setAntiAliasingMode(static_cast<Engine::AntiAliasing>(
+ antiAliasingComboBoxx_->currentIndex()));
}
@@ -234,57 +234,57 @@ MainGUI::clearStatusBar()
void
MainGUI::checkHinting()
{
- if (hintingCheckBox->isChecked())
+ if (hintingCheckBox_->isChecked())
{
- if (engine->currentFontType() == Engine::FontType_CFF)
+ if (engine_->currentFontType() == Engine::FontType_CFF)
{
- for (int i = 0; i < hintingModeComboBoxx->count(); i++)
+ for (int i = 0; i < hintingModeComboBoxx_->count(); i++)
{
- if (hintingModesCFFHash.key(i, -1) != -1)
- hintingModeComboBoxx->setItemEnabled(i, true);
+ if (hintingModesCFFHash_.key(i, -1) != -1)
+ hintingModeComboBoxx_->setItemEnabled(i, true);
else
- hintingModeComboBoxx->setItemEnabled(i, false);
+ hintingModeComboBoxx_->setItemEnabled(i, false);
}
- hintingModeComboBoxx->setCurrentIndex(currentCFFHintingMode);
+ hintingModeComboBoxx_->setCurrentIndex(currentCFFHintingMode_);
}
- else if (engine->currentFontType() == Engine::FontType_TrueType)
+ else if (engine_->currentFontType() == Engine::FontType_TrueType)
{
- for (int i = 0; i < hintingModeComboBoxx->count(); i++)
+ for (int i = 0; i < hintingModeComboBoxx_->count(); i++)
{
- if (hintingModesTrueTypeHash.key(i, -1) != -1)
- hintingModeComboBoxx->setItemEnabled(i, true);
+ if (hintingModesTrueTypeHash_.key(i, -1) != -1)
+ hintingModeComboBoxx_->setItemEnabled(i, true);
else
- hintingModeComboBoxx->setItemEnabled(i, false);
+ hintingModeComboBoxx_->setItemEnabled(i, false);
}
- hintingModeComboBoxx->setCurrentIndex(currentTTInterpreterVersion);
+ hintingModeComboBoxx_->setCurrentIndex(currentTTInterpreterVersion_);
}
else
{
- hintingModeLabel->setEnabled(false);
- hintingModeComboBoxx->setEnabled(false);
+ hintingModeLabel_->setEnabled(false);
+ hintingModeComboBoxx_->setEnabled(false);
}
- for (int i = 0; i < hintingModesAlwaysDisabled.size(); i++)
- hintingModeComboBoxx->setItemEnabled(hintingModesAlwaysDisabled[i],
+ for (int i = 0; i < hintingModesAlwaysDisabled_.size(); i++)
+ hintingModeComboBoxx_->setItemEnabled(hintingModesAlwaysDisabled_[i],
false);
- autoHintingCheckBox->setEnabled(true);
+ autoHintingCheckBox_->setEnabled(true);
checkAutoHinting();
}
else
{
- hintingModeLabel->setEnabled(false);
- hintingModeComboBoxx->setEnabled(false);
+ hintingModeLabel_->setEnabled(false);
+ hintingModeComboBoxx_->setEnabled(false);
- autoHintingCheckBox->setEnabled(false);
- horizontalHintingCheckBox->setEnabled(false);
- verticalHintingCheckBox->setEnabled(false);
- blueZoneHintingCheckBox->setEnabled(false);
- segmentDrawingCheckBox->setEnabled(false);
+ autoHintingCheckBox_->setEnabled(false);
+ horizontalHintingCheckBox_->setEnabled(false);
+ verticalHintingCheckBox_->setEnabled(false);
+ blueZoneHintingCheckBox_->setEnabled(false);
+ segmentDrawingCheckBox_->setEnabled(false);
- antiAliasingComboBoxx->setItemEnabled(Engine::AntiAliasing_Light, false);
+ antiAliasingComboBoxx_->setItemEnabled(Engine::AntiAliasing_Light, false);
}
drawGlyph();
@@ -294,17 +294,17 @@ MainGUI::checkHinting()
void
MainGUI::checkHintingMode()
{
- int index = hintingModeComboBoxx->currentIndex();
+ int index = hintingModeComboBoxx_->currentIndex();
- if (engine->currentFontType() == Engine::FontType_CFF)
+ if (engine_->currentFontType() == Engine::FontType_CFF)
{
- engine->setCFFHintingMode(hintingModesCFFHash.key(index));
- currentCFFHintingMode = index;
+ engine_->setCFFHintingMode(hintingModesCFFHash_.key(index));
+ currentCFFHintingMode_ = index;
}
- else if (engine->currentFontType() == Engine::FontType_TrueType)
+ else if (engine_->currentFontType() == Engine::FontType_TrueType)
{
- engine->setTTInterpreterVersion(hintingModesTrueTypeHash.key(index));
- currentTTInterpreterVersion = index;
+ engine_->setTTInterpreterVersion(hintingModesTrueTypeHash_.key(index));
+ currentTTInterpreterVersion_ = index;
}
// this enforces reloading of the font
@@ -315,36 +315,36 @@ MainGUI::checkHintingMode()
void
MainGUI::checkAutoHinting()
{
- if (autoHintingCheckBox->isChecked())
+ if (autoHintingCheckBox_->isChecked())
{
- hintingModeLabel->setEnabled(false);
- hintingModeComboBoxx->setEnabled(false);
+ hintingModeLabel_->setEnabled(false);
+ hintingModeComboBoxx_->setEnabled(false);
- horizontalHintingCheckBox->setEnabled(true);
- verticalHintingCheckBox->setEnabled(true);
- blueZoneHintingCheckBox->setEnabled(true);
- segmentDrawingCheckBox->setEnabled(true);
+ horizontalHintingCheckBox_->setEnabled(true);
+ verticalHintingCheckBox_->setEnabled(true);
+ blueZoneHintingCheckBox_->setEnabled(true);
+ segmentDrawingCheckBox_->setEnabled(true);
- antiAliasingComboBoxx->setItemEnabled(Engine::AntiAliasing_Light, true);
+ antiAliasingComboBoxx_->setItemEnabled(Engine::AntiAliasing_Light, true);
}
else
{
- if (engine->currentFontType() == Engine::FontType_CFF
- || engine->currentFontType() == Engine::FontType_TrueType)
+ if (engine_->currentFontType() == Engine::FontType_CFF
+ || engine_->currentFontType() == Engine::FontType_TrueType)
{
- hintingModeLabel->setEnabled(true);
- hintingModeComboBoxx->setEnabled(true);
+ hintingModeLabel_->setEnabled(true);
+ hintingModeComboBoxx_->setEnabled(true);
}
- horizontalHintingCheckBox->setEnabled(false);
- verticalHintingCheckBox->setEnabled(false);
- blueZoneHintingCheckBox->setEnabled(false);
- segmentDrawingCheckBox->setEnabled(false);
+ horizontalHintingCheckBox_->setEnabled(false);
+ verticalHintingCheckBox_->setEnabled(false);
+ blueZoneHintingCheckBox_->setEnabled(false);
+ segmentDrawingCheckBox_->setEnabled(false);
- antiAliasingComboBoxx->setItemEnabled(Engine::AntiAliasing_Light, false);
+ antiAliasingComboBoxx_->setItemEnabled(Engine::AntiAliasing_Light, false);
- if (antiAliasingComboBoxx->currentIndex() == Engine::AntiAliasing_Light)
- antiAliasingComboBoxx->setCurrentIndex(Engine::AntiAliasing_Normal);
+ if (antiAliasingComboBoxx_->currentIndex() == Engine::AntiAliasing_Light)
+ antiAliasingComboBoxx_->setCurrentIndex(Engine::AntiAliasing_Normal);
}
drawGlyph();
@@ -354,19 +354,19 @@ MainGUI::checkAutoHinting()
void
MainGUI::checkAntiAliasing()
{
- int index = antiAliasingComboBoxx->currentIndex();
+ int index = antiAliasingComboBoxx_->currentIndex();
if (index == Engine::AntiAliasing_None
|| index == Engine::AntiAliasing_Normal
|| index == Engine::AntiAliasing_Light)
{
- lcdFilterLabel->setEnabled(false);
- lcdFilterComboBox->setEnabled(false);
+ lcdFilterLabel_->setEnabled(false);
+ lcdFilterComboBox_->setEnabled(false);
}
else
{
- lcdFilterLabel->setEnabled(true);
- lcdFilterComboBox->setEnabled(true);
+ lcdFilterLabel_->setEnabled(true);
+ lcdFilterComboBox_->setEnabled(true);
}
drawGlyph();
@@ -376,18 +376,18 @@ MainGUI::checkAntiAliasing()
void
MainGUI::checkLcdFilter()
{
- int index = lcdFilterComboBox->currentIndex();
- engine->setLcdFilter(lcdFilterHash.key(index));
+ int index = lcdFilterComboBox_->currentIndex();
+ engine_->setLcdFilter(lcdFilterHash_.key(index));
}
void
MainGUI::checkShowPoints()
{
- if (showPointsCheckBox->isChecked())
- showPointNumbersCheckBox->setEnabled(true);
+ if (showPointsCheckBox_->isChecked())
+ showPointNumbersCheckBox_->setEnabled(true);
else
- showPointNumbersCheckBox->setEnabled(false);
+ showPointNumbersCheckBox_->setEnabled(false);
drawGlyph();
}
@@ -396,20 +396,20 @@ MainGUI::checkShowPoints()
void
MainGUI::checkUnits()
{
- int index = unitsComboBox->currentIndex();
+ int index = unitsComboBox_->currentIndex();
if (index == Units_px)
{
- dpiLabel->setEnabled(false);
- dpiSpinBox->setEnabled(false);
- sizeDoubleSpinBox->setSingleStep(1);
- sizeDoubleSpinBox->setValue(qRound(sizeDoubleSpinBox->value()));
+ dpiLabel_->setEnabled(false);
+ dpiSpinBox_->setEnabled(false);
+ sizeDoubleSpinBox_->setSingleStep(1);
+ sizeDoubleSpinBox_->setValue(qRound(sizeDoubleSpinBox_->value()));
}
else
{
- dpiLabel->setEnabled(true);
- dpiSpinBox->setEnabled(true);
- sizeDoubleSpinBox->setSingleStep(0.5);
+ dpiLabel_->setEnabled(true);
+ dpiSpinBox_->setEnabled(true);
+ sizeDoubleSpinBox_->setSingleStep(0.5);
}
drawGlyph();
@@ -420,19 +420,19 @@ void
MainGUI::adjustGlyphIndex(int delta)
{
// only adjust current glyph index if we have a valid font
- if (currentNumberOfGlyphs > 0)
+ if (currentNumberOfGlyphs_ > 0)
{
- currentGlyphIndex += delta;
- currentGlyphIndex = qBound(0,
- currentGlyphIndex,
- currentNumberOfGlyphs - 1);
+ currentGlyphIndex_ += delta;
+ currentGlyphIndex_ = qBound(0,
+ currentGlyphIndex_,
+ currentNumberOfGlyphs_ - 1);
}
- QString upperHex = QString::number(currentGlyphIndex, 16).toUpper();
- glyphIndexLabel->setText(QString("%1 (0x%2)")
- .arg(currentGlyphIndex)
+ QString upperHex = QString::number(currentGlyphIndex_, 16).toUpper();
+ glyphIndexLabel_->setText(QString("%1 (0x%2)")
+ .arg(currentGlyphIndex_)
.arg(upperHex));
- glyphNameLabel->setText(engine->glyphName(currentGlyphIndex));
+ glyphNameLabel_->setText(engine_->glyphName(currentGlyphIndex_));
drawGlyph();
}
@@ -441,25 +441,25 @@ MainGUI::adjustGlyphIndex(int delta)
void
MainGUI::checkCurrentFontIndex()
{
- if (engine->numberOfOpenedFonts() < 2)
+ if (engine_->numberOfOpenedFonts() < 2)
{
- previousFontButton->setEnabled(false);
- nextFontButton->setEnabled(false);
+ previousFontButton_->setEnabled(false);
+ nextFontButton_->setEnabled(false);
}
- else if (currentFontIndex == 0)
+ else if (currentFontIndex_ == 0)
{
- previousFontButton->setEnabled(false);
- nextFontButton->setEnabled(true);
+ previousFontButton_->setEnabled(false);
+ nextFontButton_->setEnabled(true);
}
- else if (currentFontIndex >= engine->numberOfOpenedFonts() - 1)
+ else if (currentFontIndex_ >= engine_->numberOfOpenedFonts() - 1)
{
- previousFontButton->setEnabled(true);
- nextFontButton->setEnabled(false);
+ previousFontButton_->setEnabled(true);
+ nextFontButton_->setEnabled(false);
}
else
{
- previousFontButton->setEnabled(true);
- nextFontButton->setEnabled(true);
+ previousFontButton_->setEnabled(true);
+ nextFontButton_->setEnabled(true);
}
}
@@ -467,25 +467,25 @@ MainGUI::checkCurrentFontIndex()
void
MainGUI::checkCurrentFaceIndex()
{
- if (currentNumberOfFaces < 2)
+ if (currentNumberOfFaces_ < 2)
{
- previousFaceButton->setEnabled(false);
- nextFaceButton->setEnabled(false);
+ previousFaceButton_->setEnabled(false);
+ nextFaceButton_->setEnabled(false);
}
- else if (currentFaceIndex == 0)
+ else if (currentFaceIndex_ == 0)
{
- previousFaceButton->setEnabled(false);
- nextFaceButton->setEnabled(true);
+ previousFaceButton_->setEnabled(false);
+ nextFaceButton_->setEnabled(true);
}
- else if (currentFaceIndex >= currentNumberOfFaces - 1)
+ else if (currentFaceIndex_ >= currentNumberOfFaces_ - 1)
{
- previousFaceButton->setEnabled(true);
- nextFaceButton->setEnabled(false);
+ previousFaceButton_->setEnabled(true);
+ nextFaceButton_->setEnabled(false);
}
else
{
- previousFaceButton->setEnabled(true);
- nextFaceButton->setEnabled(true);
+ previousFaceButton_->setEnabled(true);
+ nextFaceButton_->setEnabled(true);
}
}
@@ -493,25 +493,25 @@ MainGUI::checkCurrentFaceIndex()
void
MainGUI::checkCurrentNamedInstanceIndex()
{
- if (currentNumberOfNamedInstances < 2)
+ if (currentNumberOfNamedInstances_ < 2)
{
- previousNamedInstanceButton->setEnabled(false);
- nextNamedInstanceButton->setEnabled(false);
+ previousNamedInstanceButton_->setEnabled(false);
+ nextNamedInstanceButton_->setEnabled(false);
}
- else if (currentNamedInstanceIndex == 0)
+ else if (currentNamedInstanceIndex_ == 0)
{
- previousNamedInstanceButton->setEnabled(false);
- nextNamedInstanceButton->setEnabled(true);
+ previousNamedInstanceButton_->setEnabled(false);
+ nextNamedInstanceButton_->setEnabled(true);
}
- else if (currentNamedInstanceIndex >= currentNumberOfNamedInstances - 1)
+ else if (currentNamedInstanceIndex_ >= currentNumberOfNamedInstances_ - 1)
{
- previousNamedInstanceButton->setEnabled(true);
- nextNamedInstanceButton->setEnabled(false);
+ previousNamedInstanceButton_->setEnabled(true);
+ nextNamedInstanceButton_->setEnabled(false);
}
else
{
- previousNamedInstanceButton->setEnabled(true);
- nextNamedInstanceButton->setEnabled(true);
+ previousNamedInstanceButton_->setEnabled(true);
+ nextNamedInstanceButton_->setEnabled(true);
}
}
@@ -519,11 +519,11 @@ MainGUI::checkCurrentNamedInstanceIndex()
void
MainGUI::previousFont()
{
- if (currentFontIndex > 0)
+ if (currentFontIndex_ > 0)
{
- currentFontIndex--;
- currentFaceIndex = 0;
- currentNamedInstanceIndex = 0;
+ currentFontIndex_--;
+ currentFaceIndex_ = 0;
+ currentNamedInstanceIndex_ = 0;
showFont();
}
}
@@ -532,11 +532,11 @@ MainGUI::previousFont()
void
MainGUI::nextFont()
{
- if (currentFontIndex < engine->numberOfOpenedFonts() - 1)
+ if (currentFontIndex_ < engine_->numberOfOpenedFonts() - 1)
{
- currentFontIndex++;
- currentFaceIndex = 0;
- currentNamedInstanceIndex = 0;
+ currentFontIndex_++;
+ currentFaceIndex_ = 0;
+ currentNamedInstanceIndex_ = 0;
showFont();
}
}
@@ -545,10 +545,10 @@ MainGUI::nextFont()
void
MainGUI::previousFace()
{
- if (currentFaceIndex > 0)
+ if (currentFaceIndex_ > 0)
{
- currentFaceIndex--;
- currentNamedInstanceIndex = 0;
+ currentFaceIndex_--;
+ currentNamedInstanceIndex_ = 0;
showFont();
}
}
@@ -557,10 +557,10 @@ MainGUI::previousFace()
void
MainGUI::nextFace()
{
- if (currentFaceIndex < currentNumberOfFaces - 1)
+ if (currentFaceIndex_ < currentNumberOfFaces_ - 1)
{
- currentFaceIndex++;
- currentNamedInstanceIndex = 0;
+ currentFaceIndex_++;
+ currentNamedInstanceIndex_ = 0;
showFont();
}
}
@@ -569,9 +569,9 @@ MainGUI::nextFace()
void
MainGUI::previousNamedInstance()
{
- if (currentNamedInstanceIndex > 0)
+ if (currentNamedInstanceIndex_ > 0)
{
- currentNamedInstanceIndex--;
+ currentNamedInstanceIndex_--;
showFont();
}
}
@@ -580,9 +580,9 @@ MainGUI::previousNamedInstance()
void
MainGUI::nextNamedInstance()
{
- if (currentNamedInstanceIndex < currentNumberOfNamedInstances - 1)
+ if (currentNamedInstanceIndex_ < currentNumberOfNamedInstances_ - 1)
{
- currentNamedInstanceIndex++;
+ currentNamedInstanceIndex_++;
showFont();
}
}
@@ -591,7 +591,7 @@ MainGUI::nextNamedInstance()
void
MainGUI::zoom()
{
- int scale = zoomSpinBox->value();
+ int scale = zoomSpinBox_->value();
QTransform transform;
transform.scale(scale, scale);
@@ -602,7 +602,7 @@ MainGUI::zoom()
qreal shift = 0.5 / scale;
transform.translate(shift, shift);
- glyphView->setTransform(transform);
+ glyphView_->setTransform(transform);
}
@@ -611,28 +611,28 @@ MainGUI::setGraphicsDefaults()
{
// color tables (with suitable opacity values) for converting
// FreeType's pixmaps to something Qt understands
- monoColorTable.append(QColor(Qt::transparent).rgba());
- monoColorTable.append(QColor(Qt::black).rgba());
+ monoColorTable_.append(QColor(Qt::transparent).rgba());
+ monoColorTable_.append(QColor(Qt::black).rgba());
for (int i = 0xFF; i >= 0; i--)
- grayColorTable.append(qRgba(i, i, i, 0xFF - i));
+ grayColorTable_.append(qRgba(i, i, i, 0xFF - i));
// XXX make this user-configurable
- axisPen.setColor(Qt::black);
- axisPen.setWidth(0);
- blueZonePen.setColor(QColor(64, 64, 255, 64)); // light blue
- blueZonePen.setWidth(0);
- gridPen.setColor(Qt::lightGray);
- gridPen.setWidth(0);
- offPen.setColor(Qt::darkGreen);
- offPen.setWidth(3);
- onPen.setColor(Qt::red);
- onPen.setWidth(3);
- outlinePen.setColor(Qt::red);
- outlinePen.setWidth(0);
- segmentPen.setColor(QColor(64, 255, 128, 64)); // light green
- segmentPen.setWidth(0);
+ axisPen_.setColor(Qt::black);
+ axisPen_.setWidth(0);
+ blueZonePen_.setColor(QColor(64, 64, 255, 64)); // light blue
+ blueZonePen_.setWidth(0);
+ gridPen_.setColor(Qt::lightGray);
+ gridPen_.setWidth(0);
+ offPen_.setColor(Qt::darkGreen);
+ offPen_.setWidth(3);
+ onPen_.setColor(Qt::red);
+ onPen_.setWidth(3);
+ outlinePen_.setColor(Qt::red);
+ outlinePen_.setWidth(0);
+ segmentPen_.setColor(QColor(64, 255, 128, 64)); // light green
+ segmentPen_.setWidth(0);
}
@@ -641,82 +641,82 @@ MainGUI::drawGlyph()
{
// the call to `engine->loadOutline' updates FreeType's load flags
- if (!engine)
+ if (!engine_)
return;
- if (currentGlyphBitmapItem)
+ if (currentGlyphBitmapItem_)
{
- glyphScene->removeItem(currentGlyphBitmapItem);
- delete currentGlyphBitmapItem;
+ glyphScene_->removeItem(currentGlyphBitmapItem_);
+ delete currentGlyphBitmapItem_;
- currentGlyphBitmapItem = NULL;
+ currentGlyphBitmapItem_ = NULL;
}
- if (currentGlyphOutlineItem)
+ if (currentGlyphOutlineItem_)
{
- glyphScene->removeItem(currentGlyphOutlineItem);
- delete currentGlyphOutlineItem;
+ glyphScene_->removeItem(currentGlyphOutlineItem_);
+ delete currentGlyphOutlineItem_;
- currentGlyphOutlineItem = NULL;
+ currentGlyphOutlineItem_ = NULL;
}
- if (currentGlyphPointsItem)
+ if (currentGlyphPointsItem_)
{
- glyphScene->removeItem(currentGlyphPointsItem);
- delete currentGlyphPointsItem;
+ glyphScene_->removeItem(currentGlyphPointsItem_);
+ delete currentGlyphPointsItem_;
- currentGlyphPointsItem = NULL;
+ currentGlyphPointsItem_ = NULL;
}
- if (currentGlyphPointNumbersItem)
+ if (currentGlyphPointNumbersItem_)
{
- glyphScene->removeItem(currentGlyphPointNumbersItem);
- delete currentGlyphPointNumbersItem;
+ glyphScene_->removeItem(currentGlyphPointNumbersItem_);
+ delete currentGlyphPointNumbersItem_;
- currentGlyphPointNumbersItem = NULL;
+ currentGlyphPointNumbersItem_ = NULL;
}
applySettings();
- FT_Outline* outline = engine->loadOutline(currentGlyphIndex);
+ FT_Outline* outline = engine_->loadOutline(currentGlyphIndex_);
if (outline)
{
- if (showBitmapCheckBox->isChecked())
+ if (showBitmapCheckBox_->isChecked())
{
// XXX support LCD
FT_Pixel_Mode pixelMode = FT_PIXEL_MODE_GRAY;
- if (antiAliasingComboBoxx->currentIndex() == Engine::AntiAliasing_None)
+ if (antiAliasingComboBoxx_->currentIndex() == Engine::AntiAliasing_None)
pixelMode = FT_PIXEL_MODE_MONO;
- currentGlyphBitmapItem = new GlyphBitmap(outline,
- engine->ftLibrary(),
+ currentGlyphBitmapItem_ = new GlyphBitmap(outline,
+ engine_->ftLibrary(),
pixelMode,
- monoColorTable,
- grayColorTable);
- glyphScene->addItem(currentGlyphBitmapItem);
+ monoColorTable_,
+ grayColorTable_);
+ glyphScene_->addItem(currentGlyphBitmapItem_);
}
- if (showOutlinesCheckBox->isChecked())
+ if (showOutlinesCheckBox_->isChecked())
{
- currentGlyphOutlineItem = new GlyphOutline(outlinePen, outline);
- glyphScene->addItem(currentGlyphOutlineItem);
+ currentGlyphOutlineItem_ = new GlyphOutline(outlinePen_, outline);
+ glyphScene_->addItem(currentGlyphOutlineItem_);
}
- if (showPointsCheckBox->isChecked())
+ if (showPointsCheckBox_->isChecked())
{
- currentGlyphPointsItem = new GlyphPoints(onPen, offPen, outline);
- glyphScene->addItem(currentGlyphPointsItem);
+ currentGlyphPointsItem_ = new GlyphPoints(onPen_, offPen_, outline);
+ glyphScene_->addItem(currentGlyphPointsItem_);
- if (showPointNumbersCheckBox->isChecked())
+ if (showPointNumbersCheckBox_->isChecked())
{
- currentGlyphPointNumbersItem = new GlyphPointNumbers(onPen,
- offPen,
+ currentGlyphPointNumbersItem_ = new GlyphPointNumbers(onPen_,
+ offPen_,
outline);
- glyphScene->addItem(currentGlyphPointNumbersItem);
+ glyphScene_->addItem(currentGlyphPointNumbersItem_);
}
}
}
- glyphScene->update();
+ glyphScene_->update();
}
@@ -726,308 +726,308 @@ void
MainGUI::createLayout()
{
// left side
- fontFilenameLabel = new QLabel;
+ fontFilenameLabel_ = new QLabel;
- hintingCheckBox = new QCheckBox(tr("Hinting"));
+ hintingCheckBox_ = new QCheckBox(tr("Hinting"));
- hintingModeLabel = new QLabel(tr("Hinting Mode"));
- hintingModeLabel->setAlignment(Qt::AlignRight);
- hintingModeComboBoxx = new QComboBoxx;
- hintingModeComboBoxx->insertItem(HintingMode_TrueType_v35,
+ hintingModeLabel_ = new QLabel(tr("Hinting Mode"));
+ hintingModeLabel_->setAlignment(Qt::AlignRight);
+ hintingModeComboBoxx_ = new QComboBoxx;
+ hintingModeComboBoxx_->insertItem(HintingMode_TrueType_v35,
tr("TrueType v35"));
- hintingModeComboBoxx->insertItem(HintingMode_TrueType_v38,
+ hintingModeComboBoxx_->insertItem(HintingMode_TrueType_v38,
tr("TrueType v38"));
- hintingModeComboBoxx->insertItem(HintingMode_TrueType_v40,
+ hintingModeComboBoxx_->insertItem(HintingMode_TrueType_v40,
tr("TrueType v40"));
- hintingModeComboBoxx->insertItem(HintingMode_CFF_FreeType,
+ hintingModeComboBoxx_->insertItem(HintingMode_CFF_FreeType,
tr("CFF (FreeType)"));
- hintingModeComboBoxx->insertItem(HintingMode_CFF_Adobe,
+ hintingModeComboBoxx_->insertItem(HintingMode_CFF_Adobe,
tr("CFF (Adobe)"));
- hintingModeLabel->setBuddy(hintingModeComboBoxx);
-
- autoHintingCheckBox = new QCheckBox(tr("Auto-Hinting"));
- horizontalHintingCheckBox = new QCheckBox(tr("Horizontal Hinting"));
- verticalHintingCheckBox = new QCheckBox(tr("Vertical Hinting"));
- blueZoneHintingCheckBox = new QCheckBox(tr("Blue-Zone Hinting"));
- segmentDrawingCheckBox = new QCheckBox(tr("Segment Drawing"));
-
- antiAliasingLabel = new QLabel(tr("Anti-Aliasing"));
- antiAliasingLabel->setAlignment(Qt::AlignRight);
- antiAliasingComboBoxx = new QComboBoxx;
- antiAliasingComboBoxx->insertItem(Engine::AntiAliasing_None,
+ hintingModeLabel_->setBuddy(hintingModeComboBoxx_);
+
+ autoHintingCheckBox_ = new QCheckBox(tr("Auto-Hinting"));
+ horizontalHintingCheckBox_ = new QCheckBox(tr("Horizontal Hinting"));
+ verticalHintingCheckBox_ = new QCheckBox(tr("Vertical Hinting"));
+ blueZoneHintingCheckBox_ = new QCheckBox(tr("Blue-Zone Hinting"));
+ segmentDrawingCheckBox_ = new QCheckBox(tr("Segment Drawing"));
+
+ antiAliasingLabel_ = new QLabel(tr("Anti-Aliasing"));
+ antiAliasingLabel_->setAlignment(Qt::AlignRight);
+ antiAliasingComboBoxx_ = new QComboBoxx;
+ antiAliasingComboBoxx_->insertItem(Engine::AntiAliasing_None,
tr("None"));
- antiAliasingComboBoxx->insertItem(Engine::AntiAliasing_Normal,
+ antiAliasingComboBoxx_->insertItem(Engine::AntiAliasing_Normal,
tr("Normal"));
- antiAliasingComboBoxx->insertItem(Engine::AntiAliasing_Light,
+ antiAliasingComboBoxx_->insertItem(Engine::AntiAliasing_Light,
tr("Light"));
- antiAliasingComboBoxx->insertItem(Engine::AntiAliasing_LCD,
+ antiAliasingComboBoxx_->insertItem(Engine::AntiAliasing_LCD,
tr("LCD (RGB)"));
- antiAliasingComboBoxx->insertItem(Engine::AntiAliasing_LCD_BGR,
+ antiAliasingComboBoxx_->insertItem(Engine::AntiAliasing_LCD_BGR,
tr("LCD (BGR)"));
- antiAliasingComboBoxx->insertItem(Engine::AntiAliasing_LCD_Vertical,
+ antiAliasingComboBoxx_->insertItem(Engine::AntiAliasing_LCD_Vertical,
tr("LCD (vert. RGB)"));
- antiAliasingComboBoxx->insertItem(Engine::AntiAliasing_LCD_Vertical_BGR,
+ antiAliasingComboBoxx_->insertItem(Engine::AntiAliasing_LCD_Vertical_BGR,
tr("LCD (vert. BGR)"));
- antiAliasingLabel->setBuddy(antiAliasingComboBoxx);
+ antiAliasingLabel_->setBuddy(antiAliasingComboBoxx_);
- lcdFilterLabel = new QLabel(tr("LCD Filter"));
- lcdFilterLabel->setAlignment(Qt::AlignRight);
- lcdFilterComboBox = new QComboBox;
- lcdFilterComboBox->insertItem(LCDFilter_Default, tr("Default"));
- lcdFilterComboBox->insertItem(LCDFilter_Light, tr("Light"));
- lcdFilterComboBox->insertItem(LCDFilter_None, tr("None"));
- lcdFilterComboBox->insertItem(LCDFilter_Legacy, tr("Legacy"));
- lcdFilterLabel->setBuddy(lcdFilterComboBox);
+ lcdFilterLabel_ = new QLabel(tr("LCD Filter"));
+ lcdFilterLabel_->setAlignment(Qt::AlignRight);
+ lcdFilterComboBox_ = new QComboBox;
+ lcdFilterComboBox_->insertItem(LCDFilter_Default, tr("Default"));
+ lcdFilterComboBox_->insertItem(LCDFilter_Light, tr("Light"));
+ lcdFilterComboBox_->insertItem(LCDFilter_None, tr("None"));
+ lcdFilterComboBox_->insertItem(LCDFilter_Legacy, tr("Legacy"));
+ lcdFilterLabel_->setBuddy(lcdFilterComboBox_);
int width;
// make all labels have the same width
- width = hintingModeLabel->minimumSizeHint().width();
- width = qMax(antiAliasingLabel->minimumSizeHint().width(), width);
- width = qMax(lcdFilterLabel->minimumSizeHint().width(), width);
- hintingModeLabel->setMinimumWidth(width);
- antiAliasingLabel->setMinimumWidth(width);
- lcdFilterLabel->setMinimumWidth(width);
+ width = hintingModeLabel_->minimumSizeHint().width();
+ width = qMax(antiAliasingLabel_->minimumSizeHint().width(), width);
+ width = qMax(lcdFilterLabel_->minimumSizeHint().width(), width);
+ hintingModeLabel_->setMinimumWidth(width);
+ antiAliasingLabel_->setMinimumWidth(width);
+ lcdFilterLabel_->setMinimumWidth(width);
// ensure that all items in combo boxes fit completely;
// also make all combo boxes have the same width
- width = hintingModeComboBoxx->minimumSizeHint().width();
- width = qMax(antiAliasingComboBoxx->minimumSizeHint().width(), width);
- width = qMax(lcdFilterComboBox->minimumSizeHint().width(), width);
- hintingModeComboBoxx->setMinimumWidth(width);
- antiAliasingComboBoxx->setMinimumWidth(width);
- lcdFilterComboBox->setMinimumWidth(width);
-
- gammaLabel = new QLabel(tr("Gamma"));
- gammaLabel->setAlignment(Qt::AlignRight);
- gammaSlider = new QSlider(Qt::Horizontal);
- gammaSlider->setRange(0, 30); // in 1/10th
- gammaSlider->setTickPosition(QSlider::TicksBelow);
- gammaSlider->setTickInterval(5);
- gammaLabel->setBuddy(gammaSlider);
-
- showBitmapCheckBox = new QCheckBox(tr("Show Bitmap"));
- showPointsCheckBox = new QCheckBox(tr("Show Points"));
- showPointNumbersCheckBox = new QCheckBox(tr("Show Point Numbers"));
- showOutlinesCheckBox = new QCheckBox(tr("Show Outlines"));
-
- infoLeftLayout = new QHBoxLayout;
- infoLeftLayout->addWidget(fontFilenameLabel);
-
- hintingModeLayout = new QHBoxLayout;
- hintingModeLayout->addWidget(hintingModeLabel);
- hintingModeLayout->addWidget(hintingModeComboBoxx);
-
- horizontalHintingLayout = new QHBoxLayout;
- horizontalHintingLayout->addSpacing(20); // XXX px
- horizontalHintingLayout->addWidget(horizontalHintingCheckBox);
-
- verticalHintingLayout = new QHBoxLayout;
- verticalHintingLayout->addSpacing(20); // XXX px
- verticalHintingLayout->addWidget(verticalHintingCheckBox);
-
- blueZoneHintingLayout = new QHBoxLayout;
- blueZoneHintingLayout->addSpacing(20); // XXX px
- blueZoneHintingLayout->addWidget(blueZoneHintingCheckBox);
-
- segmentDrawingLayout = new QHBoxLayout;
- segmentDrawingLayout->addSpacing(20); // XXX px
- segmentDrawingLayout->addWidget(segmentDrawingCheckBox);
-
- antiAliasingLayout = new QHBoxLayout;
- antiAliasingLayout->addWidget(antiAliasingLabel);
- antiAliasingLayout->addWidget(antiAliasingComboBoxx);
-
- lcdFilterLayout = new QHBoxLayout;
- lcdFilterLayout->addWidget(lcdFilterLabel);
- lcdFilterLayout->addWidget(lcdFilterComboBox);
-
- gammaLayout = new QHBoxLayout;
- gammaLayout->addWidget(gammaLabel);
- gammaLayout->addWidget(gammaSlider);
-
- pointNumbersLayout = new QHBoxLayout;
- pointNumbersLayout->addSpacing(20); // XXX px
- pointNumbersLayout->addWidget(showPointNumbersCheckBox);
-
- generalTabLayout = new QVBoxLayout;
- generalTabLayout->addWidget(hintingCheckBox);
- generalTabLayout->addLayout(hintingModeLayout);
- generalTabLayout->addWidget(autoHintingCheckBox);
- generalTabLayout->addLayout(horizontalHintingLayout);
- generalTabLayout->addLayout(verticalHintingLayout);
- generalTabLayout->addLayout(blueZoneHintingLayout);
- generalTabLayout->addLayout(segmentDrawingLayout);
- generalTabLayout->addSpacing(20); // XXX px
- generalTabLayout->addStretch(1);
- generalTabLayout->addLayout(antiAliasingLayout);
- generalTabLayout->addLayout(lcdFilterLayout);
- generalTabLayout->addSpacing(20); // XXX px
- generalTabLayout->addStretch(1);
- generalTabLayout->addLayout(gammaLayout);
- generalTabLayout->addSpacing(20); // XXX px
- generalTabLayout->addStretch(1);
- generalTabLayout->addWidget(showBitmapCheckBox);
- generalTabLayout->addWidget(showPointsCheckBox);
- generalTabLayout->addLayout(pointNumbersLayout);
- generalTabLayout->addWidget(showOutlinesCheckBox);
-
- generalTabWidget = new QWidget;
- generalTabWidget->setLayout(generalTabLayout);
-
- mmgxTabWidget = new QWidget;
-
- tabWidget = new QTabWidget;
- tabWidget->addTab(generalTabWidget, tr("General"));
- tabWidget->addTab(mmgxTabWidget, tr("MM/GX"));
-
- leftLayout = new QVBoxLayout;
- leftLayout->addLayout(infoLeftLayout);
- leftLayout->addWidget(tabWidget);
+ width = hintingModeComboBoxx_->minimumSizeHint().width();
+ width = qMax(antiAliasingComboBoxx_->minimumSizeHint().width(), width);
+ width = qMax(lcdFilterComboBox_->minimumSizeHint().width(), width);
+ hintingModeComboBoxx_->setMinimumWidth(width);
+ antiAliasingComboBoxx_->setMinimumWidth(width);
+ lcdFilterComboBox_->setMinimumWidth(width);
+
+ gammaLabel_ = new QLabel(tr("Gamma"));
+ gammaLabel_->setAlignment(Qt::AlignRight);
+ gammaSlider_ = new QSlider(Qt::Horizontal);
+ gammaSlider_->setRange(0, 30); // in 1/10th
+ gammaSlider_->setTickPosition(QSlider::TicksBelow);
+ gammaSlider_->setTickInterval(5);
+ gammaLabel_->setBuddy(gammaSlider_);
+
+ showBitmapCheckBox_ = new QCheckBox(tr("Show Bitmap"));
+ showPointsCheckBox_ = new QCheckBox(tr("Show Points"));
+ showPointNumbersCheckBox_ = new QCheckBox(tr("Show Point Numbers"));
+ showOutlinesCheckBox_ = new QCheckBox(tr("Show Outlines"));
+
+ infoLeftLayout_ = new QHBoxLayout;
+ infoLeftLayout_->addWidget(fontFilenameLabel_);
+
+ hintingModeLayout_ = new QHBoxLayout;
+ hintingModeLayout_->addWidget(hintingModeLabel_);
+ hintingModeLayout_->addWidget(hintingModeComboBoxx_);
+
+ horizontalHintingLayout_ = new QHBoxLayout;
+ horizontalHintingLayout_->addSpacing(20); // XXX px
+ horizontalHintingLayout_->addWidget(horizontalHintingCheckBox_);
+
+ verticalHintingLayout_ = new QHBoxLayout;
+ verticalHintingLayout_->addSpacing(20); // XXX px
+ verticalHintingLayout_->addWidget(verticalHintingCheckBox_);
+
+ blueZoneHintingLayout_ = new QHBoxLayout;
+ blueZoneHintingLayout_->addSpacing(20); // XXX px
+ blueZoneHintingLayout_->addWidget(blueZoneHintingCheckBox_);
+
+ segmentDrawingLayout_ = new QHBoxLayout;
+ segmentDrawingLayout_->addSpacing(20); // XXX px
+ segmentDrawingLayout_->addWidget(segmentDrawingCheckBox_);
+
+ antiAliasingLayout_ = new QHBoxLayout;
+ antiAliasingLayout_->addWidget(antiAliasingLabel_);
+ antiAliasingLayout_->addWidget(antiAliasingComboBoxx_);
+
+ lcdFilterLayout_ = new QHBoxLayout;
+ lcdFilterLayout_->addWidget(lcdFilterLabel_);
+ lcdFilterLayout_->addWidget(lcdFilterComboBox_);
+
+ gammaLayout_ = new QHBoxLayout;
+ gammaLayout_->addWidget(gammaLabel_);
+ gammaLayout_->addWidget(gammaSlider_);
+
+ pointNumbersLayout_ = new QHBoxLayout;
+ pointNumbersLayout_->addSpacing(20); // XXX px
+ pointNumbersLayout_->addWidget(showPointNumbersCheckBox_);
+
+ generalTabLayout_ = new QVBoxLayout;
+ generalTabLayout_->addWidget(hintingCheckBox_);
+ generalTabLayout_->addLayout(hintingModeLayout_);
+ generalTabLayout_->addWidget(autoHintingCheckBox_);
+ generalTabLayout_->addLayout(horizontalHintingLayout_);
+ generalTabLayout_->addLayout(verticalHintingLayout_);
+ generalTabLayout_->addLayout(blueZoneHintingLayout_);
+ generalTabLayout_->addLayout(segmentDrawingLayout_);
+ generalTabLayout_->addSpacing(20); // XXX px
+ generalTabLayout_->addStretch(1);
+ generalTabLayout_->addLayout(antiAliasingLayout_);
+ generalTabLayout_->addLayout(lcdFilterLayout_);
+ generalTabLayout_->addSpacing(20); // XXX px
+ generalTabLayout_->addStretch(1);
+ generalTabLayout_->addLayout(gammaLayout_);
+ generalTabLayout_->addSpacing(20); // XXX px
+ generalTabLayout_->addStretch(1);
+ generalTabLayout_->addWidget(showBitmapCheckBox_);
+ generalTabLayout_->addWidget(showPointsCheckBox_);
+ generalTabLayout_->addLayout(pointNumbersLayout_);
+ generalTabLayout_->addWidget(showOutlinesCheckBox_);
+
+ generalTabWidget_ = new QWidget;
+ generalTabWidget_->setLayout(generalTabLayout_);
+
+ mmgxTabWidget_ = new QWidget;
+
+ tabWidget_ = new QTabWidget;
+ tabWidget_->addTab(generalTabWidget_, tr("General"));
+ tabWidget_->addTab(mmgxTabWidget_, tr("MM/GX"));
+
+ leftLayout_ = new QVBoxLayout;
+ leftLayout_->addLayout(infoLeftLayout_);
+ leftLayout_->addWidget(tabWidget_);
// we don't want to expand the left side horizontally;
// to change the policy we have to use a widget wrapper
- leftWidget = new QWidget;
- leftWidget->setLayout(leftLayout);
+ leftWidget_ = new QWidget;
+ leftWidget_->setLayout(leftLayout_);
QSizePolicy leftWidgetPolicy(QSizePolicy::Fixed, QSizePolicy::Preferred);
leftWidgetPolicy.setHorizontalStretch(0);
-
leftWidgetPolicy.setVerticalPolicy(leftWidget->sizePolicy().verticalPolicy());
-
leftWidgetPolicy.setHeightForWidth(leftWidget->sizePolicy().hasHeightForWidth());
+
leftWidgetPolicy.setVerticalPolicy(leftWidget_->sizePolicy().verticalPolicy());
+
leftWidgetPolicy.setHeightForWidth(leftWidget_->sizePolicy().hasHeightForWidth());
- leftWidget->setSizePolicy(leftWidgetPolicy);
+ leftWidget_->setSizePolicy(leftWidgetPolicy);
// right side
- glyphIndexLabel = new QLabel;
- glyphNameLabel = new QLabel;
- fontNameLabel = new QLabel;
-
- glyphScene = new QGraphicsScene;
- glyphScene->addItem(new Grid(gridPen, axisPen));
-
- currentGlyphBitmapItem = NULL;
- currentGlyphOutlineItem = NULL;
- currentGlyphPointsItem = NULL;
- currentGlyphPointNumbersItem = NULL;
-
- glyphView = new QGraphicsViewx;
- glyphView->setRenderHint(QPainter::Antialiasing, true);
- glyphView->setDragMode(QGraphicsView::ScrollHandDrag);
- glyphView->setOptimizationFlags(QGraphicsView::DontSavePainterState);
- glyphView->setViewportUpdateMode(QGraphicsView::SmartViewportUpdate);
- glyphView->setTransformationAnchor(QGraphicsView::AnchorUnderMouse);
- glyphView->setScene(glyphScene);
-
- sizeLabel = new QLabel(tr("Size "));
- sizeLabel->setAlignment(Qt::AlignRight);
- sizeDoubleSpinBox = new QDoubleSpinBox;
- sizeDoubleSpinBox->setAlignment(Qt::AlignRight);
- sizeDoubleSpinBox->setDecimals(1);
- sizeDoubleSpinBox->setRange(1, 500);
- sizeLabel->setBuddy(sizeDoubleSpinBox);
-
- unitsComboBox = new QComboBox;
- unitsComboBox->insertItem(Units_px, "px");
- unitsComboBox->insertItem(Units_pt, "pt");
-
- dpiLabel = new QLabel(tr("DPI "));
- dpiLabel->setAlignment(Qt::AlignRight);
- dpiSpinBox = new QSpinBox;
- dpiSpinBox->setAlignment(Qt::AlignRight);
- dpiSpinBox->setRange(10, 600);
- dpiLabel->setBuddy(dpiSpinBox);
-
- toStartButtonx = new QPushButtonx("|<");
- toM1000Buttonx = new QPushButtonx("-1000");
- toM100Buttonx = new QPushButtonx("-100");
- toM10Buttonx = new QPushButtonx("-10");
- toM1Buttonx = new QPushButtonx("-1");
- toP1Buttonx = new QPushButtonx("+1");
- toP10Buttonx = new QPushButtonx("+10");
- toP100Buttonx = new QPushButtonx("+100");
- toP1000Buttonx = new QPushButtonx("+1000");
- toEndButtonx = new QPushButtonx(">|");
-
- zoomLabel = new QLabel(tr("Zoom Factor"));
- zoomLabel->setAlignment(Qt::AlignRight);
- zoomSpinBox = new QSpinBoxx;
- zoomSpinBox->setAlignment(Qt::AlignRight);
- zoomSpinBox->setRange(1, 1000 - 1000 % 64);
- zoomSpinBox->setKeyboardTracking(false);
- zoomLabel->setBuddy(zoomSpinBox);
-
- previousFontButton = new QPushButton(tr("Previous Font"));
- nextFontButton = new QPushButton(tr("Next Font"));
- previousFaceButton = new QPushButton(tr("Previous Face"));
- nextFaceButton = new QPushButton(tr("Next Face"));
- previousNamedInstanceButton = new QPushButton(tr("Previous Named Instance"));
- nextNamedInstanceButton = new QPushButton(tr("Next Named Instance"));
+ glyphIndexLabel_ = new QLabel;
+ glyphNameLabel_ = new QLabel;
+ fontNameLabel_ = new QLabel;
+
+ glyphScene_ = new QGraphicsScene;
+ glyphScene_->addItem(new Grid(gridPen_, axisPen_));
+
+ currentGlyphBitmapItem_ = NULL;
+ currentGlyphOutlineItem_ = NULL;
+ currentGlyphPointsItem_ = NULL;
+ currentGlyphPointNumbersItem_ = NULL;
+
+ glyphView_ = new QGraphicsViewx;
+ glyphView_->setRenderHint(QPainter::Antialiasing, true);
+ glyphView_->setDragMode(QGraphicsView::ScrollHandDrag);
+ glyphView_->setOptimizationFlags(QGraphicsView::DontSavePainterState);
+ glyphView_->setViewportUpdateMode(QGraphicsView::SmartViewportUpdate);
+ glyphView_->setTransformationAnchor(QGraphicsView::AnchorUnderMouse);
+ glyphView_->setScene(glyphScene_);
+
+ sizeLabel_ = new QLabel(tr("Size "));
+ sizeLabel_->setAlignment(Qt::AlignRight);
+ sizeDoubleSpinBox_ = new QDoubleSpinBox;
+ sizeDoubleSpinBox_->setAlignment(Qt::AlignRight);
+ sizeDoubleSpinBox_->setDecimals(1);
+ sizeDoubleSpinBox_->setRange(1, 500);
+ sizeLabel_->setBuddy(sizeDoubleSpinBox_);
+
+ unitsComboBox_ = new QComboBox;
+ unitsComboBox_->insertItem(Units_px, "px");
+ unitsComboBox_->insertItem(Units_pt, "pt");
+
+ dpiLabel_ = new QLabel(tr("DPI "));
+ dpiLabel_->setAlignment(Qt::AlignRight);
+ dpiSpinBox_ = new QSpinBox;
+ dpiSpinBox_->setAlignment(Qt::AlignRight);
+ dpiSpinBox_->setRange(10, 600);
+ dpiLabel_->setBuddy(dpiSpinBox_);
+
+ toStartButtonx_ = new QPushButtonx("|<");
+ toM1000Buttonx_ = new QPushButtonx("-1000");
+ toM100Buttonx_ = new QPushButtonx("-100");
+ toM10Buttonx_ = new QPushButtonx("-10");
+ toM1Buttonx_ = new QPushButtonx("-1");
+ toP1Buttonx_ = new QPushButtonx("+1");
+ toP10Buttonx_ = new QPushButtonx("+10");
+ toP100Buttonx_ = new QPushButtonx("+100");
+ toP1000Buttonx_ = new QPushButtonx("+1000");
+ toEndButtonx_ = new QPushButtonx(">|");
+
+ zoomLabel_ = new QLabel(tr("Zoom Factor"));
+ zoomLabel_->setAlignment(Qt::AlignRight);
+ zoomSpinBox_ = new QSpinBoxx;
+ zoomSpinBox_->setAlignment(Qt::AlignRight);
+ zoomSpinBox_->setRange(1, 1000 - 1000 % 64);
+ zoomSpinBox_->setKeyboardTracking(false);
+ zoomLabel_->setBuddy(zoomSpinBox_);
+
+ previousFontButton_ = new QPushButton(tr("Previous Font"));
+ nextFontButton_ = new QPushButton(tr("Next Font"));
+ previousFaceButton_ = new QPushButton(tr("Previous Face"));
+ nextFaceButton_ = new QPushButton(tr("Next Face"));
+ previousNamedInstanceButton_ = new QPushButton(tr("Previous Named
Instance"));
+ nextNamedInstanceButton_ = new QPushButton(tr("Next Named Instance"));
infoRightLayout = new QGridLayout;
- infoRightLayout->addWidget(glyphIndexLabel, 0, 0);
- infoRightLayout->addWidget(glyphNameLabel, 0, 1);
- infoRightLayout->addWidget(fontNameLabel, 0, 2);
-
- navigationLayout = new QHBoxLayout;
- navigationLayout->setSpacing(0);
- navigationLayout->addStretch(1);
- navigationLayout->addWidget(toStartButtonx);
- navigationLayout->addWidget(toM1000Buttonx);
- navigationLayout->addWidget(toM100Buttonx);
- navigationLayout->addWidget(toM10Buttonx);
- navigationLayout->addWidget(toM1Buttonx);
- navigationLayout->addWidget(toP1Buttonx);
- navigationLayout->addWidget(toP10Buttonx);
- navigationLayout->addWidget(toP100Buttonx);
- navigationLayout->addWidget(toP1000Buttonx);
- navigationLayout->addWidget(toEndButtonx);
- navigationLayout->addStretch(1);
-
- sizeLayout = new QHBoxLayout;
- sizeLayout->addStretch(2);
- sizeLayout->addWidget(sizeLabel);
- sizeLayout->addWidget(sizeDoubleSpinBox);
- sizeLayout->addWidget(unitsComboBox);
- sizeLayout->addStretch(1);
- sizeLayout->addWidget(dpiLabel);
- sizeLayout->addWidget(dpiSpinBox);
- sizeLayout->addStretch(1);
- sizeLayout->addWidget(zoomLabel);
- sizeLayout->addWidget(zoomSpinBox);
- sizeLayout->addStretch(2);
+ infoRightLayout->addWidget(glyphIndexLabel_, 0, 0);
+ infoRightLayout->addWidget(glyphNameLabel_, 0, 1);
+ infoRightLayout->addWidget(fontNameLabel_, 0, 2);
+
+ navigationLayout_ = new QHBoxLayout;
+ navigationLayout_->setSpacing(0);
+ navigationLayout_->addStretch(1);
+ navigationLayout_->addWidget(toStartButtonx_);
+ navigationLayout_->addWidget(toM1000Buttonx_);
+ navigationLayout_->addWidget(toM100Buttonx_);
+ navigationLayout_->addWidget(toM10Buttonx_);
+ navigationLayout_->addWidget(toM1Buttonx_);
+ navigationLayout_->addWidget(toP1Buttonx_);
+ navigationLayout_->addWidget(toP10Buttonx_);
+ navigationLayout_->addWidget(toP100Buttonx_);
+ navigationLayout_->addWidget(toP1000Buttonx_);
+ navigationLayout_->addWidget(toEndButtonx_);
+ navigationLayout_->addStretch(1);
+
+ sizeLayout_ = new QHBoxLayout;
+ sizeLayout_->addStretch(2);
+ sizeLayout_->addWidget(sizeLabel_);
+ sizeLayout_->addWidget(sizeDoubleSpinBox_);
+ sizeLayout_->addWidget(unitsComboBox_);
+ sizeLayout_->addStretch(1);
+ sizeLayout_->addWidget(dpiLabel_);
+ sizeLayout_->addWidget(dpiSpinBox_);
+ sizeLayout_->addStretch(1);
+ sizeLayout_->addWidget(zoomLabel_);
+ sizeLayout_->addWidget(zoomSpinBox_);
+ sizeLayout_->addStretch(2);
fontLayout = new QGridLayout;
fontLayout->setColumnStretch(0, 2);
- fontLayout->addWidget(nextFontButton, 0, 1);
- fontLayout->addWidget(previousFontButton, 1, 1);
+ fontLayout->addWidget(nextFontButton_, 0, 1);
+ fontLayout->addWidget(previousFontButton_, 1, 1);
fontLayout->setColumnStretch(2, 1);
- fontLayout->addWidget(nextFaceButton, 0, 3);
- fontLayout->addWidget(previousFaceButton, 1, 3);
+ fontLayout->addWidget(nextFaceButton_, 0, 3);
+ fontLayout->addWidget(previousFaceButton_, 1, 3);
fontLayout->setColumnStretch(4, 1);
- fontLayout->addWidget(nextNamedInstanceButton, 0, 5);
- fontLayout->addWidget(previousNamedInstanceButton, 1, 5);
+ fontLayout->addWidget(nextNamedInstanceButton_, 0, 5);
+ fontLayout->addWidget(previousNamedInstanceButton_, 1, 5);
fontLayout->setColumnStretch(6, 2);
- rightLayout = new QVBoxLayout;
- rightLayout->addLayout(infoRightLayout);
- rightLayout->addWidget(glyphView);
- rightLayout->addLayout(navigationLayout);
- rightLayout->addSpacing(10); // XXX px
- rightLayout->addLayout(sizeLayout);
- rightLayout->addSpacing(10); // XXX px
- rightLayout->addLayout(fontLayout);
+ rightLayout_ = new QVBoxLayout;
+ rightLayout_->addLayout(infoRightLayout);
+ rightLayout_->addWidget(glyphView_);
+ rightLayout_->addLayout(navigationLayout_);
+ rightLayout_->addSpacing(10); // XXX px
+ rightLayout_->addLayout(sizeLayout_);
+ rightLayout_->addSpacing(10); // XXX px
+ rightLayout_->addLayout(fontLayout);
// for symmetry with the left side use a widget also
- rightWidget = new QWidget;
- rightWidget->setLayout(rightLayout);
+ rightWidget_ = new QWidget;
+ rightWidget_->setLayout(rightLayout_);
// the whole thing
- ftinspectLayout = new QHBoxLayout;
- ftinspectLayout->addWidget(leftWidget);
- ftinspectLayout->addWidget(rightWidget);
+ ftinspectLayout_ = new QHBoxLayout;
+ ftinspectLayout_->addWidget(leftWidget_);
+ ftinspectLayout_->addWidget(rightWidget_);
- ftinspectWidget = new QWidget;
- ftinspectWidget->setLayout(ftinspectLayout);
- setCentralWidget(ftinspectWidget);
+ ftinspectWidget_ = new QWidget;
+ ftinspectWidget_->setLayout(ftinspectLayout_);
+ setCentralWidget(ftinspectWidget_);
setWindowTitle("ftinspect");
}
@@ -1035,125 +1035,125 @@ MainGUI::createLayout()
void
MainGUI::createConnections()
{
- connect(hintingCheckBox, SIGNAL(clicked()),
+ connect(hintingCheckBox_, SIGNAL(clicked()),
SLOT(checkHinting()));
- connect(hintingModeComboBoxx, SIGNAL(currentIndexChanged(int)),
+ connect(hintingModeComboBoxx_, SIGNAL(currentIndexChanged(int)),
SLOT(checkHintingMode()));
- connect(antiAliasingComboBoxx, SIGNAL(currentIndexChanged(int)),
+ connect(antiAliasingComboBoxx_, SIGNAL(currentIndexChanged(int)),
SLOT(checkAntiAliasing()));
- connect(lcdFilterComboBox, SIGNAL(currentIndexChanged(int)),
+ connect(lcdFilterComboBox_, SIGNAL(currentIndexChanged(int)),
SLOT(checkLcdFilter()));
- connect(autoHintingCheckBox, SIGNAL(clicked()),
+ connect(autoHintingCheckBox_, SIGNAL(clicked()),
SLOT(checkAutoHinting()));
- connect(showBitmapCheckBox, SIGNAL(clicked()),
+ connect(showBitmapCheckBox_, SIGNAL(clicked()),
SLOT(drawGlyph()));
- connect(showPointsCheckBox, SIGNAL(clicked()),
+ connect(showPointsCheckBox_, SIGNAL(clicked()),
SLOT(checkShowPoints()));
- connect(showPointNumbersCheckBox, SIGNAL(clicked()),
+ connect(showPointNumbersCheckBox_, SIGNAL(clicked()),
SLOT(drawGlyph()));
- connect(showOutlinesCheckBox, SIGNAL(clicked()),
+ connect(showOutlinesCheckBox_, SIGNAL(clicked()),
SLOT(drawGlyph()));
- connect(sizeDoubleSpinBox, SIGNAL(valueChanged(double)),
+ connect(sizeDoubleSpinBox_, SIGNAL(valueChanged(double)),
SLOT(drawGlyph()));
- connect(unitsComboBox, SIGNAL(currentIndexChanged(int)),
+ connect(unitsComboBox_, SIGNAL(currentIndexChanged(int)),
SLOT(checkUnits()));
- connect(dpiSpinBox, SIGNAL(valueChanged(int)),
+ connect(dpiSpinBox_, SIGNAL(valueChanged(int)),
SLOT(drawGlyph()));
- connect(zoomSpinBox, SIGNAL(valueChanged(int)),
+ connect(zoomSpinBox_, SIGNAL(valueChanged(int)),
SLOT(zoom()));
- connect(previousFontButton, SIGNAL(clicked()),
+ connect(previousFontButton_, SIGNAL(clicked()),
SLOT(previousFont()));
- connect(nextFontButton, SIGNAL(clicked()),
+ connect(nextFontButton_, SIGNAL(clicked()),
SLOT(nextFont()));
- connect(previousFaceButton, SIGNAL(clicked()),
+ connect(previousFaceButton_, SIGNAL(clicked()),
SLOT(previousFace()));
- connect(nextFaceButton, SIGNAL(clicked()),
+ connect(nextFaceButton_, SIGNAL(clicked()),
SLOT(nextFace()));
- connect(previousNamedInstanceButton, SIGNAL(clicked()),
+ connect(previousNamedInstanceButton_, SIGNAL(clicked()),
SLOT(previousNamedInstance()));
- connect(nextNamedInstanceButton, SIGNAL(clicked()),
+ connect(nextNamedInstanceButton_, SIGNAL(clicked()),
SLOT(nextNamedInstance()));
- glyphNavigationMapper = new QSignalMapper;
- connect(glyphNavigationMapper, SIGNAL(mapped(int)),
+ glyphNavigationMapper_ = new QSignalMapper;
+ connect(glyphNavigationMapper_, SIGNAL(mapped(int)),
SLOT(adjustGlyphIndex(int)));
- connect(toStartButtonx, SIGNAL(clicked()),
- glyphNavigationMapper, SLOT(map()));
- connect(toM1000Buttonx, SIGNAL(clicked()),
- glyphNavigationMapper, SLOT(map()));
- connect(toM100Buttonx, SIGNAL(clicked()),
- glyphNavigationMapper, SLOT(map()));
- connect(toM10Buttonx, SIGNAL(clicked()),
- glyphNavigationMapper, SLOT(map()));
- connect(toM1Buttonx, SIGNAL(clicked()),
- glyphNavigationMapper, SLOT(map()));
- connect(toP1Buttonx, SIGNAL(clicked()),
- glyphNavigationMapper, SLOT(map()));
- connect(toP10Buttonx, SIGNAL(clicked()),
- glyphNavigationMapper, SLOT(map()));
- connect(toP100Buttonx, SIGNAL(clicked()),
- glyphNavigationMapper, SLOT(map()));
- connect(toP1000Buttonx, SIGNAL(clicked()),
- glyphNavigationMapper, SLOT(map()));
- connect(toEndButtonx, SIGNAL(clicked()),
- glyphNavigationMapper, SLOT(map()));
-
- glyphNavigationMapper->setMapping(toStartButtonx, -0x10000);
- glyphNavigationMapper->setMapping(toM1000Buttonx, -1000);
- glyphNavigationMapper->setMapping(toM100Buttonx, -100);
- glyphNavigationMapper->setMapping(toM10Buttonx, -10);
- glyphNavigationMapper->setMapping(toM1Buttonx, -1);
- glyphNavigationMapper->setMapping(toP1Buttonx, 1);
- glyphNavigationMapper->setMapping(toP10Buttonx, 10);
- glyphNavigationMapper->setMapping(toP100Buttonx, 100);
- glyphNavigationMapper->setMapping(toP1000Buttonx, 1000);
- glyphNavigationMapper->setMapping(toEndButtonx, 0x10000);
-
- connect(&engine->fontFileManager(), &FontFileManager::currentFileChanged,
- this, &MainGUI::watchCurrentFont);
+ connect(toStartButtonx_, SIGNAL(clicked()),
+ glyphNavigationMapper_, SLOT(map()));
+ connect(toM1000Buttonx_, SIGNAL(clicked()),
+ glyphNavigationMapper_, SLOT(map()));
+ connect(toM100Buttonx_, SIGNAL(clicked()),
+ glyphNavigationMapper_, SLOT(map()));
+ connect(toM10Buttonx_, SIGNAL(clicked()),
+ glyphNavigationMapper_, SLOT(map()));
+ connect(toM1Buttonx_, SIGNAL(clicked()),
+ glyphNavigationMapper_, SLOT(map()));
+ connect(toP1Buttonx_, SIGNAL(clicked()),
+ glyphNavigationMapper_, SLOT(map()));
+ connect(toP10Buttonx_, SIGNAL(clicked()),
+ glyphNavigationMapper_, SLOT(map()));
+ connect(toP100Buttonx_, SIGNAL(clicked()),
+ glyphNavigationMapper_, SLOT(map()));
+ connect(toP1000Buttonx_, SIGNAL(clicked()),
+ glyphNavigationMapper_, SLOT(map()));
+ connect(toEndButtonx_, SIGNAL(clicked()),
+ glyphNavigationMapper_, SLOT(map()));
+
+ glyphNavigationMapper_->setMapping(toStartButtonx_, -0x10000);
+ glyphNavigationMapper_->setMapping(toM1000Buttonx_, -1000);
+ glyphNavigationMapper_->setMapping(toM100Buttonx_, -100);
+ glyphNavigationMapper_->setMapping(toM10Buttonx_, -10);
+ glyphNavigationMapper_->setMapping(toM1Buttonx_, -1);
+ glyphNavigationMapper_->setMapping(toP1Buttonx_, 1);
+ glyphNavigationMapper_->setMapping(toP10Buttonx_, 10);
+ glyphNavigationMapper_->setMapping(toP100Buttonx_, 100);
+ glyphNavigationMapper_->setMapping(toP1000Buttonx_, 1000);
+ glyphNavigationMapper_->setMapping(toEndButtonx_, 0x10000);
+
+ connect(&engine_->fontFileManager(), &FontFileManager::currentFileChanged,
+ this, &MainGUI::watchCurrentFont);
}
void
MainGUI::createActions()
{
- loadFontsAct = new QAction(tr("&Load Fonts"), this);
- loadFontsAct->setShortcuts(QKeySequence::Open);
- connect(loadFontsAct, SIGNAL(triggered()), SLOT(loadFonts()));
+ loadFontsAct_ = new QAction(tr("&Load Fonts"), this);
+ loadFontsAct_->setShortcuts(QKeySequence::Open);
+ connect(loadFontsAct_, SIGNAL(triggered()), SLOT(loadFonts()));
- closeFontAct = new QAction(tr("&Close Font"), this);
- closeFontAct->setShortcuts(QKeySequence::Close);
- connect(closeFontAct, SIGNAL(triggered()), SLOT(closeFont()));
+ closeFontAct_ = new QAction(tr("&Close Font"), this);
+ closeFontAct_->setShortcuts(QKeySequence::Close);
+ connect(closeFontAct_, SIGNAL(triggered()), SLOT(closeFont()));
- exitAct = new QAction(tr("E&xit"), this);
- exitAct->setShortcuts(QKeySequence::Quit);
- connect(exitAct, SIGNAL(triggered()), SLOT(close()));
+ exitAct_ = new QAction(tr("E&xit"), this);
+ exitAct_->setShortcuts(QKeySequence::Quit);
+ connect(exitAct_, SIGNAL(triggered()), SLOT(close()));
- aboutAct = new QAction(tr("&About"), this);
- connect(aboutAct, SIGNAL(triggered()), SLOT(about()));
+ aboutAct_ = new QAction(tr("&About"), this);
+ connect(aboutAct_, SIGNAL(triggered()), SLOT(about()));
- aboutQtAct = new QAction(tr("About &Qt"), this);
- connect(aboutQtAct, SIGNAL(triggered()), SLOT(aboutQt()));
+ aboutQtAct_ = new QAction(tr("About &Qt"), this);
+ connect(aboutQtAct_, SIGNAL(triggered()), SLOT(aboutQt()));
}
void
MainGUI::createMenus()
{
- menuFile = menuBar()->addMenu(tr("&File"));
- menuFile->addAction(loadFontsAct);
- menuFile->addAction(closeFontAct);
- menuFile->addAction(exitAct);
-
- menuHelp = menuBar()->addMenu(tr("&Help"));
- menuHelp->addAction(aboutAct);
- menuHelp->addAction(aboutQtAct);
+ menuFile_ = menuBar()->addMenu(tr("&File"));
+ menuFile_->addAction(loadFontsAct_);
+ menuFile_->addAction(closeFontAct_);
+ menuFile_->addAction(exitAct_);
+
+ menuHelp_ = menuBar()->addMenu(tr("&Help"));
+ menuHelp_->addAction(aboutAct_);
+ menuHelp_->addAction(aboutQtAct_);
}
@@ -1168,22 +1168,22 @@ void
MainGUI::setDefaults()
{
// set up mappings between property values and combo box indices
- hintingModesTrueTypeHash[TT_INTERPRETER_VERSION_35] =
HintingMode_TrueType_v35;
- hintingModesTrueTypeHash[TT_INTERPRETER_VERSION_38] =
HintingMode_TrueType_v38;
- hintingModesTrueTypeHash[TT_INTERPRETER_VERSION_40] =
HintingMode_TrueType_v40;
+ hintingModesTrueTypeHash_[TT_INTERPRETER_VERSION_35] =
HintingMode_TrueType_v35;
+ hintingModesTrueTypeHash_[TT_INTERPRETER_VERSION_38] =
HintingMode_TrueType_v38;
+ hintingModesTrueTypeHash_[TT_INTERPRETER_VERSION_40] =
HintingMode_TrueType_v40;
- hintingModesCFFHash[FT_HINTING_FREETYPE] = HintingMode_CFF_FreeType;
- hintingModesCFFHash[FT_HINTING_ADOBE] = HintingMode_CFF_Adobe;
+ hintingModesCFFHash_[FT_HINTING_FREETYPE] = HintingMode_CFF_FreeType;
+ hintingModesCFFHash_[FT_HINTING_ADOBE] = HintingMode_CFF_Adobe;
- lcdFilterHash[FT_LCD_FILTER_DEFAULT] = LCDFilter_Default;
- lcdFilterHash[FT_LCD_FILTER_LIGHT] = LCDFilter_Light;
- lcdFilterHash[FT_LCD_FILTER_NONE] = LCDFilter_None;
- lcdFilterHash[FT_LCD_FILTER_LEGACY] = LCDFilter_Legacy;
+ lcdFilterHash_[FT_LCD_FILTER_DEFAULT] = LCDFilter_Default;
+ lcdFilterHash_[FT_LCD_FILTER_LIGHT] = LCDFilter_Light;
+ lcdFilterHash_[FT_LCD_FILTER_NONE] = LCDFilter_None;
+ lcdFilterHash_[FT_LCD_FILTER_LEGACY] = LCDFilter_Legacy;
- Engine::EngineDefaultValues& defaults = engine->engineDefaults();
+ Engine::EngineDefaultValues& defaults = engine_->engineDefaults();
// make copies and remove existing elements...
- QHash<int, int> hmTTHash = hintingModesTrueTypeHash;
+ QHash<int, int> hmTTHash = hintingModesTrueTypeHash_;
if (hmTTHash.contains(defaults.ttInterpreterVersionDefault))
hmTTHash.remove(defaults.ttInterpreterVersionDefault);
if (hmTTHash.contains(defaults.ttInterpreterVersionOther))
@@ -1191,47 +1191,47 @@ MainGUI::setDefaults()
if (hmTTHash.contains(defaults.ttInterpreterVersionOther1))
hmTTHash.remove(defaults.ttInterpreterVersionOther1);
- QHash<int, int> hmCFFHash = hintingModesCFFHash;
+ QHash<int, int> hmCFFHash = hintingModesCFFHash_;
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();
- hintingModesAlwaysDisabled += hmCFFHash.values();
+ hintingModesAlwaysDisabled_ = hmTTHash.values();
+ hintingModesAlwaysDisabled_ += hmCFFHash.values();
- for (int i = 0; i < hintingModesAlwaysDisabled.size(); i++)
- hintingModeComboBoxx->setItemEnabled(hintingModesAlwaysDisabled[i],
+ for (int i = 0; i < hintingModesAlwaysDisabled_.size(); i++)
+ hintingModeComboBoxx_->setItemEnabled(hintingModesAlwaysDisabled_[i],
false);
// the next four values always non-negative
- currentFontIndex = 0;
- currentFaceIndex = 0;
- currentNamedInstanceIndex = 0;
- currentGlyphIndex = 0;
+ currentFontIndex_ = 0;
+ currentFaceIndex_ = 0;
+ currentNamedInstanceIndex_ = 0;
+ currentGlyphIndex_ = 0;
- currentCFFHintingMode
- = hintingModesCFFHash[defaults.cffHintingEngineDefault];
- currentTTInterpreterVersion
- = hintingModesTrueTypeHash[defaults.ttInterpreterVersionDefault];
+ currentCFFHintingMode_
+ = hintingModesCFFHash_[defaults.cffHintingEngineDefault];
+ currentTTInterpreterVersion_
+ = hintingModesTrueTypeHash_[defaults.ttInterpreterVersionDefault];
- hintingCheckBox->setChecked(true);
+ hintingCheckBox_->setChecked(true);
- antiAliasingComboBoxx->setCurrentIndex(Engine::AntiAliasing_Normal);
- lcdFilterComboBox->setCurrentIndex(LCDFilter_Light);
+ antiAliasingComboBoxx_->setCurrentIndex(Engine::AntiAliasing_Normal);
+ lcdFilterComboBox_->setCurrentIndex(LCDFilter_Light);
- horizontalHintingCheckBox->setChecked(true);
- verticalHintingCheckBox->setChecked(true);
- blueZoneHintingCheckBox->setChecked(true);
+ horizontalHintingCheckBox_->setChecked(true);
+ verticalHintingCheckBox_->setChecked(true);
+ blueZoneHintingCheckBox_->setChecked(true);
- showBitmapCheckBox->setChecked(true);
- showOutlinesCheckBox->setChecked(true);
+ showBitmapCheckBox_->setChecked(true);
+ showOutlinesCheckBox_->setChecked(true);
- gammaSlider->setValue(18); // 1.8
- sizeDoubleSpinBox->setValue(20);
- dpiSpinBox->setValue(96);
- zoomSpinBox->setValue(20);
+ gammaSlider_->setValue(18); // 1.8
+ sizeDoubleSpinBox_->setValue(20);
+ dpiSpinBox_->setValue(96);
+ zoomSpinBox_->setValue(20);
checkHinting();
checkHintingMode();
diff --git a/src/ftinspect/maingui.hpp b/src/ftinspect/maingui.hpp
index 4a08b51..e54d220 100644
--- a/src/ftinspect/maingui.hpp
+++ b/src/ftinspect/maingui.hpp
@@ -93,142 +93,142 @@ private slots:
void zoom();
private:
- Engine* engine;
+ Engine* engine_;
- int currentFontIndex;
+ int currentFontIndex_;
- long currentNumberOfFaces;
- long currentFaceIndex;
+ long currentNumberOfFaces_;
+ long currentFaceIndex_;
- int currentNumberOfNamedInstances;
- int currentNamedInstanceIndex;
+ int currentNumberOfNamedInstances_;
+ int currentNamedInstanceIndex_;
- int currentNumberOfGlyphs;
- int currentGlyphIndex;
+ int currentNumberOfGlyphs_;
+ int currentGlyphIndex_;
- int currentCFFHintingMode;
- int currentTTInterpreterVersion;
+ int currentCFFHintingMode_;
+ int currentTTInterpreterVersion_;
// layout related stuff
- GlyphOutline *currentGlyphOutlineItem;
- GlyphPoints *currentGlyphPointsItem;
- GlyphPointNumbers *currentGlyphPointNumbersItem;
- GlyphBitmap *currentGlyphBitmapItem;
-
- QAction *aboutAct;
- QAction *aboutQtAct;
- QAction *closeFontAct;
- QAction *exitAct;
- QAction *loadFontsAct;
-
- QCheckBox *autoHintingCheckBox;
- QCheckBox *blueZoneHintingCheckBox;
- QCheckBox *hintingCheckBox;
- QCheckBox *horizontalHintingCheckBox;
- QCheckBox *segmentDrawingCheckBox;
- QCheckBox *showBitmapCheckBox;
- QCheckBox *showOutlinesCheckBox;
- QCheckBox *showPointNumbersCheckBox;
- QCheckBox *showPointsCheckBox;
- QCheckBox *verticalHintingCheckBox;
-
- QComboBoxx *antiAliasingComboBoxx;
- QComboBoxx *hintingModeComboBoxx;
- QComboBox *lcdFilterComboBox;
- QComboBox *unitsComboBox;
-
- QDoubleSpinBox *sizeDoubleSpinBox;
-
- QGraphicsScene *glyphScene;
- QGraphicsViewx *glyphView;
+ GlyphOutline *currentGlyphOutlineItem_;
+ GlyphPoints *currentGlyphPointsItem_;
+ GlyphPointNumbers *currentGlyphPointNumbersItem_;
+ GlyphBitmap *currentGlyphBitmapItem_;
+
+ QAction *aboutAct_;
+ QAction *aboutQtAct_;
+ QAction *closeFontAct_;
+ QAction *exitAct_;
+ QAction *loadFontsAct_;
+
+ QCheckBox *autoHintingCheckBox_;
+ QCheckBox *blueZoneHintingCheckBox_;
+ QCheckBox *hintingCheckBox_;
+ QCheckBox *horizontalHintingCheckBox_;
+ QCheckBox *segmentDrawingCheckBox_;
+ QCheckBox *showBitmapCheckBox_;
+ QCheckBox *showOutlinesCheckBox_;
+ QCheckBox *showPointNumbersCheckBox_;
+ QCheckBox *showPointsCheckBox_;
+ QCheckBox *verticalHintingCheckBox_;
+
+ QComboBoxx *antiAliasingComboBoxx_;
+ QComboBoxx *hintingModeComboBoxx_;
+ QComboBox *lcdFilterComboBox_;
+ QComboBox *unitsComboBox_;
+
+ QDoubleSpinBox *sizeDoubleSpinBox_;
+
+ QGraphicsScene *glyphScene_;
+ QGraphicsViewx *glyphView_;
QGridLayout *fontLayout;
QGridLayout *infoRightLayout;
- QHash<int, int> hintingModesTrueTypeHash;
- QHash<int, int> hintingModesCFFHash;
- QHash<FT_LcdFilter, int> lcdFilterHash;
-
- QHBoxLayout *antiAliasingLayout;
- QHBoxLayout *blueZoneHintingLayout;
- QHBoxLayout *ftinspectLayout;
- QHBoxLayout *gammaLayout;
- QHBoxLayout *hintingModeLayout;
- QHBoxLayout *horizontalHintingLayout;
- QHBoxLayout *infoLeftLayout;
- QHBoxLayout *lcdFilterLayout;
- QHBoxLayout *navigationLayout;
- QHBoxLayout *pointNumbersLayout;
- QHBoxLayout *segmentDrawingLayout;
- QHBoxLayout *sizeLayout;
- QHBoxLayout *verticalHintingLayout;
-
- QLabel *antiAliasingLabel;
- QLabel *dpiLabel;
- QLabel *fontFilenameLabel;
- QLabel *fontNameLabel;
- QLabel *gammaLabel;
- QLabel *glyphIndexLabel;
- QLabel *glyphNameLabel;
- QLabel *hintingModeLabel;
- QLabel *lcdFilterLabel;
- QLabel *sizeLabel;
- QLabel *zoomLabel;
-
- QList<int> hintingModesAlwaysDisabled;
-
- QLocale *locale;
-
- QMenu *menuFile;
- QMenu *menuHelp;
-
- QPen axisPen;
- QPen blueZonePen;
- QPen gridPen;
- QPen offPen;
- QPen onPen;
- QPen outlinePen;
- QPen segmentPen;
-
- QPushButton *nextFaceButton;
- QPushButton *nextFontButton;
- QPushButton *nextNamedInstanceButton;
- QPushButton *previousFaceButton;
- QPushButton *previousFontButton;
- QPushButton *previousNamedInstanceButton;
-
- QPushButtonx *toEndButtonx;
- QPushButtonx *toM1000Buttonx;
- QPushButtonx *toM100Buttonx;
- QPushButtonx *toM10Buttonx;
- QPushButtonx *toM1Buttonx;
- QPushButtonx *toP1000Buttonx;
- QPushButtonx *toP100Buttonx;
- QPushButtonx *toP10Buttonx;
- QPushButtonx *toP1Buttonx;
- QPushButtonx *toStartButtonx;
-
- QSignalMapper *glyphNavigationMapper;
-
- QSlider *gammaSlider;
-
- QSpinBox *dpiSpinBox;
- QSpinBoxx *zoomSpinBox;
-
- QTabWidget *tabWidget;
-
- QVBoxLayout *generalTabLayout;
- QVBoxLayout *leftLayout;
- QVBoxLayout *rightLayout;
-
- QVector<QRgb> grayColorTable;
- QVector<QRgb> monoColorTable;
-
- QWidget *ftinspectWidget;
- QWidget *generalTabWidget;
- QWidget *leftWidget;
- QWidget *rightWidget;
- QWidget *mmgxTabWidget;
+ QHash<int, int> hintingModesTrueTypeHash_;
+ QHash<int, int> hintingModesCFFHash_;
+ QHash<FT_LcdFilter, int> lcdFilterHash_;
+
+ QHBoxLayout *antiAliasingLayout_;
+ QHBoxLayout *blueZoneHintingLayout_;
+ QHBoxLayout *ftinspectLayout_;
+ QHBoxLayout *gammaLayout_;
+ QHBoxLayout *hintingModeLayout_;
+ QHBoxLayout *horizontalHintingLayout_;
+ QHBoxLayout *infoLeftLayout_;
+ QHBoxLayout *lcdFilterLayout_;
+ QHBoxLayout *navigationLayout_;
+ QHBoxLayout *pointNumbersLayout_;
+ QHBoxLayout *segmentDrawingLayout_;
+ QHBoxLayout *sizeLayout_;
+ QHBoxLayout *verticalHintingLayout_;
+
+ QLabel *antiAliasingLabel_;
+ QLabel *dpiLabel_;
+ QLabel *fontFilenameLabel_;
+ QLabel *fontNameLabel_;
+ QLabel *gammaLabel_;
+ QLabel *glyphIndexLabel_;
+ QLabel *glyphNameLabel_;
+ QLabel *hintingModeLabel_;
+ QLabel *lcdFilterLabel_;
+ QLabel *sizeLabel_;
+ QLabel *zoomLabel_;
+
+ QList<int> hintingModesAlwaysDisabled_;
+
+ QLocale *locale_;
+
+ QMenu *menuFile_;
+ QMenu *menuHelp_;
+
+ QPen axisPen_;
+ QPen blueZonePen_;
+ QPen gridPen_;
+ QPen offPen_;
+ QPen onPen_;
+ QPen outlinePen_;
+ QPen segmentPen_;
+
+ QPushButton *nextFaceButton_;
+ QPushButton *nextFontButton_;
+ QPushButton *nextNamedInstanceButton_;
+ QPushButton *previousFaceButton_;
+ QPushButton *previousFontButton_;
+ QPushButton *previousNamedInstanceButton_;
+
+ QPushButtonx *toEndButtonx_;
+ QPushButtonx *toM1000Buttonx_;
+ QPushButtonx *toM100Buttonx_;
+ QPushButtonx *toM10Buttonx_;
+ QPushButtonx *toM1Buttonx_;
+ QPushButtonx *toP1000Buttonx_;
+ QPushButtonx *toP100Buttonx_;
+ QPushButtonx *toP10Buttonx_;
+ QPushButtonx *toP1Buttonx_;
+ QPushButtonx *toStartButtonx_;
+
+ QSignalMapper *glyphNavigationMapper_;
+
+ QSlider *gammaSlider_;
+
+ QSpinBox *dpiSpinBox_;
+ QSpinBoxx *zoomSpinBox_;
+
+ QTabWidget *tabWidget_;
+
+ QVBoxLayout *generalTabLayout_;
+ QVBoxLayout *leftLayout_;
+ QVBoxLayout *rightLayout_;
+
+ QVector<QRgb> grayColorTable_;
+ QVector<QRgb> monoColorTable_;
+
+ QWidget *ftinspectWidget_;
+ QWidget *generalTabWidget_;
+ QWidget *leftWidget_;
+ QWidget *rightWidget_;
+ QWidget *mmgxTabWidget_;
// TODO these would be dropped with custom QAbstractItemModel
enum HintingMode
diff --git a/src/ftinspect/rendering/glyphbitmap.cpp
b/src/ftinspect/rendering/glyphbitmap.cpp
index d5c3cf3..dcef3ee 100644
--- a/src/ftinspect/rendering/glyphbitmap.cpp
+++ b/src/ftinspect/rendering/glyphbitmap.cpp
@@ -15,17 +15,17 @@ GlyphBitmap::GlyphBitmap(FT_Outline* outline,
FT_Pixel_Mode pxlMode,
const QVector<QRgb>& monoColorTbl,
const QVector<QRgb>& grayColorTbl)
-: library(lib),
- pixelMode(pxlMode),
- monoColorTable(monoColorTbl),
- grayColorTable(grayColorTbl)
+: library_(lib),
+ pixelMode_(pxlMode),
+ monoColorTable_(monoColorTbl),
+ grayColorTable_(grayColorTbl)
{
// make a copy of the outline since we are going to manipulate it
- FT_Outline_New(library,
+ FT_Outline_New(library_,
static_cast<unsigned int>(outline->n_points),
outline->n_contours,
- &transformed);
- FT_Outline_Copy(outline, &transformed);
+ &transformed_);
+ FT_Outline_Copy(outline, &transformed_);
FT_BBox cbox;
FT_Outline_Get_CBox(outline, &cbox);
@@ -36,22 +36,22 @@ GlyphBitmap::GlyphBitmap(FT_Outline* outline,
cbox.yMax = (cbox.yMax + 63) & ~63;
// we shift the outline to the origin for rendering later on
- FT_Outline_Translate(&transformed, -cbox.xMin, -cbox.yMin);
+ FT_Outline_Translate(&transformed_, -cbox.xMin, -cbox.yMin);
- bRect.setCoords(cbox.xMin / 64, -cbox.yMax / 64,
+ boundingRect_.setCoords(cbox.xMin / 64, -cbox.yMax / 64,
cbox.xMax / 64, -cbox.yMin / 64);
}
GlyphBitmap::~GlyphBitmap()
{
- FT_Outline_Done(library, &transformed);
+ FT_Outline_Done(library_, &transformed_);
}
QRectF
GlyphBitmap::boundingRect() const
{
- return bRect;
+ return boundingRect_;
}
@@ -62,20 +62,20 @@ GlyphBitmap::paint(QPainter* painter,
{
FT_Bitmap bitmap;
- int height = static_cast<int>(ceil(bRect.height()));
- int width = static_cast<int>(ceil(bRect.width()));
+ int height = static_cast<int>(ceil(boundingRect_.height()));
+ int width = static_cast<int>(ceil(boundingRect_.width()));
QImage::Format format = QImage::Format_Indexed8;
// XXX cover LCD and color
- if (pixelMode == FT_PIXEL_MODE_MONO)
+ if (pixelMode_ == FT_PIXEL_MODE_MONO)
format = QImage::Format_Mono;
QImage image(QSize(width, height), format);
- if (pixelMode == FT_PIXEL_MODE_MONO)
- image.setColorTable(monoColorTable);
+ if (pixelMode_ == FT_PIXEL_MODE_MONO)
+ image.setColorTable(monoColorTable_);
else
- image.setColorTable(grayColorTable);
+ image.setColorTable(grayColorTable_);
image.fill(0);
@@ -83,10 +83,10 @@ GlyphBitmap::paint(QPainter* painter,
bitmap.width = static_cast<unsigned int>(width);
bitmap.buffer = image.bits();
bitmap.pitch = image.bytesPerLine();
- bitmap.pixel_mode = pixelMode;
+ bitmap.pixel_mode = pixelMode_;
- FT_Error error = FT_Outline_Get_Bitmap(library,
- &transformed,
+ FT_Error error = FT_Outline_Get_Bitmap(library_,
+ &transformed_,
&bitmap);
if (error)
{
@@ -112,8 +112,8 @@ GlyphBitmap::paint(QPainter* painter,
{
// be careful not to lose the alpha channel
QRgb p = image.pixel(x, y);
- painter->fillRect(QRectF(x + bRect.left() - 1 / lod / 2,
- y + bRect.top() - 1 / lod / 2,
+ painter->fillRect(QRectF(x + boundingRect_.left() - 1 / lod / 2,
+ y + boundingRect_.top() - 1 / lod / 2,
1 + 1 / lod,
1 + 1 / lod),
QColor(qRed(p),
diff --git a/src/ftinspect/rendering/glyphbitmap.hpp
b/src/ftinspect/rendering/glyphbitmap.hpp
index 42cb108..092dccc 100644
--- a/src/ftinspect/rendering/glyphbitmap.hpp
+++ b/src/ftinspect/rendering/glyphbitmap.hpp
@@ -29,12 +29,12 @@ public:
QWidget* widget);
private:
- FT_Outline transformed;
- FT_Library library;
- unsigned char pixelMode;
- const QVector<QRgb>& monoColorTable;
- const QVector<QRgb>& grayColorTable;
- QRectF bRect;
+ FT_Outline transformed_;
+ FT_Library library_;
+ unsigned char pixelMode_;
+ const QVector<QRgb>& monoColorTable_;
+ const QVector<QRgb>& grayColorTable_;
+ QRectF boundingRect_;
};
diff --git a/src/ftinspect/rendering/glyphoutline.cpp
b/src/ftinspect/rendering/glyphoutline.cpp
index f088641..ad5d25c 100644
--- a/src/ftinspect/rendering/glyphoutline.cpp
+++ b/src/ftinspect/rendering/glyphoutline.cpp
@@ -89,16 +89,16 @@ static FT_Outline_Funcs outlineFuncs =
GlyphOutline::GlyphOutline(const QPen& outlineP,
FT_Outline* outln)
-: outlinePen(outlineP),
- outline(outln)
+: outlinePen_(outlineP),
+ outline_(outln)
{
FT_BBox cbox;
- qreal halfPenWidth = outlinePen.widthF();
+ qreal halfPenWidth = outlinePen_.widthF();
- FT_Outline_Get_CBox(outline, &cbox);
+ FT_Outline_Get_CBox(outline_, &cbox);
- bRect.setCoords(qreal(cbox.xMin) / 64 - halfPenWidth,
+ boundingRect_.setCoords(qreal(cbox.xMin) / 64 - halfPenWidth,
-qreal(cbox.yMax) / 64 - halfPenWidth,
qreal(cbox.xMax) / 64 + halfPenWidth,
-qreal(cbox.yMin) / 64 + halfPenWidth);
@@ -108,7 +108,7 @@ GlyphOutline::GlyphOutline(const QPen& outlineP,
QRectF
GlyphOutline::boundingRect() const
{
- return bRect;
+ return boundingRect_;
}
@@ -117,10 +117,10 @@ GlyphOutline::paint(QPainter* painter,
const QStyleOptionGraphicsItem*,
QWidget*)
{
- painter->setPen(outlinePen);
+ painter->setPen(outlinePen_);
QPainterPath path;
- FT_Outline_Decompose(outline, &outlineFuncs, &path);
+ FT_Outline_Decompose(outline_, &outlineFuncs, &path);
painter->drawPath(path);
}
diff --git a/src/ftinspect/rendering/glyphoutline.hpp
b/src/ftinspect/rendering/glyphoutline.hpp
index d18d12e..fa448f5 100644
--- a/src/ftinspect/rendering/glyphoutline.hpp
+++ b/src/ftinspect/rendering/glyphoutline.hpp
@@ -25,9 +25,9 @@ public:
QWidget* widget);
private:
- QPen outlinePen;
- FT_Outline* outline;
- QRectF bRect;
+ QPen outlinePen_;
+ FT_Outline* outline_;
+ QRectF boundingRect_;
};
diff --git a/src/ftinspect/rendering/glyphpointnumbers.cpp
b/src/ftinspect/rendering/glyphpointnumbers.cpp
index cc05ca7..bddee89 100644
--- a/src/ftinspect/rendering/glyphpointnumbers.cpp
+++ b/src/ftinspect/rendering/glyphpointnumbers.cpp
@@ -13,16 +13,16 @@
GlyphPointNumbers::GlyphPointNumbers(const QPen& onP,
const QPen& offP,
FT_Outline* outln)
-: onPen(onP),
- offPen(offP),
- outline(outln)
+: onPen_(onP),
+ offPen_(offP),
+ outline_(outln)
{
FT_BBox cbox;
- FT_Outline_Get_CBox(outline, &cbox);
+ FT_Outline_Get_CBox(outline_, &cbox);
// XXX fix bRect size
- bRect.setCoords(qreal(cbox.xMin) / 64,
+ boundingRect_.setCoords(qreal(cbox.xMin) / 64,
-qreal(cbox.yMax) / 64,
qreal(cbox.xMax) / 64,
-qreal(cbox.yMin) / 64);
@@ -32,7 +32,7 @@ GlyphPointNumbers::GlyphPointNumbers(const QPen& onP,
QRectF
GlyphPointNumbers::boundingRect() const
{
- return bRect;
+ return boundingRect_;
}
@@ -60,15 +60,15 @@ GlyphPointNumbers::paint(QPainter* painter,
font.setPointSizeF(font.pointSizeF() * 3 / 4);
painter->setFont(font);
- QBrush onBrush(onPen.color());
- QBrush offBrush(offPen.color());
+ QBrush onBrush(onPen_.color());
+ QBrush offBrush(offPen_.color());
painter->scale(1 / lod, 1 / lod);
#endif
- FT_Vector* points = outline->points;
- FT_Short* contours = outline->contours;
- char* tags = outline->tags;
+ FT_Vector* points = outline_->points;
+ FT_Short* contours = outline_->contours;
+ char* tags = outline_->tags;
QVector2D octants[8] = { QVector2D(1, 0),
QVector2D(0.707f, -0.707f),
@@ -81,7 +81,7 @@ GlyphPointNumbers::paint(QPainter* painter,
short ptIdx = 0;
- for (int contIdx = 0; contIdx < outline->n_contours; contIdx++ )
+ for (int contIdx = 0; contIdx < outline_->n_contours; contIdx++ )
{
for (;;)
{
diff --git a/src/ftinspect/rendering/glyphpointnumbers.hpp
b/src/ftinspect/rendering/glyphpointnumbers.hpp
index 91c6c42..61feaf0 100644
--- a/src/ftinspect/rendering/glyphpointnumbers.hpp
+++ b/src/ftinspect/rendering/glyphpointnumbers.hpp
@@ -26,10 +26,10 @@ public:
QWidget* widget);
private:
- QPen onPen;
- QPen offPen;
- FT_Outline* outline;
- QRectF bRect;
+ QPen onPen_;
+ QPen offPen_;
+ FT_Outline* outline_;
+ QRectF boundingRect_;
};
diff --git a/src/ftinspect/rendering/glyphpoints.cpp
b/src/ftinspect/rendering/glyphpoints.cpp
index ffef303..08960e6 100644
--- a/src/ftinspect/rendering/glyphpoints.cpp
+++ b/src/ftinspect/rendering/glyphpoints.cpp
@@ -12,17 +12,17 @@
GlyphPoints::GlyphPoints(const QPen& onP,
const QPen& offP,
FT_Outline* outln)
-: onPen(onP),
- offPen(offP),
- outline(outln)
+: onPen_(onP),
+ offPen_(offP),
+ outline_(outln)
{
FT_BBox cbox;
- qreal halfPenWidth = qMax(onPen.widthF(), offPen.widthF()) / 2;
+ qreal halfPenWidth = qMax(onPen_.widthF(), offPen_.widthF()) / 2;
- FT_Outline_Get_CBox(outline, &cbox);
+ FT_Outline_Get_CBox(outline_, &cbox);
- bRect.setCoords(qreal(cbox.xMin) / 64 - halfPenWidth,
+ boundingRect_.setCoords(qreal(cbox.xMin) / 64 - halfPenWidth,
-qreal(cbox.yMax) / 64 - halfPenWidth,
qreal(cbox.xMax) / 64 + halfPenWidth,
-qreal(cbox.yMin) / 64 + halfPenWidth);
@@ -32,7 +32,7 @@ GlyphPoints::GlyphPoints(const QPen& onP,
QRectF
GlyphPoints::boundingRect() const
{
- return bRect;
+ return boundingRect_;
}
@@ -73,29 +73,29 @@ GlyphPoints::paint(QPainter* painter,
onPen.setWidthF(origOnPenWidth);
offPen.setWidthF(origOffPenWidth);
#else
- QBrush onBrush(onPen.color());
- QBrush offBrush(offPen.color());
+ QBrush onBrush(onPen_.color());
+ QBrush offBrush(offPen_.color());
painter->setPen(Qt::NoPen);
- qreal onRadius = onPen.widthF() / lod;
- qreal offRadius = offPen.widthF() / lod;
+ qreal onRadius = onPen_.widthF() / lod;
+ qreal offRadius = offPen_.widthF() / lod;
- for (int i = 0; i < outline->n_points; i++)
+ for (int i = 0; i < outline_->n_points; i++)
{
- if (outline->tags[i] & FT_CURVE_TAG_ON)
+ if (outline_->tags[i] & FT_CURVE_TAG_ON)
{
painter->setBrush(onBrush);
- painter->drawEllipse(QPointF(qreal(outline->points[i].x) / 64,
- -qreal(outline->points[i].y) / 64),
+ painter->drawEllipse(QPointF(qreal(outline_->points[i].x) / 64,
+ -qreal(outline_->points[i].y) / 64),
onRadius,
onRadius);
}
else
{
painter->setBrush(offBrush);
- painter->drawEllipse(QPointF(qreal(outline->points[i].x) / 64,
- -qreal(outline->points[i].y) / 64),
+ painter->drawEllipse(QPointF(qreal(outline_->points[i].x) / 64,
+ -qreal(outline_->points[i].y) / 64),
offRadius,
offRadius);
}
diff --git a/src/ftinspect/rendering/glyphpoints.hpp
b/src/ftinspect/rendering/glyphpoints.hpp
index 8daab61..d964826 100644
--- a/src/ftinspect/rendering/glyphpoints.hpp
+++ b/src/ftinspect/rendering/glyphpoints.hpp
@@ -26,10 +26,10 @@ public:
QWidget* widget);
private:
- QPen onPen;
- QPen offPen;
- FT_Outline* outline;
- QRectF bRect;
+ QPen onPen_;
+ QPen offPen_;
+ FT_Outline* outline_;
+ QRectF boundingRect_;
};
diff --git a/src/ftinspect/rendering/grid.cpp b/src/ftinspect/rendering/grid.cpp
index 3d9b329..01b17cb 100644
--- a/src/ftinspect/rendering/grid.cpp
+++ b/src/ftinspect/rendering/grid.cpp
@@ -11,8 +11,8 @@
Grid::Grid(const QPen& gridP,
const QPen& axisP)
-: gridPen(gridP),
- axisPen(axisP)
+: gridPen_(gridP),
+ axisPen_(axisP)
{
// empty
}
@@ -40,7 +40,7 @@ Grid::paint(QPainter* painter,
const qreal lod = option->levelOfDetailFromTransform(
painter->worldTransform());
- painter->setPen(gridPen);
+ painter->setPen(gridPen_);
// don't mark pixel center with a cross if magnification is too small
if (lod > 20)
@@ -81,7 +81,7 @@ Grid::paint(QPainter* painter,
100, y);
}
- painter->setPen(axisPen);
+ painter->setPen(axisPen_);
painter->drawLine(0, -100,
0, 100);
diff --git a/src/ftinspect/rendering/grid.hpp b/src/ftinspect/rendering/grid.hpp
index 49dd99a..9740c17 100644
--- a/src/ftinspect/rendering/grid.hpp
+++ b/src/ftinspect/rendering/grid.hpp
@@ -21,8 +21,8 @@ public:
QWidget* widget);
private:
- QPen gridPen;
- QPen axisPen;
+ QPen gridPen_;
+ QPen axisPen_;
};
diff --git a/src/ftinspect/widgets/qgraphicsviewx.cpp
b/src/ftinspect/widgets/qgraphicsviewx.cpp
index a4e0ba9..4752181 100644
--- a/src/ftinspect/widgets/qgraphicsviewx.cpp
+++ b/src/ftinspect/widgets/qgraphicsviewx.cpp
@@ -9,7 +9,7 @@
QGraphicsViewx::QGraphicsViewx()
-: lastBottomLeftPointInitialized(false)
+: lastBottomLeftPointInitialized_(false)
{
// empty
}
@@ -20,7 +20,7 @@ QGraphicsViewx::scrollContentsBy(int dx,
int dy)
{
QGraphicsView::scrollContentsBy(dx, dy);
- lastBottomLeftPoint = viewport()->rect().bottomLeft();
+ lastBottomLeftPoint_ = viewport()->rect().bottomLeft();
}
@@ -31,10 +31,10 @@ QGraphicsViewx::resizeEvent(QResizeEvent* event)
// XXX I don't know how to properly initialize this value,
// thus the hack with the boolean
- if (!lastBottomLeftPointInitialized)
+ if (!lastBottomLeftPointInitialized_)
{
- lastBottomLeftPoint = viewport()->rect().bottomLeft();
- lastBottomLeftPointInitialized = true;
+ lastBottomLeftPoint_ = viewport()->rect().bottomLeft();
+ lastBottomLeftPointInitialized_ = true;
}
QPointF currentBottomLeftPoint = viewport()->rect().bottomLeft();
@@ -42,7 +42,7 @@ QGraphicsViewx::resizeEvent(QResizeEvent* event)
verticalScrollBar()->setValue(static_cast<int>(
verticalPosition
- (currentBottomLeftPoint.y()
- - lastBottomLeftPoint.y())));
+ - lastBottomLeftPoint_.y())));
}
diff --git a/src/ftinspect/widgets/qgraphicsviewx.hpp
b/src/ftinspect/widgets/qgraphicsviewx.hpp
index 1a55b2c..6ddbf12 100644
--- a/src/ftinspect/widgets/qgraphicsviewx.hpp
+++ b/src/ftinspect/widgets/qgraphicsviewx.hpp
@@ -24,8 +24,8 @@ protected:
int dy);
private:
- QPointF lastBottomLeftPoint;
- bool lastBottomLeftPointInitialized;
+ QPointF lastBottomLeftPoint_;
+ bool lastBottomLeftPointInitialized_;
};
[Prev in Thread] |
Current Thread |
[Next in Thread] |
- [freetype2-demos] master da068f1 04/41: [ftinspect] Rename all private member variables with an underscore suffix.,
Werner Lemberg <=