468 lines
16 KiB
C++
468 lines
16 KiB
C++
//========================================================================
|
|
//
|
|
// 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-2016 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, 2017 Adrian Johnson <ajohnson@redneon.com>
|
|
// Copyright (C) 2012, 2015, 2018 Albert Astals Cid <aacid@kde.org>
|
|
// Copyright (C) 2015, 2016 William Bader <williambader@hotmail.com>
|
|
// Copyright (C) 2018 Stefan Brüns <stefan.bruens@rwth-aachen.de>
|
|
//
|
|
// 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
|
|
|
|
#include "splash/SplashTypes.h"
|
|
#include "splash/SplashPattern.h"
|
|
#include "poppler-config.h"
|
|
#include "OutputDev.h"
|
|
#include "GfxState.h"
|
|
#include "GlobalParams.h"
|
|
|
|
class PDFDoc;
|
|
class Gfx8BitFont;
|
|
class SplashBitmap;
|
|
class Splash;
|
|
class SplashPath;
|
|
class SplashFontEngine;
|
|
class SplashFont;
|
|
class T3FontCache;
|
|
struct T3FontCacheTag;
|
|
struct T3GlyphStack;
|
|
struct SplashTransparencyGroup;
|
|
|
|
//------------------------------------------------------------------------
|
|
// Splash dynamic pattern
|
|
//------------------------------------------------------------------------
|
|
|
|
class SplashFunctionPattern: public SplashPattern {
|
|
public:
|
|
|
|
SplashFunctionPattern(SplashColorMode colorMode, GfxState *state, GfxFunctionShading *shading);
|
|
|
|
SplashPattern *copy() override { return new SplashFunctionPattern(colorMode, state, (GfxFunctionShading *) shading); }
|
|
|
|
~SplashFunctionPattern();
|
|
|
|
bool testPosition(int x, int y) override { return true; }
|
|
|
|
bool isStatic() override { return false; }
|
|
|
|
bool getColor(int x, int y, SplashColorPtr c) override;
|
|
|
|
virtual GfxFunctionShading *getShading() { return shading; }
|
|
|
|
bool isCMYK() override { return gfxMode == csDeviceCMYK; }
|
|
|
|
protected:
|
|
Matrix ictm;
|
|
double xMin, yMin, xMax, yMax;
|
|
GfxFunctionShading *shading;
|
|
GfxState *state;
|
|
SplashColorMode colorMode;
|
|
GfxColorSpaceMode gfxMode;
|
|
};
|
|
|
|
class SplashUnivariatePattern: public SplashPattern {
|
|
public:
|
|
|
|
SplashUnivariatePattern(SplashColorMode colorMode, GfxState *state, GfxUnivariateShading *shading);
|
|
|
|
~SplashUnivariatePattern();
|
|
|
|
bool getColor(int x, int y, SplashColorPtr c) override;
|
|
|
|
bool testPosition(int x, int y) override;
|
|
|
|
bool isStatic() override { return false; }
|
|
|
|
virtual bool getParameter(double xs, double ys, double *t) = 0;
|
|
|
|
virtual GfxUnivariateShading *getShading() { return shading; }
|
|
|
|
bool isCMYK() override { return gfxMode == csDeviceCMYK; }
|
|
|
|
protected:
|
|
Matrix ictm;
|
|
double t0, t1, dt;
|
|
GfxUnivariateShading *shading;
|
|
GfxState *state;
|
|
SplashColorMode colorMode;
|
|
GfxColorSpaceMode gfxMode;
|
|
};
|
|
|
|
class SplashAxialPattern: public SplashUnivariatePattern {
|
|
public:
|
|
|
|
SplashAxialPattern(SplashColorMode colorMode, GfxState *state, GfxAxialShading *shading);
|
|
|
|
SplashPattern *copy() override { return new SplashAxialPattern(colorMode, state, (GfxAxialShading *) shading); }
|
|
|
|
~SplashAxialPattern();
|
|
|
|
bool getParameter(double xs, double ys, double *t) override;
|
|
|
|
private:
|
|
double x0, y0, x1, y1;
|
|
double dx, dy, mul;
|
|
};
|
|
|
|
// see GfxState.h, GfxGouraudTriangleShading
|
|
class SplashGouraudPattern: public SplashGouraudColor {
|
|
public:
|
|
|
|
SplashGouraudPattern(bool bDirectColorTranslation, GfxState *state, GfxGouraudTriangleShading *shading);
|
|
|
|
SplashPattern *copy() override { return new SplashGouraudPattern(bDirectColorTranslation, state, shading); }
|
|
|
|
~SplashGouraudPattern();
|
|
|
|
bool getColor(int x, int y, SplashColorPtr c) override { return false; }
|
|
|
|
bool testPosition(int x, int y) override { return false; }
|
|
|
|
bool isStatic() override { return false; }
|
|
|
|
bool isCMYK() override { return gfxMode == csDeviceCMYK; }
|
|
|
|
bool isParameterized() override { return shading->isParameterized(); }
|
|
int getNTriangles() override { return shading->getNTriangles(); }
|
|
void getTriangle(int i, double *x0, double *y0, double *color0,
|
|
double *x1, double *y1, double *color1,
|
|
double *x2, double *y2, double *color2) override
|
|
{ shading->getTriangle(i, x0, y0, color0, x1, y1, color1, x2, y2, color2); }
|
|
|
|
void getParameterizedColor(double t, SplashColorMode mode, SplashColorPtr c) override;
|
|
|
|
private:
|
|
GfxGouraudTriangleShading *shading;
|
|
GfxState *state;
|
|
bool bDirectColorTranslation;
|
|
GfxColorSpaceMode gfxMode;
|
|
};
|
|
|
|
// see GfxState.h, GfxRadialShading
|
|
class SplashRadialPattern: public SplashUnivariatePattern {
|
|
public:
|
|
|
|
SplashRadialPattern(SplashColorMode colorMode, GfxState *state, GfxRadialShading *shading);
|
|
|
|
SplashPattern *copy() override { return new SplashRadialPattern(colorMode, state, (GfxRadialShading *) shading); }
|
|
|
|
~SplashRadialPattern();
|
|
|
|
bool getParameter(double xs, double ys, double *t) override;
|
|
|
|
private:
|
|
double x0, y0, r0, dx, dy, dr;
|
|
double a, inva;
|
|
};
|
|
|
|
//------------------------------------------------------------------------
|
|
|
|
// number of Type 3 fonts to cache
|
|
#define splashOutT3FontCacheSize 8
|
|
|
|
//------------------------------------------------------------------------
|
|
// SplashOutputDev
|
|
//------------------------------------------------------------------------
|
|
|
|
class SplashOutputDev: public OutputDev {
|
|
public:
|
|
|
|
// Constructor.
|
|
SplashOutputDev(SplashColorMode colorModeA, int bitmapRowPadA,
|
|
bool reverseVideoA, SplashColorPtr paperColorA,
|
|
bool bitmapTopDownA = true,
|
|
SplashThinLineMode thinLineMode = splashThinLineDefault,
|
|
bool overprintPreviewA = globalParams->getOverprintPreview());
|
|
|
|
// Destructor.
|
|
~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.
|
|
bool useTilingPatternFill() override { return true; }
|
|
|
|
// 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.
|
|
bool useShadedFills(int type) override
|
|
{ return (type >= 1 && type <= 5) ? true : false; }
|
|
|
|
// Does this device use upside-down coordinates?
|
|
// (Upside-down means (0,0) is the top left corner of the page.)
|
|
bool upsideDown() override { return bitmapTopDown ^ bitmapUpsideDown; }
|
|
|
|
// Does this device use drawChar() or drawString()?
|
|
bool useDrawChar() override { return true; }
|
|
|
|
// Does this device use beginType3Char/endType3Char? Otherwise,
|
|
// text in Type 3 fonts will be drawn with drawChar/drawString.
|
|
bool interpretType3Chars() override { return true; }
|
|
|
|
//----- initialization and control
|
|
|
|
// Start a page.
|
|
void startPage(int pageNum, GfxState *state, XRef *xref) override;
|
|
|
|
// End a page.
|
|
void endPage() override;
|
|
|
|
//----- save/restore graphics state
|
|
void saveState(GfxState *state) override;
|
|
void restoreState(GfxState *state) override;
|
|
|
|
//----- update graphics state
|
|
void updateAll(GfxState *state) override;
|
|
void updateCTM(GfxState *state, double m11, double m12,
|
|
double m21, double m22, double m31, double m32) override;
|
|
void updateLineDash(GfxState *state) override;
|
|
void updateFlatness(GfxState *state) override;
|
|
void updateLineJoin(GfxState *state) override;
|
|
void updateLineCap(GfxState *state) override;
|
|
void updateMiterLimit(GfxState *state) override;
|
|
void updateLineWidth(GfxState *state) override;
|
|
void updateStrokeAdjust(GfxState *state) override;
|
|
void updateFillColorSpace(GfxState *state) override;
|
|
void updateStrokeColorSpace(GfxState *state) override;
|
|
void updateFillColor(GfxState *state) override;
|
|
void updateStrokeColor(GfxState *state) override;
|
|
void updateBlendMode(GfxState *state) override;
|
|
void updateFillOpacity(GfxState *state) override;
|
|
void updateStrokeOpacity(GfxState *state) override;
|
|
void updatePatternOpacity(GfxState *state) override;
|
|
void clearPatternOpacity(GfxState *state) override;
|
|
void updateFillOverprint(GfxState *state) override;
|
|
void updateStrokeOverprint(GfxState *state) override;
|
|
void updateOverprintMode(GfxState *state) override;
|
|
void updateTransfer(GfxState *state) override;
|
|
|
|
//----- update text state
|
|
void updateFont(GfxState *state) override;
|
|
|
|
//----- path painting
|
|
void stroke(GfxState *state) override;
|
|
void fill(GfxState *state) override;
|
|
void eoFill(GfxState *state) override;
|
|
bool tilingPatternFill(GfxState *state, Gfx *gfx, Catalog *catalog, Object *str,
|
|
const double *pmat, int paintType, int tilingType, Dict *resDict,
|
|
const double *mat, const double *bbox,
|
|
int x0, int y0, int x1, int y1,
|
|
double xStep, double yStep) override;
|
|
bool functionShadedFill(GfxState *state, GfxFunctionShading *shading) override;
|
|
bool axialShadedFill(GfxState *state, GfxAxialShading *shading, double tMin, double tMax) override;
|
|
bool radialShadedFill(GfxState *state, GfxRadialShading *shading, double tMin, double tMax) override;
|
|
bool gouraudTriangleShadedFill(GfxState *state, GfxGouraudTriangleShading *shading) override;
|
|
|
|
//----- path clipping
|
|
void clip(GfxState *state) override;
|
|
void eoClip(GfxState *state) override;
|
|
void clipToStrokePath(GfxState *state) override;
|
|
|
|
//----- text drawing
|
|
void drawChar(GfxState *state, double x, double y,
|
|
double dx, double dy,
|
|
double originX, double originY,
|
|
CharCode code, int nBytes, Unicode *u, int uLen) override;
|
|
bool beginType3Char(GfxState *state, double x, double y,
|
|
double dx, double dy,
|
|
CharCode code, Unicode *u, int uLen) override;
|
|
void endType3Char(GfxState *state) override;
|
|
void beginTextObject(GfxState *state) override;
|
|
void endTextObject(GfxState *state) override;
|
|
|
|
//----- image drawing
|
|
void drawImageMask(GfxState *state, Object *ref, Stream *str,
|
|
int width, int height, bool invert,
|
|
bool interpolate, bool inlineImg) override;
|
|
void setSoftMaskFromImageMask(GfxState *state,
|
|
Object *ref, Stream *str,
|
|
int width, int height, bool invert,
|
|
bool inlineImg, double *baseMatrix) override;
|
|
void unsetSoftMaskFromImageMask(GfxState *state, double *baseMatrix) override;
|
|
void drawImage(GfxState *state, Object *ref, Stream *str,
|
|
int width, int height, GfxImageColorMap *colorMap,
|
|
bool interpolate, int *maskColors, bool inlineImg) override;
|
|
void drawMaskedImage(GfxState *state, Object *ref, Stream *str,
|
|
int width, int height,
|
|
GfxImageColorMap *colorMap,
|
|
bool interpolate,
|
|
Stream *maskStr, int maskWidth, int maskHeight,
|
|
bool maskInvert, bool maskInterpolate) override;
|
|
void drawSoftMaskedImage(GfxState *state, Object *ref, Stream *str,
|
|
int width, int height,
|
|
GfxImageColorMap *colorMap,
|
|
bool interpolate,
|
|
Stream *maskStr,
|
|
int maskWidth, int maskHeight,
|
|
GfxImageColorMap *maskColorMap,
|
|
bool maskInterpolate) override;
|
|
|
|
//----- Type 3 font operators
|
|
void type3D0(GfxState *state, double wx, double wy) override;
|
|
void type3D1(GfxState *state, double wx, double wy,
|
|
double llx, double lly, double urx, double ury) override;
|
|
|
|
//----- transparency groups and soft masks
|
|
bool checkTransparencyGroup(GfxState *state, bool knockout) override;
|
|
void beginTransparencyGroup(GfxState *state, const double *bbox,
|
|
GfxColorSpace *blendingColorSpace,
|
|
bool isolated, bool knockout,
|
|
bool forSoftMask) override;
|
|
void endTransparencyGroup(GfxState *state) override;
|
|
void paintTransparencyGroup(GfxState *state, const double *bbox) override;
|
|
void setSoftMask(GfxState *state, const double *bbox, bool alpha,
|
|
Function *transferFunc, GfxColor *backdropColor) override;
|
|
void clearSoftMask(GfxState *state) override;
|
|
|
|
//----- special access
|
|
|
|
// Called to indicate that a new PDF document has been loaded.
|
|
void startDoc(PDFDoc *docA);
|
|
|
|
void setPaperColor(SplashColorPtr paperColorA);
|
|
|
|
bool isReverseVideo() { return reverseVideo; }
|
|
void setReverseVideo(bool 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();
|
|
|
|
// Set this flag to true to generate an upside-down bitmap (useful
|
|
// for Windows BMP files).
|
|
void setBitmapUpsideDown(bool f) { bitmapUpsideDown = f; }
|
|
|
|
// 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 <skipTextA> is true, don't draw horizontal text.
|
|
// If <skipRotatedTextA> is true, don't draw rotated (non-horizontal) text.
|
|
void setSkipText(bool skipHorizTextA, bool skipRotatedTextA)
|
|
{ skipHorizText = skipHorizTextA; skipRotatedText = skipRotatedTextA; }
|
|
|
|
int getNestCount() { return nestCount; }
|
|
|
|
#if 1 //~tmp: turn off anti-aliasing temporarily
|
|
bool getVectorAntialias() override;
|
|
void setVectorAntialias(bool vaa) override;
|
|
#endif
|
|
|
|
bool getFontAntialias() { return fontAntialias; }
|
|
void setFontAntialias(bool anti) { fontAntialias = anti; }
|
|
|
|
void setFreeTypeHinting(bool enable, bool enableSlightHinting);
|
|
|
|
protected:
|
|
void doUpdateFont(GfxState *state);
|
|
|
|
private:
|
|
bool univariateShadedFill(GfxState *state, SplashUnivariatePattern *pattern, double tMin, double tMax);
|
|
|
|
void setupScreenParams(double hDPI, double vDPI);
|
|
SplashPattern *getColor(GfxGray gray);
|
|
SplashPattern *getColor(GfxRGB *rgb);
|
|
#ifdef SPLASH_CMYK
|
|
SplashPattern *getColor(GfxCMYK *cmyk);
|
|
SplashPattern *getColor(GfxColor *deviceN);
|
|
#endif
|
|
static void getMatteColor( SplashColorMode colorMode, GfxImageColorMap *colorMap, const GfxColor * matteColor, SplashColor splashMatteColor);
|
|
void setOverprintMask(GfxColorSpace *colorSpace, bool overprintFlag,
|
|
int overprintMode, const GfxColor *singleColor, bool grayIndexed = false);
|
|
SplashPath convertPath(GfxState *state, GfxPath *path,
|
|
bool dropEmptySubpaths);
|
|
void drawType3Glyph(GfxState *state, T3FontCache *t3Font,
|
|
T3FontCacheTag *tag, unsigned char *data);
|
|
#ifdef USE_CMS
|
|
bool useIccImageSrc(void *data);
|
|
static void iccTransform(void *data, SplashBitmap *bitmap);
|
|
static bool iccImageSrc(void *data, SplashColorPtr colorLine,
|
|
unsigned char *alphaLine);
|
|
#endif
|
|
static bool imageMaskSrc(void *data, SplashColorPtr line);
|
|
static bool imageSrc(void *data, SplashColorPtr colorLine,
|
|
unsigned char *alphaLine);
|
|
static bool alphaImageSrc(void *data, SplashColorPtr line,
|
|
unsigned char *alphaLine);
|
|
static bool maskedImageSrc(void *data, SplashColorPtr line,
|
|
unsigned char *alphaLine);
|
|
static bool tilingBitmapSrc(void *data, SplashColorPtr line,
|
|
unsigned char *alphaLine);
|
|
|
|
bool keepAlphaChannel; // don't fill with paper color, keep alpha channel
|
|
|
|
SplashColorMode colorMode;
|
|
int bitmapRowPad;
|
|
bool bitmapTopDown;
|
|
bool bitmapUpsideDown;
|
|
bool fontAntialias;
|
|
bool vectorAntialias;
|
|
bool overprintPreview;
|
|
bool enableFreeTypeHinting;
|
|
bool enableSlightHinting;
|
|
bool reverseVideo; // reverse video mode
|
|
SplashColor paperColor; // paper color
|
|
SplashScreenParams screenParams;
|
|
bool skipHorizText;
|
|
bool skipRotatedText;
|
|
|
|
PDFDoc *doc; // the current document
|
|
XRef *xref; // the xref of the 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
|
|
bool needFontUpdate; // set when the font needs to be updated
|
|
SplashPath *textClipPath; // clipping path built with text object
|
|
|
|
SplashTransparencyGroup * // transparency group stack
|
|
transpGroupStack;
|
|
int nestCount;
|
|
};
|
|
|
|
#endif
|