File indexing completed on 2024-05-12 16:06:37

 // -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; c-brace-offset: 0; -*-
 //
 // fontpool.cpp
 //
 // SPDX-FileCopyrightText: 2001-2005 Stefan Kebekus
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <config.h>
 
 #include "TeXFont.h"
 #include "debug_dvi.h"
 #include "fontpool.h"
 
 #include <KLocalizedString>
 
 #include <QApplication>
 #include <QPainter>
 #include <QStandardPaths>
 
 #include <cmath>
 #include <math.h>
 
 //#define DEBUG_FONTPOOL
 
 // List of permissible MetaFontModes which are supported by kdvi.
 
 // const char *MFModes[]       = { "cx", "ljfour", "lexmarks" };
 // const char *MFModenames[]   = { "Canon CX", "LaserJet 4", "Lexmark S" };
 // const int   MFResolutions[] = { 300, 600, 1200 };
 
 #ifdef PERFORMANCE_MEASUREMENT
 QTime fontPoolTimer;
 bool fontPoolTimerFlag;
 #endif
 
 fontPool::fontPool(bool useFontHinting)
 {
 #ifdef DEBUG_FONTPOOL
     qCDebug(OkularDviDebug) << "fontPool::fontPool() called";
 #endif
 
     setObjectName(QStringLiteral("Font Pool"));
 
     displayResolution_in_dpi = 100.0; // A not-too-bad-default
     useFontHints = useFontHinting;
     CMperDVIunit = 0;
     extraSearchPath.clear();
 
 #ifdef HAVE_FREETYPE
     // Initialize the Freetype Library
     if (FT_Init_FreeType(&FreeType_library) != 0) {
         qCCritical(OkularDviDebug) << "Cannot load the FreeType library. KDVI proceeds without FreeType support.";
         FreeType_could_be_loaded = false;
     } else {
         FreeType_could_be_loaded = true;
     }
 #endif
 
     // Check if the QT library supports the alpha channel of
     // QImages. Experiments show that --depending of the configuration
     // of QT at compile and runtime or the availability of the XFt
     // extension, alpha channels are either supported, or silently
     // ignored.
     QImage start(1, 1, QImage::Format_ARGB32); // Generate a 1x1 image, black with alpha=0x10
     quint32 *destScanLine = reinterpret_cast<quint32 *>(start.scanLine(0));
     *destScanLine = 0x80000000;
     QPixmap intermediate = QPixmap::fromImage(start);
     QPixmap dest(1, 1);
     dest.fill(Qt::white);
     QPainter paint(&dest);
     paint.drawPixmap(0, 0, intermediate);
     paint.end();
     start = dest.toImage().convertToFormat(QImage::Format_ARGB32);
     quint8 result = *(start.scanLine(0)) & 0xff;
 
     if ((result == 0xff) || (result == 0x00)) {
 #ifdef DEBUG_FONTPOOL
         qCDebug(OkularDviDebug) << "fontPool::fontPool(): QPixmap does not support the alpha channel";
 #endif
         QPixmapSupportsAlpha = false;
     } else {
 #ifdef DEBUG_FONTPOOL
         qCDebug(OkularDviDebug) << "fontPool::fontPool(): QPixmap supports the alpha channel";
 #endif
         QPixmapSupportsAlpha = true;
     }
 }
 
 fontPool::~fontPool()
 {
 #ifdef DEBUG_FONTPOOL
     qCDebug(OkularDviDebug) << "fontPool::~fontPool() called";
 #endif
 
     // need to manually clear the fonts _before_ freetype gets unloaded
     qDeleteAll(fontList);
     fontList.clear();
 
 #ifdef HAVE_FREETYPE
     if (FreeType_could_be_loaded == true) {
         FT_Done_FreeType(FreeType_library);
     }
 #endif
 }
 
 void fontPool::setParameters(bool _useFontHints)
 {
     // Check if glyphs need to be cleared
     if (_useFontHints != useFontHints) {
         double displayResolution = displayResolution_in_dpi;
         QList<TeXFontDefinition *>::iterator it_fontp = fontList.begin();
         for (; it_fontp != fontList.end(); ++it_fontp) {
             TeXFontDefinition *fontp = *it_fontp;
             fontp->setDisplayResolution(displayResolution * fontp->enlargement);
         }
     }
 
     useFontHints = _useFontHints;
 }
 
 TeXFontDefinition *fontPool::appendx(const QString &fontname, quint32 checksum, quint32 scale, double enlargement)
 {
     // Reuse font if possible: check if a font with that name and
     // natural resolution is already in the fontpool, and use that, if
     // possible.
     QList<TeXFontDefinition *>::iterator it_fontp = fontList.begin();
     for (; it_fontp != fontList.end(); ++it_fontp) {
         TeXFontDefinition *fontp = *it_fontp;
         if ((fontname == fontp->fontname) && ((int)(enlargement * 1000.0 + 0.5)) == (int)(fontp->enlargement * 1000.0 + 0.5)) {
             // if font is already in the list
             fontp->mark_as_used();
             return fontp;
         }
     }
 
     // If font doesn't exist yet, we have to generate a new font.
 
     double displayResolution = displayResolution_in_dpi;
 
     TeXFontDefinition *fontp = new TeXFontDefinition(fontname, displayResolution * enlargement, checksum, scale, this, enlargement);
     if (fontp == nullptr) {
         qCCritical(OkularDviDebug) << "Could not allocate memory for a font structure";
         exit(0);
     }
     fontList.append(fontp);
 
 #ifdef PERFORMANCE_MEASUREMENT
     fontPoolTimer.start();
     fontPoolTimerFlag = false;
 #endif
 
     // Now start kpsewhich/MetaFont, etc. if necessary
     return fontp;
 }
 
 bool fontPool::areFontsLocated()
 {
 #ifdef DEBUG_FONTPOOL
     qCDebug(OkularDviDebug) << "fontPool::areFontsLocated() called";
 #endif
 
     // Is there a font whose name we did not try to find out yet?
     QList<TeXFontDefinition *>::const_iterator cit_fontp = fontList.constBegin();
     for (; cit_fontp != fontList.constEnd(); ++cit_fontp) {
         TeXFontDefinition *fontp = *cit_fontp;
         if (!fontp->isLocated()) {
             return false;
         }
     }
 
 #ifdef DEBUG_FONTPOOL
     qCDebug(OkularDviDebug) << "... yes, all fonts are located (but not necessarily loaded).";
 #endif
     return true; // That says that all fonts are located.
 }
 
 void fontPool::locateFonts()
 {
     kpsewhichOutput.clear();
 
     // First, we try and find those fonts which exist on disk
     // already. If virtual fonts are found, they will add new fonts to
     // the list of fonts whose font files need to be located, so that we
     // repeat the lookup.
     bool vffound;
     do {
         vffound = false;
         locateFonts(false, false, &vffound);
     } while (vffound);
 
     // If still not all fonts are found, look again, this time with
     // on-demand generation of PK fonts enabled.
     if (!areFontsLocated()) {
         locateFonts(true, false);
     }
 
     // If still not all fonts are found, we look for TFM files as a last
     // resort, so that we can at least draw filled rectangles for
     // characters.
     if (!areFontsLocated()) {
         locateFonts(false, true);
     }
 
     // If still not all fonts are found, we give up. We mark all fonts
     // as 'located', so that we won't look for them any more, and
     // present an error message to the user.
     if (!areFontsLocated()) {
         markFontsAsLocated();
         Q_EMIT error(i18n("<qt><p>Okular was not able to locate all the font files "
                           "which are necessary to display the current DVI file. "
                           "Your document might be unreadable.</p>"
                           "<p><small><b>PATH:</b> %1</small></p>"
                           "<p><small>%2</small></p></qt>",
                           QString::fromLocal8Bit(qgetenv("PATH")),
                           kpsewhichOutput.replace(QLatin1String("\n"), QLatin1String("<br/>"))),
                      -1);
     }
 }
 
 void fontPool::locateFonts(bool makePK, bool locateTFMonly, bool *virtualFontsFound)
 {
     // Make sure kpsewhich is in PATH and not just in the CWD
     static const QString kpsewhichFullPath = QStandardPaths::findExecutable(QStringLiteral("kpsewhich"));
     if (kpsewhichFullPath.isEmpty()) {
         return;
     }
 
     // Set up the kpsewhich process. If pass == 0, look for vf-fonts and
     // disable automatic font generation as vf-fonts can't be
     // generated. If pass == 0, enable font generation, if it was
     // enabled globally.
 
     // Now generate the command line for the kpsewhich
     // program. Unfortunately, this can be rather long and involved...
     QStringList kpsewhich_args;
     kpsewhich_args << QStringLiteral("--dpi") << QStringLiteral("1200") << QStringLiteral("--mode") << QStringLiteral("lexmarks");
 
     // Disable automatic pk-font generation.
     kpsewhich_args << QString::fromLocal8Bit(makePK ? "--mktex" : "--no-mktex") << QStringLiteral("pk");
 
     // Names of fonts that shall be located
     quint16 numFontsInJob = 0;
     QList<TeXFontDefinition *>::const_iterator cit_fontp = fontList.constBegin();
     for (; cit_fontp != fontList.constEnd(); ++cit_fontp) {
         TeXFontDefinition *fontp = *cit_fontp;
         if (!fontp->isLocated()) {
             numFontsInJob++;
 
             if (locateTFMonly == true) {
                 kpsewhich_args << QStringLiteral("%1.tfm").arg(fontp->fontname);
             } else {
 #ifdef HAVE_FREETYPE
                 if (FreeType_could_be_loaded == true) {
                     const QString &filename = fontsByTeXName.findFileName(fontp->fontname);
                     if (!filename.isEmpty()) {
                         kpsewhich_args << QStringLiteral("%1").arg(filename);
                     }
                 }
 #endif
                 kpsewhich_args << QStringLiteral("%1.vf").arg(fontp->fontname) << QStringLiteral("%1.1200pk").arg(fontp->fontname);
             }
         }
     }
 
     if (numFontsInJob == 0) {
         return;
     }
 
     // If PK fonts are generated, the kpsewhich command will re-route
     // the output of MetaFont into its stderr. Here we make sure this
     // output is intercepted and parsed.
     kpsewhich_ = std::make_unique<QProcess>();
     connect(kpsewhich_.get(), &QProcess::readyReadStandardError, this, &fontPool::mf_output_receiver);
 
     // Now run... kpsewhich. In case of error, kick up a fuss.
     // This string is not going to be quoted, as it might be were it
     // a real command line, but who cares?
     const QString kpsewhich_exe = QStringLiteral("kpsewhich");
     kpsewhichOutput += QStringLiteral("<b>") + kpsewhich_exe + QLatin1Char(' ') + kpsewhich_args.join(QStringLiteral(" ")) + QStringLiteral("</b>");
 
     kpsewhich_->start(kpsewhichFullPath, kpsewhich_args, QIODevice::ReadOnly | QIODevice::Text);
     if (!kpsewhich_->waitForStarted()) {
         QApplication::restoreOverrideCursor();
         Q_EMIT error(i18n("<qt><p>There were problems running <em>kpsewhich</em>. As a result, "
                           "some font files could not be located, and your document might be unreadable.<br/>"
                           "Possible reason: the <em>kpsewhich</em> program is perhaps not installed on your system, "
                           "or it cannot be found in the current search path.</p>"
                           "<p><small><b>PATH:</b> %1</small></p>"
                           "<p><small>%2</small></p></qt>",
                           QString::fromLocal8Bit(qgetenv("PATH")),
                           kpsewhichOutput.replace(QLatin1String("\n"), QLatin1String("<br/>"))),
                      -1);
 
         // This makes sure the we don't try to run kpsewhich again
         markFontsAsLocated();
         kpsewhich_.reset();
         return;
     }
     // We wait here while the external program runs concurrently.
     kpsewhich_->waitForFinished();
 
     // Handle fatal errors.
     int const kpsewhich_exit_code = kpsewhich_->exitCode();
     if (kpsewhich_exit_code < 0) {
         Q_EMIT warning(i18n("<qt>The font generation by <em>kpsewhich</em> was aborted (exit code %1, error %2). As a "
                             "result, some font files could not be located, and your document might be unreadable.</qt>",
                             kpsewhich_exit_code,
                             kpsewhich_->errorString()),
                        -1);
 
         // This makes sure the we don't try to run kpsewhich again
         if (makePK == false) {
             markFontsAsLocated();
         }
     }
 
     // Create a list with all filenames found by the kpsewhich program.
     const QStringList fileNameList = QString::fromLocal8Bit(kpsewhich_->readAll()).split(QLatin1Char('\n'), Qt::SkipEmptyParts);
 
     // Now associate the file names found with the fonts
     QList<TeXFontDefinition *>::iterator it_fontp = fontList.begin();
     for (; it_fontp != fontList.end(); ++it_fontp) {
         TeXFontDefinition *fontp = *it_fontp;
 
         if (fontp->filename.isEmpty() == true) {
             QStringList matchingFiles;
 #ifdef HAVE_FREETYPE
             const QString &fn = fontsByTeXName.findFileName(fontp->fontname);
             if (!fn.isEmpty()) {
                 matchingFiles = fileNameList.filter(fn);
             }
 #endif
             if (matchingFiles.isEmpty() == true) {
                 matchingFiles += fileNameList.filter(QLatin1Char('/') + fontp->fontname + QLatin1Char('.'));
             }
 
             if (matchingFiles.isEmpty() != true) {
 #ifdef DEBUG_FONTPOOL
                 qCDebug(OkularDviDebug) << "Associated " << fontp->fontname << " to " << matchingFiles.first();
 #endif
                 QString fname = matchingFiles.first();
                 fontp->fontNameReceiver(fname);
                 fontp->flags |= TeXFontDefinition::FONT_KPSE_NAME;
                 if (fname.endsWith(QLatin1String(".vf"))) {
                     if (virtualFontsFound != nullptr) {
                         *virtualFontsFound = true;
                     }
                     // Constructing a virtual font will most likely insert other
                     // fonts into the fontList. After that, fontList.next() will
                     // no longer work. It is therefore safer to start over.
                     it_fontp = fontList.begin();
                     continue;
                 }
             }
         } // of if (fontp->filename.isEmpty() == true)
     }
     kpsewhich_.reset();
 }
 
 void fontPool::setCMperDVIunit(double _CMperDVI)
 {
 #ifdef DEBUG_FONTPOOL
     qCDebug(OkularDviDebug) << "fontPool::setCMperDVIunit( " << _CMperDVI << " )";
 #endif
 
     if (CMperDVIunit == _CMperDVI) {
         return;
     }
 
     CMperDVIunit = _CMperDVI;
 
     QList<TeXFontDefinition *>::iterator it_fontp = fontList.begin();
     for (; it_fontp != fontList.end(); ++it_fontp) {
         TeXFontDefinition *fontp = *it_fontp;
         fontp->setDisplayResolution(displayResolution_in_dpi * fontp->enlargement);
     }
 }
 
 void fontPool::setDisplayResolution(double _displayResolution_in_dpi)
 {
 #ifdef DEBUG_FONTPOOL
     qCDebug(OkularDviDebug) << "fontPool::setDisplayResolution( displayResolution_in_dpi=" << _displayResolution_in_dpi << " ) called";
 #endif
 
     // Ignore minute changes by less than 2 DPI. The difference would
     // hardly be visible anyway. That saves a lot of re-painting,
     // e.g. when the user resizes the window, and a flickery mouse
     // changes the window size by 1 pixel all the time.
     if (fabs(displayResolution_in_dpi - _displayResolution_in_dpi) <= 2.0) {
 #ifdef DEBUG_FONTPOOL
         qCDebug(OkularDviDebug) << "fontPool::setDisplayResolution(...): resolution wasn't changed. Aborting.";
 #endif
         return;
     }
 
     displayResolution_in_dpi = _displayResolution_in_dpi;
     double displayResolution = displayResolution_in_dpi;
 
     QList<TeXFontDefinition *>::iterator it_fontp = fontList.begin();
     for (; it_fontp != fontList.end(); ++it_fontp) {
         TeXFontDefinition *fontp = *it_fontp;
         fontp->setDisplayResolution(displayResolution * fontp->enlargement);
     }
 
     // Do something that causes re-rendering of the dvi-window
     /*@@@@
     Q_EMIT fonts_have_been_loaded(this);
     */
 }
 
 void fontPool::markFontsAsLocated()
 {
     QList<TeXFontDefinition *>::iterator it_fontp = fontList.begin();
     for (; it_fontp != fontList.end(); ++it_fontp) {
         TeXFontDefinition *fontp = *it_fontp;
         fontp->markAsLocated();
     }
 }
 
 void fontPool::mark_fonts_as_unused()
 {
 #ifdef DEBUG_FONTPOOL
     qCDebug(OkularDviDebug) << "fontPool::mark_fonts_as_unused() called";
 #endif
 
     QList<TeXFontDefinition *>::iterator it_fontp = fontList.begin();
     for (; it_fontp != fontList.end(); ++it_fontp) {
         TeXFontDefinition *fontp = *it_fontp;
         fontp->flags &= ~TeXFontDefinition::FONT_IN_USE;
     }
 }
 
 void fontPool::release_fonts()
 {
 #ifdef DEBUG_FONTPOOL
     qCDebug(OkularDviDebug) << "Release_fonts";
 #endif
 
     QMutableListIterator<TeXFontDefinition *> it_fontp(fontList);
     while (it_fontp.hasNext()) {
         TeXFontDefinition *fontp = it_fontp.next();
         if ((fontp->flags & TeXFontDefinition::FONT_IN_USE) != TeXFontDefinition::FONT_IN_USE) {
             delete fontp;
             it_fontp.remove();
         }
     }
 }
 
 void fontPool::mf_output_receiver()
 {
     if (kpsewhich_) {
         const QString output_data = QString::fromLocal8Bit(kpsewhich_->readAllStandardError());
         kpsewhichOutput.append(output_data);
         MetafontOutput.append(output_data);
     }
 
     // We'd like to print only full lines of text.
     int numleft;
     while ((numleft = MetafontOutput.indexOf(QLatin1Char('\n'))) != -1) {
         QString line = MetafontOutput.left(numleft + 1);
 #ifdef DEBUG_FONTPOOL
         qCDebug(OkularDviDebug) << "MF OUTPUT RECEIVED: " << line;
 #endif
         // If the Output of the kpsewhich program contains a line starting
         // with "kpathsea:", this means that a new MetaFont-run has been
         // started. We filter these lines out and update the display
         // accordingly.
         int startlineindex = line.indexOf(QStringLiteral("kpathsea:"));
         if (startlineindex != -1) {
             int endstartline = line.indexOf(QStringLiteral("\n"), startlineindex);
             QString startLine = line.mid(startlineindex, endstartline - startlineindex);
 
             // The last word in the startline is the name of the font which we
             // are generating. The second-to-last word is the resolution in
             // dots per inch. Display this info in the text label below the
             // progress bar.
             int lastblank = startLine.lastIndexOf(QLatin1Char(' '));
             QString fontName = startLine.mid(lastblank + 1);
             int secondblank = startLine.lastIndexOf(QLatin1Char(' '), lastblank - 1);
             QString dpi = startLine.mid(secondblank + 1, lastblank - secondblank - 1);
 
             Q_EMIT warning(i18n("Currently generating %1 at %2 dpi...", fontName, dpi), -1);
         }
         MetafontOutput = MetafontOutput.remove(0, numleft + 1);
     }
 }