mainwindow.cpp - mozsearch

++ // Copyright (C) 2018 The Qt Company Ltd.

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0

++

++ #include "mainwindow.h"

++ #include "ui_mainwindow.h"

++ #include "distancefieldmodel.h"

++

++ #include <QtCore/qdir.h>

++ #include <QtCore/qdatastream.h>

++ #include <QtCore/qmath.h>

++ #include <QtCore/qendian.h>

++ #include <QtCore/qbuffer.h>

++ #include <QtGui/qdesktopservices.h>

++ #include <QtGui/qrawfont.h>

++ #include <QtWidgets/qmessagebox.h>

++ #include <QtWidgets/qlabel.h>

++ #include <QtWidgets/qprogressbar.h>

++ #include <QtWidgets/qfiledialog.h>

++ #include <QtWidgets/qinputdialog.h>

++

++ #include <QtCore/private/qunicodetables_p.h>

++ #include <QtGui/private/qdistancefield_p.h>

++ #include <QtQuick/private/qsgareaallocator_p.h>

++ #include <QtQuick/private/qsgadaptationlayer_p.h>

++

++ QT_BEGIN_NAMESPACE

++

++ static void openHelp()

++ {

++     const int qtVersion = QT_VERSION;

++     QString url;

++     QTextStream(&url) << "https://doc.qt.io/qt-" << (qtVersion >> 16) << "/qtdistancefieldgenerator-index.html";

++     QDesktopServices::openUrl(QUrl(url));

++ }

++

++ MainWindow::MainWindow(QWidget *parent)

++     : QMainWindow(parent)

++     , ui(new Ui::MainWindow)

++     , m_settings(qApp->organizationName(), qApp->applicationName())

++     , m_model(new DistanceFieldModel(this))

++     , m_statusBarLabel(nullptr)

++     , m_statusBarProgressBar(nullptr)

++ {

++     ui->setupUi(this);

++     ui->lvGlyphs->setModel(m_model);

++

++     ui->actionHelp->setShortcut(QKeySequence::HelpContents);

++

++     m_statusBarLabel = new QLabel(this);

++     m_statusBarLabel->setText(tr("Ready"));

++     ui->statusbar->addPermanentWidget(m_statusBarLabel);

++

++     m_statusBarProgressBar = new QProgressBar(this);

++     ui->statusbar->addPermanentWidget(m_statusBarProgressBar);

++     m_statusBarProgressBar->setVisible(false);

++

++     if (m_settings.contains(QStringLiteral("fontDirectory")))

++         m_fontDir = m_settings.value(QStringLiteral("fontDirectory")).toString();

++     else

++         m_fontDir = QDir::currentPath();

++

++     qRegisterMetaType<glyph_t>("glyph_t");

++     qRegisterMetaType<QPainterPath>("QPainterPath");

++

++     restoreGeometry(m_settings.value(QStringLiteral("geometry")).toByteArray());

++

++     setupConnections();

++ }

++

++ MainWindow::~MainWindow()

++ {

++     delete ui;

++ }

++

++ void MainWindow::open(const QString &path)

++ {

++     m_fileName.clear();

++     m_fontFile = path;

++     m_fontDir = QFileInfo(path).absolutePath();

++     m_settings.setValue(QStringLiteral("fontDirectory"), m_fontDir);

++

++     ui->lwUnicodeRanges->clear();

++     ui->lwUnicodeRanges->setDisabled(true);

++     ui->action_Save->setDisabled(true);

++     ui->action_Save_as->setDisabled(true);

++     ui->tbSave->setDisabled(true);

++     ui->action_Open->setDisabled(true);

++     m_model->setFont(path);

++ }

++

++ void MainWindow::closeEvent(QCloseEvent * /*event*/)

++ {

++     m_settings.setValue(QStringLiteral("geometry"), saveGeometry());

++ }

++

++ void MainWindow::setupConnections()

