"Fossies" - the Fresh Open Source Software Archive

Member "xpdf-4.04/xpdf/PreScanOutputDev.cc" (18 Apr 2022, 8588 Bytes) of package /linux/misc/xpdf-4.04.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file.

    1 //========================================================================
    2 //
    3 // PreScanOutputDev.cc
    4 //
    5 // Copyright 2005 Glyph & Cog, LLC
    6 //
    7 //========================================================================
    8 
    9 #include <aconf.h>
   10 
   11 #ifdef USE_GCC_PRAGMAS
   12 #pragma implementation
   13 #endif
   14 
   15 #include <math.h>
   16 #include "gmempp.h"
   17 #include "GlobalParams.h"
   18 #include "Page.h"
   19 #include "Gfx.h"
   20 #include "GfxFont.h"
   21 #include "Link.h"
   22 #include "PreScanOutputDev.h"
   23 
   24 //------------------------------------------------------------------------
   25 // PreScanOutputDev
   26 //------------------------------------------------------------------------
   27 
   28 PreScanOutputDev::PreScanOutputDev() {
   29   clearStats();
   30 }
   31 
   32 PreScanOutputDev::~PreScanOutputDev() {
   33 }
   34 
   35 void PreScanOutputDev::startPage(int pageNum, GfxState *state) {
   36 }
   37 
   38 void PreScanOutputDev::endPage() {
   39 }
   40 
   41 void PreScanOutputDev::stroke(GfxState *state) {
   42   double *dash;
   43   int dashLen;
   44   double dashStart;
   45 
   46   check(state, state->getStrokeColorSpace(), state->getStrokeColor(),
   47     state->getStrokeOpacity(), state->getBlendMode());
   48   state->getLineDash(&dash, &dashLen, &dashStart);
   49   if (dashLen != 0) {
   50     gdi = gFalse;
   51   }
   52 }
   53 
   54 void PreScanOutputDev::fill(GfxState *state) {
   55   check(state, state->getFillColorSpace(), state->getFillColor(),
   56     state->getFillOpacity(), state->getBlendMode());
   57 }
   58 
   59 void PreScanOutputDev::eoFill(GfxState *state) {
   60   check(state, state->getFillColorSpace(), state->getFillColor(),
   61     state->getFillOpacity(), state->getBlendMode());
   62 }
   63 
   64 void PreScanOutputDev::tilingPatternFill(GfxState *state, Gfx *gfx,
   65                      Object *strRef,
   66                      int paintType, int tilingType,
   67                      Dict *resDict,
   68                      double *mat, double *bbox,
   69                      int x0, int y0, int x1, int y1,
   70                      double xStep, double yStep) {
   71   if (paintType == 1) {
   72     gfx->drawForm(strRef, resDict, mat, bbox);
   73   } else {
   74     check(state, state->getFillColorSpace(), state->getFillColor(),
   75       state->getFillOpacity(), state->getBlendMode());
   76   }
   77 }
   78 
   79 GBool PreScanOutputDev::shadedFill(GfxState *state, GfxShading *shading) {
   80   if (shading->getColorSpace()->getMode() != csDeviceGray &&
   81       shading->getColorSpace()->getMode() != csCalGray) {
   82     gray = gFalse;
   83   }
   84   mono = gFalse;
   85   if (state->getFillOpacity() != 1 ||
   86       state->getBlendMode() != gfxBlendNormal) {
   87     transparency = gTrue;
   88   }
   89   return gTrue;
   90 }
   91 
   92 void PreScanOutputDev::clip(GfxState *state) {
   93   //~ check for a rectangle "near" the edge of the page;
   94   //~   else set gdi to false
   95 }
   96 
   97 void PreScanOutputDev::eoClip(GfxState *state) {
   98   //~ see clip()
   99 }
  100 
  101 void PreScanOutputDev::beginStringOp(GfxState *state) {
  102   int render;
  103   GfxFont *font;
  104   double m11, m12, m21, m22;
  105   GBool simpleTTF;
  106 
  107   render = state->getRender();
  108   if (!(render & 1)) {
  109     check(state, state->getFillColorSpace(), state->getFillColor(),
  110       state->getFillOpacity(), state->getBlendMode());
  111   }
  112   if ((render & 3) == 1 || (render & 3) == 2) {
  113     check(state, state->getStrokeColorSpace(), state->getStrokeColor(),
  114       state->getStrokeOpacity(), state->getBlendMode());
  115   }
  116 
  117   font = state->getFont();
  118   state->getFontTransMat(&m11, &m12, &m21, &m22);
  119   //~ this should check for external fonts that are non-TrueType
  120   simpleTTF = fabs(m11 + m22) < 0.01 &&
  121               m11 > 0 &&
  122               fabs(m12) < 0.01 &&
  123               fabs(m21) < 0.01 &&
  124               fabs(state->getHorizScaling() - 1) < 0.001 &&
  125               (font->getType() == fontTrueType ||
  126            font->getType() == fontTrueTypeOT);
  127   if (simpleTTF) {
  128     //~ need to create a FoFiTrueType object, and check for a Unicode cmap
  129   }
  130   if (state->getRender() != 0 || !simpleTTF) {
  131     gdi = gFalse;
  132   }
  133 }
  134 
  135 void PreScanOutputDev::endStringOp(GfxState *state) {
  136 }
  137 
  138 GBool PreScanOutputDev::beginType3Char(GfxState *state, double x, double y,
  139                        double dx, double dy,
  140                        CharCode code, Unicode *u, int uLen) {
  141   // return false so all Type 3 chars get rendered (no caching)
  142   return gFalse;
  143 }
  144 
  145 void PreScanOutputDev::endType3Char(GfxState *state) {
  146 }
  147 
  148 void PreScanOutputDev::drawImageMask(GfxState *state, Object *ref, Stream *str,
  149                      int width, int height, GBool invert,
  150                      GBool inlineImg, GBool interpolate) {
  151   check(state, state->getFillColorSpace(), state->getFillColor(),
  152     state->getFillOpacity(), state->getBlendMode());
  153   if (state->getFillColorSpace()->getMode() == csPattern) {
  154     patternImgMask = gTrue;
  155   }
  156   gdi = gFalse;
  157 
  158   if (inlineImg) {
  159     str->reset();
  160     str->discardChars(height * ((width + 7) / 8));
  161     str->close();
  162   }
  163 }
  164 
  165 void PreScanOutputDev::drawImage(GfxState *state, Object *ref, Stream *str,
  166                  int width, int height,
  167                  GfxImageColorMap *colorMap,
  168                  int *maskColors, GBool inlineImg,
  169                  GBool interpolate) {
  170   GfxColorSpace *colorSpace;
  171 
  172   colorSpace = colorMap->getColorSpace();
  173   if (colorSpace->getMode() == csIndexed) {
  174     colorSpace = ((GfxIndexedColorSpace *)colorSpace)->getBase();
  175   }
  176   if (colorSpace->getMode() == csDeviceGray ||
  177       colorSpace->getMode() == csCalGray) {
  178     if (colorMap->getBits() > 1) {
  179       mono = gFalse;
  180     }
  181   } else {
  182     gray = gFalse;
  183     mono = gFalse;
  184   }
  185   if (state->getFillOpacity() != 1 ||
  186       state->getBlendMode() != gfxBlendNormal) {
  187     transparency = gTrue;
  188   }
  189   gdi = gFalse;
  190 
  191   if (inlineImg) {
  192     str->reset();
  193     str->discardChars(height * ((width * colorMap->getNumPixelComps() *
  194                  colorMap->getBits() + 7) / 8));
  195     str->close();
  196   }
  197 }
  198 
  199 void PreScanOutputDev::drawMaskedImage(GfxState *state, Object *ref,
  200                        Stream *str,
  201                        int width, int height,
  202                        GfxImageColorMap *colorMap,
  203                        Object *maskRef, Stream *maskStr,
  204                        int maskWidth, int maskHeight,
  205                        GBool maskInvert, GBool interpolate) {
  206   GfxColorSpace *colorSpace;
  207 
  208   colorSpace = colorMap->getColorSpace();
  209   if (colorSpace->getMode() == csIndexed) {
  210     colorSpace = ((GfxIndexedColorSpace *)colorSpace)->getBase();
  211   }
  212   if (colorSpace->getMode() == csDeviceGray ||
  213       colorSpace->getMode() == csCalGray) {
  214     if (colorMap->getBits() > 1) {
  215       mono = gFalse;
  216     }
  217   } else {
  218     gray = gFalse;
  219     mono = gFalse;
  220   }
  221   if (state->getFillOpacity() != 1 ||
  222       state->getBlendMode() != gfxBlendNormal) {
  223     transparency = gTrue;
  224   }
  225   gdi = gFalse;
  226 }
  227 
  228 void PreScanOutputDev::drawSoftMaskedImage(GfxState *state, Object *ref,
  229                        Stream *str,
  230                        int width, int height,
  231                        GfxImageColorMap *colorMap,
  232                        Object *maskRef, Stream *maskStr,
  233                        int maskWidth, int maskHeight,
  234                        GfxImageColorMap *maskColorMap,
  235                        double *matte, GBool interpolate) {
  236   GfxColorSpace *colorSpace;
  237 
  238   colorSpace = colorMap->getColorSpace();
  239   if (colorSpace->getMode() == csIndexed) {
  240     colorSpace = ((GfxIndexedColorSpace *)colorSpace)->getBase();
  241   }
  242   if (colorSpace->getMode() != csDeviceGray &&
  243       colorSpace->getMode() != csCalGray) {
  244     gray = gFalse;
  245   }
  246   mono = gFalse;
  247   transparency = gTrue;
  248   gdi = gFalse;
  249 }
  250 
  251 GBool PreScanOutputDev::beginTransparencyGroup(
  252                 GfxState *state, double *bbox,
  253                 GfxColorSpace *blendingColorSpace,
  254                 GBool isolated, GBool knockout,
  255                 GBool forSoftMask) {
  256   transparency = gTrue;
  257   gdi = gFalse;
  258   return gTrue;
  259 }
  260 
  261 void PreScanOutputDev::check(GfxState *state,
  262                  GfxColorSpace *colorSpace, GfxColor *color,
  263                  double opacity, GfxBlendMode blendMode) {
  264   GfxGray gr;
  265   GfxCMYK cmyk;
  266   GfxRGB rgb;
  267 
  268   if (colorSpace->getMode() == csPattern) {
  269     mono = gFalse;
  270     gray = gFalse;
  271     gdi = gFalse;
  272   } else if (colorSpace->getMode() == csDeviceGray ||
  273          colorSpace->getMode() == csCalGray) {
  274     colorSpace->getGray(color, &gr, state->getRenderingIntent());
  275     if (!(gr == 0 || gr == gfxColorComp1)) {
  276       mono = gFalse;
  277     }
  278   } else if (colorSpace->getMode() == csDeviceCMYK) {
  279     colorSpace->getCMYK(color, &cmyk, state->getRenderingIntent());
  280     if (cmyk.c != 0 || cmyk.m != 0 || cmyk.y != 0) {
  281       mono = gFalse;
  282       gray = gFalse;
  283     } else if (!(cmyk.k == 0 || cmyk.k == gfxColorComp1)) {
  284       mono = gFalse;
  285     }
  286   } else {
  287     colorSpace->getRGB(color, &rgb, state->getRenderingIntent());
  288     if (rgb.r != rgb.g || rgb.g != rgb.b || rgb.b != rgb.r) {
  289       mono = gFalse;
  290       gray = gFalse;
  291     } else if (!((rgb.r == 0 && rgb.g == 0 && rgb.b == 0) ||
  292          (rgb.r == gfxColorComp1 &&
  293           rgb.g == gfxColorComp1 &&
  294           rgb.b == gfxColorComp1))) {
  295       mono = gFalse;
  296     }
  297   }
  298   if (opacity != 1 || blendMode != gfxBlendNormal) {
  299     transparency = gTrue;
  300   }
  301 }
  302 
  303 void PreScanOutputDev::clearStats() {
  304   mono = gTrue;
  305   gray = gTrue;
  306   transparency = gFalse;
  307   patternImgMask = gFalse;
  308   gdi = gTrue;
  309 }