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

 // -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; c-brace-offset: 0; -*-
 // fontMap.cpp
 //
 // Part of KDVI - A DVI previewer for the KDE desktop environment
 //
 // SPDX-FileCopyrightText: 2003 Stefan Kebekus
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <config.h>
 
 #ifdef HAVE_FREETYPE
 
 #include "debug_dvi.h"
 #include "fontMap.h"
 #include <QFile>
 #include <QLoggingCategory>
 #include <QProcess>
 #include <QStandardPaths>
 #include <QTextStream>
 
 //#define DEBUG_FONTMAP
 
 fontMap::fontMap()
 {
     // Make sure kpsewhich is in PATH and not just in the CWD
     static const QString kpsewhichFullPath = QStandardPaths::findExecutable(QStringLiteral("kpsewhich"));
 
     // Read the map file of ps2pk which will provide us with a
     // dictionary "TeX Font names" <-> "Name of font files, Font Names
     // and Encodings" (example: the font "Times-Roman" is called
     // "ptmr8y" in the DVI file, but the Type1 font file name is
     // "utmr8a.pfb". We use the map file of "ps2pk" because that program
     // has, like kdvi (and unlike dvips), no built-in fonts.
 
     // Finding ps2pk.map is not easy. In teTeX < 3.0, the kpsewhich
     // program REQUIRES the option "--format=dvips config". In teTeX =
     // 3.0, the option "--format=map" MUST be used. Since there is no
     // way to give both options at the same time, there is seemingly no
     // other way than to try both options one after another. We use the
     // teTeX 3.0 format first.
     QProcess kpsewhich;
     kpsewhich.start(kpsewhichFullPath, QStringList() << QStringLiteral("--format=map") << QStringLiteral("ps2pk.map"), QIODevice::ReadOnly | QIODevice::Text);
 
     if (!kpsewhich.waitForStarted()) {
         qCCritical(OkularDviDebug) << "fontMap::fontMap(): kpsewhich could not be started.";
         return;
     }
 
     // We wait here while the external program runs concurrently.
     kpsewhich.waitForFinished(-1);
 
     QString map_fileName = QString::fromLocal8Bit(kpsewhich.readAll()).trimmed();
     if (map_fileName.isEmpty()) {
         // Map file not found? Then we try the teTeX < 3.0 way of finding
         // the file.
         kpsewhich.start(kpsewhichFullPath, QStringList() << QStringLiteral("--format=dvips config") << QStringLiteral("ps2pk.map"), QIODevice::ReadOnly | QIODevice::Text);
         if (!kpsewhich.waitForStarted()) {
             qCCritical(OkularDviDebug) << "fontMap::fontMap(): kpsewhich could not be started.";
             return;
         }
 
         kpsewhich.waitForFinished(-1);
 
         map_fileName = QString::fromLocal8Bit(kpsewhich.readAll()).trimmed();
         // If both versions fail, then there is nothing left to do.
         if (map_fileName.isEmpty()) {
             qCCritical(OkularDviDebug) << "fontMap::fontMap(): The file 'ps2pk.map' could not be found by kpsewhich.";
             return;
         }
     }
 
     QFile file(map_fileName);
     if (file.open(QIODevice::ReadOnly)) {
         QTextStream stream(&file);
         QString line;
         while (!stream.atEnd()) {
             line = stream.readLine().simplified();
             if (line.isEmpty() || (line.at(0) == QLatin1Char('%'))) {
                 continue;
             }
 
             QString TeXName = line.section(QLatin1Char(' '), 0, 0);
             QString FullName = line.section(QLatin1Char(' '), 1, 1);
             QString fontFileName = line.section(QLatin1Char('<'), -1).trimmed().section(QLatin1Char(' '), 0, 0);
             QString encodingName = line.section(QLatin1Char('<'), -2, -2).trimmed().section(QLatin1Char(' '), 0, 0);
             // It seems that sometimes the encoding is prepended by the
             // letter '[', which we ignore
             if ((!encodingName.isEmpty()) && (encodingName[0] == QLatin1Char('['))) {
                 encodingName = encodingName.mid(1);
             }
 
             double slant = 0.0;
             int i = line.indexOf(QStringLiteral("SlantFont"));
             if (i >= 0) {
                 bool ok;
                 slant = line.left(i).section(QLatin1Char(' '), -1, -1, QString::SectionSkipEmpty).toDouble(&ok);
                 if (ok == false) {
                     slant = 0.0;
                 }
             }
 
             fontMapEntry &entry = fontMapEntries[TeXName];
 
             entry.slant = slant;
             entry.fontFileName = fontFileName;
             entry.fullFontName = FullName;
             if (encodingName.endsWith(QLatin1String(".enc"))) {
                 entry.fontEncoding = encodingName;
             } else {
                 entry.fontEncoding.clear();
             }
         }
         file.close();
     } else {
         qCCritical(OkularDviDebug) << QStringLiteral("fontMap::fontMap(): The file '%1' could not be opened.").arg(map_fileName);
     }
 
 #ifdef DEBUG_FONTMAP
     qCDebug(OkularDviDebug) << "FontMap file parsed. Results:";
     QMap<QString, fontMapEntry>::Iterator it;
     for (it = fontMapEntries.begin(); it != fontMapEntries.end(); ++it)
         qCDebug(OkularDviDebug) << "TeXName: " << it.key() << ", FontFileName=" << it.data().fontFileName << ", FullName=" << it.data().fullFontName << ", Encoding=" << it.data().fontEncoding << ".";
     ;
 #endif
 }
 
 const QString &fontMap::findFileName(const QString &TeXName)
 {
     QMap<QString, fontMapEntry>::Iterator it = fontMapEntries.find(TeXName);
 
     if (it != fontMapEntries.end()) {
         return it.value().fontFileName;
     }
 
     static const QString nullstring;
     return nullstring;
 }
 
 const QString &fontMap::findFontName(const QString &TeXName)
 {
     QMap<QString, fontMapEntry>::Iterator it = fontMapEntries.find(TeXName);
 
     if (it != fontMapEntries.end()) {
         return it.value().fullFontName;
     }
 
     static const QString nullstring;
     return nullstring;
 }
 
 const QString &fontMap::findEncoding(const QString &TeXName)
 {
     QMap<QString, fontMapEntry>::Iterator it = fontMapEntries.find(TeXName);
 
     if (it != fontMapEntries.end()) {
         return it.value().fontEncoding;
     }
 
     static const QString nullstring;
     return nullstring;
 }
 
 double fontMap::findSlant(const QString &TeXName)
 {
     QMap<QString, fontMapEntry>::Iterator it = fontMapEntries.find(TeXName);
 
     if (it != fontMapEntries.end()) {
         return it.value().slant;
     } else {
         return 0.0;
     }
 }
 
 #endif // HAVE_FREETYPE