DviFile.h

Go to the documentation of this file.

/* This file is part of dvi2bitmap; see README for copyrights and licence */

#ifndef DVI_FILE_HEADER_READ
#define DVI_FILE_HEADER_READ 1

#include <config.h>

#ifdef HAVE_CSTD_INCLUDE
#include <cctype>
#else
#include <ctype.h>
#endif

#include <string>

#include <stack>
#include <list>
#include <map>

#include <Byte.h>
#include <DviError.h>
#include <FileByteStream.h>
#include <PkFont.h>
#include <verbosity.h>

// I think the GCC 2.8.1 stack implementation may be buggy.  
// Setting this to 1 switches on a home-made version.
// This hasn't received _extensive_ testing, but seems to work OK.
// This is pretty crappy, though, and I intend to remove it next time
// I'm feeling brave.  If you have to enable this to get this library
// to compile, therefore, tell me (norman@astro.gla.ac.uk) so that I
// don't discard this.  If you need to enable this, then you should
// probably call the DviFile constructors with read_post true, so
// that the maximum stack size can be read from the postamble, and
// the homemade posstack therefore initialised to the correct length.
#ifndef HOMEMADE_POSSTATESTACK
#define HOMEMADE_POSSTATESTACK 0
#endif

class DviFileEvent;
class DviFilePreamble;

class DviFile {
public:
    DviFile (string& s,
             int resolution=0,
             double magmag=1.0,
             bool read_postamble=true,
             bool seekable=true)
            throw (DviError);
    ~DviFile();
    bool eof();
    DviFileEvent *getEvent();
    DviFileEvent *getEndOfPage();
    enum DviUnits {
        unit_BAD,
        unit_pt,
        unit_pc,
        unit_in,
        unit_bp,
        unit_cm,
        unit_mm,
        unit_dd,
        unit_cc,
        unit_sp,
        unit_pixels,
        unit_dvi
    };
    static DviUnits unitType(string unitString);
    static string unitString(DviUnits unit);
    int currH(DviUnits units=unit_pixels) const
            throw (DviError) {
        int r;
        switch (units) {
          case unit_pixels:
            r = hh_;            /* device units */
            break;
          case unit_dvi:
            r = h_;
            break;
          case unit_sp:
            r = (netmag_ == 1.0 ? h_ : static_cast<int>(h_*netmag_));
            break;
          default:
            throw DviError("Bad unit in currH");
        }
        return r;
    }
    int currV(DviUnits units=unit_pixels) const
            throw (DviError) {
        int r;
        switch (units) {
          case unit_pixels:
            r = vv_;            /* device units */
            break;
          case unit_dvi:
            r = v_;
            break;
          case unit_sp:
            r = (netmag_ == 1.0 ? v_ : static_cast<int>(v_*netmag_));
            break;
          default:
            throw DviError("Bad unit in currV");
        }
        return r;
    }
    int hSize();
    int vSize();
    static double convertFromScaledPoints(int sp, DviUnits units,
                                          DviFile *dvif=0)
        throw (DviError);
    static int convertToScaledPoints(double length, DviUnits units,
                                     DviFile *dvif=0)
        throw (DviError);
    static double convertUnits(double length,
                               DviUnits from_units,
                               DviUnits to_units,
                               DviFile *dvif=0)
        throw (DviError);
    static verbosities verbosity(const verbosities level);
    double magnification() const { return netmag_; }
    int pt2px(double npt) const
    {
        return static_cast<int>
                (npt * dviu_per_pt_ / dviu_per_px_ + 0.5);
    }
    const string *filename () const { return &fileName_; }

    const PkFont* getFallbackFont(const PkFont* desired);

    bool haveReadPostamble() const { return have_preread_postamble_; }

private:
    string fileName_;
    int h_, v_, w_, x_, y_, z_;
    int hh_, vv_;
    int pending_hupdate_;
    int pending_hhupdate_;
    PkFont *current_font_;
    InputByteStream *dvif_;
    double dviu_per_pt_;

    double dviu_per_px_;
    double dviu_per_sp_;

    double dviu_per_(DviUnits unit);

    const double extmag_;
    double netmag_;

    // tell getEvent to skip this page
    bool skipPage_;

    int max_drift_;

    int widest_page_;
    int deepest_page_;

    Byte getByte();
    signed int getSIU(int), getSIS(int);
    unsigned int getUIU(int);
    struct {
        unsigned int mag, l, u, s, t;
    } postamble_;
    struct {
        unsigned int i, num, den, mag;
        string comment;
    } preamble_;
    void read_postamble()
            throw (DviError);
    bool have_preread_postamble_; /* we sought to it at beginning */
    bool have_read_to_postamble_; /* we have read through to end */
    void process_preamble(DviFilePreamble *);
    void fnt_def_(double fontmag, int nbytes);
    void check_duplicate_font(int);
    int pixel_round(int);
    int charWidth_ (int charno);
    int charEscapement_ (int charno);
    // updateH/V update the horizontal position by an amount in DVI units
    void updateH_ (int hup, int hhup);
    void updateV_ (int y);
    struct PosState {
        const int h, v, w, x, y, z, hh, vv;
        PosState(int h, int v, int w, int x, int y, int z, int hh, int vv)
            : h(h),v(v),w(w),x(x),y(y),z(z),hh(hh),vv(vv) { }
    };
#if HOMEMADE_POSSTATESTACK
    class PosStateStack {
        // It seems wrong to implement a stack rather than using the standard
        // one, but either I'm doing something wrong the way
        // I use the STL stack, or else it's (horrors!) buggy.  In any case,
        // it's reasonable to use a non-extendable stack, since the DVI
        // postamble specifies the maximum stack size required.
    public:
        PosStateStack(int size);
        void push(const PosState *p);
        const PosState *pop();
        bool empty() const { return i == 0; }
        void clear();
    private:
        unsigned int size, i;
        const PosState **s;
    };
    PosStateStack *posStack_;
#else
    STD::stack<PosState> posStack_;
#endif
    static verbosities verbosity_;