++ {

++     connect(ui->action_Open, &QAction::triggered, this, &MainWindow::openFont);

++     connect(ui->actionE_xit, &QAction::triggered, qApp, &QApplication::quit);

++     connect(ui->action_Save, &QAction::triggered, this, &MainWindow::save);

++     connect(ui->action_Save_as, &QAction::triggered, this, &MainWindow::saveAs);

++     connect(ui->tbSave, &QToolButton::clicked, this, &MainWindow::save);

++     connect(ui->tbSelectAll, &QToolButton::clicked, this, &MainWindow::selectAll);

++     connect(ui->actionSelect_all, &QAction::triggered, this, &MainWindow::selectAll);

++     connect(ui->actionSelect_string, &QAction::triggered, this, &MainWindow::selectString);

++     connect(ui->actionHelp, &QAction::triggered, this, openHelp);

++     connect(ui->actionAbout_App, &QAction::triggered, this, &MainWindow::about);

++     connect(ui->actionAbout_Qt, &QAction::triggered, this, [this]() {

++         QMessageBox::aboutQt(this);

++     });

++     connect(ui->lwUnicodeRanges, &QListWidget::itemSelectionChanged, this, &MainWindow::updateUnicodeRanges);

++

++     connect(ui->lvGlyphs->selectionModel(),

++             &QItemSelectionModel::selectionChanged,

++             this,

++             &MainWindow::updateSelection);

++     connect(m_model, &DistanceFieldModel::startGeneration, this, &MainWindow::startProgressBar);

++     connect(m_model, &DistanceFieldModel::stopGeneration, this, &MainWindow::stopProgressBar);

++     connect(m_model, &DistanceFieldModel::distanceFieldGenerated, this, &MainWindow::updateProgressBar);

++     connect(m_model, &DistanceFieldModel::stopGeneration, this, &MainWindow::populateUnicodeRanges);

++     connect(m_model, &DistanceFieldModel::error, this, &MainWindow::displayError);

++ }

++

++ void MainWindow::saveAs()

++ {

++     QString fileName = QFileDialog::getSaveFileName(this,

++                                                     tr("Save distance field-enriched file"),

++                                                     m_fontDir,

++                                                     tr("Font files (*.ttf *.otf);;All files (*)"));

++     if (!fileName.isEmpty()) {

++         m_fileName = fileName;

++         m_fontDir = QFileInfo(m_fileName).absolutePath();

++         m_settings.setValue(QStringLiteral("fontDirectory"), m_fontDir);

++         save();

++     }

++ }

++

++

++ #   pragma pack(1)

++ struct FontDirectoryHeader

++ {

++     quint32 sfntVersion;

++     quint16 numTables;

++     quint16 searchRange;

++     quint16 entrySelector;

++     quint16 rangeShift;

++ };

++

++ struct TableRecord

++ {

++     quint32 tag;

++     quint32 checkSum;

++     quint32 offset;

++     quint32 length;

++ };

++

++ struct QtdfHeader

++ {

++     quint8 majorVersion;

++     quint8 minorVersion;

++     quint16 pixelSize;

++     quint32 textureSize;

++     quint8 flags;

++     quint8 padding;

++     quint32 numGlyphs;

++ };

++

++ struct QtdfGlyphRecord

++ {

++     quint32 glyphIndex;

++     quint32 textureOffsetX;

++     quint32 textureOffsetY;

++     quint32 textureWidth;

++     quint32 textureHeight;

++     quint32 xMargin;

++     quint32 yMargin;

++     qint32 boundingRectX;

++     qint32 boundingRectY;

++     quint32 boundingRectWidth;

++     quint32 boundingRectHeight;

++     quint16 textureIndex;

++ };

++

++ struct QtdfTextureRecord

++ {

++     quint32 allocatedX;

++     quint32 allocatedY;

++     quint32 allocatedWidth;

++     quint32 allocatedHeight;

++     quint8 padding;

++ };

++

++ struct Head

++ {

++     quint16 majorVersion;

++     quint16 minorVersion;

++     quint32 fontRevision;

++     quint32 checkSumAdjustment;

++ };

++ #   pragma pack()

++

++ #define PAD_BUFFER(buffer, size) \

