summaryrefslogtreecommitdiff
path: root/dviware/dvi2bitmap/Bitmap.h
diff options
context:
space:
mode:
Diffstat (limited to 'dviware/dvi2bitmap/Bitmap.h')
-rw-r--r--dviware/dvi2bitmap/Bitmap.h218
1 files changed, 218 insertions, 0 deletions
diff --git a/dviware/dvi2bitmap/Bitmap.h b/dviware/dvi2bitmap/Bitmap.h
new file mode 100644
index 0000000000..b43203ade5
--- /dev/null
+++ b/dviware/dvi2bitmap/Bitmap.h
@@ -0,0 +1,218 @@
+/* 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) { };
+};
+
+/**
+ * Represents an abstract bitmap.
+ * The bitmaps written to file are subclasses of the class {@link BitmapImage}.
+ */
+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();
+ /**
+ * Sets the current bitmap to be transparent, if possible.
+ * @param sw if true, the current bitmap is set to be transparent
+ */
+ 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);
+ /**
+ * Is the bitmap empty? If nothing has (yet) been written to the
+ * bitmap, or if everything that was written was out of
+ * bounds, then the bitmap is empty.
+ *
+ * @return true if the bitmap is empty
+ */
+ bool empty () const
+ { return (bbL > W || bbR < 0 || bbT > H || bbB < 0); }
+ bool overlaps() const;
+ int* boundingBox();
+ /**
+ * Returns the total width of the bitmap. This may not the the
+ * initial size of the bitmap, if it has expanded since then.
+ * @return width of bitmap
+ */
+ int getWidth() const { return W; }
+ /**
+ * Returns the total height of the bitmap. This may not the the
+ * initial size of the bitmap, if it has expanded since then.
+ * @return height of bitmap
+ */
+ int getHeight() const { return H; }
+ /**
+ * Sets the verbosity of the current class.
+ * @param level the required verbosity
+ * @return the previous verbosity level
+ */
+ static verbosities verbosity (const verbosities level) {
+ enum verbosities oldv = verbosity_;
+ verbosity_ = level;
+ return oldv;
+ }
+ /**
+ * Sets whether bitmap information is logged. If logging is
+ * enabled, then the details of the bitmaps are sent to the
+ * <code>stdout</code> prefixed by the given string.
+ *
+ * @param prefix if non-null, then bitmap activity is logged on
+ * stdout with this prefix; if null, such logging is turned off
+ */
+ static void logBitmapInfo (const char *prefix) {
+ logBitmapPrefix_ = prefix;
+ };
+
+#if 0
+ /**
+ * Represents a location within the bitmap. Coordinates
+ * <code>x</code> and <code>y</code> are relative to the top-left
+ * corner of the bitmap, with the pixel in the top-left corner
+ * having coordinates (0,0).
+ *
+ * <p>See {@link #mark} and {@link #getMark}.
+ */
+ 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();
+
+ /** Iterator class */
+ 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);
+ /** pointer to bitmap. Pixel (x,y) is at B[y*W + x]; */
+ Byte *B;
+ /** width and height of bitmap */
+ int W, H;
+ /** Maximum height and width */
+ int maxW_, maxH_;
+ /** is the bitmap to be expandable? */
+ bool isExpandable_;
+ /** bounding box. bbL and bbT are the leftmost and topmost
+ * blackened pixels, bbR and bbB are one more than the rightmost
+ * and lowest blackened pixels. Until a call to freeze(), bb? may
+ * go outside the canvas (ie, may be negative or greater than W or
+ * H); afterwards they are bounded by 0..W and 0..H. These
+ * remain the edges of the blackened pixels even after cropping,
+ * and so it is the responsibiligy of the boundingBox() method to
+ * take cropping into account.
+ */
+ int bbL, bbR, bbT, bbB;
+ /** holds return values for boundingBox() */
+ int BB[4];
+ /** Flag is set true when the bitmap is frozen */
+ bool frozen_;
+ /** cropX is the value of bbX when the crop() method was called */
+ int cropL, cropR, cropT, cropB;
+ /** Flag is set true when the bitmap is frozen */
+ bool cropped_;
+ /** Flag is set true when the bitmap is scaled */
+ bool scaled_;
+ /** Location of mark */
+ DviFilePosition* mark_;
+ /** When cropping, set margins. Indexed by enumerator Bitmap::Margin. */
+ static int cropMarginDefault[4];
+ int cropMargin[4];
+ static bool cropMarginAbsDefault[4];
+ bool cropMarginAbs[4];
+ /** If true, make background transparent if possible */
+ bool transparent_;
+ BitmapColour fg_, bg_;
+ /** If true, custom colours have been set */
+ bool customRGB_;
+ /** Default background colours */
+ static BitmapColour def_fg_, def_bg_;
+ static bool def_customRGB_;
+ /** bits-per-pixel */
+ int bpp_;
+ /** Maximum colour index (must fit into a Byte) */
+ Byte max_colour_;
+ /** The reporting verbosity level */
+ static verbosities verbosity_;
+ /** The prefix when reporting bitmap information. Set to zero to suppress */
+ static const char* logBitmapPrefix_;
+};
+
+#endif //#ifndef BITMAP_HEADER_READ