mirror of
https://invent.kde.org/graphics/okular
synced 2024-08-25 02:45:38 +00:00
804 lines
26 KiB
C++
804 lines
26 KiB
C++
// -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; c-brace-offset: 0; -*-
|
|
// dviRenderer_prescan.cpp
|
|
//
|
|
// Part of KDVI - A DVI previewer for the KDE desktop environment
|
|
//
|
|
// (C) 2003--2004 Stefan Kebekus
|
|
// Distributed under the GPL
|
|
|
|
#include <config.h>
|
|
|
|
#include "dviRenderer.h"
|
|
#include "dvi.h"
|
|
#include "dviFile.h"
|
|
#include "kvs_debug.h"
|
|
#include "prebookmark.h"
|
|
#include "psgs.h"
|
|
#include "TeXFont.h"
|
|
|
|
#include <klocale.h>
|
|
#include <QMimeType>
|
|
#include <QMimeDatabase>
|
|
#include <kprocess.h>
|
|
|
|
#include <QApplication>
|
|
#include <QDir>
|
|
#include <QFileInfo>
|
|
#include <QImage>
|
|
#include <QPaintDevice>
|
|
#include <QProgressBar>
|
|
#include <QTextStream>
|
|
|
|
|
|
extern QPainter foreGroundPaint;
|
|
extern void parse_special_argument(const QString& strg, const char* argument_name, int* variable);
|
|
|
|
|
|
//#define DEBUG_PRESCAN
|
|
|
|
|
|
void dviRenderer::prescan_embedPS(char *cp, quint8 *beginningOfSpecialCommand)
|
|
{
|
|
#ifdef DEBUG_PRESCAN
|
|
kDebug(kvs::dvi) << "dviRenderer::prescan_embedPS( cp = " << cp << " ) ";
|
|
#endif
|
|
|
|
// Encapsulated Postscript File
|
|
if (strncasecmp(cp, "PSfile=", 7) != 0)
|
|
return;
|
|
|
|
QString command(cp+7);
|
|
|
|
QString include_command = command.simplified();
|
|
|
|
// The line is supposed to start with "..ile=", and then comes the
|
|
// filename. Figure out what the filename is and stow it away. Of
|
|
// course, this does not work if the filename contains spaces
|
|
// (already the simplified() above is wrong). If you have
|
|
// files like this, go away.
|
|
QString EPSfilename = include_command;
|
|
EPSfilename.truncate(EPSfilename.indexOf(' '));
|
|
|
|
// Strip enclosing quotation marks which are included by some LaTeX
|
|
// macro packages (but not by others). This probably means that
|
|
// graphic files are no longer found if the filename really does
|
|
// contain quotes, but we don't really care that much.
|
|
if ((EPSfilename.at(0) == '\"') && (EPSfilename.at(EPSfilename.length()-1) == '\"'))
|
|
EPSfilename = EPSfilename.mid(1,EPSfilename.length()-2);
|
|
|
|
// Now locate the Gfx file on the hard disk...
|
|
EPSfilename = ghostscript_interface::locateEPSfile(EPSfilename, baseURL);
|
|
|
|
// If the file is neither a PostScript not a PDF file, we exit here.
|
|
// The graphic file is later read when the page is rendered.
|
|
QMimeDatabase db;
|
|
QMimeType const mime_type =
|
|
db.mimeTypeForFile(EPSfilename, QMimeDatabase::MatchContent);
|
|
QString const & mime_type_name = mime_type.isValid() ? mime_type.name() : QString();
|
|
|
|
bool const is_ps_file = (mime_type_name == "application/postscript" ||
|
|
mime_type_name == "image/x-eps");
|
|
bool const is_pdf_file = (!is_ps_file &&
|
|
mime_type_name == "application/pdf");
|
|
if (!(is_ps_file || is_pdf_file))
|
|
return;
|
|
|
|
QString originalFName = EPSfilename;
|
|
|
|
embedPS_progress->setLabelText(i18n("Embedding %1", EPSfilename));
|
|
qApp->processEvents();
|
|
|
|
// If the EPSfilename really points to a PDF file, convert that file now.
|
|
if (is_pdf_file)
|
|
EPSfilename = dviFile->convertPDFtoPS(EPSfilename);
|
|
|
|
if (!QFile::exists(EPSfilename)) {
|
|
// Find the number of the page
|
|
quint32 currentOffset = beginningOfSpecialCommand - dviFile->dvi_Data();
|
|
int page=0;
|
|
for(; page < dviFile->total_pages; page++)
|
|
if ((dviFile->page_offset[page] <= currentOffset) && (currentOffset <= dviFile->page_offset[page+1]))
|
|
break;
|
|
if (is_pdf_file)
|
|
errorMsg += i18n("Page %1: The PDF file <strong>%2</strong> could not be converted to PostScript.<br>", page+1, originalFName);
|
|
else
|
|
errorMsg += i18n("Page %1: The PostScript file <strong>%2</strong> could not be found.<br>", page+1, originalFName);
|
|
embedPS_progress->progressBar()->setValue(embedPS_progress->progressBar()->value()+1);
|
|
qApp->processEvents();
|
|
return;
|
|
}
|
|
|
|
// Now parse the arguments.
|
|
int llx = 0;
|
|
int lly = 0;
|
|
int urx = 0;
|
|
int ury = 0;
|
|
int rwi = 0;
|
|
int rhi = 0;
|
|
int angle = 0;
|
|
|
|
// just to avoid ambiguities; the filename could contain keywords
|
|
include_command = include_command.mid(include_command.indexOf(' '));
|
|
|
|
parse_special_argument(include_command, "llx=", &llx);
|
|
parse_special_argument(include_command, "lly=", &lly);
|
|
parse_special_argument(include_command, "urx=", &urx);
|
|
parse_special_argument(include_command, "ury=", &ury);
|
|
parse_special_argument(include_command, "rwi=", &rwi);
|
|
parse_special_argument(include_command, "rhi=", &rhi);
|
|
parse_special_argument(include_command, "angle=", &angle);
|
|
|
|
int clip=include_command.indexOf(" clip"); // -1 if clip keyword is not present, >= 0 otherwise
|
|
|
|
// Generate the PostScript commands to be included
|
|
QString PS = QString("ps: @beginspecial %1 @llx %2 @lly %3 @urx %4 @ury").arg(llx).arg(lly).arg(urx).arg(ury);
|
|
if (rwi != 0)
|
|
PS.append( QString(" %1 @rwi").arg(rwi) );
|
|
if (rhi != 0)
|
|
PS.append( QString(" %1 @rhi").arg(rhi) );
|
|
if (angle != 0)
|
|
PS.append( QString(" %1 @angle").arg(angle) );
|
|
if (clip != -1)
|
|
PS.append(" @clip");
|
|
PS.append( " @setspecial\n" );
|
|
|
|
QFile file( EPSfilename );
|
|
if ( file.open( QIODevice::ReadOnly ) ) {
|
|
QTextStream stream( &file );
|
|
while ( !stream.atEnd() ) {
|
|
PS += stream.readLine().section( '%', 0, 0);
|
|
PS += '\n';
|
|
}
|
|
file.close();
|
|
}
|
|
PS.append( "@endspecial" );
|
|
PS = PS.simplified();
|
|
|
|
|
|
_isModified = true;
|
|
quint32 lengthOfOldSpecial = command_pointer - beginningOfSpecialCommand;
|
|
quint32 lengthOfNewSpecial = PS.length()+5;
|
|
|
|
QVector<quint8> newDVI(dviFile->size_of_file + lengthOfNewSpecial-lengthOfOldSpecial);
|
|
|
|
quint8 *commandPtrSav = command_pointer;
|
|
quint8 *endPtrSav = end_pointer;
|
|
end_pointer = newDVI.data() + dviFile->size_of_file + lengthOfNewSpecial-lengthOfOldSpecial;
|
|
memcpy(newDVI.data(), dviFile->dvi_Data(), beginningOfSpecialCommand-dviFile->dvi_Data());
|
|
command_pointer = newDVI.data()+(beginningOfSpecialCommand-dviFile->dvi_Data());
|
|
command_pointer[0] = XXX4;
|
|
command_pointer++;
|
|
writeUINT32(PS.length());
|
|
memcpy(newDVI.data()+(beginningOfSpecialCommand-dviFile->dvi_Data())+5, PS.toLatin1().constData(), PS.length() );
|
|
memcpy(newDVI.data()+(beginningOfSpecialCommand-dviFile->dvi_Data())+lengthOfNewSpecial, beginningOfSpecialCommand+lengthOfOldSpecial,
|
|
dviFile->size_of_file-(beginningOfSpecialCommand-dviFile->dvi_Data())-lengthOfOldSpecial );
|
|
|
|
// Adjust page pointers in the DVI file
|
|
dviFile->size_of_file = dviFile->size_of_file + lengthOfNewSpecial-lengthOfOldSpecial;
|
|
end_pointer = newDVI.data() + dviFile->size_of_file;
|
|
quint32 currentOffset = beginningOfSpecialCommand-dviFile->dvi_Data();
|
|
for(int i=0; i < dviFile->total_pages; i++) {
|
|
if (dviFile->page_offset[i] > currentOffset) {
|
|
dviFile->page_offset[i] = dviFile->page_offset[i] + lengthOfNewSpecial-lengthOfOldSpecial;
|
|
command_pointer = dviFile->page_offset[i] + newDVI.data() + 4*10 + 1;
|
|
quint32 a = readUINT32();
|
|
if (a > currentOffset) {
|
|
a = a + lengthOfNewSpecial-lengthOfOldSpecial;
|
|
command_pointer = dviFile->page_offset[i] + newDVI.data() + 4*10 + 1;
|
|
writeUINT32(a);
|
|
}
|
|
}
|
|
}
|
|
|
|
dviFile->beginning_of_postamble = dviFile->beginning_of_postamble + lengthOfNewSpecial - lengthOfOldSpecial;
|
|
dviFile->page_offset[int(dviFile->total_pages)] = dviFile->beginning_of_postamble;
|
|
|
|
command_pointer = newDVI.data() + dviFile->beginning_of_postamble + 1;
|
|
quint32 a = readUINT32();
|
|
if (a > currentOffset) {
|
|
a = a + lengthOfNewSpecial - lengthOfOldSpecial;
|
|
command_pointer = newDVI.data() + dviFile->beginning_of_postamble + 1;
|
|
writeUINT32(a);
|
|
}
|
|
|
|
command_pointer = newDVI.data() + dviFile->size_of_file - 1;
|
|
while((*command_pointer == TRAILER) && (command_pointer > newDVI.data()))
|
|
command_pointer--;
|
|
command_pointer -= 4;
|
|
writeUINT32(dviFile->beginning_of_postamble);
|
|
command_pointer -= 4;
|
|
|
|
command_pointer = commandPtrSav;
|
|
end_pointer = endPtrSav;
|
|
|
|
// Modify all pointers to point to the newly allocated memory
|
|
command_pointer = newDVI.data() + (command_pointer - dviFile->dvi_Data()) + lengthOfNewSpecial-lengthOfOldSpecial;
|
|
end_pointer = newDVI.data() + (end_pointer - dviFile->dvi_Data()) + lengthOfNewSpecial-lengthOfOldSpecial;
|
|
|
|
dviFile->setNewData(newDVI);
|
|
|
|
embedPS_progress->progressBar()->setValue(embedPS_progress->progressBar()->value()+1);
|
|
qApp->processEvents();
|
|
return;
|
|
}
|
|
|
|
|
|
void dviRenderer::prescan_removePageSizeInfo(char *cp, quint8 *beginningOfSpecialCommand)
|
|
{
|
|
#ifdef DEBUG_PRESCAN
|
|
kDebug(kvs::dvi) << "dviRenderer::prescan_embedPS( cp = " << cp << " ) ";
|
|
#endif
|
|
|
|
// Encapsulated Postscript File
|
|
if (strncasecmp(cp, "papersize=", 10) != 0)
|
|
return;
|
|
|
|
for (quint8 *ptr=beginningOfSpecialCommand; ptr<command_pointer; ptr++)
|
|
*ptr = NOP;
|
|
}
|
|
|
|
|
|
void dviRenderer::prescan_ParsePapersizeSpecial(const QString& _cp)
|
|
{
|
|
#ifdef DEBUG_PRESCAN
|
|
kDebug(kvs::dvi) << "Papersize-Special : papersize" << _cp;
|
|
#endif
|
|
|
|
QString cp = _cp.simplified();
|
|
|
|
if (cp[0] == '=') {
|
|
cp = cp.mid(1);
|
|
dviFile->suggestedPageSize = new pageSize;
|
|
dviFile->suggestedPageSize->setPageSize(cp);
|
|
} else
|
|
printErrorMsgForSpecials(i18n("The papersize data '%1' could not be parsed.", cp));
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
void dviRenderer::prescan_ParseBackgroundSpecial(const QString& cp)
|
|
{
|
|
QColor col = parseColorSpecification(cp.trimmed());
|
|
if (col.isValid())
|
|
for(quint16 page=current_page; page < dviFile->total_pages; page++)
|
|
PS_interface->setBackgroundColor(page, col);
|
|
return;
|
|
}
|
|
|
|
|
|
void dviRenderer::prescan_ParseHTMLAnchorSpecial(const QString& _cp)
|
|
{
|
|
QString cp = _cp;
|
|
cp.truncate(cp.indexOf('"'));
|
|
Length l;
|
|
l.setLength_in_inch(currinf.data.dvi_v/(resolutionInDPI*shrinkfactor));
|
|
anchorList[cp] = Anchor(current_page+1, l);
|
|
}
|
|
|
|
|
|
void dviRenderer::prescan_ParsePSHeaderSpecial(const QString& cp)
|
|
{
|
|
#ifdef DEBUG_PRESCAN
|
|
kDebug(kvs::dvi) << "PostScript-special, header " << cp;
|
|
#endif
|
|
|
|
QString _file = cp;
|
|
|
|
// If the file is not found in the current directory, use kpsewhich
|
|
// to find it.
|
|
if (!QFile::exists(_file)) {
|
|
// Otherwise, use kpsewhich to find the eps file.
|
|
KProcess proc;
|
|
proc << "kpsewhich" << cp;
|
|
proc.setOutputChannelMode(KProcess::SeparateChannels);
|
|
proc.execute();
|
|
_file = QString::fromLocal8Bit(proc.readLine().trimmed());
|
|
}
|
|
|
|
if (QFile::exists(_file))
|
|
PS_interface->PostScriptHeaderString->append( QString(" (%1) run\n").arg(_file) );
|
|
}
|
|
|
|
|
|
void dviRenderer::prescan_ParsePSBangSpecial(const QString& cp)
|
|
{
|
|
#ifdef DEBUG_PRESCAN
|
|
kDebug(kvs::dvi) << "PostScript-special, literal header " << cp;
|
|
#endif
|
|
|
|
PS_interface->PostScriptHeaderString->append( " @defspecial \n" );
|
|
PS_interface->PostScriptHeaderString->append( cp );
|
|
PS_interface->PostScriptHeaderString->append( " @fedspecial \n" );
|
|
}
|
|
|
|
|
|
void dviRenderer::prescan_ParsePSQuoteSpecial(const QString& cp)
|
|
{
|
|
#ifdef DEBUG_PRESCAN
|
|
kError(kvs::dvi) << "PostScript-special, literal PostScript " << cp;
|
|
#endif
|
|
|
|
double PS_H = (currinf.data.dvi_h*300.0)/(65536*1200)-300;
|
|
double PS_V = (currinf.data.dvi_v*300.0)/1200 - 300;
|
|
PostScriptOutPutString->append( QString(" %1 %2 moveto\n").arg(PS_H).arg(PS_V) );
|
|
PostScriptOutPutString->append( " @beginspecial @setspecial \n" );
|
|
PostScriptOutPutString->append( cp );
|
|
PostScriptOutPutString->append( " @endspecial \n" );
|
|
}
|
|
|
|
|
|
void dviRenderer::prescan_ParsePSSpecial(const QString& cp)
|
|
{
|
|
#ifdef DEBUG_PRESCAN
|
|
kDebug(kvs::dvi) << "PostScript-special, direct PostScript " << cp;
|
|
#endif
|
|
|
|
// Unfortunately, in some TeX distribution the hyperref package uses
|
|
// the dvips driver by default, rather than the hypertex driver. As
|
|
// a result, the DVI files produced are full of PostScript that
|
|
// specifies links and anchors, and KDVI would call the ghostscript
|
|
// interpreter for every page which makes it really slow. This is a
|
|
// major nuisance, so that we try to filter and interpret the
|
|
// hypertex generated PostScript here.
|
|
if (cp.startsWith("ps:SDict begin")) {
|
|
// We suspect this may be hyperref generated nonsense. Let's check
|
|
// for some known code that hyperref generates.
|
|
if (cp == "ps:SDict begin H.S end")
|
|
return; // start of hyperref rectangle
|
|
if (cp == "ps:SDict begin H.R end")
|
|
return; // end of hyperref rectangle
|
|
if (cp.endsWith("H.A end"))
|
|
return; // end of hyperref anchor
|
|
if (cp.endsWith("H.L end"))
|
|
return; // end of hyperref link
|
|
if (cp.startsWith("ps:SDict begin /product where{pop product(Distiller)"))
|
|
return; // hyperref tries to work around Distiller bug
|
|
if (cp.startsWith("ps:SDict begin [") && cp.endsWith(" pdfmark end")) { // hyperref definition of link/anchor/bookmark/etc
|
|
if (cp.contains("/DEST")) { // The PostScript code defines an anchor
|
|
QString anchorName = cp.section('(', 1, 1).section(')', 0, 0);
|
|
Length l;
|
|
l.setLength_in_inch(currinf.data.dvi_v/(resolutionInDPI*shrinkfactor));
|
|
anchorList[anchorName] = Anchor(current_page+1, l);
|
|
}
|
|
// The PostScript code defines a bookmark
|
|
if (cp.contains("/Dest") && cp.contains("/Title")) {
|
|
const QString childrenNumberAndMoreStuff = cp.section('-', 1, 1); // Contains from the - symbol to the end of cp, effectively containing the number of children and some stuff after it
|
|
int indexOfFirstNonDigit = 0;
|
|
foreach(const QChar &c, childrenNumberAndMoreStuff) {
|
|
if (c.isDigit()) ++indexOfFirstNonDigit;
|
|
else break;
|
|
}
|
|
prebookmarks.append(PreBookmark(PDFencodingToQString(cp.section('(', 2, 2).section(')', 0, 0)),
|
|
cp.section('(', 1, 1).section(')', 0, 0),
|
|
childrenNumberAndMoreStuff.left(indexOfFirstNonDigit).toUInt()
|
|
));
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
double PS_H = (currinf.data.dvi_h*300.0)/(65536*1200)-300;
|
|
double PS_V = (currinf.data.dvi_v*300.0)/1200 - 300;
|
|
|
|
if (cp.indexOf("ps::[begin]", 0, Qt::CaseInsensitive) == 0) {
|
|
PostScriptOutPutString->append( QString(" %1 %2 moveto\n").arg(PS_H).arg(PS_V) );
|
|
PostScriptOutPutString->append( QString(" %1\n").arg(cp.mid(11)) );
|
|
} else {
|
|
if (cp.indexOf("ps::[end]", 0, Qt::CaseInsensitive) == 0) {
|
|
PostScriptOutPutString->append( QString(" %1\n").arg(cp.mid(9)) );
|
|
} else {
|
|
if (cp.indexOf("ps::", 0, Qt::CaseInsensitive) == 0) {
|
|
PostScriptOutPutString->append( QString(" %1\n").arg(cp.mid(4)) );
|
|
} else {
|
|
PostScriptOutPutString->append( QString(" %1 %2 moveto\n").arg(PS_H).arg(PS_V) );
|
|
PostScriptOutPutString->append( QString(" %1\n").arg(cp.mid(3)) );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void dviRenderer::prescan_ParsePSFileSpecial(const QString& cp)
|
|
{
|
|
#ifdef DEBUG_PRESCAN
|
|
kDebug(kvs::dvi) << "epsf-special: psfile=" << cp;
|
|
#endif
|
|
|
|
QString include_command = cp.simplified();
|
|
|
|
// The line is supposed to start with "..ile=", and then comes the
|
|
// filename. Figure out what the filename is and stow it away. Of
|
|
// course, this does not work if the filename contains spaces
|
|
// (already the simplified() above is wrong). If you have
|
|
// files like this, go away.
|
|
QString EPSfilename = include_command;
|
|
EPSfilename.truncate(EPSfilename.indexOf(' '));
|
|
|
|
// Strip enclosing quotation marks which are included by some LaTeX
|
|
// macro packages (but not by others). This probably means that
|
|
// graphic files are no longer found if the filename really does
|
|
// contain quotes, but we don't really care that much.
|
|
if ((EPSfilename.at(0) == '\"') && (EPSfilename.at(EPSfilename.length()-1) == '\"')) {
|
|
EPSfilename = EPSfilename.mid(1,EPSfilename.length()-2);
|
|
}
|
|
|
|
// If the file name ends in 'png', 'gif', 'jpg' or 'jpeg', we assume
|
|
// that this is NOT a PostScript file, and we exit here.
|
|
QString ending = EPSfilename.section('.', -1).toLower();
|
|
if ((ending == "png") || (ending == "gif") || (ending == "jpg") || (ending == "jpeg")) {
|
|
dviFile->numberOfExternalNONPSFiles++;
|
|
return;
|
|
}
|
|
|
|
// Now assume that the graphics file *is* a PostScript file
|
|
dviFile->numberOfExternalPSFiles++;
|
|
|
|
// Now locate the Gfx file on the hard disk...
|
|
EPSfilename = ghostscript_interface::locateEPSfile(EPSfilename, baseURL);
|
|
|
|
// If the EPSfilename really points to a PDF file, convert that file now.
|
|
if (ending == "pdf") {
|
|
QString convErrorMsg;
|
|
QString oEPSfilename = EPSfilename;
|
|
EPSfilename = dviFile->convertPDFtoPS(EPSfilename, &convErrorMsg);
|
|
if (convErrorMsg.isEmpty() != true) {
|
|
emit error(convErrorMsg, -1);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Now parse the arguments.
|
|
int llx = 0;
|
|
int lly = 0;
|
|
int urx = 0;
|
|
int ury = 0;
|
|
int rwi = 0;
|
|
int rhi = 0;
|
|
int angle = 0;
|
|
|
|
// just to avoid ambiguities; the filename could contain keywords
|
|
include_command = include_command.mid(include_command.indexOf(' '));
|
|
|
|
parse_special_argument(include_command, "llx=", &llx);
|
|
parse_special_argument(include_command, "lly=", &lly);
|
|
parse_special_argument(include_command, "urx=", &urx);
|
|
parse_special_argument(include_command, "ury=", &ury);
|
|
parse_special_argument(include_command, "rwi=", &rwi);
|
|
parse_special_argument(include_command, "rhi=", &rhi);
|
|
parse_special_argument(include_command, "angle=", &angle);
|
|
|
|
int clip=include_command.indexOf(" clip"); // -1 if clip keyword is not present, >= 0 otherwise
|
|
|
|
if (QFile::exists(EPSfilename)) {
|
|
double PS_H = (currinf.data.dvi_h*300.0)/(65536*1200)-300;
|
|
double PS_V = (currinf.data.dvi_v*300.0)/1200 - 300;
|
|
PostScriptOutPutString->append( QString(" %1 %2 moveto\n").arg(PS_H).arg(PS_V) );
|
|
PostScriptOutPutString->append( "@beginspecial " );
|
|
PostScriptOutPutString->append( QString(" %1 @llx").arg(llx) );
|
|
PostScriptOutPutString->append( QString(" %1 @lly").arg(lly) );
|
|
PostScriptOutPutString->append( QString(" %1 @urx").arg(urx) );
|
|
PostScriptOutPutString->append( QString(" %1 @ury").arg(ury) );
|
|
if (rwi != 0)
|
|
PostScriptOutPutString->append( QString(" %1 @rwi").arg(rwi) );
|
|
if (rhi != 0)
|
|
PostScriptOutPutString->append( QString(" %1 @rhi").arg(rhi) );
|
|
if (angle != 0)
|
|
PostScriptOutPutString->append( QString(" %1 @angle").arg(angle) );
|
|
if (clip != -1)
|
|
PostScriptOutPutString->append(" @clip");
|
|
PostScriptOutPutString->append( " @setspecial \n" );
|
|
PostScriptOutPutString->append( QString(" (%1) run\n").arg(EPSfilename) );
|
|
PostScriptOutPutString->append( "@endspecial \n" );
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
void dviRenderer::prescan_ParseSourceSpecial(const QString& cp)
|
|
{
|
|
// if no rendering takes place, i.e. when the DVI file is first
|
|
// loaded, generate a DVI_SourceFileAnchor. These anchors are used
|
|
// in forward search, i.e. to relate references line
|
|
// "src:123file.tex" to positions in the DVI file
|
|
|
|
// extract the file name and the numeral part from the string
|
|
qint32 j;
|
|
for(j=0;j<cp.length();j++)
|
|
if (!cp.at(j).isNumber())
|
|
break;
|
|
quint32 sourceLineNumber = cp.left(j).toUInt();
|
|
QFileInfo fi1(dviFile->filename);
|
|
QString sourceFileName = QFileInfo(fi1.dir(), cp.mid(j).trimmed()).absoluteFilePath();
|
|
Length l;
|
|
l.setLength_in_inch(currinf.data.dvi_v/(resolutionInDPI*shrinkfactor));
|
|
DVI_SourceFileAnchor sfa(sourceFileName, sourceLineNumber, current_page+1, l);
|
|
sourceHyperLinkAnchors.push_back(sfa);
|
|
}
|
|
|
|
|
|
void dviRenderer::prescan_parseSpecials(char *cp, quint8 *)
|
|
{
|
|
QString special_command = QString::fromUtf8(cp);
|
|
|
|
// Now to those specials which are only interpreted during the
|
|
// prescan phase, and NOT during rendering.
|
|
|
|
// PaperSize special
|
|
if (strncasecmp(cp, "papersize", 9) == 0) {
|
|
prescan_ParsePapersizeSpecial(special_command.mid(9));
|
|
return;
|
|
}
|
|
|
|
// color special for background color
|
|
if (strncasecmp(cp, "background", 10) == 0) {
|
|
prescan_ParseBackgroundSpecial(special_command.mid(10));
|
|
return;
|
|
}
|
|
|
|
// HTML anchor special
|
|
if (strncasecmp(cp, "html:<A name=", 13) == 0) {
|
|
prescan_ParseHTMLAnchorSpecial(special_command.mid(14));
|
|
return;
|
|
}
|
|
|
|
// Postscript Header File
|
|
if (strncasecmp(cp, "header=", 7) == 0) {
|
|
prescan_ParsePSHeaderSpecial(special_command.mid(7));
|
|
return;
|
|
}
|
|
|
|
// Literal Postscript Header
|
|
if (cp[0] == '!') {
|
|
prescan_ParsePSBangSpecial(special_command.mid(1));
|
|
return;
|
|
}
|
|
|
|
// Literal Postscript inclusion
|
|
if (cp[0] == '"') {
|
|
prescan_ParsePSQuoteSpecial(special_command.mid(1));
|
|
return;
|
|
}
|
|
|
|
// PS-Postscript inclusion
|
|
if (strncasecmp(cp, "ps:", 3) == 0) {
|
|
prescan_ParsePSSpecial(special_command);
|
|
return;
|
|
}
|
|
|
|
// Encapsulated Postscript File
|
|
if (strncasecmp(cp, "PSfile=", 7) == 0) {
|
|
prescan_ParsePSFileSpecial(special_command.mid(7));
|
|
return;
|
|
}
|
|
|
|
// source special
|
|
if (strncasecmp(cp, "src:", 4) == 0) {
|
|
prescan_ParseSourceSpecial(special_command.mid(4));
|
|
return;
|
|
}
|
|
|
|
// Finally there are those special commands which must be considered
|
|
// both during rendering and during the pre-scan phase
|
|
|
|
// HTML anchor end
|
|
if (strncasecmp(cp, "html:</A>", 9) == 0) {
|
|
html_anchor_end();
|
|
return;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
void dviRenderer::prescan_setChar(unsigned int ch)
|
|
{
|
|
TeXFontDefinition *fontp = currinf.fontp;
|
|
if (fontp == NULL)
|
|
return;
|
|
|
|
if (currinf.set_char_p == &dviRenderer::set_char) {
|
|
glyph *g = ((TeXFont *)(currinf.fontp->font))->getGlyph(ch, true, globalColor);
|
|
if (g == NULL)
|
|
return;
|
|
currinf.data.dvi_h += (int)(currinf.fontp->scaled_size_in_DVI_units * dviFile->getCmPerDVIunit() *
|
|
(1200.0 / 2.54)/16.0 * g->dvi_advance_in_units_of_design_size_by_2e20 + 0.5);
|
|
return;
|
|
}
|
|
|
|
if (currinf.set_char_p == &dviRenderer::set_vf_char) {
|
|
macro *m = &currinf.fontp->macrotable[ch];
|
|
if (m->pos == NULL)
|
|
return;
|
|
currinf.data.dvi_h += (int)(currinf.fontp->scaled_size_in_DVI_units * dviFile->getCmPerDVIunit() *
|
|
(1200.0 / 2.54)/16.0 * m->dvi_advance_in_units_of_design_size_by_2e20 + 0.5);
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
void dviRenderer::prescan(parseSpecials specialParser)
|
|
{
|
|
#ifdef DEBUG_PRESCAN
|
|
kDebug(kvs::dvi) << "dviRenderer::prescan( ... )";
|
|
#endif
|
|
|
|
if (resolutionInDPI == 0.0)
|
|
setResolution(100);
|
|
|
|
qint32 RRtmp=0, WWtmp=0, XXtmp=0, YYtmp=0, ZZtmp=0;
|
|
quint8 ch;
|
|
double fontPixelPerDVIunit = dviFile->getCmPerDVIunit() * 1200.0/2.54;
|
|
|
|
stack.clear();
|
|
|
|
currinf.fontp = NULL;
|
|
currinf.set_char_p = &dviRenderer::set_no_char;
|
|
|
|
for (;;) {
|
|
ch = readUINT8();
|
|
|
|
if (ch <= (unsigned char) (SETCHAR0 + 127)) {
|
|
prescan_setChar(ch);
|
|
continue;
|
|
}
|
|
|
|
if (FNTNUM0 <= ch && ch <= (unsigned char) (FNTNUM0 + 63)) {
|
|
currinf.fontp = currinf.fonttable->value(ch - FNTNUM0);
|
|
if (currinf.fontp == NULL) {
|
|
errorMsg = i18n("The DVI code referred to font #%1, which was not previously defined.", ch - FNTNUM0);
|
|
return;
|
|
}
|
|
currinf.set_char_p = currinf.fontp->set_char_p;
|
|
continue;
|
|
}
|
|
|
|
|
|
qint32 a, b;
|
|
|
|
switch (ch) {
|
|
case SET1:
|
|
prescan_setChar(readUINT8());
|
|
break;
|
|
|
|
case SETRULE:
|
|
/* Be careful, dvicopy outputs rules with height =
|
|
0x80000000. We don't want any SIGFPE here. */
|
|
a = readUINT32();
|
|
b = readUINT32();
|
|
b = ((long) (b * 65536.0*fontPixelPerDVIunit));
|
|
currinf.data.dvi_h += b;
|
|
break;
|
|
|
|
case PUTRULE:
|
|
a = readUINT32();
|
|
b = readUINT32();
|
|
break;
|
|
|
|
case PUT1:
|
|
case NOP:
|
|
break;
|
|
|
|
case BOP:
|
|
command_pointer += 11 * 4;
|
|
currinf.data.dvi_h = 1200 << 16; // Reminder: DVI-coordinates start at (1",1") from top of page
|
|
currinf.data.dvi_v = 1200;
|
|
currinf.data.pxl_v = int(currinf.data.dvi_v/shrinkfactor);
|
|
currinf.data.w = currinf.data.x = currinf.data.y = currinf.data.z = 0;
|
|
break;
|
|
|
|
case PUSH:
|
|
stack.push(currinf.data);
|
|
break;
|
|
|
|
case POP:
|
|
if (stack.isEmpty())
|
|
return;
|
|
else
|
|
currinf.data = stack.pop();
|
|
break;
|
|
|
|
case RIGHT1:
|
|
case RIGHT2:
|
|
case RIGHT3:
|
|
case RIGHT4:
|
|
RRtmp = readINT(ch - RIGHT1 + 1);
|
|
currinf.data.dvi_h += ((long) (RRtmp * 65536.0*fontPixelPerDVIunit));
|
|
break;
|
|
|
|
case W1:
|
|
case W2:
|
|
case W3:
|
|
case W4:
|
|
WWtmp = readINT(ch - W0);
|
|
currinf.data.w = ((long) (WWtmp * 65536.0*fontPixelPerDVIunit));
|
|
case W0:
|
|
currinf.data.dvi_h += currinf.data.w;
|
|
break;
|
|
|
|
case X1:
|
|
case X2:
|
|
case X3:
|
|
case X4:
|
|
XXtmp = readINT(ch - X0);
|
|
currinf.data.x = ((long) (XXtmp * 65536.0*fontPixelPerDVIunit));
|
|
case X0:
|
|
currinf.data.dvi_h += currinf.data.x;
|
|
break;
|
|
|
|
case DOWN1:
|
|
case DOWN2:
|
|
case DOWN3:
|
|
case DOWN4:
|
|
{
|
|
qint32 DDtmp = readINT(ch - DOWN1 + 1);
|
|
currinf.data.dvi_v += ((long) (DDtmp * 65536.0*fontPixelPerDVIunit))/65536;
|
|
currinf.data.pxl_v = int(currinf.data.dvi_v/shrinkfactor);
|
|
}
|
|
break;
|
|
|
|
case Y1:
|
|
case Y2:
|
|
case Y3:
|
|
case Y4:
|
|
YYtmp = readINT(ch - Y0);
|
|
currinf.data.y = ((long) (YYtmp * 65536.0*fontPixelPerDVIunit));
|
|
case Y0:
|
|
currinf.data.dvi_v += currinf.data.y/65536;
|
|
currinf.data.pxl_v = int(currinf.data.dvi_v/shrinkfactor);
|
|
break;
|
|
|
|
case Z1:
|
|
case Z2:
|
|
case Z3:
|
|
case Z4:
|
|
ZZtmp = readINT(ch - Z0);
|
|
currinf.data.z = ((long) (ZZtmp * 65536.0*fontPixelPerDVIunit));
|
|
case Z0:
|
|
currinf.data.dvi_v += currinf.data.z/65536;
|
|
currinf.data.pxl_v = int(currinf.data.dvi_v/shrinkfactor);
|
|
break;
|
|
|
|
case FNT1:
|
|
case FNT2:
|
|
case FNT3:
|
|
case FNT4:
|
|
currinf.fontp = currinf.fonttable->value(readUINT(ch - FNT1 + 1));
|
|
if (currinf.fontp == NULL)
|
|
return;
|
|
currinf.set_char_p = currinf.fontp->set_char_p;
|
|
break;
|
|
|
|
case XXX1:
|
|
case XXX2:
|
|
case XXX3:
|
|
case XXX4:
|
|
{
|
|
quint8 *beginningOfSpecialCommand = command_pointer-1;
|
|
a = readUINT(ch - XXX1 + 1);
|
|
if (a > 0) {
|
|
char *cmd = new char[a+1];
|
|
strncpy(cmd, (char *)command_pointer, a);
|
|
command_pointer += a;
|
|
cmd[a] = '\0';
|
|
(this->*specialParser)(cmd, beginningOfSpecialCommand);
|
|
delete [] cmd;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case FNTDEF1:
|
|
case FNTDEF2:
|
|
case FNTDEF3:
|
|
case FNTDEF4:
|
|
command_pointer += 12 + ch - FNTDEF1 + 1;
|
|
command_pointer += readUINT8() + readUINT8();
|
|
break;
|
|
|
|
default:
|
|
return;
|
|
} /* end switch */
|
|
} /* end for */
|
|
}
|