Bitmap.h

Go to the documentation of this file.

//    This file is part of dvi2bitmap.
//    Copyright 1999--2002, Council for the Central Laboratory of the Research Councils
//    
//    This program is part of the Starlink Software Distribution: see
//    http://www.starlink.ac.uk 
//
//    dvi2bitmap 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 2 of the License, or
//    (at your option) any later version.
//
//    dvi2bitmap 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 dvi2bitmap; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//    The General Public License is distributed along with this
//    program in the file LICENCE.
//
//    Author: Norman Gray <norman@astro.gla.ac.uk>
//    $Id: Bitmap.h,v 1.32 2003/10/03 13:17:41 norman Exp $


#ifndef BITMAP_HEADER_READ
#define BITMAP_HEADER_READ 1

#include "Byte.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;
    };

    class BitmapMark {
    public:
        double x, y;
    };
    void mark(const double x, const double y);
    BitmapMark* 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_;
    BitmapMark* 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

---