apdf/splash/Splash.h

   1 //========================================================================
   2 //
   3 // Splash.h
   4 //
   5 //========================================================================
   6
   7 #ifndef SPLASH_H
   8 #define SPLASH_H
   9
  10 #include <aconf.h>
  11
  12 #ifdef USE_GCC_PRAGMAS
  13 #pragma interface
  14 #endif
  15
  16 #include "SplashTypes.h"
  17 #include "SplashClip.h"
  18
  19 class SplashBitmap;
  20 struct SplashGlyphBitmap;
  21 class SplashState;
  22 class SplashPattern;
  23 class SplashScreen;
  24 class SplashPath;
  25 class SplashXPath;
  26 class SplashFont;
  27
  28 //------------------------------------------------------------------------
  29
  30 // Retrieves the next line of pixels in an image mask.  Normally,
  31 // fills in *<line> and returns true.  If the image stream is
  32 // exhausted, returns false.
  33 typedef GBool (*SplashImageMaskSource)(void *data, SplashColorPtr pixel);
  34
  35 // Retrieves the next line of pixels in an image.  Normally, fills in
  36 // *<line> and returns true.  If the image stream is exhausted,
  37 // returns false.
  38 typedef GBool (*SplashImageSource)(void *data, SplashColorPtr line);
  39
  40 //------------------------------------------------------------------------
  41 // Splash
  42 //------------------------------------------------------------------------
  43
  44 class Splash {
  45 public:
  46
  47   // Create a new rasterizer object.
  48   Splash(SplashBitmap *bitmapA);
  49
  50   ~Splash();
  51
  52   //----- state read
  53
  54   SplashPattern *getStrokePattern();
  55   SplashPattern *getFillPattern();
  56   SplashScreen *getScreen();
  57   SplashBlendFunc getBlendFunc();
  58   SplashCoord getStrokeAlpha();
  59   SplashCoord getFillAlpha();
  60   SplashCoord getLineWidth();
  61   int getLineCap();
  62   int getLineJoin();
  63   SplashCoord getMiterLimit();
  64   SplashCoord getFlatness();
  65   SplashCoord *getLineDash();
  66   int getLineDashLength();
  67   SplashCoord getLineDashPhase();
  68   SplashClip *getClip();
  69
  70   //----- state write
  71
  72   void setStrokePattern(SplashPattern *strokeColor);
  73   void setFillPattern(SplashPattern *fillColor);
  74   void setScreen(SplashScreen *screen);
  75   void setBlendFunc(SplashBlendFunc func);
  76   void setStrokeAlpha(SplashCoord alpha);
  77   void setFillAlpha(SplashCoord alpha);
  78   void setLineWidth(SplashCoord lineWidth);
  79   void setLineCap(int lineCap);
  80   void setLineJoin(int lineJoin);
  81   void setMiterLimit(SplashCoord miterLimit);
  82   void setFlatness(SplashCoord flatness);
  83   // the <lineDash> array will be copied
  84   void setLineDash(SplashCoord *lineDash, int lineDashLength,
  85                    SplashCoord lineDashPhase);
  86   void clipResetToRect(SplashCoord x0, SplashCoord y0,
  87                        SplashCoord x1, SplashCoord y1);
  88   SplashError clipToRect(SplashCoord x0, SplashCoord y0,
  89                          SplashCoord x1, SplashCoord y1);
  90   SplashError clipToPath(SplashPath *path, GBool eo);
  91
  92   //----- state save/restore
  93
  94   void saveState();
  95   SplashError restoreState();
  96
  97   //----- soft mask
  98
  99   void setSoftMask(SplashBitmap *softMaskA);
 100
 101   //----- drawing operations
 102
 103   // Fill the bitmap with <color>.  This is not subject to clipping.
 104   void clear(SplashColorPtr color);
 105
 106   // Stroke a path using the current stroke pattern.
 107   SplashError stroke(SplashPath *path);
 108
 109   // Fill a path using the current fill pattern.
 110   SplashError fill(SplashPath *path, GBool eo);
 111
 112   // Fill a path, XORing with the current fill pattern.
 113   SplashError xorFill(SplashPath *path, GBool eo);
 114
 115   // Draw a character, using the current fill pattern.
 116   SplashError fillChar(SplashCoord x, SplashCoord y, int c, SplashFont *font);
 117
 118   // Draw a glyph, using the current fill pattern.  This function does
 119   // not free any data, i.e., it ignores glyph->freeData.
 120   SplashError fillGlyph(SplashCoord x, SplashCoord y,
 121                         SplashGlyphBitmap *glyph);
 122
 123   // Draws an image mask using the fill color.  This will read <h>
 124   // lines of <w> pixels from <src>, starting with the top line.  "1"
 125   // pixels will be drawn with the current fill color; "0" pixels are
 126   // transparent.  The matrix:
 127   //    [ mat[0] mat[1] 0 ]
 128   //    [ mat[2] mat[3] 0 ]
 129   //    [ mat[4] mat[5] 1 ]
 130   // maps a unit square to the desired destination for the image, in
 131   // PostScript style:
 132   //    [x' y' 1] = [x y 1] * mat
 133   // Note that the Splash y axis points downward, and the image source
 134   // is assumed to produce pixels in raster order, starting from the
 135   // top line.
 136   SplashError fillImageMask(SplashImageMaskSource src, void *srcData,
 137                             int w, int h, SplashCoord *mat);
 138
 139   // Draw an image.  This will read <h> lines of <w> pixels from
 140   // <src>, starting with the top line.  These pixels are assumed to
 141   // be in the source mode, <srcMode>.  The following combinations of
 142   // source and target modes are supported:
 143   //    source       target
 144   //    ------       ------
 145   //    Mono1        Mono1
 146   //    Mono8        Mono1   -- with dithering
 147   //    Mono8        Mono8
 148   //    RGB8         RGB8
 149   //    BGR8         BGR8
 150   //    ARGB8        RGB8    -- with source alpha (masking)
 151   //    BGRA8        BGR8    -- with source alpha (masking)
 152   // The matrix behaves as for fillImageMask.
 153   SplashError drawImage(SplashImageSource src, void *srcData,
 154                         SplashColorMode srcMode,
 155                         int w, int h, SplashCoord *mat);
 156
 157   //----- misc
 158
 159   // Return the associated bitmap.
 160   SplashBitmap *getBitmap() { return bitmap; }
 161
 162   // Get a bounding box which includes all modifications since the
 163   // last call to clearModRegion.
 164   void getModRegion(int *xMin, int *yMin, int *xMax, int *yMax)
 165     { *xMin = modXMin; *yMin = modYMin; *xMax = modXMax; *yMax = modYMax; }
 166
 167   // Clear the modified region bounding box.
 168   void clearModRegion();
 169
 170   // Get clipping status for the last drawing operation subject to
 171   // clipping.
 172   SplashClipResult getClipRes() { return opClipRes; }
 173
 174   // Toggle debug mode on or off.
 175   void setDebugMode(GBool debugModeA) { debugMode = debugModeA; }
 176
 177 private:
 178
 179   void updateModX(int x);
 180   void updateModY(int y);
 181   void strokeNarrow(SplashXPath *xPath);
 182   void strokeWide(SplashXPath *xPath);
 183   SplashXPath *makeDashedPath(SplashXPath *xPath);
 184   SplashError fillWithPattern(SplashPath *path, GBool eo,
 185                               SplashPattern *pattern, SplashCoord alpha);
 186   void drawPixel(int x, int y, SplashColorPtr color,
 187                  SplashCoord alpha, GBool noClip);
 188   void drawPixel(int x, int y, SplashPattern *pattern,
 189                  SplashCoord alpha, GBool noClip);
 190   void drawSpan(int x0, int x1, int y, SplashPattern *pattern,
 191                 SplashCoord alpha, GBool noClip);
 192   void xorSpan(int x0, int x1, int y, SplashPattern *pattern, GBool noClip);
 193   void dumpPath(SplashPath *path);
 194   void dumpXPath(SplashXPath *path);
 195
 196   SplashBitmap *bitmap;
 197   SplashState *state;
 198   SplashBitmap *softMask;
 199   int modXMin, modYMin, modXMax, modYMax;
 200   SplashClipResult opClipRes;
 201   GBool debugMode;
 202 };
 203
 204 #endif