node-poppler 5.1.2 → 5.1.5

package/src/lib/win32/poppler-22.01.0/Library/include/poppler/splash/Splash.h

@@ -1,336 +0,0 @@
-//========================================================================
-//
-// Splash.h
-//
-//========================================================================
-
-//========================================================================
-//
-// 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 Marco Pesenti Gritti <mpg@redhat.com>
-// Copyright (C) 2007, 2011, 2018, 2019, 2021 Albert Astals Cid <aacid@kde.org>
-// Copyright (C) 2010-2013, 2015 Thomas Freitag <Thomas.Freitag@alfa.de>
-// Copyright (C) 2010 Christian Feuersänger <cfeuersaenger@googlemail.com>
-// Copyright (C) 2012, 2017 Adrian Johnson <ajohnson@redneon.com>
-// Copyright (C) 2020 Oliver Sander <oliver.sander@tu-dresden.de>
-// Copyright (C) 2020 Tobias Deiminger <haxtibal@posteo.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 SPLASH_H
-#define SPLASH_H
-
-#include <cstddef>
-#include "SplashTypes.h"
-#include "SplashClip.h"
-#include "SplashPattern.h"
-#include "poppler_private_export.h"
-
-class SplashBitmap;
-struct SplashGlyphBitmap;
-class SplashState;
-class SplashScreen;
-class SplashPath;
-class SplashXPath;
-class SplashFont;
-struct SplashPipe;
-
-//------------------------------------------------------------------------
-
-// Retrieves the next line of pixels in an image mask.  Normally,
-// fills in *<line> and returns true.  If the image stream is
-// exhausted, returns false.
-typedef bool (*SplashImageMaskSource)(void *data, SplashColorPtr pixel);
-
-// Retrieves the next line of pixels in an image.  Normally, fills in
-// *<line> and returns true.  If the image stream is exhausted,
-// returns false.
-typedef bool (*SplashImageSource)(void *data, SplashColorPtr colorLine, unsigned char *alphaLine);
-
-// Use ICCColorSpace to transform a bitmap
-typedef void (*SplashICCTransform)(void *data, SplashBitmap *bitmap);
-
-//------------------------------------------------------------------------
-
-enum SplashPipeResultColorCtrl
-{
-    splashPipeResultColorNoAlphaBlendCMYK,
-    splashPipeResultColorNoAlphaBlendDeviceN,
-    splashPipeResultColorNoAlphaBlendRGB,
-    splashPipeResultColorNoAlphaBlendMono,
-    splashPipeResultColorAlphaNoBlendMono,
-    splashPipeResultColorAlphaNoBlendRGB,
-    splashPipeResultColorAlphaNoBlendCMYK,
-    splashPipeResultColorAlphaNoBlendDeviceN,
-    splashPipeResultColorAlphaBlendMono,
-    splashPipeResultColorAlphaBlendRGB,
-    splashPipeResultColorAlphaBlendCMYK,
-    splashPipeResultColorAlphaBlendDeviceN
-};
-
-//------------------------------------------------------------------------
-// Splash
-//------------------------------------------------------------------------
-
-class POPPLER_PRIVATE_EXPORT Splash
-{
-public:
-    // Create a new rasterizer object.
-    Splash(SplashBitmap *bitmapA, bool vectorAntialiasA, SplashScreenParams *screenParams = nullptr);
-    Splash(SplashBitmap *bitmapA, bool vectorAntialiasA, SplashScreen *screenA);
-
-    ~Splash();
-
-    Splash(const Splash &) = delete;
-    Splash &operator=(const Splash &) = delete;
-
-    //----- state read
-
-    SplashCoord *getMatrix();
-    SplashPattern *getStrokePattern();
-    SplashPattern *getFillPattern();
-    SplashScreen *getScreen();
-    SplashBlendFunc getBlendFunc();
-    SplashCoord getStrokeAlpha();
-    SplashCoord getFillAlpha();
-    SplashCoord getLineWidth();
-    int getLineCap();
-    int getLineJoin();
-    SplashCoord getMiterLimit();
-    SplashCoord getFlatness();
-    SplashCoord *getLineDash();
-    int getLineDashLength();
-    SplashCoord getLineDashPhase();
-    bool getStrokeAdjust();
-    SplashClip *getClip();
-    SplashBitmap *getSoftMask();
-    bool getInNonIsolatedGroup();
-
-    //----- state write
-
-    void setMatrix(SplashCoord *matrix);
-    void setStrokePattern(SplashPattern *strokePattern);
-    void setFillPattern(SplashPattern *fillPattern);
-    void setScreen(SplashScreen *screen);
-    void setBlendFunc(SplashBlendFunc func);
-    void setStrokeAlpha(SplashCoord alpha);
-    void setFillAlpha(SplashCoord alpha);
-    void setPatternAlpha(SplashCoord strokeAlpha, SplashCoord fillAlpha);
-    void clearPatternAlpha();
-    void setFillOverprint(bool fop);
-    void setStrokeOverprint(bool sop);
-    void setOverprintMode(int opm);
-    void setLineWidth(SplashCoord lineWidth);
-    void setLineCap(int lineCap);
-    void setLineJoin(int lineJoin);
-    void setMiterLimit(SplashCoord miterLimit);
-    void setFlatness(SplashCoord flatness);
-    // the <lineDash> array will be copied
-    void setLineDash(SplashCoord *lineDash, int lineDashLength, SplashCoord lineDashPhase);
-    void setStrokeAdjust(bool strokeAdjust);
-    // NB: uses transformed coordinates.
-    void clipResetToRect(SplashCoord x0, SplashCoord y0, SplashCoord x1, SplashCoord y1);
-    // NB: uses transformed coordinates.
-    SplashError clipToRect(SplashCoord x0, SplashCoord y0, SplashCoord x1, SplashCoord y1);
-    // NB: uses untransformed coordinates.
-    SplashError clipToPath(SplashPath *path, bool eo);
-    void setSoftMask(SplashBitmap *softMask);
-    void setInNonIsolatedGroup(SplashBitmap *alpha0BitmapA, int alpha0XA, int alpha0YA);
-    void setTransfer(unsigned char *red, unsigned char *green, unsigned char *blue, unsigned char *gray);
-    void setOverprintMask(unsigned int overprintMask, bool additive);
-
-    //----- state save/restore
-
-    void saveState();
-    SplashError restoreState();
-
-    //----- drawing operations
-
-    // Fill the bitmap with <color>.  This is not subject to clipping.
-    void clear(SplashColorPtr color, unsigned char alpha = 0x00);
-
-    // Stroke a path using the current stroke pattern.
-    SplashError stroke(SplashPath *path);
-
-    // Fill a path using the current fill pattern.
-    SplashError fill(SplashPath *path, bool eo);
-
-    // Fill a path, XORing with the current fill pattern.
-    SplashError xorFill(SplashPath *path, bool eo);
-
-    // Draw a character, using the current fill pattern.
-    SplashError fillChar(SplashCoord x, SplashCoord y, int c, SplashFont *font);
-
-    // Draw a glyph, using the current fill pattern.  This function does
-    // not free any data, i.e., it ignores glyph->freeData.
-    void fillGlyph(SplashCoord x, SplashCoord y, SplashGlyphBitmap *glyph);
-
-    // Draws an image mask using the fill color.  This will read <h>
-    // lines of <w> pixels from <src>, starting with the top line.  "1"
-    // pixels will be drawn with the current fill color; "0" pixels are
-    // transparent.  The matrix:
-    //    [ mat[0] mat[1] 0 ]
-    //    [ mat[2] mat[3] 0 ]
-    //    [ mat[4] mat[5] 1 ]
-    // maps a unit square to the desired destination for the image, in
-    // PostScript style:
-    //    [x' y' 1] = [x y 1] * mat
-    // Note that the Splash y axis points downward, and the image source
-    // is assumed to produce pixels in raster order, starting from the
-    // top line.
-    SplashError fillImageMask(SplashImageMaskSource src, void *srcData, int w, int h, SplashCoord *mat, bool glyphMode);
-
-    // Draw an image.  This will read <h> lines of <w> pixels from
-    // <src>, starting with the top line.  These pixels are assumed to
-    // be in the source mode, <srcMode>.  If <srcAlpha> is true, the
-    // alpha values returned by <src> are used; otherwise they are
-    // ignored.  The following combinations of source and target modes
-    // are supported:
-    //    source       target
-    //    ------       ------
-    //    Mono1        Mono1
-    //    Mono8        Mono1   -- with dithering
-    //    Mono8        Mono8
-    //    RGB8         RGB8
-    //    BGR8         BGR8
-    //    CMYK8        CMYK8
-    // The matrix behaves as for fillImageMask.
-    SplashError drawImage(SplashImageSource src, SplashICCTransform tf, void *srcData, SplashColorMode srcMode, bool srcAlpha, int w, int h, SplashCoord *mat, bool interpolate, bool tilingPattern = false);
-
-    // Composite a rectangular region from <src> onto this Splash
-    // object.
-    SplashError composite(SplashBitmap *src, int xSrc, int ySrc, int xDest, int yDest, int w, int h, bool noClip, bool nonIsolated, bool knockout = false, SplashCoord knockoutOpacity = 1.0);
-
-    // Composite this Splash object onto a background color.  The
-    // background alpha is assumed to be 1.
-    void compositeBackground(SplashColorConstPtr color);
-
-    // Copy a rectangular region from <src> onto the bitmap belonging to
-    // this Splash object.  The destination alpha values are all set to
-    // zero.
-    SplashError blitTransparent(SplashBitmap *src, int xSrc, int ySrc, int xDest, int yDest, int w, int h);
-    void blitImage(SplashBitmap *src, bool srcAlpha, int xDest, int yDest);
-
-    //----- misc
-
-    // Construct a path for a stroke, given the path to be stroked and
-    // the line width <w>.  All other stroke parameters are taken from
-    // the current state.  If <flatten> is true, this function will
-    // first flatten the path and handle the linedash.
-    SplashPath *makeStrokePath(SplashPath *path, SplashCoord w, bool flatten = true);
-
-    // Return the associated bitmap.
-    SplashBitmap *getBitmap() { return bitmap; }
-
-    // Set the minimum line width.
-    void setMinLineWidth(SplashCoord w) { minLineWidth = w; }
-
-    // Setter/Getter for thin line mode
-    void setThinLineMode(SplashThinLineMode thinLineModeA) { thinLineMode = thinLineModeA; }
-    SplashThinLineMode getThinLineMode() { return thinLineMode; }
-
-    // Get clipping status for the last drawing operation subject to
-    // clipping.
-    SplashClipResult getClipRes() { return opClipRes; }
-
-    // Toggle debug mode on or off.
-    void setDebugMode(bool debugModeA) { debugMode = debugModeA; }
-
-#if 1 //~tmp: turn off anti-aliasing temporarily
-    void setInShading(bool sh) { inShading = sh; }
-    bool getVectorAntialias() { return vectorAntialias; }
-    void setVectorAntialias(bool vaa) { vectorAntialias = vaa; }
-#endif
-
-    // Do shaded fills with dynamic patterns
-    //
-    // clipToStrokePath: Whether the current clip region is a stroke path.
-    //   In that case, strokeAlpha is used rather than fillAlpha.
-    SplashError shadedFill(SplashPath *path, bool hasBBox, SplashPattern *pattern, bool clipToStrokePath);
-    // Draw a gouraud triangle shading.
-    bool gouraudTriangleShadedFill(SplashGouraudColor *shading);
-
-private:
-    void pipeInit(SplashPipe *pipe, int x, int y, SplashPattern *pattern, SplashColorPtr cSrc, unsigned char aInput, bool usesShape, bool nonIsolatedGroup, bool knockout = false, unsigned char knockoutOpacity = 255);
-    void pipeRun(SplashPipe *pipe);
-    void pipeRunSimpleMono1(SplashPipe *pipe);
-    void pipeRunSimpleMono8(SplashPipe *pipe);
-    void pipeRunSimpleRGB8(SplashPipe *pipe);
-    void pipeRunSimpleXBGR8(SplashPipe *pipe);
-    void pipeRunSimpleBGR8(SplashPipe *pipe);
-    void pipeRunSimpleCMYK8(SplashPipe *pipe);
-    void pipeRunSimpleDeviceN8(SplashPipe *pipe);
-    void pipeRunAAMono1(SplashPipe *pipe);
-    void pipeRunAAMono8(SplashPipe *pipe);
-    void pipeRunAARGB8(SplashPipe *pipe);
-    void pipeRunAAXBGR8(SplashPipe *pipe);
-    void pipeRunAABGR8(SplashPipe *pipe);
-    void pipeRunAACMYK8(SplashPipe *pipe);
-    void pipeRunAADeviceN8(SplashPipe *pipe);
-    void pipeSetXY(SplashPipe *pipe, int x, int y);
-    void pipeIncX(SplashPipe *pipe);
-    void drawPixel(SplashPipe *pipe, int x, int y, bool noClip);
-    void drawAAPixelInit();
-    void drawAAPixel(SplashPipe *pipe, int x, int y);
-    void drawSpan(SplashPipe *pipe, int x0, int x1, int y, bool noClip);
-    void drawAALine(SplashPipe *pipe, int x0, int x1, int y, bool adjustLine = false, unsigned char lineOpacity = 0);
-    void transform(const SplashCoord *matrix, SplashCoord xi, SplashCoord yi, SplashCoord *xo, SplashCoord *yo);
-    void strokeNarrow(SplashPath *path);
-    void strokeWide(SplashPath *path, SplashCoord w);
-    SplashPath *flattenPath(SplashPath *path, SplashCoord *matrix, SplashCoord flatness);
-    void flattenCurve(SplashCoord x0, SplashCoord y0, SplashCoord x1, SplashCoord y1, SplashCoord x2, SplashCoord y2, SplashCoord x3, SplashCoord y3, SplashCoord *matrix, SplashCoord flatness2, SplashPath *fPath);
-    SplashPath *makeDashedPath(SplashPath *xPath);
-    void getBBoxFP(SplashPath *path, SplashCoord *xMinA, SplashCoord *yMinA, SplashCoord *xMaxA, SplashCoord *yMaxA);
-    SplashError fillWithPattern(SplashPath *path, bool eo, SplashPattern *pattern, SplashCoord alpha);
-    bool pathAllOutside(SplashPath *path);
-    void fillGlyph2(int x0, int y0, SplashGlyphBitmap *glyph, bool noclip);
-    void arbitraryTransformMask(SplashImageMaskSource src, void *srcData, int srcWidth, int srcHeight, SplashCoord *mat, bool glyphMode);
-    SplashBitmap *scaleMask(SplashImageMaskSource src, void *srcData, int srcWidth, int srcHeight, int scaledWidth, int scaledHeight);
-    void scaleMaskYdownXdown(SplashImageMaskSource src, void *srcData, int srcWidth, int srcHeight, int scaledWidth, int scaledHeight, SplashBitmap *dest);
-    void scaleMaskYdownXup(SplashImageMaskSource src, void *srcData, int srcWidth, int srcHeight, int scaledWidth, int scaledHeight, SplashBitmap *dest);
-    void scaleMaskYupXdown(SplashImageMaskSource src, void *srcData, int srcWidth, int srcHeight, int scaledWidth, int scaledHeight, SplashBitmap *dest);
-    void scaleMaskYupXup(SplashImageMaskSource src, void *srcData, int srcWidth, int srcHeight, int scaledWidth, int scaledHeight, SplashBitmap *dest);
-    void blitMask(SplashBitmap *src, int xDest, int yDest, SplashClipResult clipRes);
-    SplashError arbitraryTransformImage(SplashImageSource src, SplashICCTransform tf, void *srcData, SplashColorMode srcMode, int nComps, bool srcAlpha, int srcWidth, int srcHeight, SplashCoord *mat, bool interpolate,
-                                        bool tilingPattern = false);
-    SplashBitmap *scaleImage(SplashImageSource src, void *srcData, SplashColorMode srcMode, int nComps, bool srcAlpha, int srcWidth, int srcHeight, int scaledWidth, int scaledHeight, bool interpolate, bool tilingPattern = false);
-    bool scaleImageYdownXdown(SplashImageSource src, void *srcData, SplashColorMode srcMode, int nComps, bool srcAlpha, int srcWidth, int srcHeight, int scaledWidth, int scaledHeight, SplashBitmap *dest);
-    bool scaleImageYdownXup(SplashImageSource src, void *srcData, SplashColorMode srcMode, int nComps, bool srcAlpha, int srcWidth, int srcHeight, int scaledWidth, int scaledHeight, SplashBitmap *dest);
-    bool scaleImageYupXdown(SplashImageSource src, void *srcData, SplashColorMode srcMode, int nComps, bool srcAlpha, int srcWidth, int srcHeight, int scaledWidth, int scaledHeight, SplashBitmap *dest);
-    bool scaleImageYupXup(SplashImageSource src, void *srcData, SplashColorMode srcMode, int nComps, bool srcAlpha, int srcWidth, int srcHeight, int scaledWidth, int scaledHeight, SplashBitmap *dest);
-    bool scaleImageYupXupBilinear(SplashImageSource src, void *srcData, SplashColorMode srcMode, int nComps, bool srcAlpha, int srcWidth, int srcHeight, int scaledWidth, int scaledHeight, SplashBitmap *dest);
-    void vertFlipImage(SplashBitmap *img, int width, int height, int nComps);
-    void blitImage(SplashBitmap *src, bool srcAlpha, int xDest, int yDest, SplashClipResult clipRes);
-    void blitImageClipped(SplashBitmap *src, bool srcAlpha, int xSrc, int ySrc, int xDest, int yDest, int w, int h);
-    void dumpPath(SplashPath *path);
-    void dumpXPath(SplashXPath *path);
-
-    static SplashPipeResultColorCtrl pipeResultColorNoAlphaBlend[];
-    static SplashPipeResultColorCtrl pipeResultColorAlphaNoBlend[];
-    static SplashPipeResultColorCtrl pipeResultColorAlphaBlend[];
-    static int pipeNonIsoGroupCorrection[];
-
-    SplashBitmap *bitmap;
-    SplashState *state;
-    SplashBitmap *aaBuf;
-    int aaBufY;
-    SplashBitmap *alpha0Bitmap; // for non-isolated groups, this is the
-                                //   bitmap containing the alpha0 values
-    int alpha0X, alpha0Y; // offset within alpha0Bitmap
-    SplashCoord aaGamma[splashAASize * splashAASize + 1];
-    SplashCoord minLineWidth;
-    SplashThinLineMode thinLineMode;
-    SplashClipResult opClipRes;
-    bool vectorAntialias;
-    bool inShading;
-    bool debugMode;
-};
-
-#endif

