/usr/include/poppler/SplashOutputDev.h is in libpoppler-dev 0.18.4-1ubuntu2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 | //========================================================================
//
// SplashOutputDev.h
//
// Copyright 2003 Glyph & Cog, LLC
//
//========================================================================
//========================================================================
//
// Modified under the Poppler project - http://poppler.freedesktop.org
//
// All changes made under the Poppler project to this file are licensed
// under GPL version 2 or later
//
// Copyright (C) 2005 Takashi Iwai <tiwai@suse.de>
// Copyright (C) 2009-2011 Thomas Freitag <Thomas.Freitag@alfa.de>
// Copyright (C) 2009 Carlos Garcia Campos <carlosgc@gnome.org>
// Copyright (C) 2010 Christian Feuersänger <cfeuersaenger@googlemail.com>
// Copyright (C) 2011 Andreas Hartmetz <ahartmetz@gmail.com>
// Copyright (C) 2011 Andrea Canciani <ranma42@gmail.com>
// Copyright (C) 2011 Adrian Johnson <ajohnson@redneon.com>
//
// To see a description of the changes please see the Changelog file that
// came with your tarball or type make ChangeLog if you are building from git
//
//========================================================================
#ifndef SPLASHOUTPUTDEV_H
#define SPLASHOUTPUTDEV_H
#ifdef USE_GCC_PRAGMAS
#pragma interface
#endif
#include "goo/gtypes.h"
#include "splash/SplashTypes.h"
#include "splash/SplashPattern.h"
#include "poppler-config.h"
#include "OutputDev.h"
#include "GfxState.h"
class Gfx8BitFont;
class SplashBitmap;
class Splash;
class SplashPath;
class SplashFontEngine;
class SplashFont;
class T3FontCache;
struct T3FontCacheTag;
struct T3GlyphStack;
struct SplashTransparencyGroup;
//------------------------------------------------------------------------
// SplashOverprintColor
//------------------------------------------------------------------------
class SplashOverprintColor: public SplashPattern {
public:
SplashOverprintColor(GfxColorSpace *colorSpace, SplashColorPtr colorA, Guchar tolerance);
virtual SplashPattern *copy() { return new SplashOverprintColor(colorSpace, color, tolerance); }
virtual ~SplashOverprintColor();
virtual GBool getColor(int x, int y, SplashColorPtr c);
virtual GBool testPosition(int x, int y) { return gFalse; }
virtual GBool isStatic() { return gTrue; }
virtual void overprint(GBool op, Guchar alphaSrc, SplashColorPtr colorSrc,
Guchar alphaDest, SplashColorPtr colorDest, SplashColorPtr colorResult);
private:
GfxColorSpace *colorSpace;
SplashColor color;
Guchar tolerance;
};
//------------------------------------------------------------------------
// Splash dynamic pattern
//------------------------------------------------------------------------
class SplashUnivariatePattern: public SplashPattern {
public:
SplashUnivariatePattern(SplashColorMode colorMode, GfxState *state, GfxUnivariateShading *shading);
virtual ~SplashUnivariatePattern();
virtual GBool getColor(int x, int y, SplashColorPtr c);
virtual GBool testPosition(int x, int y);
virtual GBool isStatic() { return gFalse; }
virtual GBool getParameter(double xs, double ys, double *t) = 0;
virtual GfxUnivariateShading *getShading() { return shading; }
protected:
Matrix ictm;
double t0, t1, dt;
GfxUnivariateShading *shading;
GfxState *state;
SplashColorMode colorMode;
};
class SplashAxialPattern: public SplashUnivariatePattern {
public:
SplashAxialPattern(SplashColorMode colorMode, GfxState *state, GfxAxialShading *shading);
virtual SplashPattern *copy() { return new SplashAxialPattern(colorMode, state, (GfxAxialShading *) shading); }
virtual ~SplashAxialPattern();
virtual GBool getParameter(double xs, double ys, double *t);
virtual void overprint(GBool op, Guchar alphaSrc, SplashColorPtr colorSrc,
Guchar alphaDest, SplashColorPtr colorDest, SplashColorPtr colorResult);
private:
double x0, y0, x1, y1;
double dx, dy, mul;
SplashOverprintColor *opPattern;
};
// see GfxState.h, GfxGouraudTriangleShading
class SplashGouraudPattern: public SplashGouraudColor {
public:
SplashGouraudPattern(GBool bDirectColorTranslation, GfxState *state, GfxGouraudTriangleShading *shading, SplashColorMode mode);
virtual SplashPattern *copy() { return new SplashGouraudPattern(bDirectColorTranslation, state, shading, mode); }
virtual ~SplashGouraudPattern();
virtual GBool getColor(int x, int y, SplashColorPtr c) { return gFalse; }
virtual GBool testPosition(int x, int y) { return gFalse; }
virtual GBool isStatic() { return gFalse; }
virtual GBool isParameterized() { return shading->isParameterized(); }
virtual int getNTriangles() { return shading->getNTriangles(); }
virtual void getTriangle(int i, double *x0, double *y0, double *color0,
double *x1, double *y1, double *color1,
double *x2, double *y2, double *color2)
{ return shading->getTriangle(i, x0, y0, color0, x1, y1, color1, x2, y2, color2); }
virtual void getParameterizedColor(double t, SplashColorMode mode, SplashColorPtr c);
virtual void overprint(GBool op, Guchar alphaSrc, SplashColorPtr colorSrc,
Guchar alphaDest, SplashColorPtr colorDest, SplashColorPtr colorResult);
private:
GfxGouraudTriangleShading *shading;
GfxState *state;
GBool bDirectColorTranslation;
SplashOverprintColor *opPattern;
SplashColorMode mode;
};
// see GfxState.h, GfxRadialShading
class SplashRadialPattern: public SplashUnivariatePattern {
public:
SplashRadialPattern(SplashColorMode colorMode, GfxState *state, GfxRadialShading *shading);
virtual SplashPattern *copy() { return new SplashRadialPattern(colorMode, state, (GfxRadialShading *) shading); }
virtual ~SplashRadialPattern();
virtual GBool getParameter(double xs, double ys, double *t);
virtual void overprint(GBool op, Guchar alphaSrc, SplashColorPtr colorSrc,
Guchar alphaDest, SplashColorPtr colorDest, SplashColorPtr colorResult);
private:
double x0, y0, r0, dx, dy, dr;
double a, inva;
SplashOverprintColor *opPattern;
};
//------------------------------------------------------------------------
// number of Type 3 fonts to cache
#define splashOutT3FontCacheSize 8
//------------------------------------------------------------------------
// SplashOutputDev
//------------------------------------------------------------------------
class SplashOutputDev: public OutputDev {
public:
// Constructor.
SplashOutputDev(SplashColorMode colorModeA, int bitmapRowPadA,
GBool reverseVideoA, SplashColorPtr paperColorA,
GBool bitmapTopDownA = gTrue,
GBool allowAntialiasA = gTrue);
// Destructor.
virtual ~SplashOutputDev();
//----- get info about output device
// Does this device use tilingPatternFill()? If this returns false,
// tiling pattern fills will be reduced to a series of other drawing
// operations.
virtual GBool useTilingPatternFill() { return gTrue; }
// Does this device use functionShadedFill(), axialShadedFill(), and
// radialShadedFill()? If this returns false, these shaded fills
// will be reduced to a series of other drawing operations.
virtual GBool useShadedFills(int type)
{ return (type >= 2 && type <= 5) ? gTrue : gFalse; }
// Does this device use upside-down coordinates?
// (Upside-down means (0,0) is the top left corner of the page.)
virtual GBool upsideDown() { return gTrue; }
// Does this device use drawChar() or drawString()?
virtual GBool useDrawChar() { return gTrue; }
// Does this device use beginType3Char/endType3Char? Otherwise,
// text in Type 3 fonts will be drawn with drawChar/drawString.
virtual GBool interpretType3Chars() { return gTrue; }
// This device now supports text in pattern colorspace!
virtual GBool supportTextCSPattern(GfxState *state)
{ return state->getFillColorSpace()->getMode() == csPattern; }
//----- initialization and control
// Start a page.
virtual void startPage(int pageNum, GfxState *state);
// End a page.
virtual void endPage();
//----- save/restore graphics state
virtual void saveState(GfxState *state);
virtual void restoreState(GfxState *state);
//----- update graphics state
virtual void updateAll(GfxState *state);
virtual void updateCTM(GfxState *state, double m11, double m12,
double m21, double m22, double m31, double m32);
virtual void updateLineDash(GfxState *state);
virtual void updateFlatness(GfxState *state);
virtual void updateLineJoin(GfxState *state);
virtual void updateLineCap(GfxState *state);
virtual void updateMiterLimit(GfxState *state);
virtual void updateLineWidth(GfxState *state);
virtual void updateStrokeAdjust(GfxState *state);
virtual void updateFillColor(GfxState *state);
virtual void updateStrokeColor(GfxState *state);
virtual void updateBlendMode(GfxState *state);
virtual void updateFillOpacity(GfxState *state);
virtual void updateStrokeOpacity(GfxState *state);
virtual void updateFillOverprint(GfxState *state);
virtual void updateStrokeOverprint(GfxState *state);
virtual void updateOverprintMode(GfxState *state);
//----- update text state
virtual void updateFont(GfxState *state);
//----- path painting
virtual void stroke(GfxState *state);
virtual void fill(GfxState *state);
virtual void eoFill(GfxState *state);
virtual GBool tilingPatternFill(GfxState *state, Catalog *catalog, Object *str,
double *pmat, int paintType, int tilingType, Dict *resDict,
double *mat, double *bbox,
int x0, int y0, int x1, int y1,
double xStep, double yStep);
virtual GBool axialShadedFill(GfxState *state, GfxAxialShading *shading, double tMin, double tMax);
virtual GBool radialShadedFill(GfxState *state, GfxRadialShading *shading, double tMin, double tMax);
virtual GBool gouraudTriangleShadedFill(GfxState *state, GfxGouraudTriangleShading *shading);
//----- path clipping
virtual void clip(GfxState *state);
virtual void eoClip(GfxState *state);
virtual void clipToStrokePath(GfxState *state);
//----- text drawing
virtual void drawChar(GfxState *state, double x, double y,
double dx, double dy,
double originX, double originY,
CharCode code, int nBytes, Unicode *u, int uLen);
virtual GBool beginType3Char(GfxState *state, double x, double y,
double dx, double dy,
CharCode code, Unicode *u, int uLen);
virtual void endType3Char(GfxState *state);
virtual void beginTextObject(GfxState *state);
virtual GBool deviceHasTextClip(GfxState *state) { return textClipPath && haveCSPattern; }
virtual void endTextObject(GfxState *state);
//----- image drawing
virtual void drawImageMask(GfxState *state, Object *ref, Stream *str,
int width, int height, GBool invert,
GBool interpolate, GBool inlineImg);
virtual void drawImage(GfxState *state, Object *ref, Stream *str,
int width, int height, GfxImageColorMap *colorMap,
GBool interpolate, int *maskColors, GBool inlineImg);
virtual void drawMaskedImage(GfxState *state, Object *ref, Stream *str,
int width, int height,
GfxImageColorMap *colorMap,
GBool interpolate,
Stream *maskStr, int maskWidth, int maskHeight,
GBool maskInvert, GBool maskInterpolate);
virtual void drawSoftMaskedImage(GfxState *state, Object *ref, Stream *str,
int width, int height,
GfxImageColorMap *colorMap,
GBool interpolate,
Stream *maskStr,
int maskWidth, int maskHeight,
GfxImageColorMap *maskColorMap,
GBool maskInterpolate);
// If current colorspace ist pattern,
// need this device special handling for masks in pattern colorspace?
// Default is false
virtual GBool fillMaskCSPattern(GfxState * state)
{ return state->getFillColorSpace()->getMode() == csPattern; }
virtual void endMaskClip(GfxState * /*state*/);
//----- Type 3 font operators
virtual void type3D0(GfxState *state, double wx, double wy);
virtual void type3D1(GfxState *state, double wx, double wy,
double llx, double lly, double urx, double ury);
//----- transparency groups and soft masks
virtual void beginTransparencyGroup(GfxState *state, double *bbox,
GfxColorSpace *blendingColorSpace,
GBool isolated, GBool knockout,
GBool forSoftMask);
virtual void endTransparencyGroup(GfxState *state);
virtual void paintTransparencyGroup(GfxState *state, double *bbox);
virtual void setSoftMask(GfxState *state, double *bbox, GBool alpha,
Function *transferFunc, GfxColor *backdropColor);
virtual void clearSoftMask(GfxState *state);
//----- special access
// Called to indicate that a new PDF document has been loaded.
void startDoc(XRef *xrefA);
void setPaperColor(SplashColorPtr paperColorA);
GBool isReverseVideo() { return reverseVideo; }
void setReverseVideo(GBool reverseVideoA) { reverseVideo = reverseVideoA; }
// Get the bitmap and its size.
SplashBitmap *getBitmap() { return bitmap; }
int getBitmapWidth();
int getBitmapHeight();
// Returns the last rasterized bitmap, transferring ownership to the
// caller.
SplashBitmap *takeBitmap();
// Get the Splash object.
Splash *getSplash() { return splash; }
// Get the modified region.
void getModRegion(int *xMin, int *yMin, int *xMax, int *yMax);
// Clear the modified region.
void clearModRegion();
SplashFont *getCurrentFont() { return font; }
#if 1 //~tmp: turn off anti-aliasing temporarily
virtual GBool getVectorAntialias();
virtual void setVectorAntialias(GBool vaa);
#endif
void setFreeTypeHinting(GBool enable, GBool enableSlightHinting);
private:
GBool univariateShadedFill(GfxState *state, SplashUnivariatePattern *pattern, double tMin, double tMax);
void setupScreenParams(double hDPI, double vDPI);
#if SPLASH_CMYK
SplashPattern *getColor(GfxColorSpace *colorSpace, GfxGray gray, GfxRGB *rgb, GfxCMYK *cmyk);
#else
SplashPattern *getColor(GfxGray gray, GfxRGB *rgb);
#endif
SplashPath *convertPath(GfxState *state, GfxPath *path);
void doUpdateFont(GfxState *state);
void drawType3Glyph(T3FontCache *t3Font,
T3FontCacheTag *tag, Guchar *data);
static GBool imageMaskSrc(void *data, SplashColorPtr line);
static GBool imageSrc(void *data, SplashColorPtr colorLine,
Guchar *alphaLine);
static GBool alphaImageSrc(void *data, SplashColorPtr line,
Guchar *alphaLine);
static GBool maskedImageSrc(void *data, SplashColorPtr line,
Guchar *alphaLine);
static GBool tilingBitmapSrc(void *data, SplashColorPtr line,
Guchar *alphaLine);
GBool haveCSPattern; // set if text has been drawn with a
// clipping render mode because of pattern colorspace
GBool keepAlphaChannel; // don't fill with paper color, keep alpha channel
SplashColorMode colorMode;
int bitmapRowPad;
GBool bitmapTopDown;
GBool allowAntialias;
GBool vectorAntialias;
GBool enableFreeTypeHinting;
GBool enableSlightHinting;
GBool reverseVideo; // reverse video mode
SplashColor paperColor; // paper color
SplashScreenParams screenParams;
XRef *xref; // xref table for current document
SplashBitmap *bitmap;
Splash *splash;
SplashFontEngine *fontEngine;
T3FontCache * // Type 3 font cache
t3FontCache[splashOutT3FontCacheSize];
int nT3Fonts; // number of valid entries in t3FontCache
T3GlyphStack *t3GlyphStack; // Type 3 glyph context stack
SplashFont *font; // current font
GBool needFontUpdate; // set when the font needs to be updated
SplashPath *textClipPath; // clipping path built with text object
SplashTransparencyGroup * // transparency group stack
transpGroupStack;
SplashBitmap *maskBitmap; // for image masks in pattern colorspace
};
#endif
|