mirror of
https://github.com/riuson/lcd-image-converter.git
synced 2026-03-03 06:44:13 +01:00
924 lines
25 KiB
C++
924 lines
25 KiB
C++
/*
|
|
* LCD Image Converter. Converts images and fonts for embedded applications.
|
|
* Copyright (C) 2013 riuson
|
|
* mailto: riuson@gmail.com
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/
|
|
*/
|
|
|
|
#include "fontdocument.h"
|
|
#include <QFile>
|
|
#include <QDomDocument>
|
|
#include <QBuffer>
|
|
#include <QImage>
|
|
#include <QFontDatabase>
|
|
#include <QModelIndexList>
|
|
#include <QModelIndex>
|
|
#include <QFileDialog>
|
|
#include <QTextStream>
|
|
#include <QPainter>
|
|
#include <QWidget>
|
|
#include <QTextCodec>
|
|
#include "datacontainer.h"
|
|
#include "tagslist.h"
|
|
#include "parser.h"
|
|
#include "dialogfontchanged.h"
|
|
#include "fonteditoroptions.h"
|
|
#include "fonthelper.h"
|
|
#include "preset.h"
|
|
#include "fontparameters.h"
|
|
#include "fonthelper.h"
|
|
#include "parsedimagedata.h"
|
|
#include "fontoptions.h"
|
|
#include "bitmaphelper.h"
|
|
|
|
namespace Data
|
|
{
|
|
namespace Containers
|
|
{
|
|
|
|
FontDocument::FontDocument(QObject *parent) :
|
|
QObject(parent)
|
|
{
|
|
this->mContainer = new DataContainer(this);
|
|
this->connect(this->mContainer, SIGNAL(dataChanged(bool)), SLOT(mon_container_dataChanged(bool)));
|
|
|
|
this->mNestedChangesCounter = 0;
|
|
|
|
this->beginChanges();
|
|
|
|
this->setDocumentName(QString("Font"));
|
|
this->setDocumentFilename("");
|
|
this->setOutputFilename("");
|
|
this->setAntialiasing(false);
|
|
this->setMonospaced(false);
|
|
|
|
this->endChanges(true);
|
|
this->mContainer->historyInit();
|
|
}
|
|
|
|
FontDocument::~FontDocument()
|
|
{
|
|
}
|
|
|
|
bool FontDocument::load(const QString &fileName)
|
|
{
|
|
bool result = false;
|
|
|
|
QFile file(fileName);
|
|
|
|
if (file.open(QIODevice::ReadOnly)) {
|
|
this->beginChanges();
|
|
|
|
QDomDocument doc;
|
|
QString errorMsg;
|
|
QString converted;
|
|
int errorColumn, errorLine;
|
|
|
|
this->mContainer->blockSignals(true);
|
|
|
|
if (doc.setContent(&file, &errorMsg, &errorLine, &errorColumn)) {
|
|
QDomElement root = doc.documentElement();
|
|
|
|
if (root.tagName() == "data") {
|
|
result = true;
|
|
this->setDocumentName(root.attribute("name", fileName));
|
|
|
|
QString fontFamily, style;
|
|
int size = 0;
|
|
int ascent = 0, descent = 0;
|
|
bool monospaced = false, antialiasing = false;
|
|
QColor foreground = FontEditorOptions::foreColor();
|
|
QColor background = FontEditorOptions::backColor();
|
|
|
|
QDomNode n = root.firstChild();
|
|
|
|
while (!n.isNull()) {
|
|
QDomElement e = n.toElement();
|
|
|
|
if (!e.isNull()) {
|
|
if (e.tagName() == "family") {
|
|
fontFamily = e.text();
|
|
} else if (e.tagName() == "style") {
|
|
style = e.text();
|
|
} else if (e.tagName() == "size") {
|
|
bool ok;
|
|
int a = e.text().toInt(&ok);
|
|
|
|
if (ok) {
|
|
size = a;
|
|
} else {
|
|
result = false;
|
|
}
|
|
} else if (e.tagName() == "ascent") {
|
|
bool ok;
|
|
int a = e.text().toInt(&ok);
|
|
|
|
if (ok) {
|
|
ascent = a;
|
|
} else {
|
|
result = false;
|
|
}
|
|
} else if (e.tagName() == "descent") {
|
|
bool ok;
|
|
int a = e.text().toInt(&ok);
|
|
|
|
if (ok) {
|
|
descent = a;
|
|
} else {
|
|
result = false;
|
|
}
|
|
} else if (e.tagName() == "widthType") {
|
|
monospaced = (e.text() == "monospaced");
|
|
} else if (e.tagName() == "antialiasing") {
|
|
antialiasing = (e.text() == "true");
|
|
} else if (e.tagName() == "foreground") {
|
|
bool ok;
|
|
QString str = e.text();
|
|
qint32 a = str.toUInt(&ok, 16);
|
|
|
|
if (ok) {
|
|
foreground = Parsing::Conversion::BitmapHelper::fromRgba(QRgb(a));
|
|
} else {
|
|
result = false;
|
|
}
|
|
} else if (e.tagName() == "background") {
|
|
bool ok;
|
|
QString str = e.text();
|
|
qint32 a = str.toUInt(&ok, 16);
|
|
|
|
if (ok) {
|
|
background = Parsing::Conversion::BitmapHelper::fromRgba(QRgb(a));
|
|
} else {
|
|
result = false;
|
|
}
|
|
} else if (e.tagName() == "converted") {
|
|
converted = e.text();
|
|
}
|
|
}
|
|
|
|
n = n.nextSibling();
|
|
}
|
|
|
|
QDomNodeList nodesChar = root.elementsByTagName("char");
|
|
|
|
for (int i = 0; i < nodesChar.count(); i++) {
|
|
QDomElement e = nodesChar.at(i).toElement();
|
|
bool ok;
|
|
int code = e.attribute("code", "none").toInt(&ok, 16);
|
|
|
|
if (ok) {
|
|
QDomElement nodePicture = e.firstChildElement("picture");
|
|
|
|
if (nodePicture.isElement()) {
|
|
QString str = nodePicture.text();
|
|
QByteArray ba = QByteArray::fromBase64(str.toLatin1());
|
|
QBuffer buffer(&ba);
|
|
QImage image;
|
|
image.load(&buffer, "PNG");
|
|
|
|
QString key = QString(QChar(code));
|
|
this->mContainer->setImage(key, &image);
|
|
}
|
|
} else {
|
|
result = false;
|
|
}
|
|
}
|
|
|
|
QFontDatabase fonts;
|
|
QFont font = fonts.font(fontFamily, style, size);
|
|
font.setPixelSize(size);
|
|
this->setUsedFont(font);
|
|
|
|
this->setUsedStyle(style);
|
|
this->setMonospaced(monospaced);
|
|
this->setAntialiasing(antialiasing);
|
|
this->setForeground(foreground);
|
|
this->setBackground(background);
|
|
this->setAscent(ascent);
|
|
this->setDescent(descent);
|
|
}
|
|
}
|
|
|
|
file.close();
|
|
|
|
this->mContainer->blockSignals(false);
|
|
|
|
this->setDocumentFilename(fileName);
|
|
this->setOutputFilename(converted);
|
|
|
|
this->endChanges(true);
|
|
|
|
this->mContainer->historyInit();
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
bool FontDocument::save(const QString &fileName)
|
|
{
|
|
bool result = false;
|
|
|
|
QDomDocument doc;
|
|
QDomProcessingInstruction procInstruction = doc.createProcessingInstruction("xml", "version=\"1.0\" encoding=\"utf-8\"");
|
|
doc.appendChild(procInstruction);
|
|
|
|
QDomElement nodeRoot = doc.createElement("data");
|
|
doc.appendChild(nodeRoot);
|
|
|
|
QString chars;
|
|
FontParameters parameters;
|
|
this->fontCharacters(&chars, ¶meters);
|
|
|
|
nodeRoot.setAttribute("type", "font");
|
|
nodeRoot.setAttribute("name", this->documentName());
|
|
|
|
//font family
|
|
QDomElement nodeFamily = doc.createElement("family");
|
|
nodeRoot.appendChild(nodeFamily);
|
|
nodeFamily.appendChild(doc.createTextNode(parameters.family));
|
|
|
|
// size
|
|
QDomElement nodeSize = doc.createElement("size");
|
|
nodeRoot.appendChild(nodeSize);
|
|
nodeSize.appendChild(doc.createTextNode(QString("%1").arg(parameters.size)));
|
|
|
|
// ascent
|
|
QDomElement nodeAscent = doc.createElement("ascent");
|
|
nodeRoot.appendChild(nodeAscent);
|
|
nodeAscent.appendChild(doc.createTextNode(QString("%1").arg(parameters.ascent)));
|
|
|
|
// descent
|
|
QDomElement nodeDescent = doc.createElement("descent");
|
|
nodeRoot.appendChild(nodeDescent);
|
|
nodeDescent.appendChild(doc.createTextNode(QString("%1").arg(parameters.descent)));
|
|
|
|
// style
|
|
QDomElement nodeStyle = doc.createElement("style");
|
|
nodeRoot.appendChild(nodeStyle);
|
|
nodeStyle.appendChild(doc.createTextNode(parameters.style));
|
|
|
|
// monospaced or proportional
|
|
QDomElement nodeWidthType = doc.createElement("widthType");
|
|
nodeRoot.appendChild(nodeWidthType);
|
|
|
|
if (parameters.monospaced) {
|
|
nodeWidthType.appendChild(doc.createTextNode("monospaced"));
|
|
} else {
|
|
nodeWidthType.appendChild(doc.createTextNode("proportional"));
|
|
}
|
|
|
|
// antialiasing
|
|
QDomElement nodeAntialiasing = doc.createElement("antialiasing");
|
|
nodeRoot.appendChild(nodeAntialiasing);
|
|
|
|
if (parameters.antiAliasing) {
|
|
nodeAntialiasing.appendChild(doc.createTextNode("true"));
|
|
} else {
|
|
nodeAntialiasing.appendChild(doc.createTextNode("false"));
|
|
}
|
|
|
|
// foreground
|
|
QDomElement nodeForeground = doc.createElement("foreground");
|
|
nodeRoot.appendChild(nodeForeground);
|
|
nodeForeground.appendChild(doc.createTextNode(QString("%1").arg((quint32)parameters.foreground.rgba(), 8, 16, QChar('0'))));
|
|
|
|
// background
|
|
QDomElement nodeBackground = doc.createElement("background");
|
|
nodeRoot.appendChild(nodeBackground);
|
|
nodeBackground.appendChild(doc.createTextNode(QString("%1").arg((quint32)parameters.background.rgba(), 8, 16, QChar('0'))));
|
|
|
|
// string
|
|
QDomElement nodeString = doc.createElement("string");
|
|
nodeRoot.appendChild(nodeString);
|
|
nodeString.appendChild(doc.createTextNode(Parsing::Conversion::FontHelper::escapeControlChars(chars)));
|
|
|
|
// converted file name
|
|
QDomElement nodeConverted = doc.createElement("converted");
|
|
nodeRoot.appendChild(nodeConverted);
|
|
nodeConverted.appendChild(doc.createTextNode(this->outputFilename()));
|
|
|
|
// chars list
|
|
QDomElement nodeChars = doc.createElement("chars");
|
|
nodeRoot.appendChild(nodeChars);
|
|
|
|
QListIterator<QString> it(this->mContainer->keys());
|
|
it.toFront();
|
|
|
|
while (it.hasNext()) {
|
|
QString key = it.next();
|
|
// char
|
|
QDomElement nodeChar = doc.createElement("char");
|
|
nodeChars.appendChild(nodeChar);
|
|
nodeChar.setAttribute("character", Parsing::Conversion::FontHelper::escapeControlChars(key));
|
|
nodeChar.setAttribute("code", QString("%1").arg(key.at(0).unicode(), 4, 16, QChar('0')));
|
|
|
|
QDomElement nodePicture = doc.createElement("picture");
|
|
nodeChar.appendChild(nodePicture);
|
|
|
|
nodePicture.setAttribute("format", "png");
|
|
|
|
QByteArray ba;
|
|
QBuffer buffer(&ba);
|
|
buffer.open(QIODevice::WriteOnly);
|
|
this->mContainer->image(key)->save(&buffer, "PNG");
|
|
QString data = ba.toBase64();
|
|
|
|
QDomText nodeData = doc.createTextNode(data);
|
|
nodePicture.appendChild(nodeData);
|
|
}
|
|
|
|
QFile file(fileName);
|
|
|
|
if (file.open(QIODevice::WriteOnly)) {
|
|
QTextStream stream(&file);
|
|
doc.save(stream, 4);
|
|
|
|
this->beginChanges();
|
|
|
|
this->setDocumentFilename(fileName);
|
|
file.close();
|
|
result = true;
|
|
|
|
this->endChanges(true);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
bool FontDocument::changed() const
|
|
{
|
|
bool result = this->mContainer->changed();
|
|
return result;
|
|
}
|
|
|
|
QString FontDocument::documentFilename() const
|
|
{
|
|
QVariant result = this->mContainer->commonInfo("filename");
|
|
return result.toString();
|
|
}
|
|
|
|
QString FontDocument::documentName() const
|
|
{
|
|
QVariant result = this->mContainer->commonInfo("document name");
|
|
return result.toString();
|
|
}
|
|
|
|
void FontDocument::setDocumentName(const QString &value)
|
|
{
|
|
this->mContainer->setCommonInfo("document name", value);
|
|
}
|
|
|
|
QString FontDocument::outputFilename() const
|
|
{
|
|
QVariant result = this->mContainer->commonInfo("converted filename");
|
|
return result.toString();
|
|
}
|
|
|
|
void FontDocument::setOutputFilename(const QString &value)
|
|
{
|
|
this->mContainer->setCommonInfo("converted filename", QVariant(value));
|
|
}
|
|
|
|
DataContainer *FontDocument::dataContainer() const
|
|
{
|
|
return this->mContainer;
|
|
}
|
|
|
|
QString FontDocument::convert(Preset *preset)
|
|
{
|
|
Parsing::TagsList tags;
|
|
|
|
if (!this->documentFilename().isEmpty()) {
|
|
tags.setTagValue(Parsing::TagsList::Tag::DocumentFilename, this->documentFilename());
|
|
} else {
|
|
tags.setTagValue(Parsing::TagsList::Tag::DocumentFilename, "unsaved");
|
|
}
|
|
|
|
tags.setTagValue(Parsing::TagsList::Tag::DocumentName, this->documentName());
|
|
tags.setTagValue(Parsing::TagsList::Tag::DocumentNameWithoutSpaces, this->documentName().remove(QRegExp("\\W", Qt::CaseInsensitive)));
|
|
|
|
QString chars;
|
|
FontParameters parameters;
|
|
this->fontCharacters(&chars, ¶meters);
|
|
|
|
tags.setTagValue(Parsing::TagsList::Tag::DocumentDataType, "font");
|
|
tags.setTagValue(Parsing::TagsList::Tag::FontFamily, parameters.family);
|
|
tags.setTagValue(Parsing::TagsList::Tag::FontSize, QString("%1").arg(parameters.size));
|
|
tags.setTagValue(Parsing::TagsList::Tag::FontStyle, parameters.style);
|
|
tags.setTagValue(Parsing::TagsList::Tag::FontString, Parsing::Conversion::FontHelper::escapeControlChars(chars));
|
|
tags.setTagValue(Parsing::TagsList::Tag::FontAntiAliasing, parameters.antiAliasing ? "yes" : "no");
|
|
tags.setTagValue(Parsing::TagsList::Tag::FontWidthType, parameters.monospaced ? "monospaced" : "proportional");
|
|
tags.setTagValue(Parsing::TagsList::Tag::FontAscent, QString("%1").arg(parameters.ascent));
|
|
tags.setTagValue(Parsing::TagsList::Tag::FontDescent, QString("%1").arg(parameters.descent));
|
|
|
|
const QStringList orderedKeys = this->sortKeysWithEncoding(this->dataContainer()->keys(), preset);
|
|
|
|
QMap<QString, Parsing::ParsedImageData *> images;
|
|
this->prepareImages(preset, orderedKeys, &images, tags);
|
|
Parsing::Parser parser(Parsing::Parser::TypeFont, preset, this);
|
|
QString result = parser.convert(this, orderedKeys, &images, tags);
|
|
|
|
return result;
|
|
}
|
|
|
|
void FontDocument::beginChanges()
|
|
{
|
|
if (!this->mContainer->historyInitialized()) {
|
|
this->mContainer->historyInit();
|
|
}
|
|
|
|
this->mNestedChangesCounter++;
|
|
}
|
|
|
|
void FontDocument::endChanges(bool suppress)
|
|
{
|
|
if (this->mNestedChangesCounter > 0) {
|
|
if (--this->mNestedChangesCounter == 0) {
|
|
bool changed = this->mContainer->changed();
|
|
|
|
if (suppress) {
|
|
this->mContainer->setChanged(false);
|
|
changed = false;
|
|
}
|
|
|
|
if (changed) {
|
|
this->mContainer->stateSave();
|
|
}
|
|
|
|
emit this->documentChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
bool FontDocument::canUndo()
|
|
{
|
|
return this->mContainer->canUndo();
|
|
}
|
|
|
|
bool FontDocument::canRedo()
|
|
{
|
|
return this->mContainer->canRedo();
|
|
}
|
|
|
|
void FontDocument::undo()
|
|
{
|
|
this->mContainer->stateUndo();
|
|
|
|
emit this->documentChanged();
|
|
}
|
|
|
|
void FontDocument::redo()
|
|
{
|
|
this->mContainer->stateRedo();
|
|
|
|
emit this->documentChanged();
|
|
}
|
|
|
|
void FontDocument::fontCharacters(QString *chars,
|
|
Data::Containers::FontParameters *parameters)
|
|
{
|
|
QStringList charList(this->mContainer->keys());
|
|
*chars = charList.join("");
|
|
parameters->family = this->usedFont().family();
|
|
parameters->size = this->usedFont().pixelSize();
|
|
parameters->style = this->usedStyle();
|
|
parameters->monospaced = this->monospaced();
|
|
parameters->antiAliasing = this->antialiasing();
|
|
parameters->foreground = this->foreground();
|
|
parameters->background = this->background();
|
|
parameters->ascent = this->ascent();
|
|
parameters->descent = this->descent();
|
|
}
|
|
|
|
void FontDocument::setFontCharacters(const QString &chars,
|
|
const Data::Containers::FontParameters ¶meters)
|
|
{
|
|
QFontDatabase fonts;
|
|
|
|
bool regenerateAll = false;
|
|
|
|
this->mContainer->blockSignals(true);
|
|
|
|
if (this->mContainer->count() > 1) {
|
|
if (this->usedFont().family() != parameters.family ||
|
|
this->usedStyle() != parameters.style ||
|
|
this->usedFont().pixelSize() != parameters.size ||
|
|
this->monospaced() != parameters.monospaced ||
|
|
this->antialiasing() != parameters.antiAliasing ||
|
|
this->foreground() != parameters.foreground ||
|
|
this->background() != parameters.background ||
|
|
this->ascent() != parameters.ascent ||
|
|
this->descent() != parameters.descent) {
|
|
DialogFontChanged dialog(qobject_cast<QWidget *>(this->parent()));
|
|
|
|
if (dialog.exec() == QDialog::Accepted) {
|
|
regenerateAll = dialog.regenerateAll();
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
} else { // for newly created fonts
|
|
regenerateAll = true;
|
|
}
|
|
|
|
this->beginChanges();
|
|
|
|
// create font with specified parameters
|
|
QFont fontNew = fonts.font(parameters.family, parameters.style, parameters.size);
|
|
fontNew.setPixelSize(parameters.size);
|
|
|
|
if (parameters.antiAliasing) {
|
|
fontNew.setStyleStrategy(QFont::PreferAntialias);
|
|
} else {
|
|
fontNew.setStyleStrategy(QFont::NoAntialias);
|
|
}
|
|
|
|
// remove old characters
|
|
if (regenerateAll) {
|
|
this->mContainer->clear();
|
|
|
|
// save new font
|
|
this->setUsedFont(fontNew);
|
|
this->setUsedStyle(parameters.style);
|
|
this->setMonospaced(parameters.monospaced);
|
|
this->setAntialiasing(parameters.antiAliasing);
|
|
this->setAscent(parameters.ascent);
|
|
this->setDescent(parameters.descent);
|
|
this->setForeground(parameters.foreground);
|
|
this->setBackground(parameters.background);
|
|
} else {
|
|
// remove characters, which not present in new characters list
|
|
QStringList keys = this->mContainer->keys();
|
|
QListIterator<QString> it(keys);
|
|
it.toFront();
|
|
|
|
while (it.hasNext()) {
|
|
QString a = it.next();
|
|
|
|
if (!chars.contains(a)) {
|
|
this->mContainer->removeImage(a);
|
|
}
|
|
}
|
|
}
|
|
|
|
// find max size
|
|
int width = 0, height = 0;
|
|
QFontMetrics metrics(fontNew);
|
|
|
|
if (parameters.monospaced) {
|
|
for (int i = 0; i < chars.count(); i++) {
|
|
width = qMax(width, metrics.width(chars.at(i)));
|
|
}
|
|
|
|
height = metrics.height();
|
|
}
|
|
|
|
// generate new characters
|
|
QStringList keys = this->mContainer->keys();
|
|
QStringList userOrdered;
|
|
|
|
for (int i = 0; i < chars.count(); i++) {
|
|
QString key = QString(chars.at(i));
|
|
userOrdered.append(key);
|
|
|
|
// if character not exists, create it
|
|
if (!keys.contains(key)) {
|
|
keys.append(key);
|
|
QImage image = Parsing::Conversion::FontHelper::drawCharacter(chars.at(i),
|
|
fontNew,
|
|
parameters.foreground,
|
|
parameters.background,
|
|
width,
|
|
height,
|
|
parameters.antiAliasing);
|
|
this->mContainer->setImage(key, new QImage(image));
|
|
}
|
|
}
|
|
|
|
this->mContainer->reorderTo(&userOrdered);
|
|
|
|
this->mContainer->blockSignals(false);
|
|
|
|
this->endChanges(false);
|
|
}
|
|
|
|
void FontDocument::setDocumentFilename(const QString &value)
|
|
{
|
|
if (this->documentFilename() != value) {
|
|
this->mContainer->setCommonInfo("filename", QVariant(value));
|
|
}
|
|
}
|
|
|
|
QFont FontDocument::usedFont() const
|
|
{
|
|
QVariant var = this->mContainer->commonInfo("used font");
|
|
|
|
if (!var.isNull()) {
|
|
QFont result = var.value<QFont>();
|
|
return result;
|
|
}
|
|
|
|
return QFont();
|
|
}
|
|
|
|
void FontDocument::setUsedFont(const QFont &value)
|
|
{
|
|
this->mContainer->setCommonInfo("used font", value);
|
|
}
|
|
|
|
QString FontDocument::usedStyle() const
|
|
{
|
|
return this->mContainer->commonInfo("style").toString();
|
|
}
|
|
|
|
void FontDocument::setUsedStyle(const QString &value)
|
|
{
|
|
this->mContainer->setCommonInfo("style", value);
|
|
}
|
|
|
|
bool FontDocument::monospaced() const
|
|
{
|
|
return this->mContainer->commonInfo("monospaced").toBool();
|
|
}
|
|
|
|
void FontDocument::setMonospaced(const bool value)
|
|
{
|
|
this->mContainer->setCommonInfo("monospaced", value);
|
|
}
|
|
|
|
bool FontDocument::antialiasing() const
|
|
{
|
|
return this->mContainer->commonInfo("antialiasing").toBool();
|
|
}
|
|
|
|
void FontDocument::setAntialiasing(const bool value)
|
|
{
|
|
this->mContainer->setCommonInfo("antialiasing", value);
|
|
}
|
|
|
|
QColor FontDocument::foreground() const
|
|
{
|
|
bool ok;
|
|
quint32 rgbValue = this->mContainer->commonInfo("foreground").toUInt(&ok);
|
|
|
|
if (ok) {
|
|
return Parsing::Conversion::BitmapHelper::fromRgba(QRgb(rgbValue));
|
|
}
|
|
|
|
return FontEditorOptions::foreColor();
|
|
}
|
|
|
|
void FontDocument::setForeground(const QColor value)
|
|
{
|
|
this->mContainer->setCommonInfo("foreground", (quint32)value.rgba());
|
|
}
|
|
|
|
QColor FontDocument::background() const
|
|
{
|
|
bool ok;
|
|
quint32 rgbValue = this->mContainer->commonInfo("background").toUInt(&ok);
|
|
|
|
if (ok) {
|
|
return Parsing::Conversion::BitmapHelper::fromRgba(QRgb(rgbValue));
|
|
}
|
|
|
|
return FontEditorOptions::backColor();
|
|
}
|
|
|
|
void FontDocument::setBackground(const QColor value)
|
|
{
|
|
this->mContainer->setCommonInfo("background", (quint32)value.rgba());
|
|
}
|
|
|
|
int FontDocument::ascent() const
|
|
{
|
|
return this->mContainer->commonInfo("ascent").toInt();
|
|
}
|
|
|
|
void FontDocument::setAscent(int value)
|
|
{
|
|
this->mContainer->setCommonInfo("ascent", value);
|
|
}
|
|
|
|
int FontDocument::descent() const
|
|
{
|
|
return this->mContainer->commonInfo("descent").toInt();
|
|
}
|
|
|
|
void FontDocument::setDescent(int value)
|
|
{
|
|
this->mContainer->setCommonInfo("descent", value);
|
|
}
|
|
|
|
void FontDocument::prepareImages(Preset *preset, const QStringList &orderedKeys, QMap<QString, Parsing::ParsedImageData *> *images, const Parsing::TagsList &tags) const
|
|
{
|
|
DataContainer *data = this->dataContainer();
|
|
|
|
// collect ParsedImageData
|
|
{
|
|
QListIterator<QString> it(orderedKeys);
|
|
it.toFront();
|
|
|
|
while (it.hasNext()) {
|
|
const QString key = it.next();
|
|
QImage image = QImage(*data->image(key));
|
|
|
|
Parsing::ParsedImageData *data = new Parsing::ParsedImageData(preset, &image, tags);
|
|
images->insert(key, data);
|
|
}
|
|
}
|
|
|
|
// collect other info
|
|
{
|
|
bool useBom = preset->font()->bom();
|
|
QString encoding = preset->font()->encoding();
|
|
|
|
QListIterator<QString> it(orderedKeys);
|
|
it.toFront();
|
|
|
|
while (it.hasNext()) {
|
|
QString key = it.next();
|
|
|
|
Parsing::ParsedImageData *imageData = images->value(key);
|
|
|
|
if (imageData != nullptr) {
|
|
QString charCode = this->hexCode(key, encoding, useBom);
|
|
imageData->tags()->setTagValue(Parsing::TagsList::Tag::OutputCharacterCode, charCode);
|
|
imageData->tags()->setTagValue(Parsing::TagsList::Tag::OutputCharacterText, Parsing::Conversion::FontHelper::escapeControlChars(key));
|
|
}
|
|
}
|
|
}
|
|
|
|
// find duplicates
|
|
{
|
|
// map of same character keys by hash
|
|
QMap<uint, Parsing::ParsedImageData *> similarMap;
|
|
|
|
QListIterator<QString> it(orderedKeys);
|
|
it.toFront();
|
|
|
|
while (it.hasNext()) {
|
|
QString key = it.next();
|
|
|
|
Parsing::ParsedImageData *imageData = images->value(key);
|
|
|
|
if (imageData != nullptr) {
|
|
// detect same characters
|
|
Parsing::ParsedImageData *similarImageData = similarMap.value(imageData->hash(), nullptr);
|
|
|
|
if (similarImageData != nullptr) {
|
|
QString similarCode = similarImageData->tags()->tagValue(Parsing::TagsList::Tag::OutputCharacterCode);
|
|
QString similarText = similarImageData->tags()->tagValue(Parsing::TagsList::Tag::OutputCharacterText);
|
|
imageData->tags()->setTagValue(Parsing::TagsList::Tag::OutputCharacterCodeSimilar, similarCode);
|
|
imageData->tags()->setTagValue(Parsing::TagsList::Tag::OutputCharacterTextSimilar, similarText);
|
|
} else {
|
|
similarMap.insert(imageData->hash(), imageData);
|
|
imageData->tags()->setTagValue(Parsing::TagsList::Tag::OutputCharacterCodeSimilar, QString());
|
|
imageData->tags()->setTagValue(Parsing::TagsList::Tag::OutputCharacterTextSimilar, QString());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
QString FontDocument::hexCode(const QString &key, const QString &encoding, bool bom) const
|
|
{
|
|
QString result;
|
|
QTextCodec *codec = QTextCodec::codecForName(encoding.toLatin1());
|
|
|
|
QChar ch = key.at(0);
|
|
QByteArray codeArray = codec->fromUnicode(&ch, 1);
|
|
|
|
quint64 code = 0;
|
|
|
|
for (int i = 0; i < codeArray.count() && i < 8; i++) {
|
|
code = code << 8;
|
|
code |= (quint8)codeArray.at(i);
|
|
}
|
|
|
|
if (encoding.contains("UTF-16")) {
|
|
// reorder bytes
|
|
quint64 a =
|
|
((code & 0x000000000000ff00ULL) >> 8) |
|
|
((code & 0x00000000000000ffULL) << 8);
|
|
code &= 0xffffffffffff0000ULL;
|
|
code |= a;
|
|
|
|
if (bom) {
|
|
// 0xfeff00c1
|
|
result = QString("%1").arg(code, 8, 16, QChar('0'));
|
|
} else {
|
|
// 0x00c1
|
|
code &= 0x000000000000ffffULL;
|
|
result = QString("%1").arg(code, 4, 16, QChar('0'));
|
|
}
|
|
} else if (encoding.contains("UTF-32")) {
|
|
// reorder bytes
|
|
quint64 a =
|
|
((code & 0x00000000ff000000ULL) >> 24) |
|
|
((code & 0x0000000000ff0000ULL) >> 8) |
|
|
((code & 0x000000000000ff00ULL) << 8) |
|
|
((code & 0x00000000000000ffULL) << 24);
|
|
code &= 0xffffffff00000000ULL;
|
|
code |= a;
|
|
|
|
if (bom) {
|
|
// 0x0000feff000000c1
|
|
result = QString("%1").arg(code, 16, 16, QChar('0'));
|
|
} else {
|
|
// 0x000000c1
|
|
code &= 0x00000000ffffffffULL;
|
|
result = QString("%1").arg(code, 8, 16, QChar('0'));
|
|
}
|
|
} else {
|
|
result = QString("%1").arg(code, codeArray.count() * 2, 16, QChar('0'));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
bool caseInsensitiveLessThan(const QString &s1, const QString &s2)
|
|
{
|
|
return s1.toLower() < s2.toLower();
|
|
}
|
|
|
|
bool caseInsensitiveMoreThan(const QString &s1, const QString &s2)
|
|
{
|
|
return s1.toLower() > s2.toLower();
|
|
}
|
|
|
|
const QStringList FontDocument::sortKeysWithEncoding(const QStringList &keys, Preset *preset) const
|
|
{
|
|
|
|
bool useBom = preset->font()->bom();
|
|
QString encoding = preset->font()->encoding();
|
|
CharactersSortOrder order = preset->font()->sortOrder();
|
|
|
|
if (order == Parsing::Conversion::Options::CharactersSortOrder::None) {
|
|
return keys;
|
|
}
|
|
|
|
QMap <QString, QString> map;
|
|
|
|
QListIterator<QString> it(keys);
|
|
it.toFront();
|
|
|
|
while (it.hasNext()) {
|
|
const QString key = it.next();
|
|
const QString hex = this->hexCode(key, encoding, useBom);
|
|
map.insert(hex, key);
|
|
}
|
|
|
|
QStringList hexCodes = map.keys();
|
|
|
|
switch (order) {
|
|
case Parsing::Conversion::Options::CharactersSortOrder::Ascending:
|
|
qSort(hexCodes.begin(), hexCodes.end(), caseInsensitiveLessThan);
|
|
break;
|
|
|
|
case Parsing::Conversion::Options::CharactersSortOrder::Descending:
|
|
qSort(hexCodes.begin(), hexCodes.end(), caseInsensitiveMoreThan);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
QStringList result;
|
|
it = QListIterator<QString>(hexCodes);
|
|
it.toFront();
|
|
|
|
while (it.hasNext()) {
|
|
const QString key = it.next();
|
|
result.append(map.value(key));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void FontDocument::mon_container_dataChanged(bool historyStateMoved)
|
|
{
|
|
if (this->mNestedChangesCounter == 0) {
|
|
if (!historyStateMoved) {
|
|
this->mContainer->stateSave();
|
|
}
|
|
|
|
emit this->documentChanged();
|
|
}
|
|
}
|
|
|
|
} // namespace Containers
|
|
} // namespace Data
|