++     { \

++         int paddingNeed = size % 4; \

++         if (paddingNeed > 0) { \

++             const char padding[3] = { 0, 0, 0 }; \

++             buffer.write(padding, 4 - paddingNeed); \

++         } \

++     }

++

++ #define ALIGN_OFFSET(offset) \

++     { \

++         int paddingNeed = offset % 4; \

++         if (paddingNeed > 0) \

++             offset += 4 - paddingNeed; \

++     }

++

++ #define TO_FIXED_POINT(value) \

++     ((int)(value*qreal(65536)))

++

++ void MainWindow::save()

++ {

++     QModelIndexList list = ui->lvGlyphs->selectionModel()->selectedIndexes();

++     if (list.isEmpty()) {

++         QMessageBox::warning(this,

++                              tr("Nothing to save"),

++                              tr("No glyphs selected for saving."),

++                              QMessageBox::Ok);

++         return;

++     }

++

++     if (m_fileName.isEmpty()) {

++         saveAs();

++         return;

++     }

++

++     QFile inFile(m_fontFile);

++     if (!inFile.open(QIODevice::ReadOnly)) {

++         QMessageBox::warning(this,

++                              tr("Can't read original font"),

++                              tr("Cannot open '%s' for reading. The original font file must remain in place until the new file has been saved.").arg(m_fontFile),

++                              QMessageBox::Ok);

++         return;

++     }

++

++     QByteArray output;

++     quint32 headOffset = 0;

++

++     {

++         QBuffer outBuffer(&output);

++         outBuffer.open(QIODevice::WriteOnly);

++

++         uchar *inData = inFile.map(0, inFile.size());

++         if (inData == nullptr) {

++             QMessageBox::warning(this,

++                                  tr("Can't map input file"),

++                                  tr("Unable to memory map input file '%s'.").arg(m_fontFile));

++             return;

++         }

++

++         uchar *end = inData + inFile.size();

++         if (inData + sizeof(FontDirectoryHeader) > end) {

++             QMessageBox::warning(this,

++                                  tr("Can't read font directory"),

++                                  tr("Input file seems to be invalid or corrupt."),

++                                  QMessageBox::Ok);

++             return;

++         }

++

++         FontDirectoryHeader fontDirectoryHeader;

++         memcpy(&fontDirectoryHeader, inData, sizeof(FontDirectoryHeader));

++         quint16 numTables = qFromBigEndian(fontDirectoryHeader.numTables) + 1;

++         fontDirectoryHeader.numTables = qToBigEndian(numTables);

++         {

++             quint16 searchRange = qFromBigEndian(fontDirectoryHeader.searchRange);

++             if (searchRange / 16 < numTables) {

++                 quint16 pot = (searchRange / 16) * 2;

++                 searchRange = pot * 16;

++                 fontDirectoryHeader.searchRange = qToBigEndian(searchRange);

++                 fontDirectoryHeader.rangeShift = qToBigEndian(numTables * 16 - searchRange);

++

++                 quint16 entrySelector = 0;

++                 while (pot > 1) {

++                     pot >>= 1;

++                     entrySelector++;

++                 }

++                 fontDirectoryHeader.entrySelector = qToBigEndian(entrySelector);

++             }

++         }

++

++         outBuffer.write(reinterpret_cast<char *>(&fontDirectoryHeader),

++                         sizeof(FontDirectoryHeader));

++

++         QVarLengthArray<std::pair<quint32, quint32>> offsetLengthPairs;

++         offsetLengthPairs.reserve(numTables - 1);

++

++         // Copy the offset table, updating offsets

++         TableRecord *offsetTable = reinterpret_cast<TableRecord *>(inData + sizeof(FontDirectoryHeader));

++         quint32 currentOffset = sizeof(FontDirectoryHeader) + sizeof(TableRecord) * numTables;

++         for (int i = 0; i < numTables - 1; ++i) {

++             ALIGN_OFFSET(currentOffset)

++

++             quint32 originalOffset = qFromBigEndian(offsetTable->offset);

++             quint32 length = qFromBigEndian(offsetTable->length);

++             offsetLengthPairs.append({originalOffset, length});

++             if (offsetTable->tag == qFromBigEndian(QFont::Tag("head").value()))

++                 headOffset = currentOffset;

++

++             TableRecord newTableRecord;

++             memcpy(&newTableRecord, offsetTable, sizeof(TableRecord));

++             newTableRecord.offset = qToBigEndian(currentOffset);

++             outBuffer.write(reinterpret_cast<char *>(&newTableRecord), sizeof(TableRecord));

++

++             offsetTable++;

++             currentOffset += length;

++         }

++

++         if (headOffset == 0) {

++             QMessageBox::warning(this,

++                                  tr("Invalid font file"),

++                                  tr("Font file does not have 'head' table."),

++                                  QMessageBox::Ok);

++             return;

++         }

++

++         QByteArray qtdf = createSfntTable();

++         if (qtdf.isEmpty())

++             return;

++

++         {

++             ALIGN_OFFSET(currentOffset)

++

++             TableRecord qtdfRecord;

++             qtdfRecord.offset = qToBigEndian(currentOffset);

++             qtdfRecord.length = qToBigEndian(quint32(qtdf.size()));

++             qtdfRecord.tag = qFromBigEndian(QFont::Tag("qtdf").value());

++             quint32 checkSum = 0;

++             const quint32 *start = reinterpret_cast<const quint32 *>(qtdf.constData());

++             const quint32 *end = reinterpret_cast<const quint32 *>(qtdf.constData() + qtdf.size());

++             while (start < end)

++                 checkSum += *(start++);

++             qtdfRecord.checkSum = qToBigEndian(checkSum);

++

++             outBuffer.write(reinterpret_cast<char *>(&qtdfRecord),

++                             sizeof(TableRecord));

++         }

++

++         // Copy all font tables

++         for (const std::pair<quint32, quint32> &offsetLengthPair : offsetLengthPairs) {

++             PAD_BUFFER(outBuffer, output.size())

++             outBuffer.write(reinterpret_cast<char *>(inData + offsetLengthPair.first),

++                             offsetLengthPair.second);

++         }

++

++         PAD_BUFFER(outBuffer, output.size())

++         outBuffer.write(qtdf);

++     }

++

++     // Clear 'head' checksum and calculate new check sum adjustment

++     Head *head = reinterpret_cast<Head *>(output.data() + headOffset);

++     head->checkSumAdjustment = 0;

++

++     quint32 checkSum = 0;

++     const quint32 *start = reinterpret_cast<const quint32 *>(output.constData());

++     const quint32 *end = reinterpret_cast<const quint32 *>(output.constData() + output.size());

++     while (start < end)

++         checkSum += *(start++);

++

++     head->checkSumAdjustment = qToBigEndian(0xB1B0AFBA - checkSum);

++

++     QFile outFile(m_fileName);

++     if (!outFile.open(QIODevice::WriteOnly)) {

++         QMessageBox::warning(this,

++                              tr("Can't write to file"),

++                              tr("Cannot open the file '%s' for writing").arg(m_fileName),

++                              QMessageBox::Ok);

++         return;

++     }

++

++     outFile.write(output);

++ }

