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

 // -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; c-brace-offset: 0; -*-
 // TeXFont_PFB.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
 
 // This file is compiled only if the FreeType library is present on
 // the system
 
 #include <config.h>
 
 #ifdef HAVE_FREETYPE
 
 #include "TeXFont_PFB.h"
 #include "debug_dvi.h"
 #include "fontpool.h"
 
 #include <KLocalizedString>
 
 #include <QImage>
 #include <QLoggingCategory>
 
 //#define DEBUG_PFB 1
 
 TeXFont_PFB::TeXFont_PFB(TeXFontDefinition *parent, fontEncoding *enc, double slant)
     : TeXFont(parent)
     , face(nullptr)
 {
 #ifdef DEBUG_PFB
     if (enc != 0)
         qCDebug(OkularDviDebug) << "TeXFont_PFB::TeXFont_PFB( parent=" << parent << ", encoding=" << enc->encodingFullName << " )";
     else
         qCDebug(OkularDviDebug) << "TeXFont_PFB::TeXFont_PFB( parent=" << parent << ", encoding=0 )";
 #endif
 
     fatalErrorInFontLoading = false;
 
     int error = FT_New_Face(parent->font_pool->FreeType_library, parent->filename.toLocal8Bit().constData(), 0, &face);
 
     if (error == FT_Err_Unknown_File_Format) {
         errorMessage = i18n("The font file %1 could be opened and read, but its font format is unsupported.", parent->filename);
         qCCritical(OkularDviDebug) << errorMessage;
         fatalErrorInFontLoading = true;
         return;
     } else if (error) {
         errorMessage = i18n("The font file %1 is broken, or it could not be opened or read.", parent->filename);
         qCCritical(OkularDviDebug) << errorMessage;
         fatalErrorInFontLoading = true;
         return;
     }
 
     // Take care of slanting, and transform all characters in the font, if necessary.
     if (slant != 0.0) {
         // Construct a transformation matrix for vertical shear which will
         // be used to transform the characters.
         transformationMatrix.xx = 0x10000;
         transformationMatrix.xy = (FT_Fixed)(slant * 0x10000);
         transformationMatrix.yx = 0;
         transformationMatrix.yy = 0x10000;
 
         FT_Set_Transform(face, &transformationMatrix, nullptr);
     }
 
     if (face->family_name != nullptr) {
         parent->fullFontName = QString::fromLocal8Bit(face->family_name);
     }
 
     // Finally, we need to set up the charMap array, which maps TeX
     // character codes to glyph indices in the font. (Remark: the
     // charMap, and the font encoding procedure is necessary, because
     // TeX is only able to address character codes 0-255 while
     // e.g. Type1 fonts may contain several thousands of characters)
     if (enc != nullptr) {
         parent->fullEncodingName = enc->encodingFullName.remove(QStringLiteral("Encoding"));
         parent->fullEncodingName = enc->encodingFullName.remove(QStringLiteral("encoding"));
 
         // An encoding vector is given for this font, i.e. an array of
         // character names (such as: 'parenleft' or 'dotlessj'). We use
         // the FreeType library function 'FT_Get_Name_Index()' to
         // associate glyph indices to those names.
 #ifdef DEBUG_PFB
         qCDebug(OkularDviDebug) << "Trying to associate glyph indices to names from the encoding vector.";
 #endif
         for (int i = 0; i < 256; i++) {
             charMap[i] = FT_Get_Name_Index(face, (FT_String *)(enc->glyphNameVector[i].toLatin1().data()));
 #ifdef DEBUG_PFB
             qCDebug(OkularDviDebug) << i << ": " << enc->glyphNameVector[i] << ", GlyphIndex=" << charMap[i];
 #endif
         }
     } else {
         // If there is no encoding vector available, we check if the font
         // itself contains a charmap that could be used. An admissible
         // charMap will be stored under platform_id=7 and encoding_id=2.
         FT_CharMap found = nullptr;
         for (int n = 0; n < face->num_charmaps; n++) {
             FT_CharMap charmap = face->charmaps[n];
             if (charmap->platform_id == 7 && charmap->encoding_id == 2) {
                 found = charmap;
                 break;
             }
         }
 
         if ((found != nullptr) && (FT_Set_Charmap(face, found) == 0)) {
             // Feed the charMap array with the charmap data found in the
             // previous step.
 #ifdef DEBUG_PFB
             qCDebug(OkularDviDebug) << "No encoding given: using charmap platform=7, encoding=2 that is contained in the font.";
 #endif
             for (int i = 0; i < 256; i++) {
                 charMap[i] = FT_Get_Char_Index(face, i);
             }
         } else {
             if ((found == nullptr) && (face->charmap != nullptr)) {
 #ifdef DEBUG_PFB
                 qCDebug(OkularDviDebug) << "No encoding given: using charmap platform=" << face->charmap->platform_id << ", encoding=" << face->charmap->encoding_id << " that is contained in the font.";
 #endif
                 for (int i = 0; i < 256; i++) {
                     charMap[i] = FT_Get_Char_Index(face, i);
                 }
             } else {
                 // As a last resort, we use the identity map.
 #ifdef DEBUG_PFB
                 qCDebug(OkularDviDebug) << "No encoding given, no suitable charmaps found in the font: using identity charmap.";
 #endif
                 for (int i = 0; i < 256; i++) {
                     charMap[i] = i;
                 }
             }
         }
     }
 }
 
 TeXFont_PFB::~TeXFont_PFB()
 {
     FT_Done_Face(face);
 }
 
 glyph *TeXFont_PFB::getGlyph(quint16 ch, bool generateCharacterPixmap, const QColor &color)
 {
 #ifdef DEBUG_PFB
     qCDebug(OkularDviDebug) << "TeXFont_PFB::getGlyph( ch=" << ch << ", '" << (char)(ch) << "', generateCharacterPixmap=" << generateCharacterPixmap << " )";
 #endif
 
     // Paranoia checks
     if (ch >= TeXFontDefinition::max_num_of_chars_in_font) {
         qCCritical(OkularDviDebug) << "TeXFont_PFB::getGlyph(): Argument is too big.";
         return glyphtable;
     }
 
     // This is the address of the glyph that will be returned.
     glyph *g = glyphtable + ch;
 
     if (fatalErrorInFontLoading == true) {
         return g;
     }
 
     if ((generateCharacterPixmap == true) && ((g->shrunkenCharacter.isNull()) || (color != g->color))) {
         int error;
         unsigned int res = (unsigned int)(parent->displayResolution_in_dpi / parent->enlargement + 0.5);
         g->color = color;
 
         // Character height in 1/64th of points (reminder: 1 pt = 1/72 inch)
         // Only approximate, may vary from file to file!!!! @@@@@
 
         long int characterSize_in_printers_points_by_64 = (long int)((64.0 * 72.0 * parent->scaled_size_in_DVI_units * parent->font_pool->getCMperDVIunit()) / 2.54 + 0.5);
         error = FT_Set_Char_Size(face, 0, characterSize_in_printers_points_by_64, res, res);
         if (error) {
             QString msg = i18n("FreeType reported an error when setting the character size for font file %1.", parent->filename);
             if (errorMessage.isEmpty()) {
                 errorMessage = msg;
             }
             qCCritical(OkularDviDebug) << msg;
             g->shrunkenCharacter = QImage(1, 1, QImage::Format_RGB32);
             g->shrunkenCharacter.fill(qRgb(255, 255, 255));
             return g;
         }
 
         // load glyph image into the slot and erase the previous one
         if (parent->font_pool->getUseFontHints() == true) {
             error = FT_Load_Glyph(face, charMap[ch], FT_LOAD_DEFAULT);
         } else {
             error = FT_Load_Glyph(face, charMap[ch], FT_LOAD_NO_HINTING);
         }
 
         if (error) {
             QString msg = i18n("FreeType is unable to load glyph #%1 from font file %2.", ch, parent->filename);
             if (errorMessage.isEmpty()) {
                 errorMessage = msg;
             }
             qCCritical(OkularDviDebug) << msg;
             g->shrunkenCharacter = QImage(1, 1, QImage::Format_RGB32);
             g->shrunkenCharacter.fill(qRgb(255, 255, 255));
             return g;
         }
 
         // convert to an anti-aliased bitmap
         error = FT_Render_Glyph(face->glyph, ft_render_mode_normal);
         if (error) {
             QString msg = i18n("FreeType is unable to render glyph #%1 from font file %2.", ch, parent->filename);
             if (errorMessage.isEmpty()) {
                 errorMessage = msg;
             }
             qCCritical(OkularDviDebug) << msg;
             g->shrunkenCharacter = QImage(1, 1, QImage::Format_RGB32);
             g->shrunkenCharacter.fill(qRgb(255, 255, 255));
             return g;
         }
 
         FT_GlyphSlot slot = face->glyph;
 
         if ((slot->bitmap.width == 0) || (slot->bitmap.rows == 0)) {
             if (errorMessage.isEmpty()) {
                 errorMessage = i18n("Glyph #%1 is empty.", ch);
             }
             qCCritical(OkularDviDebug) << i18n("Glyph #%1 from font file %2 is empty.", ch, parent->filename);
             g->shrunkenCharacter = QImage(15, 15, QImage::Format_RGB32);
             g->shrunkenCharacter.fill(qRgb(255, 0, 0));
             g->x2 = 0;
             g->y2 = 15;
         } else {
             QImage imgi(slot->bitmap.width, slot->bitmap.rows, QImage::Format_ARGB32);
 
             // Do QPixmaps fully support the alpha channel? If yes, we use
             // that. Otherwise, use other routines as a fallback
             if (parent->font_pool->QPixmapSupportsAlpha) {
                 // If the alpha channel is properly supported, we set the
                 // character glyph to a colored rectangle, and define the
                 // character outline only using the alpha channel. That
                 // ensures good quality rendering for overlapping characters.
                 uchar *srcScanLine = slot->bitmap.buffer;
                 for (unsigned int row = 0; row < slot->bitmap.rows; row++) {
                     uchar *destScanLine = imgi.scanLine(row);
                     for (unsigned int col = 0; col < slot->bitmap.width; col++) {
                         destScanLine[4 * col + 0] = color.blue();
                         destScanLine[4 * col + 1] = color.green();
                         destScanLine[4 * col + 2] = color.red();
                         destScanLine[4 * col + 3] = srcScanLine[col];
                     }
                     srcScanLine += slot->bitmap.pitch;
                 }
             } else {
                 // If the alpha channel is not supported... QT seems to turn
                 // the alpha channel into a crude bitmap which is used to mask
                 // the resulting QPixmap. In this case, we define the
                 // character outline using the image data, and use the alpha
                 // channel only to store "maximally opaque" or "completely
                 // transparent" values. When characters are rendered,
                 // overlapping characters are no longer correctly drawn, but
                 // quality is still sufficient for most purposes. One notable
                 // exception is output from the gftodvi program, which will be
                 // partially unreadable.
                 quint16 rInv = 0xFF - color.red();
                 quint16 gInv = 0xFF - color.green();
                 quint16 bInv = 0xFF - color.blue();
 
                 for (unsigned int y = 0; y < slot->bitmap.rows; y++) {
                     quint8 *srcScanLine = slot->bitmap.buffer + y * slot->bitmap.pitch;
                     unsigned int *destScanLine = reinterpret_cast<unsigned int *>(imgi.scanLine(y));
                     for (unsigned int col = 0; col < slot->bitmap.width; col++) {
                         quint16 data = *srcScanLine;
                         // The value stored in "data" now has the following meaning:
                         // data = 0 -> white; data = 0xff -> use "color"
                         *destScanLine = qRgba(0xFF - (rInv * data + 0x7F) / 0xFF, 0xFF - (gInv * data + 0x7F) / 0xFF, 0xFF - (bInv * data + 0x7F) / 0xFF, (data > 0x03) ? 0xff : 0x00);
                         destScanLine++;
                         srcScanLine++;
                     }
                 }
             }
 
             g->shrunkenCharacter = imgi;
             g->x2 = -slot->bitmap_left;
             g->y2 = slot->bitmap_top;
         }
     }
 
     // Load glyph width, if that hasn't been done yet.
     if (g->dvi_advance_in_units_of_design_size_by_2e20 == 0) {
         int error = FT_Load_Glyph(face, charMap[ch], FT_LOAD_NO_SCALE);
         if (error) {
             QString msg = i18n("FreeType is unable to load metric for glyph #%1 from font file %2.", ch, parent->filename);
             if (errorMessage.isEmpty()) {
                 errorMessage = msg;
             }
             qCCritical(OkularDviDebug) << msg;
             g->dvi_advance_in_units_of_design_size_by_2e20 = 1;
         }
         g->dvi_advance_in_units_of_design_size_by_2e20 = (qint32)(((qint64)(1 << 20) * (qint64)face->glyph->metrics.horiAdvance) / (qint64)face->units_per_EM);
     }
 
     return g;
 }
 
 #endif // HAVE_FREETYPE