package/src/lib/win32/poppler-22.01.0/Library/include/poppler/splash/SplashBitmap.h

@@ -1,127 +0,0 @@
-//========================================================================
-//
-// SplashBitmap.h
-//
-//========================================================================
-
-//========================================================================
-//
-// 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) 2007 Ilmari Heikkinen <ilmari.heikkinen@gmail.com>
-// Copyright (C) 2009 Shen Liang <shenzhuxi@gmail.com>
-// Copyright (C) 2009, 2012, 2018, 2021 Albert Astals Cid <aacid@kde.org>
-// Copyright (C) 2009 Stefan Thomas <thomas@eload24.com>
-// Copyright (C) 2010, 2017 Adrian Johnson <ajohnson@redneon.com>
-// Copyright (C) 2010 Harry Roberts <harry.roberts@midnight-labs.org>
-// Copyright (C) 2010 Christian Feuersänger <cfeuersaenger@googlemail.com>
-// Copyright (C) 2010 William Bader <williambader@hotmail.com>
-// Copyright (C) 2012 Thomas Freitag <Thomas.Freitag@alfa.de>
-// Copyright (C) 2015 Adam Reichold <adamreichold@myopera.com>
-// Copyright (C) 2016 Kenji Uno <ku@digitaldolphins.jp>
-// Copyright (C) 2018 Martin Packman <gzlist@googlemail.com>
-// Copyright (C) 2019 Oliver Sander <oliver.sander@tu-dresden.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 SPLASHBITMAP_H
-#define SPLASHBITMAP_H
-
-#include "SplashTypes.h"
-#include "poppler/GfxState.h"
-#include "poppler_private_export.h"
-#include <cstdio>
-
-class ImgWriter;
-
-//------------------------------------------------------------------------
-// SplashBitmap
-//------------------------------------------------------------------------
-
-class POPPLER_PRIVATE_EXPORT SplashBitmap
-{
-public:
-    // Create a new bitmap.  It will have <widthA> x <heightA> pixels in
-    // color mode <modeA>.  Rows will be padded out to a multiple of
-    // <rowPad> bytes.  If <topDown> is false, the bitmap will be stored
-    // upside-down, i.e., with the last row first in memory.
-    SplashBitmap(int widthA, int heightA, int rowPad, SplashColorMode modeA, bool alphaA, bool topDown = true, const std::vector<GfxSeparationColorSpace *> *separationList = nullptr);
-    static SplashBitmap *copy(const SplashBitmap *src);
-
-    ~SplashBitmap();
-
-    SplashBitmap(const SplashBitmap &) = delete;
-    SplashBitmap &operator=(const SplashBitmap &) = delete;
-
-    int getWidth() const { return width; }
-    int getHeight() const { return height; }
-    int getRowSize() const { return rowSize; }
-    int getAlphaRowSize() const { return width; }
-    int getRowPad() const { return rowPad; }
-    SplashColorMode getMode() const { return mode; }
-    SplashColorPtr getDataPtr() { return data; }
-    unsigned char *getAlphaPtr() { return alpha; }
-    std::vector<GfxSeparationColorSpace *> *getSeparationList() { return separationList; }
-    SplashColorConstPtr getDataPtr() const { return data; }
-    const unsigned char *getAlphaPtr() const { return alpha; }
-    const std::vector<GfxSeparationColorSpace *> *getSeparationList() const { return separationList; }
-
-    SplashError writePNMFile(char *fileName);
-    SplashError writePNMFile(FILE *f);
-    SplashError writeAlphaPGMFile(char *fileName);
-
-    struct WriteImgParams
-    {
-        int jpegQuality = -1;
-        bool jpegProgressive = false;
-        GooString tiffCompression;
-        bool jpegOptimize = false;
-    };
-
-    SplashError writeImgFile(SplashImageFileFormat format, const char *fileName, int hDPI, int vDPI, WriteImgParams *params = nullptr);
-    SplashError writeImgFile(SplashImageFileFormat format, FILE *f, int hDPI, int vDPI, WriteImgParams *params = nullptr);
-    SplashError writeImgFile(ImgWriter *writer, FILE *f, int hDPI, int vDPI, SplashColorMode imageWriterFormat);
-
-    enum ConversionMode
-    {
-        conversionOpaque,
-        conversionAlpha,
-        conversionAlphaPremultiplied
-    };
-
-    bool convertToXBGR(ConversionMode conversionMode = conversionOpaque);
-
-    void getPixel(int x, int y, SplashColorPtr pixel);
-    void getRGBLine(int y, SplashColorPtr line);
-    void getXBGRLine(int y, SplashColorPtr line, ConversionMode conversionMode = conversionOpaque);
-    void getCMYKLine(int y, SplashColorPtr line);
-    unsigned char getAlpha(int x, int y);
-
-    // Caller takes ownership of the bitmap data.  The SplashBitmap
-    // object is no longer valid -- the next call should be to the
-    // destructor.
-    SplashColorPtr takeData();
-
-private:
-    int width, height; // size of bitmap
-    int rowPad;
-    int rowSize; // size of one row of data, in bytes
-                 //   - negative for bottom-up bitmaps
-    SplashColorMode mode; // color mode
-    SplashColorPtr data; // pointer to row zero of the color data
-    unsigned char *alpha; // pointer to row zero of the alpha data
-                          //   (always top-down)
-    std::vector<GfxSeparationColorSpace *> *separationList; // list of spot colorants and their mapping functions
-
-    friend class Splash;
-
-    void setJpegParams(ImgWriter *writer, WriteImgParams *params);
-};
-
-#endif