++

++ QByteArray MainWindow::createSfntTable()

++ {

++     QModelIndexList list = ui->lvGlyphs->selectionModel()->selectedIndexes();

++     Q_ASSERT(!list.isEmpty());

++

++     QByteArray ret;

++     {

++         QBuffer buffer(&ret);

++         buffer.open(QIODevice::WriteOnly);

++

++         QtdfHeader header;

++         header.majorVersion = 5;

++         header.minorVersion = 12;

++         header.pixelSize = qToBigEndian(quint16(qRound(m_model->pixelSize())));

++

++         const quint8 padding = 2;

++         qreal scaleFactor = qreal(1) / QT_DISTANCEFIELD_SCALE(m_model->doubleGlyphResolution());

++         const int radius = QT_DISTANCEFIELD_RADIUS(m_model->doubleGlyphResolution())

++                 / QT_DISTANCEFIELD_SCALE(m_model->doubleGlyphResolution());

++

++         quint32 textureSize = ui->sbMaximumTextureSize->value();

++

++         // Since we are using a single area allocator that spans all textures, we need

++         // to split the textures one row before the actual maximum size, otherwise

++         // glyphs that fall on the edge between two textures will expand the texture

++         // they are assigned to, and this will end up being larger than the max.

++         textureSize -= quint32(qCeil(m_model->pixelSize() * scaleFactor) + radius * 2 + padding * 2);

++         header.textureSize = qToBigEndian(textureSize);

++

++         header.padding = padding;

++         header.flags = m_model->doubleGlyphResolution() ? 1 : 0;

++         header.numGlyphs = qToBigEndian(quint32(list.size()));

++         buffer.write(reinterpret_cast<char *>(&header),

++                      sizeof(QtdfHeader));

++

++         // Maximum height allocator to find optimal number of textures

++         QList<QRect> allocatedAreaPerTexture;

++

++         struct GlyphData {

++             QSGDistanceFieldGlyphCache::TexCoord texCoord;

++             QRectF boundingRect;

++             QSize glyphSize;

++             int textureIndex;

++         };

++         QList<GlyphData> glyphDatas;

++         glyphDatas.resize(m_model->rowCount());

++

++         int textureCount = 0;

++

++         {

++             QTransform scaleDown;

++             scaleDown.scale(scaleFactor, scaleFactor);

++

++             {

++                 bool foundOptimalSize = false;

++                 while (!foundOptimalSize) {

++                     allocatedAreaPerTexture.clear();

++

++                     QSGAreaAllocator allocator(QSize(textureSize, textureSize * (++textureCount)));

++

++                     int i;

++                     for (i = 0; i < list.size(); ++i) {

++                         int glyphIndex = list.at(i).row();

++                         GlyphData &glyphData = glyphDatas[glyphIndex];

++

++                         QPainterPath path = m_model->path(glyphIndex);

++                         glyphData.boundingRect = scaleDown.mapRect(path.boundingRect());

++                         int glyphWidth = qCeil(glyphData.boundingRect.width()) + radius * 2;

++                         int glyphHeight = qCeil(glyphData.boundingRect.height()) + radius * 2;

++

++                         glyphData.glyphSize = QSize(glyphWidth + padding * 2, glyphHeight + padding * 2);

++

++                         if (glyphData.glyphSize.width() > qint32(textureSize)

++                                 || glyphData.glyphSize.height() > qint32(textureSize)) {

++                             QMessageBox::warning(this,

++                                                  tr("Glyph too large for texture"),

++                                                  tr("Glyph %1 is too large to fit in texture of size %2.")

++                                                  .arg(glyphIndex).arg(textureSize));

++                             return QByteArray();

++                         }

++

++                         QRect rect = allocator.allocate(glyphData.glyphSize);

++                         if (rect.isNull())

++                             break;

++

++                         glyphData.textureIndex = rect.y() / textureSize;

++                         while (glyphData.textureIndex >= allocatedAreaPerTexture.size())

++                             allocatedAreaPerTexture.append(QRect(0, 0, 1, 1));

++

++                         allocatedAreaPerTexture[glyphData.textureIndex] |= QRect(rect.x(),

++                                                             rect.y() % textureSize,

++                                                             rect.width(),

++                                                             rect.height());

++

++                         glyphData.texCoord.xMargin = QT_DISTANCEFIELD_RADIUS(m_model->doubleGlyphResolution()) / qreal(QT_DISTANCEFIELD_SCALE(m_model->doubleGlyphResolution()));

++                         glyphData.texCoord.yMargin = QT_DISTANCEFIELD_RADIUS(m_model->doubleGlyphResolution()) / qreal(QT_DISTANCEFIELD_SCALE(m_model->doubleGlyphResolution()));

++                         glyphData.texCoord.x = rect.x() + padding;

++                         glyphData.texCoord.y = rect.y() % textureSize + padding;

++                         glyphData.texCoord.width = glyphData.boundingRect.width();

++                         glyphData.texCoord.height = glyphData.boundingRect.height();

++

++                         glyphDatas.append(glyphData);

++                     }

++

++                     foundOptimalSize = i == list.size();

++                     if (foundOptimalSize)

++                         buffer.write(allocator.serialize());

++                 }

++             }

++         }

++

++         QList<QDistanceField> textures;

++         textures.resize(textureCount);

++

++         for (int textureIndex = 0; textureIndex < textureCount; ++textureIndex) {

++             textures[textureIndex] = QDistanceField(allocatedAreaPerTexture.at(textureIndex).width(),

++                                                     allocatedAreaPerTexture.at(textureIndex).height());

++

++             QRect rect = allocatedAreaPerTexture.at(textureIndex);

++

++             QtdfTextureRecord record;

++             record.allocatedX = qToBigEndian(rect.x());

++             record.allocatedY = qToBigEndian(rect.y());

++             record.allocatedWidth = qToBigEndian(rect.width());

++             record.allocatedHeight = qToBigEndian(rect.height());

++             record.padding = padding;

++             buffer.write(reinterpret_cast<char *>(&record),

++                          sizeof(QtdfTextureRecord));

++         }

++

++         {

++             for (int i = 0; i < list.size(); ++i) {

++                 int glyphIndex = list.at(i).row();

++                 QImage image = m_model->distanceField(glyphIndex);

++

++                 const GlyphData &glyphData = glyphDatas.at(glyphIndex);

++

++                 QtdfGlyphRecord glyphRecord;

++                 glyphRecord.glyphIndex = qToBigEndian(glyphIndex);

++                 glyphRecord.textureOffsetX = qToBigEndian(TO_FIXED_POINT(glyphData.texCoord.x));

++                 glyphRecord.textureOffsetY = qToBigEndian(TO_FIXED_POINT(glyphData.texCoord.y));

++                 glyphRecord.textureWidth = qToBigEndian(TO_FIXED_POINT(glyphData.texCoord.width));

++                 glyphRecord.textureHeight = qToBigEndian(TO_FIXED_POINT(glyphData.texCoord.height));

++                 glyphRecord.xMargin = qToBigEndian(TO_FIXED_POINT(glyphData.texCoord.xMargin));

++                 glyphRecord.yMargin = qToBigEndian(TO_FIXED_POINT(glyphData.texCoord.yMargin));

++                 glyphRecord.boundingRectX = qToBigEndian(TO_FIXED_POINT(glyphData.boundingRect.x()));

++                 glyphRecord.boundingRectY = qToBigEndian(TO_FIXED_POINT(glyphData.boundingRect.y()));

++                 glyphRecord.boundingRectWidth = qToBigEndian(TO_FIXED_POINT(glyphData.boundingRect.width()));

++                 glyphRecord.boundingRectHeight = qToBigEndian(TO_FIXED_POINT(glyphData.boundingRect.height()));

++                 glyphRecord.textureIndex = qToBigEndian(quint16(glyphData.textureIndex));

++                 buffer.write(reinterpret_cast<char *>(&glyphRecord), sizeof(QtdfGlyphRecord));

++

++                 int expectedWidth = qCeil(glyphData.texCoord.width + glyphData.texCoord.xMargin * 2);

++                 image = image.copy(-padding, -padding,

++                                    expectedWidth + padding  * 2,

++                                    image.height() + padding * 2);

++

++                 uchar *inBits = image.scanLine(0);

++                 uchar *outBits = textures[glyphData.textureIndex].scanLine(int(glyphData.texCoord.y) - padding)

++                                     + int(glyphData.texCoord.x) - padding;

++                 for (int y = 0; y < image.height(); ++y) {

++                     memcpy(outBits, inBits, image.width());

++                     inBits += image.bytesPerLine();

++                     outBits += textures[glyphData.textureIndex].width();

++                 }

++             }

++         }

++

++         for (int i = 0; i < textures.size(); ++i) {

++             const QDistanceField &texture = textures.at(i);

++             const QRect &allocatedArea = allocatedAreaPerTexture.at(i);

++             buffer.write(reinterpret_cast<const char *>(texture.constBits()),

++                        allocatedArea.width() * allocatedArea.height());

++         }

++

++         PAD_BUFFER(buffer, ret.size())

++     }

++

++     return ret;

++ }

