/*************************************************************************
** DVIReader.hpp **
** **
** This file is part of dvisvgm -- a fast DVI to SVG converter **
** Copyright (C) 2005-2024 Martin Gieseking <martin.gieseking@uos.de> **
** **
** This program is free software; you can redistribute it and/or **
** modify it under the terms of the GNU General Public License as **
** published by the Free Software Foundation; either version 3 of **
** the License, or (at your option) any later version. **
** **
** This program is distributed in the hope that it will be useful, but **
** WITHOUT ANY WARRANTY; without even the implied warranty of **
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the **
** GNU General Public License for more details. **
** **
** You should have received a copy of the GNU General Public License **
** along with this program; if not, see <http://www.gnu.org/licenses/>. **
*************************************************************************/
#ifndef DVIREADER_HPP
#define DVIREADER_HPP
#include <cstdint>
#include <limits>
#include <map>
#include <stack>
#include <string>
#include "BasicDVIReader.hpp"
#include "Color.hpp"
#include "VFActions.hpp"
class Font;
class FontStyle;
class HashFunction;
class NativeFont;
class VirtualFont;
class DVIReader : public BasicDVIReader, public VFActions {
protected:
enum class WritingMode {LR=0, TB=1, BT=3};
enum class SetFontMode {SF_SHORT, SF_LONG, VF_ENTER, VF_LEAVE};
enum class MoveMode {SETCHAR, CHANGEPOS};
struct DVIState {
double h, v; ///< horizontal and vertical cursor position
double x, w, y, z; ///< additional registers to store horizontal (x, w) and vertical (y, z) positions
WritingMode d; ///< direction: 0: horizontal, 1: vertical(top->bottom), 3: vertical (bottom->top)
DVIState () {reset();}
void reset () {h = v = x = w = y = z = 0.0; d=WritingMode::LR;}
};
public:
explicit DVIReader (std::istream &is);
bool executeDocument ();
void executeAll ();
bool executePage (unsigned n);
double getXPos () const override {return _dviState.h;}
double getYPos () const override {return _dviState.v;}
int stackDepth () const override {return _stateStack.size();}
int currentFontNumber () const {return _currFontNum;}
unsigned currentPageNumber () const override {return _currPageNum;}
unsigned numberOfPages () const {return _bopOffsets.empty() ? 0 : _bopOffsets.size()-1;}
protected:
size_t numberOfPageBytes (int n) const {return _bopOffsets.size() > 1 ? _bopOffsets[n+1]-_bopOffsets[n] : 0;}
bool computePageHash (size_t pageno, HashFunction &hashFunc);
virtual void moveRight (double dx, MoveMode mode);
virtual void moveDown (double dy, MoveMode mode);
void putVFChar (Font *font, uint32_t c);
double putGlyphArray (bool xonly, std::vector<double> &dx, std::vector<double> &dy, std::vector<uint16_t> &glyphs);
const Font* defineFont (uint32_t fontnum, const std::string &name, uint32_t cs, double dsize, double ssize);
void setFont (int num, SetFontMode mode);
const DVIState& dviState() const {return _dviState;}
double dvi2bp () const {return _dvi2bp;}
bool inPage () const {return _inPage;}
// VFAction methods
void defineVFFont (uint32_t fontnum, const std::string &path, const std::string &name, uint32_t checksum, double dsize, double ssize) override;
void defineVFChar (uint32_t c, std::vector<char> &&dvi) override;
// The following template methods provide higher-level access to the DVI commands.
// In contrast to their cmdXXX pendants, they don't require any handling of the input stream.
// All command arguments are delivered as function parameters. These methods are called after
// the DVI registers have been updated, i.e. currState() represents the state after executing
// the command. If the previous register state is required, prevState() can be used.
virtual void dviPre (uint8_t id, uint32_t numer, uint32_t denom, uint32_t mag, const std::string &comment) {}
virtual void dviPost (uint16_t stdepth, uint16_t pages, uint32_t pw, uint32_t ph, uint32_t mag, uint32_t num, uint32_t den, uint32_t lbopofs) {}
virtual void dviPostPost (uint8_t id, uint32_t postOffset) {}
virtual void dviBop (const std::vector<int32_t> &c, int32_t prevBopOffset) {}
virtual void dviEop () {}
virtual void dviSetChar0 (uint32_t c, const Font *font) {}
virtual void dviSetChar (uint32_t c, const Font *font) {}
virtual void dviPutChar (uint32_t c, const Font *font) {}
virtual void dviSetRule (double h, double w) {}
virtual void dviPutRule (double h, double w) {}
virtual void dviNop () {}
virtual void dviPush () {}
virtual void dviPop () {}
virtual void dviRight (double dx) {}
virtual void dviDown (double dy) {}
virtual void dviX0 () {}
virtual void dviY0 () {}
virtual void dviW0 () {}
virtual void dviZ0 () {}
virtual void dviX (double x) {}
virtual void dviY (double y) {}
virtual void dviW (double w) {}
virtual void dviZ (double z) {}
virtual void dviFontDef (uint32_t fontnum, uint32_t checksum, const Font *font) {}
virtual void dviFontNum (uint32_t fontnum, SetFontMode mode, const Font *font) {}
virtual void dviDir (WritingMode dir) {}
virtual void dviXXX (const std::string &str) {}
virtual void dviXPic (uint8_t box, const std::vector<int32_t> &matrix, int16_t page, const std::string &path) {}
virtual void dviXFontDef (uint32_t fontnum, const NativeFont *font) {}
virtual void dviXGlyphArray (std::vector<double> &dx, std::vector<double> &dy, std::vector<uint16_t> &glyphs, const Font &font) {}
virtual void dviXGlyphString (std::vector<double> &dx, std::vector<uint16_t> &glyphs, const Font &font) {}
virtual void dviXTextAndGlyphs (std::vector<double> &dx, std::vector<double> &dy, std::vector<uint16_t> &chars, std::vector<uint16_t> &glyphs, const Font &font) {}
private:
// The following low-level methods evaluate the DVI commands read from
// the input stream and call the corresponding dviXXX methods.
void cmdSetChar0 (int c) override;
void cmdSetChar (int len) override;
void cmdPutChar (int len) override;
void cmdSetRule (int len) override;
void cmdPutRule (int len) override;
void cmdNop (int len) override;
void cmdBop (int len) override;
void cmdEop (int len) override;
void cmdPush (int len) override;
void cmdPop (int len) override;
void cmdDir (int len) override;
void cmdRight (int len) override;
void cmdDown (int len) override;
void cmdX0 (int len) override;
void cmdY0 (int len) override;
void cmdW0 (int len) override;
void cmdZ0 (int len) override;
void cmdX (int len) override;
void cmdY (int len) override;
void cmdW (int len) override;
void cmdZ (int len) override;
void cmdFontDef (int len) override;
void cmdFontNum0 (int n) override;
void cmdFontNum (int len) override;
void cmdXXX (int len) override;
void cmdPre (int len) override;
void cmdPost (int len) override;
void cmdPostPost (int len) override;
void cmdXPic (int len) override;
void cmdXFontDef (int len) override;
void cmdXGlyphArray (int len) override;
void cmdXGlyphString (int len) override;
void cmdXTextAndGlyphs (int len) override;
private:
bool _inPage=false; ///< true if stream pointer is between bop and eop
unsigned _currPageNum=0; ///< current page number (1 is first page)
int _currFontNum=0; ///< current font number
double _dvi2bp=0.0; ///< factor to convert dvi units to PS points
uint32_t _mag=1; ///< magnification factor * 1000
DVIState _dviState; ///< current state of the DVI registers
std::stack<DVIState> _stateStack;
std::vector<uint32_t> _bopOffsets;
};
#endif