package/src/lib/win32/poppler-22.01.0/Library/include/poppler/splash/SplashClip.h

@@ -1,131 +0,0 @@
-//========================================================================
-//
-// SplashClip.h
-//
-//========================================================================
-
-//========================================================================
-//
-// 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) 2010, 2018, 2021 Albert Astals Cid <aacid@kde.org>
-// Copyright (C) 2013 Thomas Freitag <Thomas.Freitag@alfa.de>
-// Copyright (C) 2019 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 SPLASHCLIP_H
-#define SPLASHCLIP_H
-
-#include "SplashTypes.h"
-
-#include <memory>
-#include <vector>
-
-class SplashPath;
-class SplashXPath;
-class SplashXPathScanner;
-class SplashBitmap;
-
-//------------------------------------------------------------------------
-
-enum SplashClipResult
-{
-    splashClipAllInside,
-    splashClipAllOutside,
-    splashClipPartial
-};
-
-//------------------------------------------------------------------------
-// SplashClip
-//------------------------------------------------------------------------
-
-class SplashClip
-{
-public:
-    // Create a clip, for the given rectangle.
-    SplashClip(SplashCoord x0, SplashCoord y0, SplashCoord x1, SplashCoord y1, bool antialiasA);
-
-    // Copy a clip.
-    SplashClip *copy() const { return new SplashClip(this); }
-
-    ~SplashClip();
-
-    SplashClip(const SplashClip &) = delete;
-    SplashClip &operator=(const SplashClip &) = delete;
-
-    // Reset the clip to a rectangle.
-    void resetToRect(SplashCoord x0, SplashCoord y0, SplashCoord x1, SplashCoord y1);
-
-    // Intersect the clip with a rectangle.
-    SplashError clipToRect(SplashCoord x0, SplashCoord y0, SplashCoord x1, SplashCoord y1);
-
-    // Intersect the clip with <path>.
-    SplashError clipToPath(SplashPath *path, SplashCoord *matrix, SplashCoord flatness, bool eo);
-
-    // Returns true if (<x>,<y>) is inside the clip.
-    bool test(int x, int y)
-    {
-        // check the rectangle
-        if (x < xMinI || x > xMaxI || y < yMinI || y > yMaxI) {
-            return false;
-        }
-
-        // check the paths
-        return testClipPaths(x, y);
-    }
-
-    // Tests a rectangle against the clipping region.  Returns one of:
-    //   - splashClipAllInside if the entire rectangle is inside the
-    //     clipping region, i.e., all pixels in the rectangle are
-    //     visible
-    //   - splashClipAllOutside if the entire rectangle is outside the
-    //     clipping region, i.e., all the pixels in the rectangle are
-    //     clipped
-    //   - splashClipPartial if the rectangle is part inside and part
-    //     outside the clipping region
-    SplashClipResult testRect(int rectXMin, int rectYMin, int rectXMax, int rectYMax);
-
-    // Similar to testRect, but tests a horizontal span.
-    SplashClipResult testSpan(int spanXMin, int spanXMax, int spanY);
-
-    // Clips an anti-aliased line by setting pixels to zero.  On entry,
-    // all non-zero pixels are between <x0> and <x1>.  This function
-    // will update <x0> and <x1>.
-    void clipAALine(SplashBitmap *aaBuf, int *x0, int *x1, int y, bool adjustVertLine = false);
-
-    // Get the rectangle part of the clip region.
-    SplashCoord getXMin() { return xMin; }
-    SplashCoord getXMax() { return xMax; }
-    SplashCoord getYMin() { return yMin; }
-    SplashCoord getYMax() { return yMax; }
-
-    // Get the rectangle part of the clip region, in integer coordinates.
-    int getXMinI() { return xMinI; }
-    int getXMaxI() { return xMaxI; }
-    int getYMinI() { return yMinI; }
-    int getYMaxI() { return yMaxI; }
-
-    // Get the number of arbitrary paths used by the clip region.
-    int getNumPaths() { return length; }
-
-protected:
-    explicit SplashClip(const SplashClip *clip);
-    void grow(int nPaths);
-    bool testClipPaths(int x, int y);
-
-    bool antialias;
-    SplashCoord xMin, yMin, xMax, yMax;
-    int xMinI, yMinI, xMaxI, yMaxI;
-    unsigned char *flags;
-    std::vector<std::shared_ptr<SplashXPathScanner>> scanners;
-    int length, size;
-};
-
-#endif

package/src/lib/win32/poppler-22.01.0/Library/include/poppler/splash/SplashErrorCodes.h

@@ -1,50 +0,0 @@
-//========================================================================
-//
-// SplashErrorCodes.h
-//
-//========================================================================
-
-//========================================================================
-//
-// 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) 2006, 2009 Albert Astals Cid <aacid@kde.org>
-//
-// 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 SPLASHERRORCODES_H
-#define SPLASHERRORCODES_H
-
-//------------------------------------------------------------------------
-
-#define splashOk 0 // no error
-
-#define splashErrNoCurPt 1 // no current point
-
-#define splashErrEmptyPath 2 // zero points in path
-
-#define splashErrBogusPath 3 // only one point in subpath
-
-#define splashErrNoSave 4 // state stack is empty
-
-#define splashErrOpenFile 5 // couldn't open file
-
-#define splashErrNoGlyph 6 // couldn't get the requested glyph
-
-#define splashErrModeMismatch 7 // invalid combination of color modes
-
-#define splashErrSingularMatrix 8 // matrix is singular
-
-#define splashErrBadArg 9 // bad argument
-
-#define splashErrZeroImage 254 // image of 0x0
-
-#define splashErrGeneric 255
-
-#endif