++

++ void MainWindow::writeFile()

++ {

++     Q_ASSERT(!m_fileName.isEmpty());

++

++     QFile file(m_fileName);

++     if (file.open(QIODevice::WriteOnly)) {

++

++     } else {

++         QMessageBox::warning(this,

++                              tr("Can't open file for writing"),

++                              tr("Unable to open file '%1' for writing").arg(m_fileName),

++                              QMessageBox::Ok);

++     }

++ }

++

++ void MainWindow::openFont()

++ {

++     QString fileName = QFileDialog::getOpenFileName(this,

++                                                     tr("Open font file"),

++                                                     m_fontDir,

++                                                     tr("Fonts (*.ttf *.otf);;All files (*)"));

++     if (!fileName.isEmpty())

++         open(fileName);

++ }

++

++ void MainWindow::updateProgressBar()

++ {

++     m_statusBarProgressBar->setValue(m_statusBarProgressBar->value() + 1);

++     updateSelection();

++ }

++

++ void MainWindow::startProgressBar(quint16 glyphCount)

++ {

++     ui->action_Open->setDisabled(false);

++     m_statusBarLabel->setText(tr("Generating"));

++     m_statusBarProgressBar->setMaximum(glyphCount);

++     m_statusBarProgressBar->setMinimum(0);

++     m_statusBarProgressBar->setValue(0);

++     m_statusBarProgressBar->setVisible(true);

++ }

