mirror of
https://bitbucket.org/smil3y/kde-extraapps.git
synced 2025-02-24 10:52:53 +00:00
485 lines
16 KiB
C++
485 lines
16 KiB
C++
// -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; c-brace-offset: 0; -*-
|
|
//
|
|
// fontpool.cpp
|
|
//
|
|
// (C) 2001-2005 Stefan Kebekus
|
|
// Distributed under the GPL
|
|
|
|
#include <config.h>
|
|
|
|
#include "fontpool.h"
|
|
#include "kvs_debug.h"
|
|
#include "TeXFont.h"
|
|
|
|
#include <klocale.h>
|
|
|
|
#include <QApplication>
|
|
#include <QPainter>
|
|
|
|
#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
|
|
kDebug(kvs::dvi) << "fontPool::fontPool() called";
|
|
#endif
|
|
|
|
setObjectName( QLatin1String("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 ) {
|
|
kError(kvs::dvi) << "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 = (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
|
|
kDebug(kvs::dvi) << "fontPool::fontPool(): QPixmap does not support the alpha channel";
|
|
#endif
|
|
QPixmapSupportsAlpha = false;
|
|
} else {
|
|
#ifdef DEBUG_FONTPOOL
|
|
kDebug(kvs::dvi) << "fontPool::fontPool(): QPixmap supports the alpha channel";
|
|
#endif
|
|
QPixmapSupportsAlpha = true;
|
|
}
|
|
}
|
|
|
|
|
|
fontPool::~fontPool()
|
|
{
|
|
#ifdef DEBUG_FONTPOOL
|
|
kDebug(kvs::dvi) << "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 == 0) {
|
|
kError(kvs::dvi) << "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
|
|
kDebug(kvs::dvi) << "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
|
|
kDebug(kvs::dvi) << "... 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();
|
|
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(qgetenv("PATH")),
|
|
kpsewhichOutput.replace(QLatin1String("\n"), QLatin1String("<br/>"))), -1);
|
|
}
|
|
}
|
|
|
|
|
|
void fontPool::locateFonts(bool makePK, bool locateTFMonly, bool *virtualFontsFound)
|
|
{
|
|
// 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, ennable 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 << "--dpi" << "1200"
|
|
<< "--mode" << "lexmarks";
|
|
|
|
// Disable automatic pk-font generation.
|
|
kpsewhich_args << (makePK ? "--mktex" : "--no-mktex") << "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 << QString("%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 << QString("%1").arg(filename);
|
|
}
|
|
#endif
|
|
kpsewhich_args << QString("%1.vf").arg(fontp->fontname)
|
|
<< QString("%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_ = new QProcess(this);
|
|
connect(kpsewhich_, SIGNAL(readyReadStandardError()),
|
|
this, SLOT(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 = "kpsewhich";
|
|
kpsewhichOutput +=
|
|
"<b>" + kpsewhich_exe + ' ' + kpsewhich_args.join(" ") + "</b>";
|
|
|
|
kpsewhich_->start(kpsewhich_exe, kpsewhich_args,
|
|
QIODevice::ReadOnly|QIODevice::Text);
|
|
if (!kpsewhich_->waitForStarted()) {
|
|
QApplication::restoreOverrideCursor();
|
|
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(qgetenv("PATH")),
|
|
kpsewhichOutput.replace(QLatin1String("\n"), QLatin1String("<br/>"))), -1);
|
|
|
|
// This makes sure the we don't try to run kpsewhich again
|
|
markFontsAsLocated();
|
|
delete kpsewhich_;
|
|
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) {
|
|
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(kpsewhich_->readAll()).split('\n', QString::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("/"+fontp->fontname+".");
|
|
|
|
if (matchingFiles.isEmpty() != true) {
|
|
#ifdef DEBUG_FONTPOOL
|
|
kDebug(kvs::dvi) << "Associated " << fontp->fontname << " to " << matchingFiles.first();
|
|
#endif
|
|
QString fname = matchingFiles.first();
|
|
fontp->fontNameReceiver(fname);
|
|
fontp->flags |= TeXFontDefinition::FONT_KPSE_NAME;
|
|
if (fname.endsWith(".vf")) {
|
|
if (virtualFontsFound != 0)
|
|
*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)
|
|
}
|
|
delete kpsewhich_;
|
|
}
|
|
|
|
|
|
void fontPool::setCMperDVIunit( double _CMperDVI )
|
|
{
|
|
#ifdef DEBUG_FONTPOOL
|
|
kDebug(kvs::dvi) << "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
|
|
kDebug(kvs::dvi) << "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
|
|
kDebug(kvs::dvi) << "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
|
|
/*@@@@
|
|
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
|
|
kDebug(kvs::dvi) << "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
|
|
kDebug(kvs::dvi) << "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_)
|
|
return;
|
|
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('\n')) != -1) {
|
|
QString line = MetafontOutput.left(numleft+1);
|
|
#ifdef DEBUG_FONTPOOL
|
|
kDebug(kvs::dvi) << "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("kpathsea:");
|
|
if (startlineindex != -1) {
|
|
int endstartline = line.indexOf("\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(' ');
|
|
QString fontName = startLine.mid(lastblank+1);
|
|
int secondblank = startLine.lastIndexOf(' ',lastblank-1);
|
|
QString dpi = startLine.mid(secondblank+1,lastblank-secondblank-1);
|
|
|
|
emit warning( i18n("Currently generating %1 at %2 dpi...", fontName, dpi), -1 );
|
|
}
|
|
MetafontOutput = MetafontOutput.remove(0,numleft+1);
|
|
}
|
|
}
|
|
|
|
#include "moc_fontpool.cpp"
|