source: trunk/poppler/mypoppler/poppler/CairoOutputDev.h @ 277

Last change on this file since 277 was 277, checked in by rbri, 12 years ago

PDF plugin: Poppler library updated to version 0.12.3

File size: 16.7 KB
Line 
1//========================================================================
2//
3// CairoOutputDev.h
4//
5// Copyright 2003 Glyph & Cog, LLC
6// Copyright 2004 Red Hat, INC
7//
8//========================================================================
9
10//========================================================================
11//
12// Modified under the Poppler project - http://poppler.freedesktop.org
13//
14// All changes made under the Poppler project to this file are licensed
15// under GPL version 2 or later
16//
17// Copyright (C) 2005-2008 Jeff Muizelaar <jeff@infidigm.net>
18// Copyright (C) 2005, 2006 Kristian HÞgsberg <krh@redhat.com>
19// Copyright (C) 2005 Nickolay V. Shmyrev <nshmyrev@yandex.ru>
20// Copyright (C) 2006-2009 Carlos Garcia Campos <carlosgc@gnome.org>
21// Copyright (C) 2008, 2009 Adrian Johnson <ajohnson@redneon.com>
22// Copyright (C) 2008 Michael Vrable <mvrable@cs.ucsd.edu>
23//
24// To see a description of the changes please see the Changelog file that
25// came with your tarball or type make ChangeLog if you are building from git
26//
27//========================================================================
28
29#ifndef CAIROOUTPUTDEV_H
30#define CAIROOUTPUTDEV_H
31
32#ifdef USE_GCC_PRAGMAS
33#pragma interface
34#endif
35
36#include "goo/gtypes.h"
37#include <cairo-ft.h>
38#include "OutputDev.h"
39#include "TextOutputDev.h"
40#include "GfxState.h"
41
42class GfxState;
43class GfxPath;
44class Gfx8BitFont;
45struct GfxRGB;
46class CairoFontEngine;
47class CairoFont;
48
49//------------------------------------------------------------------------
50
51//------------------------------------------------------------------------
52// CairoImage
53//------------------------------------------------------------------------
54class CairoImage {
55public:
56  // Constructor.
57  CairoImage (double x1, double y1, double x2, double y2);
58
59  // Destructor.
60  ~CairoImage ();
61
62  // Set the image cairo surface
63  void setImage (cairo_surface_t *image);
64 
65  // Get the image cairo surface
66  cairo_surface_t *getImage () const { return image; }
67
68  // Get the image rectangle
69  void getRect (double *xa1, double *ya1, double *xa2, double *ya2)
70          { *xa1 = x1; *ya1 = y1; *xa2 = x2; *ya2 = y2; }
71 
72private:
73  cairo_surface_t *image;  // image cairo surface
74  double x1, y1;          // upper left corner
75  double x2, y2;          // lower right corner
76};
77
78
79//------------------------------------------------------------------------
80// CairoOutputDev
81//------------------------------------------------------------------------
82
83class CairoOutputDev: public OutputDev {
84public:
85
86  // Constructor.
87  CairoOutputDev();
88
89  // Destructor.
90  virtual ~CairoOutputDev();
91
92  //----- get info about output device
93
94  // Does this device use upside-down coordinates?
95  // (Upside-down means (0,0) is the top left corner of the page.)
96  virtual GBool upsideDown() { return gTrue; }
97
98  // Does this device use drawChar() or drawString()?
99  virtual GBool useDrawChar() { return gTrue; }
100
101  // Does this device use tilingPatternFill()?  If this returns false,
102  // tiling pattern fills will be reduced to a series of other drawing
103  // operations.
104  virtual GBool useTilingPatternFill() { return gTrue; }
105
106  // Does this device use functionShadedFill(), axialShadedFill(), and
107  // radialShadedFill()?  If this returns false, these shaded fills
108  // will be reduced to a series of other drawing operations.
109  virtual GBool useShadedFills() { return gTrue; }
110
111  // Does this device use FillColorStop()?
112  virtual GBool useFillColorStop() { return gTrue; }
113
114  // Does this device use beginType3Char/endType3Char?  Otherwise,
115  // text in Type 3 fonts will be drawn with drawChar/drawString.
116  virtual GBool interpretType3Chars() { return gFalse; }
117
118  //----- initialization and control
119
120  // Start a page.
121  virtual void startPage(int pageNum, GfxState *state);
122
123  // End a page.
124  virtual void endPage();
125
126  //----- link borders
127  virtual void drawLink(Link *link, Catalog *catalog);
128
129  //----- save/restore graphics state
130  virtual void saveState(GfxState *state);
131  virtual void restoreState(GfxState *state);
132
133  //----- update graphics state
134  virtual void updateAll(GfxState *state);
135  virtual void setDefaultCTM(double *ctm);
136  virtual void updateCTM(GfxState *state, double m11, double m12,
137                         double m21, double m22, double m31, double m32);
138  virtual void updateLineDash(GfxState *state);
139  virtual void updateFlatness(GfxState *state);
140  virtual void updateLineJoin(GfxState *state);
141  virtual void updateLineCap(GfxState *state);
142  virtual void updateMiterLimit(GfxState *state);
143  virtual void updateLineWidth(GfxState *state);
144  virtual void updateFillColor(GfxState *state);
145  virtual void updateStrokeColor(GfxState *state);
146  virtual void updateFillOpacity(GfxState *state);
147  virtual void updateStrokeOpacity(GfxState *state);
148  virtual void updateFillColorStop(GfxState *state, double offset);
149  virtual void updateBlendMode(GfxState *state);
150
151  //----- update text state
152  virtual void updateFont(GfxState *state);
153  virtual void updateRender(GfxState *state);
154
155  //----- path painting
156  virtual void stroke(GfxState *state);
157  virtual void fill(GfxState *state);
158  virtual void eoFill(GfxState *state);
159  virtual GBool tilingPatternFill(GfxState *state, Object *str,
160                                  int paintType, Dict *resDict,
161                                  double *mat, double *bbox,
162                                  int x0, int y0, int x1, int y1,
163                                  double xStep, double yStep);
164  virtual GBool axialShadedFill(GfxState *state, GfxAxialShading *shading, double tMin, double tMax);
165  virtual GBool axialShadedSupportExtend(GfxState *state, GfxAxialShading *shading);
166  virtual GBool radialShadedFill(GfxState *state, GfxRadialShading *shading, double sMin, double sMax);
167  virtual GBool radialShadedSupportExtend(GfxState *state, GfxRadialShading *shading);
168
169  //----- path clipping
170  virtual void clip(GfxState *state);
171  virtual void eoClip(GfxState *state);
172
173  //----- text drawing
174  void beginString(GfxState *state, GooString *s);
175  void endString(GfxState *state);
176  void drawChar(GfxState *state, double x, double y,
177                double dx, double dy,
178                double originX, double originY,
179                CharCode code, int nBytes, Unicode *u, int uLen);
180
181  virtual GBool beginType3Char(GfxState *state, double x, double y,
182                               double dx, double dy,
183                               CharCode code, Unicode *u, int uLen);
184  virtual void endType3Char(GfxState *state);
185  virtual void beginTextObject(GfxState *state);
186  virtual GBool deviceHasTextClip(GfxState *state) { return textClipPath && haveCSPattern; }
187  virtual void endTextObject(GfxState *state);
188
189  // If current colorspace is pattern,
190  // does this device support text in pattern colorspace?
191  virtual GBool supportTextCSPattern(GfxState *state) {
192      return state->getFillColorSpace()->getMode() == csPattern; }
193
194  // If current colorspace is pattern,
195  // need this device special handling for masks in pattern colorspace?
196  virtual GBool fillMaskCSPattern(GfxState * state) {
197      return state->getFillColorSpace()->getMode() == csPattern; }
198
199  virtual void endMaskClip(GfxState *state);
200
201  //----- grouping operators
202  virtual void beginMarkedContent(char *name, Dict *properties);
203  virtual void endMarkedContent(GfxState *state); 
204
205  //----- image drawing
206  virtual void drawImageMask(GfxState *state, Object *ref, Stream *str,
207                             int width, int height, GBool invert, GBool interpolate,
208                             GBool inlineImg);
209  void drawImageMaskPrescaled(GfxState *state, Object *ref, Stream *str,
210                              int width, int height, GBool invert, GBool interpolate,
211                              GBool inlineImg);
212  void drawImageMaskRegular(GfxState *state, Object *ref, Stream *str,
213                            int width, int height, GBool invert, GBool interpolate,
214                            GBool inlineImg);
215
216  virtual void drawImage(GfxState *state, Object *ref, Stream *str,
217                         int width, int height, GfxImageColorMap *colorMap,
218                         GBool interpolate, int *maskColors, GBool inlineImg);
219  virtual void drawSoftMaskedImage(GfxState *state, Object *ref, Stream *str,
220                                   int width, int height,
221                                   GfxImageColorMap *colorMap,
222                                   GBool interpolate,
223                                   Stream *maskStr,
224                                   int maskWidth, int maskHeight,
225                                   GfxImageColorMap *maskColorMap,
226                                   GBool maskInterpolate);
227
228  virtual void drawMaskedImage(GfxState *state, Object *ref, Stream *str,
229                               int width, int height,
230                               GfxImageColorMap *colorMap,
231                               GBool interpolate,
232                               Stream *maskStr,
233                               int maskWidth, int maskHeight,
234                               GBool maskInvert, GBool maskInterpolate);
235
236  //----- transparency groups and soft masks
237  virtual void beginTransparencyGroup(GfxState * /*state*/, double * /*bbox*/,
238                                      GfxColorSpace * /*blendingColorSpace*/,
239                                      GBool /*isolated*/, GBool /*knockout*/,
240                                      GBool /*forSoftMask*/);
241  virtual void endTransparencyGroup(GfxState * /*state*/);
242  void popTransparencyGroup();
243  virtual void paintTransparencyGroup(GfxState * /*state*/, double * /*bbox*/);
244  virtual void setSoftMask(GfxState * /*state*/, double * /*bbox*/, GBool /*alpha*/,
245                           Function * /*transferFunc*/, GfxColor * /*backdropColor*/);
246  virtual void clearSoftMask(GfxState * /*state*/);
247
248  //----- Type 3 font operators
249  virtual void type3D0(GfxState *state, double wx, double wy);
250  virtual void type3D1(GfxState *state, double wx, double wy,
251      double llx, double lly, double urx, double ury);
252
253  //----- special access
254 
255  // Called to indicate that a new PDF document has been loaded.
256  void startDoc(XRef *xrefA, Catalog *catalogA, CairoFontEngine *fontEngine = NULL);
257 
258  GBool isReverseVideo() { return gFalse; }
259 
260  void setCairo (cairo_t *cr);
261  void setTextPage (TextPage *text);
262  void setPrinting (GBool printing) { this->printing = printing; needFontUpdate = gTrue; }
263
264  void setInType3Char(GBool inType3Char) { this->inType3Char = inType3Char; }
265  void getType3GlyphWidth (double *wx, double *wy) { *wx = t3_glyph_wx; *wy = t3_glyph_wy; }
266  GBool hasType3GlyphBBox () { return t3_glyph_has_bbox; }
267  double *getType3GlyphBBox () { return t3_glyph_bbox; }
268
269protected:
270  void doPath(cairo_t *cairo, GfxState *state, GfxPath *path);
271 
272  GfxRGB fill_color, stroke_color;
273  cairo_pattern_t *fill_pattern, *stroke_pattern;
274  double fill_opacity;
275  double stroke_opacity;
276  CairoFont *currentFont;
277 
278  XRef *xref;                   // xref table for current document
279  Catalog *catalog;
280
281  static FT_Library ft_lib;
282  static GBool ft_lib_initialized;
283
284  CairoFontEngine *fontEngine;
285  GBool fontEngine_owner;
286
287  cairo_t *cairo;
288  cairo_matrix_t orig_matrix;
289  GBool needFontUpdate;                // set when the font needs to be updated
290  GBool printing;
291  cairo_surface_t *surface;
292  cairo_glyph_t *glyphs;
293  int glyphCount;
294  cairo_path_t *textClipPath;
295  GBool inType3Char;            // inside a Type 3 CharProc
296  double t3_glyph_wx, t3_glyph_wy;
297  GBool t3_glyph_has_bbox;
298  double t3_glyph_bbox[4];
299
300  GBool prescaleImages;
301
302  TextPage *text;               // text for the current page
303  ActualText *actualText;
304
305  cairo_pattern_t *group;
306  cairo_pattern_t *shape;
307  cairo_pattern_t *mask;
308  cairo_surface_t *cairo_shape_surface;
309  cairo_t *cairo_shape;
310  int knockoutCount;
311  struct ColorSpaceStack {
312    GBool knockout;
313    GfxColorSpace *cs;
314    struct ColorSpaceStack *next;
315  } * groupColorSpaceStack;
316
317  struct MaskStack {
318      cairo_pattern_t *mask;
319      struct MaskStack *next;
320  } *maskStack;
321
322  GBool haveCSPattern;  // set if text has been drawn with a
323                        //   clipping render mode because of pattern colorspace
324  int savedRender;      // use if pattern colorspace
325};
326
327//------------------------------------------------------------------------
328// CairoImageOutputDev
329//------------------------------------------------------------------------
330
331//XXX: this should ideally not inherit from CairoOutputDev but use it instead perhaps
332class CairoImageOutputDev: public CairoOutputDev {
333public:
334
335  // Constructor.
336  CairoImageOutputDev();
337
338  // Destructor.
339  virtual ~CairoImageOutputDev();
340
341  //----- get info about output device
342
343  // Does this device use upside-down coordinates?
344  // (Upside-down means (0,0) is the top left corner of the page.)
345  virtual GBool upsideDown() { return gTrue; }
346
347  // Does this device use drawChar() or drawString()?
348  virtual GBool useDrawChar() { return gFalse; }
349
350  // Does this device use tilingPatternFill()?  If this returns false,
351  // tiling pattern fills will be reduced to a series of other drawing
352  // operations.
353  virtual GBool useTilingPatternFill() { return gTrue; }
354
355  // Does this device use functionShadedFill(), axialShadedFill(), and
356  // radialShadedFill()?  If this returns false, these shaded fills
357  // will be reduced to a series of other drawing operations.
358  virtual GBool useShadedFills() { return gTrue; }
359
360  // Does this device use FillColorStop()?
361  virtual GBool useFillColorStop() { return gFalse; }
362
363  // Does this device use beginType3Char/endType3Char?  Otherwise,
364  // text in Type 3 fonts will be drawn with drawChar/drawString.
365  virtual GBool interpretType3Chars() { return gFalse; }
366
367  // Does this device need non-text content?
368  virtual GBool needNonText() { return gTrue; }
369
370    //----- link borders
371  virtual void drawLink(Link *link, Catalog *catalog) { }
372
373  //----- save/restore graphics state
374  virtual void saveState(GfxState *state) { }
375  virtual void restoreState(GfxState *state) { }
376
377  //----- update graphics state
378  virtual void updateAll(GfxState *state) { }
379  virtual void setDefaultCTM(double *ctm) { }
380  virtual void updateCTM(GfxState *state, double m11, double m12,
381                                 double m21, double m22, double m31, double m32) { }
382  virtual void updateLineDash(GfxState *state) { }
383  virtual void updateFlatness(GfxState *state) { }
384  virtual void updateLineJoin(GfxState *state) { }
385  virtual void updateLineCap(GfxState *state) { }
386  virtual void updateMiterLimit(GfxState *state) { }
387  virtual void updateLineWidth(GfxState *state) { }
388  virtual void updateFillColor(GfxState *state) { }
389  virtual void updateStrokeColor(GfxState *state) { }
390  virtual void updateFillOpacity(GfxState *state) { }
391  virtual void updateStrokeOpacity(GfxState *state) { }
392  virtual void updateBlendMode(GfxState *state) { }
393
394  //----- update text state
395  virtual void updateFont(GfxState *state) { }
396
397  //----- path painting
398  virtual void stroke(GfxState *state) { }
399  virtual void fill(GfxState *state) { }
400  virtual void eoFill(GfxState *state) { }
401  virtual GBool tilingPatternFill(GfxState *state, Object *str,
402                                  int paintType, Dict *resDict,
403                                  double *mat, double *bbox,
404                                  int x0, int y0, int x1, int y1,
405                                  double xStep, double yStep) { return gTrue; }
406  virtual GBool axialShadedFill(GfxState *state,
407                                GfxAxialShading *shading,
408                                double tMin, double tMax) { return gTrue; }
409  virtual GBool radialShadedFill(GfxState *state,
410                                 GfxRadialShading *shading,
411                                 double sMin, double sMax) { return gTrue; }
412
413  //----- path clipping
414  virtual void clip(GfxState *state) { }
415  virtual void eoClip(GfxState *state) { }
416
417  //----- image drawing
418  virtual void drawImageMask(GfxState *state, Object *ref, Stream *str,
419                             int width, int height, GBool invert,
420                             GBool interpolate, GBool inlineImg);
421  virtual void drawImage(GfxState *state, Object *ref, Stream *str,
422                         int width, int height, GfxImageColorMap *colorMap,
423                         GBool interpolate, int *maskColors, GBool inlineImg);
424  virtual void drawSoftMaskedImage(GfxState *state, Object *ref, Stream *str,
425                                   int width, int height,
426                                   GfxImageColorMap *colorMap,
427                                   GBool interpolate,
428                                   Stream *maskStr,
429                                   int maskWidth, int maskHeight,
430                                   GfxImageColorMap *maskColorMap,
431                                   GBool maskInterpolate);
432  virtual void drawMaskedImage(GfxState *state, Object *ref, Stream *str,
433                               int width, int height,
434                               GfxImageColorMap *colorMap,
435                               GBool interpolate,
436                               Stream *maskStr,
437                               int maskWidth, int maskHeight,
438                               GBool maskInvert, GBool maskInterpolate);
439
440  //----- transparency groups and soft masks
441  virtual void beginTransparencyGroup(GfxState * /*state*/, double * /*bbox*/,
442                                      GfxColorSpace * /*blendingColorSpace*/,
443                                      GBool /*isolated*/, GBool /*knockout*/,
444                                      GBool /*forSoftMask*/) {}
445  virtual void endTransparencyGroup(GfxState * /*state*/) {}
446  virtual void paintTransparencyGroup(GfxState * /*state*/, double * /*bbox*/) {}
447  virtual void setSoftMask(GfxState * /*state*/, double * /*bbox*/, GBool /*alpha*/,
448                           Function * /*transferFunc*/, GfxColor * /*backdropColor*/) {}
449  virtual void clearSoftMask(GfxState * /*state*/) {}
450
451  //----- Image list
452  // By default images are not rendred
453  void setImageDrawDecideCbk(GBool (*cbk)(int img_id, void *data),
454                             void *data) { imgDrawCbk = cbk; imgDrawCbkData = data; }
455  // Iterate through list of images.
456  int getNumImages() const { return numImages; }
457  CairoImage *getImage(int i) const { return images[i]; }
458
459private:
460  void saveImage(CairoImage *image);
461 
462  CairoImage **images;
463  int numImages;
464  int size;
465  GBool (*imgDrawCbk)(int img_id, void *data);
466  void *imgDrawCbkData;
467};
468
469#endif
Note: See TracBrowser for help on using the repository browser.