Bitmap.h

Go to the documentation of this file.

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


#ifndef BITMAP_HEADER_READ
#define BITMAP_HEADER_READ 1

#include "Byte.h"
//#include "DviFile.h"            /* needed by BitmapMark */
#include "DviFilePosition.h"
#include "DviError.h"
#include "verbosity.h"

class BitmapError : public DviError {
 public:
    BitmapError(string s) : DviError(s) { };
};

class Bitmap {
 public:
    Bitmap (const int width, const int height, const int bpp=1,
            bool expandable=true,
            const int maxwidth=-1, const int maxheight=-1)
            throw (BitmapError);
    ~Bitmap();

    // make sure Left..Bottom are 0..3 (I should use an iterator, I know...)
    enum Margin { Left=0, Right=1, Top=2, Bottom=3, All};

    void paint (const int x, const int y, const int w, const int h,
                const Byte* b)
            throw (BitmapError);
    void rule (const int x, const int y, const int w, const int h)
            throw (BitmapError);
    void strut (const int x, const int y,
                const int l, const int r,
                const int t, const int b)
            throw (BitmapError);
    void write (const string filename, const string format)
            throw (BitmapError);
    void freeze ();
    void crop ();
    static void cropDefault (Margin spec, int pixels, bool absolute=false)
            throw (BitmapError);
    void crop (Margin spec, int pixels, bool absolute=false)
            throw (BitmapError);
    void blur ();
    void clear();
    void setTransparent(const bool sw) { transparent_ = sw; }
    typedef struct BitmapColour_s {
        Byte red, green, blue;
    } BitmapColour;
    void setRGB (const bool fg, const BitmapColour*);
    static void setDefaultRGB (const bool fg, const BitmapColour*);
    void scaleDown (const int factor)
            throw (BitmapError);
    bool empty () const
        { return (bbL > W || bbR < 0 || bbT > H || bbB < 0); }
    bool overlaps() const;
    int* boundingBox();
    int getWidth() const { return W; }
    int getHeight() const { return H; }
    static verbosities verbosity (const verbosities level) {
        enum verbosities oldv = verbosity_;
        verbosity_ = level;
        return oldv;
    }
    static void logBitmapInfo (const char *prefix) {
        logBitmapPrefix_ = prefix;
    };

#if 0

    class BitmapMark {
    private:
        double x, y;
        DviFile* dvif;
    public:
        BitmapMark(DviFile*, double x_sp, double y_sp);
        double getX(const DviFile::DviUnits u);
        double getY(const DviFile::DviUnits u);
        void shift(double dx, double dy, DviFile::DviUnits u);
        void scale(double factor);
        // make a static copy
        BitmapMark* copy();
    };
    void mark(DviFile*, const double x, const double y);
    BitmapMark* getMark();
#endif
    void mark(DviFilePosition*);
    DviFilePosition* getMark();

    class const_iterator 
    {
    public:
        Byte* operator*() 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();
        void init(Byte* b, int startx, int starty, int width, int nrows);
        Byte* b_;
        int rowLength_;
        int rowNumber_;
        int startColumn_;
        int lastRow_;
        friend class Bitmap;
    };
    const_iterator runningIterator_;
    static const_iterator endIterator_;
    const_iterator begin();
    const_iterator end() const;

 private:
    void normalizeBB_(int& l, int& r, int& t, int& b);
    void usesBitmapArea_(const int ulx, const int uly,
                         const int lrx, const int lry);
    Byte *B;
    int W, H;
    int maxW_, maxH_;
    bool isExpandable_;
    int bbL, bbR, bbT, bbB;
    int BB[4];
    bool frozen_;
    int cropL, cropR, cropT, cropB;
    bool cropped_;
    bool scaled_;
    DviFilePosition* mark_;
    static int  cropMarginDefault[4];
    int  cropMargin[4];
    static bool cropMarginAbsDefault[4];
    bool cropMarginAbs[4];
    bool transparent_;
    BitmapColour fg_, bg_;
    bool customRGB_;
    static BitmapColour def_fg_, def_bg_;
    static bool def_customRGB_;
    int bpp_;
    Byte max_colour_;
    static verbosities verbosity_;
    static const char* logBitmapPrefix_;
};

#endif //#ifndef BITMAP_HEADER_READ