++

++ void MainWindow::stopProgressBar()

++ {

++     m_statusBarLabel->setText(tr("Ready"));

++     m_statusBarProgressBar->setVisible(false);

++ }

++

++ void MainWindow::selectAll()

++ {

++     QModelIndexList list = ui->lvGlyphs->selectionModel()->selectedIndexes();

++     if (list.size() == ui->lvGlyphs->model()->rowCount())

++         ui->lvGlyphs->clearSelection();

++     else

++         ui->lvGlyphs->selectAll();

++ }

++

++ void MainWindow::updateSelection()

++ {

++     QModelIndexList list = ui->lvGlyphs->selectionModel()->selectedIndexes();

++     QString label;

++     if (list.size() == ui->lvGlyphs->model()->rowCount())

++         label = tr("Deselect &All");

++     else

++         label = tr("Select &All");

++

++     ui->tbSelectAll->setText(label);

++     ui->actionSelect_all->setText(label);

++

++     if (m_model != nullptr && ui->lwUnicodeRanges->count() > 0) {

++         // Ignore selection changes until we are done

++         disconnect(ui->lwUnicodeRanges, &QListWidget::itemSelectionChanged, this, &MainWindow::updateUnicodeRanges);

++

++         QSet<int> selectedGlyphIndexes;

++         for (const QModelIndex &modelIndex : list)

++             selectedGlyphIndexes.insert(modelIndex.row());

++

++         QList<DistanceFieldModel::UnicodeRange> unicodeRanges = m_model->unicodeRanges();

++         std::sort(unicodeRanges.begin(), unicodeRanges.end());

++

++         Q_ASSERT(ui->lwUnicodeRanges->count() == unicodeRanges.size());

++         for (int i = 0; i < unicodeRanges.size(); ++i) {

++             DistanceFieldModel::UnicodeRange unicodeRange = unicodeRanges.at(i);

++             QListWidgetItem *item = ui->lwUnicodeRanges->item(i);

++

++             QList<glyph_t> glyphIndexes = m_model->glyphIndexesForUnicodeRange(unicodeRange);

++             Q_ASSERT(!glyphIndexes.isEmpty());

++

++             item->setSelected(true);

++             for (glyph_t glyphIndex : glyphIndexes) {

++                 if (!selectedGlyphIndexes.contains(glyphIndex)) {

++                     item->setSelected(false);

++                     break;

++                 }

++             }

++         }

++

++         connect(ui->lwUnicodeRanges, &QListWidget::itemSelectionChanged, this, &MainWindow::updateUnicodeRanges);

++     }

++ }