 public:
    class FontSet {
    private:
        FontSet();
        ~FontSet();
        void add(int fnt_num, PkFont* newfont);
        PkFont* get(int fnt_num);
        friend class DviFile;
        typedef STD::map<int,PkFont*> FontMap;
        FontMap fontMap_;
    public:
        bool empty() const { return fontMap_.empty(); }
        size_t size() const { return fontMap_.size(); }
        class const_iterator;
        friend class DviFile::FontSet::const_iterator; /* so it sees FontMap */
        class const_iterator {
        public:
            const PkFont* operator*() const throw (DviError);
            const_iterator& operator++() throw (DviError);
            bool operator==(const const_iterator& it) const;
            bool operator!=(const const_iterator& it) const;
            ~const_iterator();
        private:
            const_iterator();
            const_iterator(FontMap m);
            STD::list<PkFont*> fontlist_;
            friend class DviFile::FontSet;
        };
        const_iterator begin() const;
        const_iterator end() const;
    private:
        mutable const_iterator* myIter_;
    };
 private:
    FontSet fontSet_;
 public:
    const FontSet* getFontSet() const { return &fontSet_; }
    // Why can't I have 'FontSet& getFontSet() const { return fontSet_; };'?

#if 0
 public:
    class const_iterator {
    public:
        const PkFont* operator*() const throw (DviBug);
        const_iterator& operator++();
        bool operator==(const const_iterator& it) const;
        bool operator!=(const const_iterator& it) const;
#if 0
        bool operator==(const const_iterator& it) const
                { return finished_ == it.finished_; }
        bool operator!=(const const_iterator& it) const
                { return finished_ != it.finished_; }
#endif
    private:
        /* These should be implementable more compactly, since we're
           just using map's iterator, but there's some visibility
           subtlety that escapes me... */
        const_iterator(FontMap::const_iterator m,
                       FontMap::const_iterator me) {
            mapiter_ = m;
            endmapiter_ = me;
            finished_ = false;
        };
        const_iterator() : finished_(true) { }
        FontMap::const_iterator mapiter_;
        FontMap::const_iterator endmapiter_;
        bool finished_;
        friend class DviFile;
    };
    const_iterator begin() {
        return const_iterator(fontMap_.begin(), fontMap_.end());
    }
    const_iterator end() const { return const_iterator(); };
    friend class const_iterator;
#endif
};


/* DviFileEvent is what is returned to the client from the DVI reading class.
 * Declare one derived class for each type of event.
 *
 * This is rather bad design - these classes should be subclasses of DviFile
 * above.
 * DviFileEvent is a virtual class, so these derived classes should have
 * non-virtual destructors.
 * XXX these shouldn't be subclasses of DviFile, I don't think, but
 * they should have DviFile as a friend (correct?), so that only
 * DviFile can create instances
 */
class DviFileEvent {
 public:
    enum eventTypes { setchar, setrule, fontchange, special,
                      page, preamble, postamble };
    virtual void debug() const;

    eventTypes type() const { return type_; }

    const unsigned char opcode() const { return opcode_; }

    void release();

    static verbosities verbosity(const verbosities level);

 protected:
    DviFileEvent(unsigned char opcode, eventTypes t, DviFile *dp=0);
    static verbosities verbosity_;

 private:
    const unsigned char opcode_;
    DviFile *dviFile_;
    const eventTypes type_;

    static void releaseEvent(DviFileEvent *e);
};

class DviFileSetChar : public DviFileEvent {
 public:
    DviFileSetChar(int charno, DviFile *dptr);
    DviFileSetChar(int opcode, int charno, DviFile *dptr);
    void debug() const;
    const int charno() const { return charno_; }
 private:
    const int charno_;
};

class DviFileSetRule: public DviFileEvent {
 public:
    const int h;
    const int w;
    DviFileSetRule(unsigned char opcode, DviFile *dptr, int h, int w)
            : DviFileEvent(opcode, setrule, dptr), h(h), w(w) { }
    void debug() const;
};

class DviFileFontChange : public DviFileEvent {
 public:
    DviFileFontChange(unsigned char opcode, PkFont *f)
            : DviFileEvent(opcode, fontchange), font(f) { }
    void debug() const;
    const PkFont *font;
};

class DviFileSpecial : public DviFileEvent {
 public:
    DviFileSpecial(unsigned char opcode, string str)
            : DviFileEvent(opcode, special), specialString(str) { }
    const string specialString;
    void debug() const;
};

class DviFilePage : public DviFileEvent {
 public:
    DviFilePage(unsigned char opcode, bool isStart)
            : DviFileEvent(opcode, page), isStart(isStart) { }
    void debug() const;
    const bool isStart;
    signed int count[10];
    signed int previous;
};

class DviFilePreamble : public DviFileEvent {
 public:
    DviFilePreamble()
            : DviFileEvent(247, preamble) { }
    void debug() const;
    unsigned int dviType;
    unsigned int num;
    unsigned int den;
    unsigned int mag;
    string comment;
};

class DviFilePostamble : public DviFileEvent {
 public:
    DviFilePostamble()
            : DviFileEvent(248, postamble) { }
};

#endif //#ifndef DVI_FILE_HEADER_READ