Ignore:
Timestamp:
Jun 30, 2008, 10:13:07 AM (13 years ago)
Author:
Eugene Romanenko
Message:

PDF plugin: poppler library updated to version 0.8.3

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/poppler/mypoppler/poppler/GfxState.cc

    r134 r250  
    2323#include "GfxState.h"
    2424#include "GfxFont.h"
    25 #include "UGooString.h"
    2625
    2726//------------------------------------------------------------------------
     
    6362//------------------------------------------------------------------------
    6463
    65 struct gfxBlendModeName {
     64struct GfxBlendModeInfo {
    6665  char *name;
    6766  GfxBlendMode mode;
    6867};
    6968
    70 static gfxBlendModeName gfxBlendModeNames[] = {
     69static GfxBlendModeInfo gfxBlendModeNames[] = {
    7170  { "Normal",     gfxBlendNormal },
    7271  { "Compatible", gfxBlendNormal },
     
    8988
    9089#define nGfxBlendModeNames \
    91           ((int)((sizeof(gfxBlendModeNames) / sizeof(gfxBlendModeName))))
     90          ((int)((sizeof(gfxBlendModeNames) / sizeof(GfxBlendModeInfo))))
    9291         
    9392//------------------------------------------------------------------------
     
    265264}
    266265
     266void GfxDeviceGrayColorSpace::getDefaultColor(GfxColor *color) {
     267  color->c[0] = 0;
     268}
     269
    267270//------------------------------------------------------------------------
    268271// GfxCalGrayColorSpace
     
    362365}
    363366
     367void GfxCalGrayColorSpace::getDefaultColor(GfxColor *color) {
     368  color->c[0] = 0;
     369}
     370
    364371//------------------------------------------------------------------------
    365372// GfxDeviceRGBColorSpace
     
    425432  cmyk->y = y - k;
    426433  cmyk->k = k;
     434}
     435
     436void GfxDeviceRGBColorSpace::getDefaultColor(GfxColor *color) {
     437  color->c[0] = 0;
     438  color->c[1] = 0;
     439  color->c[2] = 0;
    427440}
    428441
     
    576589  cmyk->y = y - k;
    577590  cmyk->k = k;
     591}
     592
     593void GfxCalRGBColorSpace::getDefaultColor(GfxColor *color) {
     594  color->c[0] = 0;
     595  color->c[1] = 0;
     596  color->c[2] = 0;
    578597}
    579598
     
    668687}
    669688
     689void GfxDeviceCMYKColorSpace::getDefaultColor(GfxColor *color) {
     690  color->c[0] = 0;
     691  color->c[1] = 0;
     692  color->c[2] = 0;
     693  color->c[3] = gfxColorComp1;
     694}
     695
    670696//------------------------------------------------------------------------
    671697// GfxLabColorSpace
     
    783809  getRGB(color, &rgb);
    784810  *gray = clip01((GfxColorComp)(0.299 * rgb.r +
    785                  0.587 * rgb.g +
     811                                0.587 * rgb.g +
    786812                                0.114 * rgb.b + 0.5));
    787813}
     
    843869  cmyk->y = y - k;
    844870  cmyk->k = k;
     871}
     872
     873void GfxLabColorSpace::getDefaultColor(GfxColor *color) {
     874  color->c[0] = 0;
     875  if (aMin > 0) {
     876    color->c[1] = dblToCol(aMin);
     877  } else if (aMax < 0) {
     878    color->c[1] = dblToCol(aMax);
     879  } else {
     880    color->c[1] = 0;
     881  }
     882  if (bMin > 0) {
     883    color->c[2] = dblToCol(bMin);
     884  } else if (bMax < 0) {
     885    color->c[2] = dblToCol(bMax);
     886  } else {
     887    color->c[2] = 0;
     888  }
    845889}
    846890
     
    9751019}
    9761020
     1021void GfxICCBasedColorSpace::getDefaultColor(GfxColor *color) {
     1022  int i;
     1023
     1024  for (i = 0; i < nComps; ++i) {
     1025    if (rangeMin[i] > 0) {
     1026      color->c[i] = dblToCol(rangeMin[i]);
     1027    } else if (rangeMax[i] < 0) {
     1028      color->c[i] = dblToCol(rangeMax[i]);
     1029    } else {
     1030      color->c[i] = 0;
     1031    }
     1032  }
     1033}
     1034
    9771035void GfxICCBasedColorSpace::getDefaultRanges(double *decodeLow,
    9781036                                             double *decodeRange,
     
    10611119      for (j = 0; j < n; ++j) {
    10621120        if ((x = obj1.streamGetChar()) == EOF) {
    1063           error(-1, "Bad Indexed color space (lookup table stream too short)");
    1064           goto err3;
     1121          error(-1, "Bad Indexed color space (lookup table stream too short) padding with zeroes");
     1122          x = 0;
    10651123        }
    10661124        cs->lookup[i*n + j] = (Guchar)x;
     
    11221180
    11231181void GfxIndexedColorSpace::getRGBLine(Guchar *in, unsigned int *out, int length) {
    1124   GfxColor color2;
    11251182  Guchar *line;
    11261183  int i, j, n;
     
    11411198
    11421199  base->getCMYK(mapColorToBase(color, &color2), cmyk);
     1200}
     1201
     1202void GfxIndexedColorSpace::getDefaultColor(GfxColor *color) {
     1203  color->c[0] = 0;
    11431204}
    11441205
     
    11601221  alt = altA;
    11611222  func = funcA;
     1223  nonMarking = !name->cmp("None");
    11621224}
    11631225
     
    12561318}
    12571319
     1320void GfxSeparationColorSpace::getDefaultColor(GfxColor *color) {
     1321  color->c[0] = gfxColorComp1;
     1322}
     1323
    12581324//------------------------------------------------------------------------
    12591325// GfxDeviceNColorSpace
     
    12661332  alt = altA;
    12671333  func = funcA;
     1334  nonMarking = gFalse;
    12681335}
    12691336
     
    12861353    cs->names[i] = names[i]->copy();
    12871354  }
     1355  cs->nonMarking = nonMarking;
    12881356  return cs;
    12891357}
     
    13351403  obj1.free();
    13361404  cs = new GfxDeviceNColorSpace(nCompsA, altA, funcA);
     1405  cs->nonMarking = gTrue;
    13371406  for (i = 0; i < nCompsA; ++i) {
    13381407    cs->names[i] = namesA[i];
     1408    if (namesA[i]->cmp("None")) {
     1409      cs->nonMarking = gFalse;
     1410    }
    13391411  }
    13401412  return cs;
     
    13951467  }
    13961468  alt->getCMYK(&color2, cmyk);
     1469}
     1470
     1471void GfxDeviceNColorSpace::getDefaultColor(GfxColor *color) {
     1472  int i;
     1473
     1474  for (i = 0; i < nComps; ++i) {
     1475    color->c[i] = gfxColorComp1;
     1476  }
    13971477}
    13981478
     
    14501530  cmyk->c = cmyk->m = cmyk->y = 0;
    14511531  cmyk->k = 1;
     1532}
     1533
     1534void GfxPatternColorSpace::getDefaultColor(GfxColor *color) {
     1535  color->c[0]=0;
    14521536}
    14531537
     
    18841968    x0A = obj1.arrayGet(0, &obj2)->getNum();
    18851969    obj2.free();
    1886     y0A = obj1.arrayGet(1, &obj2)->getNum();
     1970    x1A = obj1.arrayGet(1, &obj2)->getNum();
    18871971    obj2.free();
    1888     x1A = obj1.arrayGet(2, &obj2)->getNum();
     1972    y0A = obj1.arrayGet(2, &obj2)->getNum();
    18891973    obj2.free();
    18901974    y1A = obj1.arrayGet(3, &obj2)->getNum();
     
    32663350  colorSpace = colorSpaceA;
    32673351
     3352  // this is a hack to support 16 bits images, everywhere
     3353  // we assume a component fits in 8 bits, with this hack
     3354  // we treat 16 bit images as 8 bit ones until it's fixed correctly.
     3355  // The hack has another part on ImageStream::getLine
     3356  if (maxPixel > 255) maxPixel = 255;
     3357
     3358  // initialize
     3359  for (k = 0; k < gfxColorMaxComps; ++k) {
     3360    lookup[k] = NULL;
     3361  }
     3362
    32683363  // get decode map
    32693364  if (decode->isNull()) {
     
    33003395  // only one component), we store color values in the lookup table
    33013396  // rather than component values.
    3302   for (k = 0; k < gfxColorMaxComps; ++k) {
    3303     lookup[k] = NULL;
    3304   }
    33053397  colorSpace2 = NULL;
    33063398  nComps2 = 0;
     
    33723464 err1:
    33733465  ok = gFalse;
    3374   for (k = 0; k < gfxColorMaxComps; ++k) {
    3375     lookup[k] = NULL;
    3376   }
    33773466  byte_lookup = NULL;
    33783467}
     
    34603549
    34613550void GfxImageColorMap::getGrayLine(Guchar *in, Guchar *out, int length) {
    3462   GfxColor color;
    3463   double *p;
    34643551  int i, j;
    3465   Guchar *inp, *outp, *tmp_line;
    3466   GfxColorSpace *base;
     3552  Guchar *inp, *tmp_line;
    34673553
    34683554  switch (colorSpace->getMode()) {
     
    34933579
    34943580void GfxImageColorMap::getRGBLine(Guchar *in, unsigned int *out, int length) {
    3495   GfxColor color;
    3496   double *p;
    34973581  int i, j;
    3498   Guchar *inp, *outp, *tmp_line;
    3499   GfxColorSpace *base;
     3582  Guchar *inp, *tmp_line;
    35003583
    35013584  switch (colorSpace->getMode()) {
     
    37423825//------------------------------------------------------------------------
    37433826
    3744 GfxState::GfxState(double hDPI, double vDPI, PDFRectangle *pageBox,
     3827GfxState::GfxState(double hDPIA, double vDPIA, PDFRectangle *pageBox,
    37453828                   int rotateA, GBool upsideDown) {
    37463829  double kx, ky;
    37473830
     3831  hDPI = hDPIA;
     3832  vDPI = vDPIA;
    37483833  rotate = rotateA;
    37493834  px1 = pageBox->x1;
     
    38023887  fillOverprint = gFalse;
    38033888  strokeOverprint = gFalse;
     3889  transfer[0] = transfer[1] = transfer[2] = transfer[3] = NULL;
    38043890
    38053891  lineWidth = 1;
     
    38113897  lineCap = 0;
    38123898  miterLimit = 10;
     3899  strokeAdjust = gFalse;
    38133900
    38143901  font = NULL;
     
    38373924
    38383925GfxState::~GfxState() {
     3926  int i;
     3927
    38393928  if (fillColorSpace) {
    38403929    delete fillColorSpace;
     
    38483937  if (strokePattern) {
    38493938    delete strokePattern;
     3939  }
     3940  for (i = 0; i < 4; ++i) {
     3941    if (transfer[i]) {
     3942      delete transfer[i];
     3943    }
    38503944  }
    38513945  gfree(lineDash);
     
    38643958// Used for copy();
    38653959GfxState::GfxState(GfxState *state) {
     3960  int i;
     3961
    38663962  memcpy(this, state, sizeof(GfxState));
    38673963  if (fillColorSpace) {
     
    38763972  if (strokePattern) {
    38773973    strokePattern = state->strokePattern->copy();
     3974  }
     3975  for (i = 0; i < 4; ++i) {
     3976    if (transfer[i]) {
     3977      transfer[i] = state->transfer[i]->copy();
     3978    }
    38783979  }
    38793980  if (lineDashLength > 0) {
     
    40254126}
    40264127
     4128void GfxState::shiftCTM(double tx, double ty) {
     4129  ctm[4] += tx;
     4130  ctm[5] += ty;
     4131  clipXMin += tx;
     4132  clipYMin += ty;
     4133  clipXMax += tx;
     4134  clipYMax += ty;
     4135}
     4136
    40274137void GfxState::setFillColorSpace(GfxColorSpace *colorSpace) {
    40284138  if (fillColorSpace) {
     
    40594169  font = fontA;
    40604170  fontSize = fontSizeA;
     4171}
     4172
     4173void GfxState::setTransfer(Function **funcs) {
     4174  int i;
     4175
     4176  for (i = 0; i < 4; ++i) {
     4177    if (transfer[i]) {
     4178      delete transfer[i];
     4179    }
     4180    transfer[i] = funcs[i];
     4181  }
    40614182}
    40624183
     
    41154236}
    41164237
     4238void GfxState::clipToStrokePath() {
     4239  double xMin, yMin, xMax, yMax, x, y, t0, t1;
     4240  GfxSubpath *subpath;
     4241  int i, j;
     4242
     4243  xMin = xMax = yMin = yMax = 0; // make gcc happy
     4244  for (i = 0; i < path->getNumSubpaths(); ++i) {
     4245    subpath = path->getSubpath(i);
     4246    for (j = 0; j < subpath->getNumPoints(); ++j) {
     4247      transform(subpath->getX(j), subpath->getY(j), &x, &y);
     4248      if (i == 0 && j == 0) {
     4249        xMin = xMax = x;
     4250        yMin = yMax = y;
     4251      } else {
     4252        if (x < xMin) {
     4253          xMin = x;
     4254        } else if (x > xMax) {
     4255          xMax = x;
     4256        }
     4257        if (y < yMin) {
     4258          yMin = y;
     4259        } else if (y > yMax) {
     4260          yMax = y;
     4261        }
     4262      }
     4263    }
     4264  }
     4265
     4266  // allow for the line width
     4267  //~ miter joins can extend farther than this
     4268  t0 = fabs(ctm[0]);
     4269  t1 = fabs(ctm[2]);
     4270  if (t0 > t1) {
     4271    xMin -= 0.5 * lineWidth * t0;
     4272    xMax += 0.5 * lineWidth * t0;
     4273  } else {
     4274    xMin -= 0.5 * lineWidth * t1;
     4275    xMax += 0.5 * lineWidth * t1;
     4276  }
     4277  t0 = fabs(ctm[0]);
     4278  t1 = fabs(ctm[3]);
     4279  if (t0 > t1) {
     4280    yMin -= 0.5 * lineWidth * t0;
     4281    yMax += 0.5 * lineWidth * t0;
     4282  } else {
     4283    yMin -= 0.5 * lineWidth * t1;
     4284    yMax += 0.5 * lineWidth * t1;
     4285  }
     4286
     4287  if (xMin > clipXMin) {
     4288    clipXMin = xMin;
     4289  }
     4290  if (yMin > clipYMin) {
     4291    clipYMin = yMin;
     4292  }
     4293  if (xMax < clipXMax) {
     4294    clipXMax = xMax;
     4295  }
     4296  if (yMax < clipYMax) {
     4297    clipYMax = yMax;
     4298  }
     4299}
     4300
    41174301void GfxState::textShift(double tx, double ty) {
    41184302  double dx, dy;
Note: See TracChangeset for help on using the changeset viewer.