root/middleware-offline/trunk/_src/eidmw/pteid-poppler/poppler/CairoOutputDev.h @ 226

Revision 226, 17.8 KB (checked in by vsilva, 8 years ago)

Improve PDF native Signature

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