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

Last change on this file since 461 was 461, checked in by Silvan Scherrer, 11 years ago

poppler update to 0.14.2

File size: 17.1 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-2010 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 void clipToStrokePath(GfxState *state);
160  virtual GBool tilingPatternFill(GfxState *state, Object *str,
161                                  int paintType, Dict *resDict,
162                                  double *mat, double *bbox,
163                                  int x0, int y0, int x1, int y1,
164                                  double xStep, double yStep);
165  virtual GBool axialShadedFill(GfxState *state, GfxAxialShading *shading, double tMin, double tMax);
166  virtual GBool axialShadedSupportExtend(GfxState *state, GfxAxialShading *shading);
167  virtual GBool radialShadedFill(GfxState *state, GfxRadialShading *shading, double sMin, double sMax);
168  virtual GBool radialShadedSupportExtend(GfxState *state, GfxRadialShading *shading);
169
170  //----- path clipping
171  virtual void clip(GfxState *state);
172  virtual void eoClip(GfxState *state);
173
174  //----- text drawing
175  void beginString(GfxState *state, GooString *s);
176  void endString(GfxState *state);
177  void drawChar(GfxState *state, double x, double y,
178                double dx, double dy,
179                double originX, double originY,
180                CharCode code, int nBytes, Unicode *u, int uLen);
181
182  virtual GBool beginType3Char(GfxState *state, double x, double y,
183                               double dx, double dy,
184                               CharCode code, Unicode *u, int uLen);
185  virtual void endType3Char(GfxState *state);
186  virtual void beginTextObject(GfxState *state);
187  virtual GBool deviceHasTextClip(GfxState *state) { return textClipPath && haveCSPattern; }
188  virtual void endTextObject(GfxState *state);
189
190  // If current colorspace is pattern,
191  // does this device support text in pattern colorspace?
192  virtual GBool supportTextCSPattern(GfxState *state) {
193      return state->getFillColorSpace()->getMode() == csPattern; }
194
195  // If current colorspace is pattern,
196  // need this device special handling for masks in pattern colorspace?
197  virtual GBool fillMaskCSPattern(GfxState * state) {
198      return state->getFillColorSpace()->getMode() == csPattern; }
199
200  virtual void endMaskClip(GfxState *state);
201
202  //----- grouping operators
203  virtual void beginMarkedContent(char *name, Dict *properties);
204  virtual void endMarkedContent(GfxState *state); 
205
206  //----- image drawing
207  virtual void drawImageMask(GfxState *state, Object *ref, Stream *str,
208                             int width, int height, GBool invert, GBool interpolate,
209                             GBool inlineImg);
210  void drawImageMaskPrescaled(GfxState *state, Object *ref, Stream *str,
211                              int width, int height, GBool invert, GBool interpolate,
212                              GBool inlineImg);
213  void drawImageMaskRegular(GfxState *state, Object *ref, Stream *str,
214                            int width, int height, GBool invert, GBool interpolate,
215                            GBool inlineImg);
216
217  virtual void drawImage(GfxState *state, Object *ref, Stream *str,
218                         int width, int height, GfxImageColorMap *colorMap,
219                         GBool interpolate, int *maskColors, GBool inlineImg);
220  virtual void drawSoftMaskedImage(GfxState *state, Object *ref, Stream *str,
221                                   int width, int height,
222                                   GfxImageColorMap *colorMap,
223                                   GBool interpolate,
224                                   Stream *maskStr,
225                                   int maskWidth, int maskHeight,
226                                   GfxImageColorMap *maskColorMap,
227                                   GBool maskInterpolate);
228
229  virtual void drawMaskedImage(GfxState *state, Object *ref, Stream *str,
230                               int width, int height,
231                               GfxImageColorMap *colorMap,
232                               GBool interpolate,
233                               Stream *maskStr,
234                               int maskWidth, int maskHeight,
235                               GBool maskInvert, GBool maskInterpolate);
236
237  //----- transparency groups and soft masks
238  virtual void beginTransparencyGroup(GfxState * /*state*/, double * /*bbox*/,
239                                      GfxColorSpace * /*blendingColorSpace*/,
240                                      GBool /*isolated*/, GBool /*knockout*/,
241                                      GBool /*forSoftMask*/);
242  virtual void endTransparencyGroup(GfxState * /*state*/);
243  void popTransparencyGroup();
244  virtual void paintTransparencyGroup(GfxState * /*state*/, double * /*bbox*/);
245  virtual void setSoftMask(GfxState * /*state*/, double * /*bbox*/, GBool /*alpha*/,
246                           Function * /*transferFunc*/, GfxColor * /*backdropColor*/);
247  virtual void clearSoftMask(GfxState * /*state*/);
248
249  //----- Type 3 font operators
250  virtual void type3D0(GfxState *state, double wx, double wy);
251  virtual void type3D1(GfxState *state, double wx, double wy,
252      double llx, double lly, double urx, double ury);
253
254  //----- special access
255 
256  // Called to indicate that a new PDF document has been loaded.
257  void startDoc(XRef *xrefA, Catalog *catalogA, CairoFontEngine *fontEngine = NULL);
258 
259  GBool isReverseVideo() { return gFalse; }
260 
261  void setCairo (cairo_t *cr);
262  void setTextPage (TextPage *text);
263  void setPrinting (GBool printing) { this->printing = printing; needFontUpdate = gTrue; }
264
265  void setInType3Char(GBool inType3Char) { this->inType3Char = inType3Char; }
266  void getType3GlyphWidth (double *wx, double *wy) { *wx = t3_glyph_wx; *wy = t3_glyph_wy; }
267  GBool hasType3GlyphBBox () { return t3_glyph_has_bbox; }
268  double *getType3GlyphBBox () { return t3_glyph_bbox; }
269
270protected:
271  void doPath(cairo_t *cairo, GfxState *state, GfxPath *path);
272  cairo_surface_t *downscaleSurface(cairo_surface_t *orig_surface);
273  void getScaledSize(int orig_width, int orig_height,
274                     int *scaledWidth, int *scaledHeight);
275  cairo_filter_t getFilterForSurface(cairo_surface_t *image,
276                                     GBool interpolate);
277  GBool getStreamData (Stream *str, char **buffer, int *length);
278 
279  GfxRGB fill_color, stroke_color;
280  cairo_pattern_t *fill_pattern, *stroke_pattern;
281  double fill_opacity;
282  double stroke_opacity;
283  CairoFont *currentFont;
284 
285  XRef *xref;                   // xref table for current document
286  Catalog *catalog;
287
288  static FT_Library ft_lib;
289  static GBool ft_lib_initialized;
290
291  CairoFontEngine *fontEngine;
292  GBool fontEngine_owner;
293
294  cairo_t *cairo;
295  cairo_matrix_t orig_matrix;
296  GBool needFontUpdate;                // set when the font needs to be updated
297  GBool printing;
298  cairo_surface_t *surface;
299  cairo_glyph_t *glyphs;
300  int glyphCount;
301  cairo_path_t *textClipPath;
302  GBool inType3Char;            // inside a Type 3 CharProc
303  double t3_glyph_wx, t3_glyph_wy;
304  GBool t3_glyph_has_bbox;
305  double t3_glyph_bbox[4];
306
307  GBool prescaleImages;
308
309  TextPage *text;               // text for the current page
310  ActualText *actualText;
311
312  cairo_pattern_t *group;
313  cairo_pattern_t *shape;
314  cairo_pattern_t *mask;
315  cairo_surface_t *cairo_shape_surface;
316  cairo_t *cairo_shape;
317  int knockoutCount;
318  struct ColorSpaceStack {
319    GBool knockout;
320    GfxColorSpace *cs;
321    struct ColorSpaceStack *next;
322  } * groupColorSpaceStack;
323
324  struct MaskStack {
325      cairo_pattern_t *mask;
326      struct MaskStack *next;
327  } *maskStack;
328
329  GBool haveCSPattern;  // set if text has been drawn with a
330                        //   clipping render mode because of pattern colorspace
331  int savedRender;      // use if pattern colorspace
332};
333
334//------------------------------------------------------------------------
335// CairoImageOutputDev
336//------------------------------------------------------------------------
337
338//XXX: this should ideally not inherit from CairoOutputDev but use it instead perhaps
339class CairoImageOutputDev: public CairoOutputDev {
340public:
341
342  // Constructor.
343  CairoImageOutputDev();
344
345  // Destructor.
346  virtual ~CairoImageOutputDev();
347
348  //----- get info about output device
349
350  // Does this device use upside-down coordinates?
351  // (Upside-down means (0,0) is the top left corner of the page.)
352  virtual GBool upsideDown() { return gTrue; }
353
354  // Does this device use drawChar() or drawString()?
355  virtual GBool useDrawChar() { return gFalse; }
356
357  // Does this device use tilingPatternFill()?  If this returns false,
358  // tiling pattern fills will be reduced to a series of other drawing
359  // operations.
360  virtual GBool useTilingPatternFill() { return gTrue; }
361
362  // Does this device use functionShadedFill(), axialShadedFill(), and
363  // radialShadedFill()?  If this returns false, these shaded fills
364  // will be reduced to a series of other drawing operations.
365  virtual GBool useShadedFills() { return gTrue; }
366
367  // Does this device use FillColorStop()?
368  virtual GBool useFillColorStop() { return gFalse; }
369
370  // Does this device use beginType3Char/endType3Char?  Otherwise,
371  // text in Type 3 fonts will be drawn with drawChar/drawString.
372  virtual GBool interpretType3Chars() { return gFalse; }
373
374  // Does this device need non-text content?
375  virtual GBool needNonText() { return gTrue; }
376
377    //----- link borders
378  virtual void drawLink(Link *link, Catalog *catalog) { }
379
380  //----- save/restore graphics state
381  virtual void saveState(GfxState *state) { }
382  virtual void restoreState(GfxState *state) { }
383
384  //----- update graphics state
385  virtual void updateAll(GfxState *state) { }
386  virtual void setDefaultCTM(double *ctm) { }
387  virtual void updateCTM(GfxState *state, double m11, double m12,
388                                 double m21, double m22, double m31, double m32) { }
389  virtual void updateLineDash(GfxState *state) { }
390  virtual void updateFlatness(GfxState *state) { }
391  virtual void updateLineJoin(GfxState *state) { }
392  virtual void updateLineCap(GfxState *state) { }
393  virtual void updateMiterLimit(GfxState *state) { }
394  virtual void updateLineWidth(GfxState *state) { }
395  virtual void updateFillColor(GfxState *state) { }
396  virtual void updateStrokeColor(GfxState *state) { }
397  virtual void updateFillOpacity(GfxState *state) { }
398  virtual void updateStrokeOpacity(GfxState *state) { }
399  virtual void updateBlendMode(GfxState *state) { }
400
401  //----- update text state
402  virtual void updateFont(GfxState *state) { }
403
404  //----- path painting
405  virtual void stroke(GfxState *state) { }
406  virtual void fill(GfxState *state) { }
407  virtual void eoFill(GfxState *state) { }
408  virtual GBool tilingPatternFill(GfxState *state, Object *str,
409                                  int paintType, Dict *resDict,
410                                  double *mat, double *bbox,
411                                  int x0, int y0, int x1, int y1,
412                                  double xStep, double yStep) { return gTrue; }
413  virtual GBool axialShadedFill(GfxState *state,
414                                GfxAxialShading *shading,
415                                double tMin, double tMax) { return gTrue; }
416  virtual GBool radialShadedFill(GfxState *state,
417                                 GfxRadialShading *shading,
418                                 double sMin, double sMax) { return gTrue; }
419
420  //----- path clipping
421  virtual void clip(GfxState *state) { }
422  virtual void eoClip(GfxState *state) { }
423
424  //----- image drawing
425  virtual void drawImageMask(GfxState *state, Object *ref, Stream *str,
426                             int width, int height, GBool invert,
427                             GBool interpolate, GBool inlineImg);
428  virtual void drawImage(GfxState *state, Object *ref, Stream *str,
429                         int width, int height, GfxImageColorMap *colorMap,
430                         GBool interpolate, int *maskColors, GBool inlineImg);
431  virtual void drawSoftMaskedImage(GfxState *state, Object *ref, Stream *str,
432                                   int width, int height,
433                                   GfxImageColorMap *colorMap,
434                                   GBool interpolate,
435                                   Stream *maskStr,
436                                   int maskWidth, int maskHeight,
437                                   GfxImageColorMap *maskColorMap,
438                                   GBool maskInterpolate);
439  virtual void drawMaskedImage(GfxState *state, Object *ref, Stream *str,
440                               int width, int height,
441                               GfxImageColorMap *colorMap,
442                               GBool interpolate,
443                               Stream *maskStr,
444                               int maskWidth, int maskHeight,
445                               GBool maskInvert, GBool maskInterpolate);
446
447  //----- transparency groups and soft masks
448  virtual void beginTransparencyGroup(GfxState * /*state*/, double * /*bbox*/,
449                                      GfxColorSpace * /*blendingColorSpace*/,
450                                      GBool /*isolated*/, GBool /*knockout*/,
451                                      GBool /*forSoftMask*/) {}
452  virtual void endTransparencyGroup(GfxState * /*state*/) {}
453  virtual void paintTransparencyGroup(GfxState * /*state*/, double * /*bbox*/) {}
454  virtual void setSoftMask(GfxState * /*state*/, double * /*bbox*/, GBool /*alpha*/,
455                           Function * /*transferFunc*/, GfxColor * /*backdropColor*/) {}
456  virtual void clearSoftMask(GfxState * /*state*/) {}
457
458  //----- Image list
459  // By default images are not rendred
460  void setImageDrawDecideCbk(GBool (*cbk)(int img_id, void *data),
461                             void *data) { imgDrawCbk = cbk; imgDrawCbkData = data; }
462  // Iterate through list of images.
463  int getNumImages() const { return numImages; }
464  CairoImage *getImage(int i) const { return images[i]; }
465
466private:
467  void saveImage(CairoImage *image);
468 
469  CairoImage **images;
470  int numImages;
471  int size;
472  GBool (*imgDrawCbk)(int img_id, void *data);
473  void *imgDrawCbkData;
474};
475
476#endif
Note: See TracBrowser for help on using the repository browser.