Load cups into easysw/current.
[thirdparty/cups.git] / pdftops / Splash.h
1 //========================================================================
2 //
3 // Splash.h
4 //
5 //========================================================================
6
7 #ifndef SPLASH_H
8 #define SPLASH_H
9
10 #include <config.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