++

++ void MainWindow::updateUnicodeRanges()

++ {

++     if (m_model == nullptr)

++         return;

++

++     disconnect(ui->lvGlyphs->selectionModel(),

++                &QItemSelectionModel::selectionChanged,

++                this,

++                &MainWindow::updateSelection);

++

++     QItemSelection selectedItems;

++

++     for (int i = 0; i < ui->lwUnicodeRanges->count(); ++i) {

++         QListWidgetItem *item = ui->lwUnicodeRanges->item(i);

++         if (item->isSelected()) {

++             DistanceFieldModel::UnicodeRange unicodeRange = item->data(Qt::UserRole).value<DistanceFieldModel::UnicodeRange>();

++             QList<glyph_t> glyphIndexes = m_model->glyphIndexesForUnicodeRange(unicodeRange);

++

++             for (glyph_t glyphIndex : glyphIndexes) {

++                 QModelIndex index = m_model->index(glyphIndex);

++                 selectedItems.select(index, index);

++             }

++         }

++     }

++

++     ui->lvGlyphs->selectionModel()->clearSelection();

++     if (!selectedItems.isEmpty())

++         ui->lvGlyphs->selectionModel()->select(selectedItems, QItemSelectionModel::Select);

++

++     connect(ui->lvGlyphs->selectionModel(),

++             &QItemSelectionModel::selectionChanged,

++             this,

++             &MainWindow::updateSelection);

++ }

++

++ void MainWindow::populateUnicodeRanges()

++ {

++     QList<DistanceFieldModel::UnicodeRange> unicodeRanges = m_model->unicodeRanges();

++     std::sort(unicodeRanges.begin(), unicodeRanges.end());

++

++     for (DistanceFieldModel::UnicodeRange unicodeRange : unicodeRanges) {

++         QString name = m_model->nameForUnicodeRange(unicodeRange);

++         QListWidgetItem *item = new QListWidgetItem(name, ui->lwUnicodeRanges);

++         item->setData(Qt::UserRole, unicodeRange);

++     }

++

++     ui->lwUnicodeRanges->setDisabled(false);

++     ui->action_Save->setDisabled(false);

++     ui->action_Save_as->setDisabled(false);

++     ui->tbSave->setDisabled(false);

++ }

++

++ void MainWindow::displayError(const QString &errorString)

++ {

++     QMessageBox::warning(this, tr("Error when parsing font file"), errorString, QMessageBox::Ok);

++ }

++

++ void MainWindow::selectString()

++ {

++     QString s = QInputDialog::getText(this,

++                                       tr("Select glyphs for string"),

++                                       tr("String to parse:"));

++     if (!s.isEmpty()) {

++         QList<uint> ucs4String = s.toUcs4();

++         for (uint ucs4 : ucs4String) {

++             glyph_t glyph = m_model->glyphIndexForUcs4(ucs4);

++             if (glyph != 0) {

++                 ui->lvGlyphs->selectionModel()->select(m_model->index(glyph),

++                                                        QItemSelectionModel::Select);

++             }

++         }

++     }

++ }

++

++ void MainWindow::about()

++ {

++     QMessageBox *msgBox = new QMessageBox(this);

++     msgBox->setAttribute(Qt::WA_DeleteOnClose);

++     msgBox->setWindowTitle(tr("About Qt Distance Field Generator"));

++     msgBox->setText(tr("<h3>Qt Distance Field Generator</h3>"

++                        "<p>Version %1.<br/>"

++                        "The Qt Distance Field Generator tool allows "

++                        "to prepare a font cache for Qt applications.</p>"

++                        "<p>Copyright (C) The Qt Company Ltd. and other contributors.</p>")

++                     .arg(QLatin1String(QT_VERSION_STR)));

++     msgBox->show();

++ }

++

++ QT_END_NAMESPACE

Revision control