GfxState.cpp

//========================================================================
//
// GfxState.cpp
//
// Copyright 1996-2002 Glyph & Cog, LLC
//
//========================================================================
 
#include <aconf.h>
 
#ifdef USE_GCC_PRAGMAS
#pragma implementation
#endif
 
#include <stddef.h>
#include <math.h>
#include <string.h> // for memcpy()
#include "gmem.h"
#include "Error.h"
#include "Object.h"
#include "Array.h"
#include "Page.h"
#include "GfxState.h"
 
//------------------------------------------------------------------------
 
static inline double clip01(double x) {
  return (x < 0) ? 0 : ((x > 1) ? 1 : x);
}
 
//------------------------------------------------------------------------
// GfxColorSpace
//------------------------------------------------------------------------
 
GfxColorSpace::GfxColorSpace() {
}
 
GfxColorSpace::~GfxColorSpace() {
}
 
GfxColorSpace *GfxColorSpace::parse(Object *csObj) {
  GfxColorSpace *cs;
  Object obj1;
 
  cs = NULL;
  if (csObj->isName()) {
    if (csObj->isName("DeviceGray") || csObj->isName("G")) {
      cs = new GfxDeviceGrayColorSpace();
    } else if (csObj->isName("DeviceRGB") || csObj->isName("RGB")) {
      cs = new GfxDeviceRGBColorSpace();
    } else if (csObj->isName("DeviceCMYK") || csObj->isName("CMYK")) {
      cs = new GfxDeviceCMYKColorSpace();
    } else if (csObj->isName("Pattern")) {
      cs = new GfxPatternColorSpace(NULL);
    } else {
      error(-1, "Bad color space '%s'", csObj->getName());
    }
  } else if (csObj->isArray()) {
    csObj->arrayGet(0, &obj1);
    if (obj1.isName("DeviceGray") || obj1.isName("G")) {
      cs = new GfxDeviceGrayColorSpace();
    } else if (obj1.isName("DeviceRGB") || obj1.isName("RGB")) {
      cs = new GfxDeviceRGBColorSpace();
    } else if (obj1.isName("DeviceCMYK") || obj1.isName("CMYK")) {
      cs = new GfxDeviceCMYKColorSpace();
    } else if (obj1.isName("CalGray")) {
      cs = GfxCalGrayColorSpace::parse(csObj->getArray());
    } else if (obj1.isName("CalRGB")) {
      cs = GfxCalRGBColorSpace::parse(csObj->getArray());
    } else if (obj1.isName("Lab")) {
      cs = GfxLabColorSpace::parse(csObj->getArray());
    } else if (obj1.isName("ICCBased")) {
      cs = GfxICCBasedColorSpace::parse(csObj->getArray());
    } else if (obj1.isName("Indexed") || obj1.isName("I")) {
      cs = GfxIndexedColorSpace::parse(csObj->getArray());
    } else if (obj1.isName("Separation")) {
      cs = GfxSeparationColorSpace::parse(csObj->getArray());
    } else if (obj1.isName("DeviceN")) {
      cs = GfxDeviceNColorSpace::parse(csObj->getArray());
    } else if (obj1.isName("Pattern")) {
      cs = GfxPatternColorSpace::parse(csObj->getArray());
    } else {
      error(-1, "Bad color space '%s'", csObj->getName());
    }
    obj1.free();
  } else {
    error(-1, "Bad color space - expected name or array");
  }
  return cs;
}
 
void GfxColorSpace::getDefaultRanges(double *decodeLow, double *decodeRange,
                                     int /*maxImgPixel*/) const {
  int i;
 
  for (i = 0; i < getNComps(); ++i) {
    decodeLow[i] = 0;
    decodeRange[i] = 1;
  }
}
 
//------------------------------------------------------------------------
// GfxDeviceGrayColorSpace
//------------------------------------------------------------------------
 
GfxDeviceGrayColorSpace::GfxDeviceGrayColorSpace() {
}
 
GfxDeviceGrayColorSpace::~GfxDeviceGrayColorSpace() {
}
 
GfxColorSpace *GfxDeviceGrayColorSpace::copy() const {
  return new GfxDeviceGrayColorSpace();
}
 
void GfxDeviceGrayColorSpace::getGray(const GfxColor *color, double *gray) const {
  *gray = clip01(color->c[0]);
}
 
void GfxDeviceGrayColorSpace::getRGB(const GfxColor *color, GfxRGB *rgb) const {
  rgb->r = rgb->g = rgb->b = clip01(color->c[0]);
}
 
void GfxDeviceGrayColorSpace::getCMYK(const GfxColor *color, GfxCMYK *cmyk) const {
  cmyk->c = cmyk->m = cmyk->y = 0;
  cmyk->k = clip01(1 - color->c[0]);
}
 
//------------------------------------------------------------------------
// GfxCalGrayColorSpace
//------------------------------------------------------------------------
 
GfxCalGrayColorSpace::GfxCalGrayColorSpace() {
  whiteX = whiteY = whiteZ = 1;
  blackX = blackY = blackZ = 0;
  gamma = 1;
}
 
GfxCalGrayColorSpace::~GfxCalGrayColorSpace() {
}
 
GfxColorSpace *GfxCalGrayColorSpace::copy() const {
  GfxCalGrayColorSpace *cs;
 
  cs = new GfxCalGrayColorSpace();
  cs->whiteX = whiteX;
  cs->whiteY = whiteY;
  cs->whiteZ = whiteZ;
  cs->blackX = blackX;
  cs->blackY = blackY;
  cs->blackZ = blackZ;
  cs->gamma = gamma;
  return cs;
}
 
GfxColorSpace *GfxCalGrayColorSpace::parse(Array *arr) {
  GfxCalGrayColorSpace *cs;
  Object obj1, obj2, obj3;
 
  arr->get(1, &obj1);
  if (!obj1.isDict()) {
    error(-1, "Bad CalGray color space");
    obj1.free();
    return NULL;
  }
  cs = new GfxCalGrayColorSpace();
  if (obj1.dictLookup("WhitePoint", &obj2)->isArray() &&
      obj2.arrayGetLength() == 3) {
    obj2.arrayGet(0, &obj3);
    cs->whiteX = obj3.getNum();
    obj3.free();
    obj2.arrayGet(1, &obj3);
    cs->whiteY = obj3.getNum();
    obj3.free();
    obj2.arrayGet(2, &obj3);
    cs->whiteZ = obj3.getNum();
    obj3.free();
  }
  obj2.free();
  if (obj1.dictLookup("BlackPoint", &obj2)->isArray() &&
      obj2.arrayGetLength() == 3) {
    obj2.arrayGet(0, &obj3);
    cs->blackX = obj3.getNum();
    obj3.free();
    obj2.arrayGet(1, &obj3);
    cs->blackY = obj3.getNum();
    obj3.free();
    obj2.arrayGet(2, &obj3);
    cs->blackZ = obj3.getNum();
    obj3.free();
  }
  obj2.free();
  if (obj1.dictLookup("Gamma", &obj2)->isNum()) {
    cs->gamma = obj2.getNum();
  }
  obj2.free();
  obj1.free();
  return cs;
}
 
void GfxCalGrayColorSpace::getGray(const GfxColor *color, double *gray) const {
  *gray = clip01(color->c[0]);
}
 
void GfxCalGrayColorSpace::getRGB(const GfxColor *color, GfxRGB *rgb) const {
  rgb->r = rgb->g = rgb->b = clip01(color->c[0]);
}
 
void GfxCalGrayColorSpace::getCMYK(const GfxColor *color, GfxCMYK *cmyk) const {
  cmyk->c = cmyk->m = cmyk->y = 0;
  cmyk->k = clip01(1 - color->c[0]);
}
 
//------------------------------------------------------------------------
// GfxDeviceRGBColorSpace
//------------------------------------------------------------------------
 
GfxDeviceRGBColorSpace::GfxDeviceRGBColorSpace() {
}
 
GfxDeviceRGBColorSpace::~GfxDeviceRGBColorSpace() {
}
 
GfxColorSpace *GfxDeviceRGBColorSpace::copy() const {
  return new GfxDeviceRGBColorSpace();
}
 
void GfxDeviceRGBColorSpace::getGray(const GfxColor *color, double *gray) const {
  *gray = clip01(0.299 * color->c[0] +
         0.587 * color->c[1] +
         0.114 * color->c[2]);
}
 
void GfxDeviceRGBColorSpace::getRGB(const GfxColor *color, GfxRGB *rgb) const {
  rgb->r = clip01(color->c[0]);
  rgb->g = clip01(color->c[1]);
  rgb->b = clip01(color->c[2]);
}
 
void GfxDeviceRGBColorSpace::getCMYK(const GfxColor *color, GfxCMYK *cmyk) const {
  double c, m, y, k;
 
  c = clip01(1 - color->c[0]);
  m = clip01(1 - color->c[1]);
  y = clip01(1 - color->c[2]);
  k = c;
  if (m < k) {
    k = m;
  }
  if (y < k) {
    k = y;
  }
  cmyk->c = c - k;
  cmyk->m = m - k;
  cmyk->y = y - k;
  cmyk->k = k;
}
 
//------------------------------------------------------------------------
// GfxCalRGBColorSpace
//------------------------------------------------------------------------
 
GfxCalRGBColorSpace::GfxCalRGBColorSpace() {
  whiteX = whiteY = whiteZ = 1;
  blackX = blackY = blackZ = 0;
  gammaR = gammaG = gammaB = 1;
  mat[0] = 1; mat[1] = 0; mat[2] = 0;
  mat[3] = 0; mat[4] = 1; mat[5] = 0;
  mat[6] = 0; mat[7] = 0; mat[8] = 1;
}
 
GfxCalRGBColorSpace::~GfxCalRGBColorSpace() {
}
 
GfxColorSpace *GfxCalRGBColorSpace::copy() const {
  GfxCalRGBColorSpace *cs;
  int i;
 
  cs = new GfxCalRGBColorSpace();
  cs->whiteX = whiteX;
  cs->whiteY = whiteY;
  cs->whiteZ = whiteZ;
  cs->blackX = blackX;
  cs->blackY = blackY;
  cs->blackZ = blackZ;
  cs->gammaR = gammaR;
  cs->gammaG = gammaG;
  cs->gammaB = gammaB;
  for (i = 0; i < 9; ++i) {
    cs->mat[i] = mat[i];
  }
  return cs;
}
 
GfxColorSpace *GfxCalRGBColorSpace::parse(Array *arr) {
  GfxCalRGBColorSpace *cs;
  Object obj1, obj2, obj3;
  int i;
 
  arr->get(1, &obj1);
  if (!obj1.isDict()) {
    error(-1, "Bad CalRGB color space");
    obj1.free();
    return NULL;
  }
  cs = new GfxCalRGBColorSpace();
  if (obj1.dictLookup("WhitePoint", &obj2)->isArray() &&
      obj2.arrayGetLength() == 3) {
    obj2.arrayGet(0, &obj3);
    cs->whiteX = obj3.getNum();
    obj3.free();
    obj2.arrayGet(1, &obj3);
    cs->whiteY = obj3.getNum();
    obj3.free();
    obj2.arrayGet(2, &obj3);
    cs->whiteZ = obj3.getNum();
    obj3.free();
  }
  obj2.free();
  if (obj1.dictLookup("BlackPoint", &obj2)->isArray() &&
      obj2.arrayGetLength() == 3) {
    obj2.arrayGet(0, &obj3);
    cs->blackX = obj3.getNum();
    obj3.free();
    obj2.arrayGet(1, &obj3);
    cs->blackY = obj3.getNum();
    obj3.free();
    obj2.arrayGet(2, &obj3);
    cs->blackZ = obj3.getNum();
    obj3.free();
  }
  obj2.free();
  if (obj1.dictLookup("Gamma", &obj2)->isArray() &&
      obj2.arrayGetLength() == 3) {
    obj2.arrayGet(0, &obj3);
    cs->gammaR = obj3.getNum();
    obj3.free();
    obj2.arrayGet(1, &obj3);
    cs->gammaG = obj3.getNum();
    obj3.free();
    obj2.arrayGet(2, &obj3);
    cs->gammaB = obj3.getNum();
    obj3.free();
  }
  obj2.free();
  if (obj1.dictLookup("Matrix", &obj2)->isArray() &&
      obj2.arrayGetLength() == 9) {
    for (i = 0; i < 9; ++i) {
      obj2.arrayGet(i, &obj3);
      cs->mat[i] = obj3.getNum();
      obj3.free();
    }
  }
  obj2.free();
  obj1.free();
  return cs;
}
 
void GfxCalRGBColorSpace::getGray(const GfxColor *color, double *gray) const {
  *gray = clip01(0.299 * color->c[0] +
         0.587 * color->c[1] +
         0.114 * color->c[2]);
}
 
void GfxCalRGBColorSpace::getRGB(const GfxColor *color, GfxRGB *rgb) const {
  rgb->r = clip01(color->c[0]);
  rgb->g = clip01(color->c[1]);
  rgb->b = clip01(color->c[2]);
}
 
void GfxCalRGBColorSpace::getCMYK(const GfxColor *color, GfxCMYK *cmyk) const {
  double c, m, y, k;
 
  c = clip01(1 - color->c[0]);
  m = clip01(1 - color->c[1]);
  y = clip01(1 - color->c[2]);
  k = c;
  if (m < k) {
    k = m;
  }
  if (y < k) {
    k = y;
  }
  cmyk->c = c - k;
  cmyk->m = m - k;
  cmyk->y = y - k;
  cmyk->k = k;
}
 
//------------------------------------------------------------------------
// GfxDeviceCMYKColorSpace
//------------------------------------------------------------------------
 
GfxDeviceCMYKColorSpace::GfxDeviceCMYKColorSpace() {
}
 
GfxDeviceCMYKColorSpace::~GfxDeviceCMYKColorSpace() {
}
 
GfxColorSpace *GfxDeviceCMYKColorSpace::copy() const {
  return new GfxDeviceCMYKColorSpace();
}
 
void GfxDeviceCMYKColorSpace::getGray(const GfxColor *color, double *gray) const {
  *gray = clip01(1 - color->c[3]
         - 0.299 * color->c[0]
         - 0.587 * color->c[1]
         - 0.114 * color->c[2]);
}
 
void GfxDeviceCMYKColorSpace::getRGB(const GfxColor *color, GfxRGB *rgb) const {
  double c, m, y, aw, ac, am, ay, ar, ag, ab;
 
  c = clip01(color->c[0] + color->c[3]);
  m = clip01(color->c[1] + color->c[3]);
  y = clip01(color->c[2] + color->c[3]);
  aw = (1-c) * (1-m) * (1-y);
  ac = c * (1-m) * (1-y);
  am = (1-c) * m * (1-y);
  ay = (1-c) * (1-m) * y;
  ar = (1-c) * m * y;
  ag = c * (1-m) * y;
  ab = c * m * (1-y);
  rgb->r = clip01(aw + 0.9137*am + 0.9961*ay + 0.9882*ar);
  rgb->g = clip01(aw + 0.6196*ac + ay + 0.5176*ag);
  rgb->b = clip01(aw + 0.7804*ac + 0.5412*am + 0.0667*ar + 0.2118*ag +
          0.4863*ab);
}
 
void GfxDeviceCMYKColorSpace::getCMYK(const GfxColor *color, GfxCMYK *cmyk) const {
  cmyk->c = clip01(color->c[0]);
  cmyk->m = clip01(color->c[1]);
  cmyk->y = clip01(color->c[2]);
  cmyk->k = clip01(color->c[3]);
}
 
//------------------------------------------------------------------------
// GfxLabColorSpace
//------------------------------------------------------------------------
 
// This is the inverse of MatrixLMN in Example 4.10 from the PostScript
// Language Reference, Third Edition.
static double xyzrgb[3][3] = {
  {  3.240449, -1.537136, -0.498531 },
  { -0.969265,  1.876011,  0.041556 },
  {  0.055643, -0.204026,  1.057229 }
};
 
GfxLabColorSpace::GfxLabColorSpace() {
  whiteX = whiteY = whiteZ = 1;
  blackX = blackY = blackZ = 0;
  aMin = bMin = -100;
  aMax = bMax = 100;
}
 
GfxLabColorSpace::~GfxLabColorSpace() {
}
 
GfxColorSpace *GfxLabColorSpace::copy() const {
  GfxLabColorSpace *cs;
 
  cs = new GfxLabColorSpace();
  cs->whiteX = whiteX;
  cs->whiteY = whiteY;
  cs->whiteZ = whiteZ;
  cs->blackX = blackX;
  cs->blackY = blackY;
  cs->blackZ = blackZ;
  cs->aMin = aMin;
  cs->aMax = aMax;
  cs->bMin = bMin;
  cs->bMax = bMax;
  cs->kr = kr;
  cs->kg = kg;
  cs->kb = kb;
  return cs;
}
 
GfxColorSpace *GfxLabColorSpace::parse(Array *arr) {
  GfxLabColorSpace *cs;
  Object obj1, obj2, obj3;
 
  arr->get(1, &obj1);
  if (!obj1.isDict()) {
    error(-1, "Bad Lab color space");
    obj1.free();
    return NULL;
  }
  cs = new GfxLabColorSpace();
  if (obj1.dictLookup("WhitePoint", &obj2)->isArray() &&
      obj2.arrayGetLength() == 3) {
    obj2.arrayGet(0, &obj3);
    cs->whiteX = obj3.getNum();
    obj3.free();
    obj2.arrayGet(1, &obj3);
    cs->whiteY = obj3.getNum();
    obj3.free();
    obj2.arrayGet(2, &obj3);
    cs->whiteZ = obj3.getNum();
    obj3.free();
  }
  obj2.free();
  if (obj1.dictLookup("BlackPoint", &obj2)->isArray() &&
      obj2.arrayGetLength() == 3) {
    obj2.arrayGet(0, &obj3);
    cs->blackX = obj3.getNum();
    obj3.free();
    obj2.arrayGet(1, &obj3);
    cs->blackY = obj3.getNum();
    obj3.free();
    obj2.arrayGet(2, &obj3);
    cs->blackZ = obj3.getNum();
    obj3.free();
  }
  obj2.free();
  if (obj1.dictLookup("Range", &obj2)->isArray() &&
      obj2.arrayGetLength() == 4) {
    obj2.arrayGet(0, &obj3);
    cs->aMin = obj3.getNum();
    obj3.free();
    obj2.arrayGet(1, &obj3);
    cs->aMax = obj3.getNum();
    obj3.free();
    obj2.arrayGet(2, &obj3);
    cs->bMin = obj3.getNum();
    obj3.free();
    obj2.arrayGet(3, &obj3);
    cs->bMax = obj3.getNum();
    obj3.free();
  }
  obj2.free();
  obj1.free();
 
  cs->kr = 1 / (xyzrgb[0][0] * cs->whiteX +
        xyzrgb[0][1] * cs->whiteY +
        xyzrgb[0][2] * cs->whiteZ);
  cs->kg = 1 / (xyzrgb[1][0] * cs->whiteX +
        xyzrgb[1][1] * cs->whiteY +
        xyzrgb[1][2] * cs->whiteZ);
  cs->kb = 1 / (xyzrgb[2][0] * cs->whiteX +
        xyzrgb[2][1] * cs->whiteY +
        xyzrgb[2][2] * cs->whiteZ);
 
  return cs;
}
 
void GfxLabColorSpace::getGray(const GfxColor *color, double *gray) const {
  GfxRGB rgb;
 
  getRGB(color, &rgb);
  *gray = clip01(0.299 * rgb.r +
         0.587 * rgb.g +
         0.114 * rgb.b);
}
 
void GfxLabColorSpace::getRGB(const GfxColor *color, GfxRGB *rgb) const {
  double X, Y, Z;
  double t1, t2;
  double r, g, b;
 
  // convert L*a*b* to CIE 1931 XYZ color space
  t1 = (color->c[0] + 16) / 116;
  t2 = t1 + color->c[1] / 500;
  if (t2 >= (6.0 / 29.0)) {
    X = t2 * t2 * t2;
  } else {
    X = (108.0 / 841.0) * (t2 - (4.0 / 29.0));
  }
  X *= whiteX;
  if (t1 >= (6.0 / 29.0)) {
    Y = t1 * t1 * t1;
  } else {
    Y = (108.0 / 841.0) * (t1 - (4.0 / 29.0));
  }
  Y *= whiteY;
  t2 = t1 - color->c[2] / 200;
  if (t2 >= (6.0 / 29.0)) {
    Z = t2 * t2 * t2;
  } else {
    Z = (108.0 / 841.0) * (t2 - (4.0 / 29.0));
  }
  Z *= whiteZ;
 
  // convert XYZ to RGB, including gamut mapping and gamma correction
  r = xyzrgb[0][0] * X + xyzrgb[0][1] * Y + xyzrgb[0][2] * Z;
  g = xyzrgb[1][0] * X + xyzrgb[1][1] * Y + xyzrgb[1][2] * Z;
  b = xyzrgb[2][0] * X + xyzrgb[2][1] * Y + xyzrgb[2][2] * Z;
  rgb->r = pow(clip01(r * kr), 0.5);
  rgb->g = pow(clip01(g * kg), 0.5);
  rgb->b = pow(clip01(b * kb), 0.5);
}
 
void GfxLabColorSpace::getCMYK(const GfxColor *color, GfxCMYK *cmyk) const {
  GfxRGB rgb;
  double c, m, y, k;
 
  getRGB(color, &rgb);
  c = clip01(1 - rgb.r);
  m = clip01(1 - rgb.g);
  y = clip01(1 - rgb.b);
  k = c;
  if (m < k) {
    k = m;
  }
  if (y < k) {
    k = y;
  }
  cmyk->c = c - k;
  cmyk->m = m - k;
  cmyk->y = y - k;
  cmyk->k = k;
}
 
void GfxLabColorSpace::getDefaultRanges(double *decodeLow, double *decodeRange,
                                        int /*maxImgPixel*/) const {
  decodeLow[0] = 0;
  decodeRange[0] = 100;
  decodeLow[1] = aMin;
  decodeRange[1] = aMax - aMin;
  decodeLow[2] = bMin;
  decodeRange[2] = bMax - bMin;
}
 
//------------------------------------------------------------------------
// GfxICCBasedColorSpace
//------------------------------------------------------------------------
 
GfxICCBasedColorSpace::GfxICCBasedColorSpace(int nCompsA, GfxColorSpace *altA,
                         const Ref *iccProfileStreamA) {
  nComps = nCompsA;
  alt = altA;
  iccProfileStream = *iccProfileStreamA;
  rangeMin[0] = rangeMin[1] = rangeMin[2] = rangeMin[3] = 0;
  rangeMax[0] = rangeMax[1] = rangeMax[2] = rangeMax[3] = 1;
}
 
GfxICCBasedColorSpace::~GfxICCBasedColorSpace() {
  delete alt;
}
 
GfxColorSpace *GfxICCBasedColorSpace::copy() const {
  GfxICCBasedColorSpace *cs;
  int i;
 
  cs = new GfxICCBasedColorSpace(nComps, alt->copy(), &iccProfileStream);
  for (i = 0; i < 4; ++i) {
    cs->rangeMin[i] = rangeMin[i];
    cs->rangeMax[i] = rangeMax[i];
  }
  return cs;
}
 
GfxColorSpace *GfxICCBasedColorSpace::parse(Array *arr) {
  GfxICCBasedColorSpace *cs;
  Ref iccProfileStreamA;
  int nCompsA;
  GfxColorSpace *altA;
  Dict *dict;
  Object obj1, obj2, obj3;
  int i;
 
  arr->getNF(1, &obj1);
  if (obj1.isRef()) {
    iccProfileStreamA = obj1.getRef();
  } else {
    iccProfileStreamA.num = 0;
    iccProfileStreamA.gen = 0;
  }
  obj1.free();
  arr->get(1, &obj1);
  if (!obj1.isStream()) {
    error(-1, "Bad ICCBased color space (stream)");
    obj1.free();
    return NULL;
  }
  dict = obj1.streamGetDict();
  if (!dict->lookup("N", &obj2)->isInt()) {
    error(-1, "Bad ICCBased color space (N)");
    obj2.free();
    obj1.free();
    return NULL;
  }
  nCompsA = obj2.getInt();
  obj2.free();
  if (nCompsA > gfxColorMaxComps) {
    error(-1, "ICCBased color space with too many (%d > %d) components",
      nCompsA, gfxColorMaxComps);
    nCompsA = gfxColorMaxComps;
  }
  if (dict->lookup("Alternate", &obj2)->isNull() ||
      !(altA = GfxColorSpace::parse(&obj2))) {
    switch (nCompsA) {
    case 1:
      altA = new GfxDeviceGrayColorSpace();
      break;
    case 3:
      altA = new GfxDeviceRGBColorSpace();
      break;
    case 4:
      altA = new GfxDeviceCMYKColorSpace();
      break;
    default:
      error(-1, "Bad ICCBased color space - invalid N");
      obj2.free();
      obj1.free();
      return NULL;
    }
  }
  obj2.free();
  cs = new GfxICCBasedColorSpace(nCompsA, altA, &iccProfileStreamA);
  if (dict->lookup("Range", &obj2)->isArray() &&
      obj2.arrayGetLength() == 2 * nCompsA) {
    for (i = 0; i < nCompsA; ++i) {
      obj2.arrayGet(2*i, &obj3);
      cs->rangeMin[i] = obj3.getNum();
      obj3.free();
      obj2.arrayGet(2*i+1, &obj3);
      cs->rangeMax[i] = obj3.getNum();
      obj3.free();
    }
  }
  obj2.free();
  obj1.free();
  return cs;
}
 
void GfxICCBasedColorSpace::getGray(const GfxColor *color, double *gray) const {
  alt->getGray(color, gray);
}
 
void GfxICCBasedColorSpace::getRGB(const GfxColor *color, GfxRGB *rgb) const {
  alt->getRGB(color, rgb);
}
 
void GfxICCBasedColorSpace::getCMYK(const GfxColor *color, GfxCMYK *cmyk) const {
  alt->getCMYK(color, cmyk);
}
 
void GfxICCBasedColorSpace::getDefaultRanges(double *decodeLow,
                         double *decodeRange,
                         int /*maxImgPixel*/) const {
  int i;
 
  for (i = 0; i < nComps; ++i) {
    decodeLow[i] = rangeMin[i];
    decodeRange[i] = rangeMax[i] - rangeMin[i];
  }
}
 
//------------------------------------------------------------------------
// GfxIndexedColorSpace
//------------------------------------------------------------------------
 
GfxIndexedColorSpace::GfxIndexedColorSpace(GfxColorSpace *baseA,
                       int indexHighA) {
  base = baseA;
  indexHigh = indexHighA;
  lookup = (Guchar *)gmalloc((indexHigh + 1) * base->getNComps() *
                 sizeof(Guchar));
}
 
GfxIndexedColorSpace::~GfxIndexedColorSpace() {
  delete base;
  gfree(lookup);
}
 
GfxColorSpace *GfxIndexedColorSpace::copy() const {
  GfxIndexedColorSpace *cs;
 
  cs = new GfxIndexedColorSpace(base->copy(), indexHigh);
  memcpy(cs->lookup, lookup,
     (indexHigh + 1) * base->getNComps() * sizeof(Guchar));
  return cs;
}
 
GfxColorSpace *GfxIndexedColorSpace::parse(Array *arr) {
  GfxIndexedColorSpace *cs;
  GfxColorSpace *baseA;
  int indexHighA;
  Object obj1;
  int x;
  char *s;
  int n, i, j;
 
  if (arr->getLength() != 4) {
    error(-1, "Bad Indexed color space");
    goto err1;
  }
  arr->get(1, &obj1);
  if (!(baseA = GfxColorSpace::parse(&obj1))) {
    error(-1, "Bad Indexed color space (base color space)");
    goto err2;
  }
  obj1.free();
  if (!arr->get(2, &obj1)->isInt()) {
    error(-1, "Bad Indexed color space (hival)");
    goto err2;
  }
  indexHighA = obj1.getInt();
  obj1.free();
  cs = new GfxIndexedColorSpace(baseA, indexHighA);
  arr->get(3, &obj1);
  n = baseA->getNComps();
  if (obj1.isStream()) {
    obj1.streamReset();
    for (i = 0; i <= indexHighA; ++i) {
      for (j = 0; j < n; ++j) {
    if ((x = obj1.streamGetChar()) == EOF) {
      error(-1, "Bad Indexed color space (lookup table stream too short)");
      goto err3;
    }
    cs->lookup[i*n + j] = (Guchar)x;
      }
    }
    obj1.streamClose();
  } else if (obj1.isString()) {
    if (obj1.getString()->getLength() < (indexHighA + 1) * n) {
      error(-1, "Bad Indexed color space (lookup table string too short)");
      goto err3;
    }
    s = obj1.getString()->getCString();
    for (i = 0; i <= indexHighA; ++i) {
      for (j = 0; j < n; ++j) {
    cs->lookup[i*n + j] = (Guchar)*s++;
      }
    }
  } else {
    error(-1, "Bad Indexed color space (lookup table)");
    goto err3;
  }
  obj1.free();
  return cs;
 
 err3:
  delete cs;
 err2:
  obj1.free();
 err1:
  return NULL;
}
 
void GfxIndexedColorSpace::getGray(const GfxColor *color, double *gray) const {
  Guchar *p;
  GfxColor color2;
  double low[gfxColorMaxComps], range[gfxColorMaxComps];
  int n, i;
 
  n = base->getNComps();
  base->getDefaultRanges(low, range, indexHigh);
  p = &lookup[(int)(color->c[0] + 0.5) * n];
  for (i = 0; i < n; ++i) {
    color2.c[i] = low[i] + (p[i] / 255.0) * range[i];
  }
  base->getGray(&color2, gray);
}
 
void GfxIndexedColorSpace::getRGB(const GfxColor *color, GfxRGB *rgb) const {
  Guchar *p;
  GfxColor color2;
  double low[gfxColorMaxComps], range[gfxColorMaxComps];
  int n, i;
 
  n = base->getNComps();
  base->getDefaultRanges(low, range, indexHigh);
  p = &lookup[(int)(color->c[0] + 0.5) * n];
  for (i = 0; i < n; ++i) {
    color2.c[i] = low[i] + (p[i] / 255.0) * range[i];
  }
  base->getRGB(&color2, rgb);
}
 
void GfxIndexedColorSpace::getCMYK(const GfxColor *color, GfxCMYK *cmyk) const {
  Guchar *p;
  GfxColor color2;
  double low[gfxColorMaxComps], range[gfxColorMaxComps];
  int n, i;
 
  n = base->getNComps();
  base->getDefaultRanges(low, range, indexHigh);
  p = &lookup[(int)(color->c[0] + 0.5) * n];
  for (i = 0; i < n; ++i) {
    color2.c[i] = low[i] + (p[i] / 255.0) * range[i];
  }
  base->getCMYK(&color2, cmyk);
}
 
void GfxIndexedColorSpace::getDefaultRanges(double *decodeLow,
                        double *decodeRange,
                        int maxImgPixel) const {
  decodeLow[0] = 0;
  decodeRange[0] = maxImgPixel;
}
 
//------------------------------------------------------------------------
// GfxSeparationColorSpace
//------------------------------------------------------------------------
 
GfxSeparationColorSpace::GfxSeparationColorSpace(GString *nameA,
                         GfxColorSpace *altA,
                         Function *funcA) {
  name = nameA;
  alt = altA;
  func = funcA;
}
 
GfxSeparationColorSpace::~GfxSeparationColorSpace() {
  delete name;
  delete alt;
  delete func;
}
 
GfxColorSpace *GfxSeparationColorSpace::copy() const {
  return new GfxSeparationColorSpace(name->copy(), alt->copy(), func->copy());
}
 
//~ handle the 'All' and 'None' colorants
GfxColorSpace *GfxSeparationColorSpace::parse(Array *arr) {
  GfxSeparationColorSpace *cs;
  GString *nameA;
  GfxColorSpace *altA;
  Function *funcA;
  Object obj1;
 
  if (arr->getLength() != 4) {
    error(-1, "Bad Separation color space");
    goto err1;
  }
  if (!arr->get(1, &obj1)->isName()) {
    error(-1, "Bad Separation color space (name)");
    goto err2;
  }
  nameA = new GString(obj1.getName());
  obj1.free();
  arr->get(2, &obj1);
  if (!(altA = GfxColorSpace::parse(&obj1))) {
    error(-1, "Bad Separation color space (alternate color space)");
    goto err3;
  }
  obj1.free();
  arr->get(3, &obj1);
  if (!(funcA = Function::parse(&obj1))) {
    goto err4;
  }
  obj1.free();
  cs = new GfxSeparationColorSpace(nameA, altA, funcA);
  return cs;
 
 err4:
  delete altA;
 err3:
  delete nameA;
 err2:
  obj1.free();
 err1:
  return NULL;
}
 
void GfxSeparationColorSpace::getGray(const GfxColor *color, double *gray) const {
  GfxColor color2;
 
  func->transform(color->c, color2.c);
  alt->getGray(&color2, gray);
}
 
void GfxSeparationColorSpace::getRGB(const GfxColor *color, GfxRGB *rgb) const {
  GfxColor color2;
 
  func->transform(color->c, color2.c);
  alt->getRGB(&color2, rgb);
}
 
void GfxSeparationColorSpace::getCMYK(const GfxColor *color, GfxCMYK *cmyk) const {
  GfxColor color2;
 
  func->transform(color->c, color2.c);
  alt->getCMYK(&color2, cmyk);
}
 
//------------------------------------------------------------------------
// GfxDeviceNColorSpace
//------------------------------------------------------------------------
 
GfxDeviceNColorSpace::GfxDeviceNColorSpace(int nCompsA,
                       GfxColorSpace *altA,
                       Function *funcA) {
  nComps = nCompsA;
  alt = altA;
  func = funcA;
}
 
GfxDeviceNColorSpace::~GfxDeviceNColorSpace() {
  int i;
 
  for (i = 0; i < nComps; ++i) {
    delete names[i];
  }
  delete alt;
  delete func;
}
 
GfxColorSpace *GfxDeviceNColorSpace::copy() const {
  GfxDeviceNColorSpace *cs;
  int i;
 
  cs = new GfxDeviceNColorSpace(nComps, alt->copy(), func->copy());
  for (i = 0; i < nComps; ++i) {
    cs->names[i] = names[i]->copy();
  }
  return cs;
}
 
//~ handle the 'None' colorant
GfxColorSpace *GfxDeviceNColorSpace::parse(Array *arr) {
  GfxDeviceNColorSpace *cs;
  int nCompsA;
  GString *namesA[gfxColorMaxComps];
  GfxColorSpace *altA;
  Function *funcA;
  Object obj1, obj2;
  int i;
 
  if (arr->getLength() != 4 && arr->getLength() != 5) {
    error(-1, "Bad DeviceN color space");
    goto err1;
  }
  if (!arr->get(1, &obj1)->isArray()) {
    error(-1, "Bad DeviceN color space (names)");
    goto err2;
  }
  nCompsA = obj1.arrayGetLength();
  if (nCompsA > gfxColorMaxComps) {
    error(-1, "DeviceN color space with too many (%d > %d) components",
         nCompsA, gfxColorMaxComps);
    nCompsA = gfxColorMaxComps;
  }
  for (i = 0; i < nCompsA; ++i) {
    if (!obj1.arrayGet(i, &obj2)->isName()) {
      error(-1, "Bad DeviceN color space (names)");
      obj2.free();
      goto err2;
    }
    namesA[i] = new GString(obj2.getName());
    obj2.free();
  }
  obj1.free();
  arr->get(2, &obj1);
  if (!(altA = GfxColorSpace::parse(&obj1))) {
    error(-1, "Bad DeviceN color space (alternate color space)");
    goto err3;
  }
  obj1.free();
  arr->get(3, &obj1);
  if (!(funcA = Function::parse(&obj1))) {
    goto err4;
  }
  obj1.free();
  cs = new GfxDeviceNColorSpace(nCompsA, altA, funcA);
  for (i = 0; i < nCompsA; ++i) {
    cs->names[i] = namesA[i];
  }
  return cs;
 
 err4:
  delete altA;
 err3:
  for (i = 0; i < nCompsA; ++i) {
    delete namesA[i];
  }
 err2:
  obj1.free();
 err1:
  return NULL;
}
 
void GfxDeviceNColorSpace::getGray(const GfxColor *color, double *gray) const {
  GfxColor color2;
 
  func->transform(color->c, color2.c);
  alt->getGray(&color2, gray);
}
 
void GfxDeviceNColorSpace::getRGB(const GfxColor *color, GfxRGB *rgb) const {
  GfxColor color2;
 
  func->transform(color->c, color2.c);
  alt->getRGB(&color2, rgb);
}
 
void GfxDeviceNColorSpace::getCMYK(const GfxColor *color, GfxCMYK *cmyk) const {
  GfxColor color2;
 
  func->transform(color->c, color2.c);
  alt->getCMYK(&color2, cmyk);
}
 
//------------------------------------------------------------------------
// GfxPatternColorSpace
//------------------------------------------------------------------------
 
GfxPatternColorSpace::GfxPatternColorSpace(GfxColorSpace *underA) {
  under = underA;
}
 
GfxPatternColorSpace::~GfxPatternColorSpace() {
  if (under) {
    delete under;
  }
}
 
GfxColorSpace *GfxPatternColorSpace::copy() const {
  return new GfxPatternColorSpace(under ? under->copy() :
                          (GfxColorSpace *)NULL);
}
 
GfxColorSpace *GfxPatternColorSpace::parse(Array *arr) {
  GfxPatternColorSpace *cs;
  GfxColorSpace *underA;
  Object obj1;
 
  if (arr->getLength() != 1 && arr->getLength() != 2) {
    error(-1, "Bad Pattern color space");
    return NULL;
  }
  underA = NULL;
  if (arr->getLength() == 2) {
    arr->get(1, &obj1);
    if (!(underA = GfxColorSpace::parse(&obj1))) {
      error(-1, "Bad Pattern color space (underlying color space)");
      obj1.free();
      return NULL;
    }
    obj1.free();
  }
  cs = new GfxPatternColorSpace(underA);
  return cs;
}
 
void GfxPatternColorSpace::getGray(const GfxColor */*color*/, double *gray) const {
  *gray = 0;
}
 
void GfxPatternColorSpace::getRGB(const GfxColor */*color*/, GfxRGB *rgb) const {
  rgb->r = rgb->g = rgb->b = 0;
}
 
void GfxPatternColorSpace::getCMYK(const GfxColor */*color*/, GfxCMYK *cmyk) const {
  cmyk->c = cmyk->m = cmyk->y = 0;
  cmyk->k = 1;
}
 
//------------------------------------------------------------------------
// Pattern
//------------------------------------------------------------------------
 
GfxPattern::GfxPattern(int typeA) {
  type = typeA;
}
 
GfxPattern::~GfxPattern() {
}
 
GfxPattern *GfxPattern::parse(Object *obj) {
  GfxPattern *pattern;
  Dict *dict;
  Object obj1;
 
  pattern = NULL;
  if (obj->isStream()) {
    dict = obj->streamGetDict();
    dict->lookup("PatternType", &obj1);
    if (obj1.isInt() && obj1.getInt() == 1) {
      pattern = new GfxTilingPattern(dict, obj);
    }
    obj1.free();
  }
  return pattern;
}
 
//------------------------------------------------------------------------
// GfxTilingPattern
//------------------------------------------------------------------------
 
GfxTilingPattern::GfxTilingPattern(Dict *streamDict, Object *stream):
  GfxPattern(1)
{
  Object obj1, obj2;
  int i;
 
  if (streamDict->lookup("PaintType", &obj1)->isInt()) {
    paintType = obj1.getInt();
  } else {
    paintType = 1;
    error(-1, "Invalid or missing PaintType in pattern");
  }
  obj1.free();
  if (streamDict->lookup("TilingType", &obj1)->isInt()) {
    tilingType = obj1.getInt();
  } else {
    tilingType = 1;
    error(-1, "Invalid or missing TilingType in pattern");
  }
  obj1.free();
  bbox[0] = bbox[1] = 0;
  bbox[2] = bbox[3] = 1;
  if (streamDict->lookup("BBox", &obj1)->isArray() &&
      obj1.arrayGetLength() == 4) {
    for (i = 0; i < 4; ++i) {
      if (obj1.arrayGet(i, &obj2)->isNum()) {
    bbox[i] = obj2.getNum();
      }
      obj2.free();
    }
  } else {
    error(-1, "Invalid or missing BBox in pattern");
  }
  obj1.free();
  if (streamDict->lookup("XStep", &obj1)->isNum()) {
    xStep = obj1.getNum();
  } else {
    xStep = 1;
    error(-1, "Invalid or missing XStep in pattern");
  }
  obj1.free();
  if (streamDict->lookup("YStep", &obj1)->isNum()) {
    yStep = obj1.getNum();
  } else {
    yStep = 1;
    error(-1, "Invalid or missing YStep in pattern");
  }
  obj1.free();
  if (!streamDict->lookup("Resources", &resDict)->isDict()) {
    resDict.free();
    resDict.initNull();
    error(-1, "Invalid or missing Resources in pattern");
  }
  matrix[0] = 1; matrix[1] = 0;
  matrix[2] = 0; matrix[3] = 1;
  matrix[4] = 0; matrix[5] = 0;
  if (streamDict->lookup("Matrix", &obj1)->isArray() &&
      obj1.arrayGetLength() == 6) {
    for (i = 0; i < 6; ++i) {
      if (obj1.arrayGet(i, &obj2)->isNum()) {
    matrix[i] = obj2.getNum();
      }
      obj2.free();
    }
  }
  obj1.free();
  stream->copy(&contentStream);
}
 
GfxTilingPattern::~GfxTilingPattern() {
  resDict.free();
  contentStream.free();
}
 
GfxPattern *GfxTilingPattern::copy() {
  return new GfxTilingPattern(this);
}
 
GfxTilingPattern::GfxTilingPattern(GfxTilingPattern *pat):
  GfxPattern(1)
{
  memcpy(this, pat, sizeof(GfxTilingPattern));
  pat->resDict.copy(&resDict);
  pat->contentStream.copy(&contentStream);
}
 
//------------------------------------------------------------------------
// GfxShading
//------------------------------------------------------------------------
 
GfxShading::GfxShading() {
}
 
GfxShading::~GfxShading() {
  delete colorSpace;
}
 
GfxShading *GfxShading::parse(Object *obj) {
  GfxShading *shading;
  int typeA;
  GfxColorSpace *colorSpaceA;
  GfxColor backgroundA;
  GBool hasBackgroundA;
  double xMinA, yMinA, xMaxA, yMaxA;
  GBool hasBBoxA;
  Object obj1, obj2;
  int i;
 
  shading = NULL;
  if (obj->isDict()) {
 
    if (!obj->dictLookup("ShadingType", &obj1)->isInt()) {
      error(-1, "Invalid ShadingType in shading dictionary");
      obj1.free();
      goto err1;
    }
    typeA = obj1.getInt();
    obj1.free();
 
    obj->dictLookup("ColorSpace", &obj1);
    if (!(colorSpaceA = GfxColorSpace::parse(&obj1))) {
      error(-1, "Bad color space in shading dictionary");
      obj1.free();
      goto err1;
    }
    obj1.free();
 
    for (i = 0; i < gfxColorMaxComps; ++i) {
      backgroundA.c[i] = 0;
    }
    hasBackgroundA = gFalse;
    if (obj->dictLookup("Background", &obj1)->isArray()) {
      if (obj1.arrayGetLength() == colorSpaceA->getNComps()) {
    hasBackgroundA = gTrue;
    for (i = 0; i < colorSpaceA->getNComps(); ++i) {
      backgroundA.c[i] = obj1.arrayGet(i, &obj2)->getNum();
      obj2.free();
    }
      } else {
    error(-1, "Bad Background in shading dictionary");
      }
    }
    obj1.free();
 
    xMinA = yMinA = xMaxA = yMaxA = 0;
    hasBBoxA = gFalse;
    if (obj->dictLookup("BBox", &obj1)->isArray()) {
      if (obj1.arrayGetLength() == 4) {
    hasBBoxA = gTrue;
    xMinA = obj1.arrayGet(0, &obj2)->getNum();
    obj2.free();
    yMinA = obj1.arrayGet(1, &obj2)->getNum();
    obj2.free();
    xMaxA = obj1.arrayGet(2, &obj2)->getNum();
    obj2.free();
    yMaxA = obj1.arrayGet(3, &obj2)->getNum();
    obj2.free();
      } else {
    error(-1, "Bad BBox in shading dictionary");
      }
    }
    obj1.free();
 
    switch (typeA) {
    case 2:
      shading = GfxAxialShading::parse(obj->getDict());
      break;
    case 3:
      shading = GfxRadialShading::parse(obj->getDict());
      break;
    default:
      error(-1, "Unimplemented shading type %d", typeA);
      goto err1;
    }
 
    if (shading) {
      shading->type = typeA;
      shading->colorSpace = colorSpaceA;
      shading->background = backgroundA;
      shading->hasBackground = hasBackgroundA;
      shading->xMin = xMinA;
      shading->yMin = yMinA;
      shading->xMax = xMaxA;
      shading->yMax = yMaxA;
      shading->hasBBox = hasBBoxA;
    } else {
      delete colorSpaceA;
    }
  }
 
  return shading;
 
 err1:
  return NULL;
}
 
//------------------------------------------------------------------------
// GfxAxialShading
//------------------------------------------------------------------------
 
GfxAxialShading::GfxAxialShading(double x0A, double y0A,
                 double x1A, double y1A,
                 double t0A, double t1A,
                 Function **funcsA, int nFuncsA,
                 GBool extend0A, GBool extend1A) {
  int i;
 
  x0 = x0A;
  y0 = y0A;
  x1 = x1A;
  y1 = y1A;
  t0 = t0A;
  t1 = t1A;
  nFuncs = nFuncsA;
  for (i = 0; i < nFuncs; ++i) {
    funcs[i] = funcsA[i];
  }
  extend0 = extend0A;
  extend1 = extend1A;
}
 
GfxAxialShading::~GfxAxialShading() {
  int i;
 
  for (i = 0; i < nFuncs; ++i) {
    delete funcs[i];
  }
}
 
GfxAxialShading *GfxAxialShading::parse(Dict *dict) {
  double x0A, y0A, x1A, y1A;
  double t0A, t1A;
  Function *funcsA[gfxColorMaxComps];
  int nFuncsA;
  GBool extend0A, extend1A;
  Object obj1, obj2;
  int i;
 
  x0A = y0A = x1A = y1A = 0;
  if (dict->lookup("Coords", &obj1)->isArray() &&
      obj1.arrayGetLength() == 4) {
    x0A = obj1.arrayGet(0, &obj2)->getNum();
    obj2.free();
    y0A = obj1.arrayGet(1, &obj2)->getNum();
    obj2.free();
    x1A = obj1.arrayGet(2, &obj2)->getNum();
    obj2.free();
    y1A = obj1.arrayGet(3, &obj2)->getNum();
    obj2.free();
  } else {
    error(-1, "Missing or invalid Coords in shading dictionary");
    goto err1;
  }
  obj1.free();
 
  t0A = 0;
  t1A = 1;
  if (dict->lookup("Domain", &obj1)->isArray() &&
      obj1.arrayGetLength() == 2) {
    t0A = obj1.arrayGet(0, &obj2)->getNum();
    obj2.free();
    t1A = obj1.arrayGet(1, &obj2)->getNum();
    obj2.free();
  }
  obj1.free();
 
  dict->lookup("Function", &obj1);
  if (obj1.isArray()) {
    nFuncsA = obj1.arrayGetLength();
    for (i = 0; i < nFuncsA; ++i) {
      obj1.arrayGet(i, &obj2);
      if (!(funcsA[i] = Function::parse(&obj2))) {
    obj1.free();
    obj2.free();
    goto err1;
      }
      obj2.free();
    }
  } else {
    nFuncsA = 1;
    if (!(funcsA[0] = Function::parse(&obj1))) {
      obj1.free();
      goto err1;
    }
  }
  obj1.free();
 
  extend0A = extend1A = gFalse;
  if (dict->lookup("Extend", &obj1)->isArray() &&
      obj1.arrayGetLength() == 2) {
    extend0A = obj1.arrayGet(0, &obj2)->getBool();
    obj2.free();
    extend1A = obj1.arrayGet(1, &obj2)->getBool();
    obj2.free();
  }
  obj1.free();
 
  return new GfxAxialShading(x0A, y0A, x1A, y1A, t0A, t1A,
                 funcsA, nFuncsA, extend0A, extend1A);
 
 err1:
  return NULL;
}
 
void GfxAxialShading::getColor(double t, GfxColor *color) {
  int i;
 
  for (i = 0; i < nFuncs; ++i) {
    funcs[i]->transform(&t, &color->c[i]);
  }
}
 
//------------------------------------------------------------------------
// GfxRadialShading
//------------------------------------------------------------------------
 
GfxRadialShading::GfxRadialShading(double x0A, double y0A, double r0A,
                   double x1A, double y1A, double r1A,
                   double t0A, double t1A,
                   Function **funcsA, int nFuncsA,
                   GBool extend0A, GBool extend1A) {
  int i;
 
  x0 = x0A;
  y0 = y0A;
  r0 = r0A;
  x1 = x1A;
  y1 = y1A;
  r1 = r1A;
  t0 = t0A;
  t1 = t1A;
  nFuncs = nFuncsA;
  for (i = 0; i < nFuncs; ++i) {
    funcs[i] = funcsA[i];
  }
  extend0 = extend0A;
  extend1 = extend1A;
}
 
GfxRadialShading::~GfxRadialShading() {
  int i;
 
  for (i = 0; i < nFuncs; ++i) {
    delete funcs[i];
  }
}
 
GfxRadialShading *GfxRadialShading::parse(Dict *dict) {
  double x0A, y0A, r0A, x1A, y1A, r1A;
  double t0A, t1A;
  Function *funcsA[gfxColorMaxComps];
  int nFuncsA;
  GBool extend0A, extend1A;
  Object obj1, obj2;
  int i;
 
  x0A = y0A = r0A = x1A = y1A = r1A = 0;
  if (dict->lookup("Coords", &obj1)->isArray() &&
      obj1.arrayGetLength() == 6) {
    x0A = obj1.arrayGet(0, &obj2)->getNum();
    obj2.free();
    y0A = obj1.arrayGet(1, &obj2)->getNum();
    obj2.free();
    r0A = obj1.arrayGet(2, &obj2)->getNum();
    obj2.free();
    x1A = obj1.arrayGet(3, &obj2)->getNum();
    obj2.free();
    y1A = obj1.arrayGet(4, &obj2)->getNum();
    obj2.free();
    r1A = obj1.arrayGet(5, &obj2)->getNum();
    obj2.free();
  } else {
    error(-1, "Missing or invalid Coords in shading dictionary");
    goto err1;
  }
  obj1.free();
 
  t0A = 0;
  t1A = 1;
  if (dict->lookup("Domain", &obj1)->isArray() &&
      obj1.arrayGetLength() == 2) {
    t0A = obj1.arrayGet(0, &obj2)->getNum();
    obj2.free();
    t1A = obj1.arrayGet(1, &obj2)->getNum();
    obj2.free();
  }
  obj1.free();
 
  dict->lookup("Function", &obj1);
  if (obj1.isArray()) {
    nFuncsA = obj1.arrayGetLength();
    for (i = 0; i < nFuncsA; ++i) {
      obj1.arrayGet(i, &obj2);
      if (!(funcsA[i] = Function::parse(&obj2))) {
    obj1.free();
    obj2.free();
    goto err1;
      }
      obj2.free();
    }
  } else {
    nFuncsA = 1;
    if (!(funcsA[0] = Function::parse(&obj1))) {
      obj1.free();
      goto err1;
    }
  }
  obj1.free();
 
  extend0A = extend1A = gFalse;
  if (dict->lookup("Extend", &obj1)->isArray() &&
      obj1.arrayGetLength() == 2) {
    extend0A = obj1.arrayGet(0, &obj2)->getBool();
    obj2.free();
    extend1A = obj1.arrayGet(1, &obj2)->getBool();
    obj2.free();
  }
  obj1.free();
 
  return new GfxRadialShading(x0A, y0A, r0A, x1A, y1A, r1A, t0A, t1A,
                  funcsA, nFuncsA, extend0A, extend1A);
 
 err1:
  return NULL;
}
 
void GfxRadialShading::getColor(double t, GfxColor *color) {
  int i;
 
  for (i = 0; i < nFuncs; ++i) {
    funcs[i]->transform(&t, &color->c[i]);
  }
}
 
//------------------------------------------------------------------------
// GfxImageColorMap
//------------------------------------------------------------------------
 
GfxImageColorMap::GfxImageColorMap(int bitsA, Object *decode,
                   GfxColorSpace *colorSpaceA) {
  GfxIndexedColorSpace *indexedCS;
  GfxSeparationColorSpace *sepCS;
  int maxPixel, indexHigh;
  const Guchar *lookup2;
  const Function *sepFunc;
  Object obj;
  double x[gfxColorMaxComps];
  double y[gfxColorMaxComps];
  int i, j, k;
 
  ok = gTrue;
 
  // bits per component and color space
  bits = bitsA;
  maxPixel = (1 << bits) - 1;
  colorSpace = colorSpaceA;
 
  // get decode map
  if (decode->isNull()) {
    nComps = colorSpace->getNComps();
    colorSpace->getDefaultRanges(decodeLow, decodeRange, maxPixel);
  } else if (decode->isArray()) {
    nComps = decode->arrayGetLength() / 2;
    if (nComps != colorSpace->getNComps()) {
      goto err1;
    }
    for (i = 0; i < nComps; ++i) {
      decode->arrayGet(2*i, &obj);
      if (!obj.isNum()) {
    goto err2;
      }
      decodeLow[i] = obj.getNum();
      obj.free();
      decode->arrayGet(2*i+1, &obj);
      if (!obj.isNum()) {
    goto err2;
      }
      decodeRange[i] = obj.getNum() - decodeLow[i];
      obj.free();
    }
  } else {
    goto err1;
  }
 
  // Construct a lookup table -- this stores pre-computed decoded
  // values for each component, i.e., the result of applying the
  // decode mapping to each possible image pixel component value.
  //
  // Optimization: for Indexed and Separation color spaces (which have
  // only one component), we store color values in the lookup table
  // rather than component values.
  colorSpace2 = NULL;
  nComps2 = 0;
  if (colorSpace->getMode() == csIndexed) {
    // Note that indexHigh may not be the same as maxPixel --
    // Distiller will remove unused palette entries, resulting in
    // indexHigh < maxPixel.
    indexedCS = (GfxIndexedColorSpace *)colorSpace;
    colorSpace2 = indexedCS->getBase();
    indexHigh = indexedCS->getIndexHigh();
    nComps2 = colorSpace2->getNComps();
    lookup = (double *)gmalloc((indexHigh + 1) * nComps2 * sizeof(double));
    lookup2 = indexedCS->getLookup();
    colorSpace2->getDefaultRanges(x, y, indexHigh);
    for (i = 0; i <= indexHigh; ++i) {
      j = (int)(decodeLow[0] + (i * decodeRange[0]) / maxPixel + 0.5);
      for (k = 0; k < nComps2; ++k) {
    lookup[j*nComps2 + k] = x[k] + (lookup2[i*nComps2 + k] / 255.0) * y[k];
      }
    }
  } else if (colorSpace->getMode() == csSeparation) {
    sepCS = (GfxSeparationColorSpace *)colorSpace;
    colorSpace2 = sepCS->getAlt();
    nComps2 = colorSpace2->getNComps();
    lookup = (double *)gmalloc((maxPixel + 1) * nComps2 * sizeof(double));
    sepFunc = sepCS->getFunc();
    for (i = 0; i <= maxPixel; ++i) {
      x[0] = decodeLow[0] + (i * decodeRange[0]) / maxPixel;
      sepFunc->transform(x, y);
      for (k = 0; k < nComps2; ++k) {
    lookup[i*nComps2 + k] = y[k];
      }
    }
  } else {
    lookup = (double *)gmalloc((maxPixel + 1) * nComps * sizeof(double));
    for (i = 0; i <= maxPixel; ++i) {
      for (k = 0; k < nComps; ++k) {
    lookup[i*nComps + k] = decodeLow[k] +
                             (i * decodeRange[k]) / maxPixel;
      }
    }
  }
 
  return;
 
 err2:
  obj.free();
 err1:
  ok = gFalse;
}
 
GfxImageColorMap::~GfxImageColorMap() {
  delete colorSpace;
  gfree(lookup);
}
 
void GfxImageColorMap::getGray(Guchar *x, double *gray) {
  GfxColor color;
  double *p;
  int i;
 
  if (colorSpace2) {
    p = &lookup[x[0] * nComps2];
    for (i = 0; i < nComps2; ++i) {
      color.c[i] = *p++;
    }
    colorSpace2->getGray(&color, gray);
  } else {
    for (i = 0; i < nComps; ++i) {
      color.c[i] = lookup[x[i] * nComps + i];
    }
    colorSpace->getGray(&color, gray);
  }
}
 
void GfxImageColorMap::getRGB(Guchar *x, GfxRGB *rgb) {
  GfxColor color;
  double *p;
  int i;
 
  if (colorSpace2) {
    p = &lookup[x[0] * nComps2];
    for (i = 0; i < nComps2; ++i) {
      color.c[i] = *p++;
    }
    colorSpace2->getRGB(&color, rgb);
  } else {
    for (i = 0; i < nComps; ++i) {
      color.c[i] = lookup[x[i] * nComps + i];
    }
    colorSpace->getRGB(&color, rgb);
  }
}
 
void GfxImageColorMap::getCMYK(Guchar *x, GfxCMYK *cmyk) {
  GfxColor color;
  double *p;
  int i;
 
  if (colorSpace2) {
    p = &lookup[x[0] * nComps2];
    for (i = 0; i < nComps2; ++i) {
      color.c[i] = *p++;
    }
    colorSpace2->getCMYK(&color, cmyk);
  } else {
    for (i = 0; i < nComps; ++i) {
      color.c[i] = lookup[x[i] * nComps + i];
    }
    colorSpace->getCMYK(&color, cmyk);
  }
}
 
//------------------------------------------------------------------------
// GfxSubpath and GfxPath
//------------------------------------------------------------------------
 
GfxSubpath::GfxSubpath(double x1, double y1) {
  size = 16;
  x = (double *)gmalloc(size * sizeof(double));
  y = (double *)gmalloc(size * sizeof(double));
  curve = (GBool *)gmalloc(size * sizeof(GBool));
  n = 1;
  x[0] = x1;
  y[0] = y1;
  curve[0] = gFalse;
  closed = gFalse;
}
 
GfxSubpath::~GfxSubpath() {
  gfree(x);
  gfree(y);
  gfree(curve);
}
 
// Used for copy().
GfxSubpath::GfxSubpath(GfxSubpath *subpath) {
  size = subpath->size;
  n = subpath->n;
  x = (double *)gmalloc(size * sizeof(double));
  y = (double *)gmalloc(size * sizeof(double));
  curve = (GBool *)gmalloc(size * sizeof(GBool));
  memcpy(x, subpath->x, n * sizeof(double));
  memcpy(y, subpath->y, n * sizeof(double));
  memcpy(curve, subpath->curve, n * sizeof(GBool));
  closed = subpath->closed;
}
 
void GfxSubpath::lineTo(double x1, double y1) {
  if (n >= size) {
    size += 16;
    x = (double *)grealloc(x, size * sizeof(double));
    y = (double *)grealloc(y, size * sizeof(double));
    curve = (GBool *)grealloc(curve, size * sizeof(GBool));
  }
  x[n] = x1;
  y[n] = y1;
  curve[n] = gFalse;
  ++n;
}
 
void GfxSubpath::curveTo(double x1, double y1, double x2, double y2,
             double x3, double y3) {
  if (n+3 > size) {
    size += 16;
    x = (double *)grealloc(x, size * sizeof(double));
    y = (double *)grealloc(y, size * sizeof(double));
    curve = (GBool *)grealloc(curve, size * sizeof(GBool));
  }
  x[n] = x1;
  y[n] = y1;
  x[n+1] = x2;
  y[n+1] = y2;
  x[n+2] = x3;
  y[n+2] = y3;
  curve[n] = curve[n+1] = gTrue;
  curve[n+2] = gFalse;
  n += 3;
}
 
void GfxSubpath::close() {
  if (x[n-1] != x[0] || y[n-1] != y[0]) {
    lineTo(x[0], y[0]);
  }
  closed = gTrue;
}
 
GfxPath::GfxPath() {
  justMoved = gFalse;
  size = 16;
  n = 0;
  firstX = firstY = 0;
  subpaths = (GfxSubpath **)gmalloc(size * sizeof(GfxSubpath *));
}
 
GfxPath::~GfxPath() {
  int i;
 
  for (i = 0; i < n; ++i)
    delete subpaths[i];
  gfree(subpaths);
}
 
// Used for copy().
GfxPath::GfxPath(GBool justMoved1, double firstX1, double firstY1,
         GfxSubpath **subpaths1, int n1, int size1) {
  int i;
 
  justMoved = justMoved1;
  firstX = firstX1;
  firstY = firstY1;
  size = size1;
  n = n1;
  subpaths = (GfxSubpath **)gmalloc(size * sizeof(GfxSubpath *));
  for (i = 0; i < n; ++i)
    subpaths[i] = subpaths1[i]->copy();
}
 
void GfxPath::moveTo(double x, double y) {
  justMoved = gTrue;
  firstX = x;
  firstY = y;
}
 
void GfxPath::lineTo(double x, double y) {
  if (justMoved) {
    if (n >= size) {
      size += 16;
      subpaths = (GfxSubpath **)
               grealloc(subpaths, size * sizeof(GfxSubpath *));
    }
    subpaths[n] = new GfxSubpath(firstX, firstY);
    ++n;
    justMoved = gFalse;
  }
  subpaths[n-1]->lineTo(x, y);
}
 
void GfxPath::curveTo(double x1, double y1, double x2, double y2,
         double x3, double y3) {
  if (justMoved) {
    if (n >= size) {
      size += 16;
      subpaths = (GfxSubpath **)
               grealloc(subpaths, size * sizeof(GfxSubpath *));
    }
    subpaths[n] = new GfxSubpath(firstX, firstY);
    ++n;
    justMoved = gFalse;
  }
  subpaths[n-1]->curveTo(x1, y1, x2, y2, x3, y3);
}
 
void GfxPath::close() {
  // this is necessary to handle the pathological case of
  // moveto/closepath/clip, which defines an empty clipping region
  if (justMoved) {
    if (n >= size) {
      size += 16;
      subpaths = (GfxSubpath **)
               grealloc(subpaths, size * sizeof(GfxSubpath *));
    }
    subpaths[n] = new GfxSubpath(firstX, firstY);
    ++n;
    justMoved = gFalse;
  }
  subpaths[n-1]->close();
}
 
//------------------------------------------------------------------------
// GfxState
//------------------------------------------------------------------------
 
GfxState::GfxState(double dpi, PDFRectangle *pageBox, int rotate,
           GBool upsideDown) {
  double k;
 
  px1 = pageBox->x1;
  py1 = pageBox->y1;
  px2 = pageBox->x2;
  py2 = pageBox->y2;
  k = dpi / 72.0;
  if (rotate == 90) {
    ctm[0] = 0;
    ctm[1] = upsideDown ? k : -k;
    ctm[2] = k;
    ctm[3] = 0;
    ctm[4] = -k * py1;
    ctm[5] = k * (upsideDown ? -px1 : px2);
    pageWidth = k * (py2 - py1);
    pageHeight = k * (px2 - px1);
  } else if (rotate == 180) {
    ctm[0] = -k;
    ctm[1] = 0;
    ctm[2] = 0;
    ctm[3] = upsideDown ? k : -k;
    ctm[4] = k * px2;
    ctm[5] = k * (upsideDown ? -py1 : py2);
    pageWidth = k * (px2 - px1);
    pageHeight = k * (py2 - py1);
  } else if (rotate == 270) {
    ctm[0] = 0;
    ctm[1] = upsideDown ? -k : k;
    ctm[2] = -k;
    ctm[3] = 0;
    ctm[4] = k * py2;
    ctm[5] = k * (upsideDown ? px2 : -px1);
    pageWidth = k * (py2 - py1);
    pageHeight = k * (px2 - px1);
  } else {
    ctm[0] = k;
    ctm[1] = 0;
    ctm[2] = 0;
    ctm[3] = upsideDown ? -k : k;
    ctm[4] = -k * px1;
    ctm[5] = k * (upsideDown ? py2 : -py1);
    pageWidth = k * (px2 - px1);
    pageHeight = k * (py2 - py1);
  }
 
  fillColorSpace = new GfxDeviceGrayColorSpace();
  strokeColorSpace = new GfxDeviceGrayColorSpace();
  fillColor.c[0] = 0;
  strokeColor.c[0] = 0;
  fillPattern = NULL;
  strokePattern = NULL;
  fillOpacity = 1;
  strokeOpacity = 1;
 
  lineWidth = 1;
  lineDash = NULL;
  lineDashLength = 0;
  lineDashStart = 0;
  flatness = 0;
  lineJoin = 0;
  lineCap = 0;
  miterLimit = 10;
 
  font = NULL;
  fontSize = 0;
  textMat[0] = 1; textMat[1] = 0;
  textMat[2] = 0; textMat[3] = 1;
  textMat[4] = 0; textMat[5] = 0;
  charSpace = 0;
  wordSpace = 0;
  horizScaling = 1;
  leading = 0;
  rise = 0;
  render = 0;
 
  path = new GfxPath();
  curX = curY = 0;
  lineX = lineY = 0;
 
  clipXMin = 0;
  clipYMin = 0;
  clipXMax = pageWidth;
  clipYMax = pageHeight;
 
  saved = NULL;
}
 
GfxState::~GfxState() {
  if (fillColorSpace) {
    delete fillColorSpace;
  }
  if (strokeColorSpace) {
    delete strokeColorSpace;
  }
  if (fillPattern) {
    delete fillPattern;
  }
  if (strokePattern) {
    delete strokePattern;
  }
  gfree(lineDash);
  if (path) {
    // this gets set to NULL by restore()
    delete path;
  }
  if (saved) {
    delete saved;
  }
}
 
// Used for copy();
GfxState::GfxState(const GfxState *state) {
  memcpy(this, state, sizeof(GfxState));
  if (fillColorSpace) {
    fillColorSpace = state->fillColorSpace->copy();
  }
  if (strokeColorSpace) {
    strokeColorSpace = state->strokeColorSpace->copy();
  }
  if (fillPattern) {
    fillPattern = state->fillPattern->copy();
  }
  if (strokePattern) {
    strokePattern = state->strokePattern->copy();
  }
  if (lineDashLength > 0) {
    lineDash = (double *)gmalloc(lineDashLength * sizeof(double));
    memcpy(lineDash, state->lineDash, lineDashLength * sizeof(double));
  }
  saved = NULL;
}
 
void GfxState::getUserClipBBox(double *xMin, double *yMin,
                   double *xMax, double *yMax) const {
  double ictm[6];
  double xMin1, yMin1, xMax1, yMax1, det, tx, ty;
 
  // invert the CTM
  det = 1 / (ctm[0] * ctm[3] - ctm[1] * ctm[2]);
  ictm[0] = ctm[3] * det;
  ictm[1] = -ctm[1] * det;
  ictm[2] = -ctm[2] * det;
  ictm[3] = ctm[0] * det;
  ictm[4] = (ctm[2] * ctm[5] - ctm[3] * ctm[4]) * det;
  ictm[5] = (ctm[1] * ctm[4] - ctm[0] * ctm[5]) * det;
 
  // transform all four corners of the clip bbox; find the min and max
  // x and y values
  xMin1 = xMax1 = clipXMin * ictm[0] + clipYMin * ictm[2] + ictm[4];
  yMin1 = yMax1 = clipXMin * ictm[1] + clipYMin * ictm[3] + ictm[5];
  tx = clipXMin * ictm[0] + clipYMax * ictm[2] + ictm[4];
  ty = clipXMin * ictm[1] + clipYMax * ictm[3] + ictm[5];
  if (tx < xMin1) {
    xMin1 = tx;
  } else if (tx > xMax1) {
    xMax1 = tx;
  }
  if (ty < yMin1) {
    yMin1 = ty;
  } else if (ty > yMax1) {
    yMax1 = ty;
  }
  tx = clipXMax * ictm[0] + clipYMin * ictm[2] + ictm[4];
  ty = clipXMax * ictm[1] + clipYMin * ictm[3] + ictm[5];
  if (tx < xMin1) {
    xMin1 = tx;
  } else if (tx > xMax1) {
    xMax1 = tx;
  }
  if (ty < yMin1) {
    yMin1 = ty;
  } else if (ty > yMax1) {
    yMax1 = ty;
  }
  tx = clipXMax * ictm[0] + clipYMax * ictm[2] + ictm[4];
  ty = clipXMax * ictm[1] + clipYMax * ictm[3] + ictm[5];
  if (tx < xMin1) {
    xMin1 = tx;
  } else if (tx > xMax1) {
    xMax1 = tx;
  }
  if (ty < yMin1) {
    yMin1 = ty;
  } else if (ty > yMax1) {
    yMax1 = ty;
  }
 
  *xMin = xMin1;
  *yMin = yMin1;
  *xMax = xMax1;
  *yMax = yMax1;
}
 
double GfxState::transformWidth(double w) {
  double x, y;
 
  x = ctm[0] + ctm[2];
  y = ctm[1] + ctm[3];
  return w * sqrt(0.5 * (x * x + y * y));
}
 
double GfxState::getTransformedFontSize() {
  double x1, y1, x2, y2;
 
  x1 = textMat[2] * fontSize;
  y1 = textMat[3] * fontSize;
  x2 = ctm[0] * x1 + ctm[2] * y1;
  y2 = ctm[1] * x1 + ctm[3] * y1;
  return sqrt(x2 * x2 + y2 * y2);
}
 
void GfxState::getFontTransMat(double *m11, double *m12,
                   double *m21, double *m22) {
  *m11 = (textMat[0] * ctm[0] + textMat[1] * ctm[2]) * fontSize;
  *m12 = (textMat[0] * ctm[1] + textMat[1] * ctm[3]) * fontSize;
  *m21 = (textMat[2] * ctm[0] + textMat[3] * ctm[2]) * fontSize;
  *m22 = (textMat[2] * ctm[1] + textMat[3] * ctm[3]) * fontSize;
}
 
void GfxState::setCTM(double a, double b, double c,
              double d, double e, double f) {
  int i;
 
  ctm[0] = a;
  ctm[1] = b;
  ctm[2] = c;
  ctm[3] = d;
  ctm[4] = e;
  ctm[5] = f;
 
  // avoid FP exceptions on badly messed up PDF files
  for (i = 0; i < 6; ++i) {
    if (ctm[i] > 1e10) {
      ctm[i] = 1e10;
    } else if (ctm[i] < -1e10) {
      ctm[i] = -1e10;
    }
  }
}
 
void GfxState::concatCTM(double a, double b, double c,
             double d, double e, double f) {
  double a1 = ctm[0];
  double b1 = ctm[1];
  double c1 = ctm[2];
  double d1 = ctm[3];
  int i;
 
  ctm[0] = a * a1 + b * c1;
  ctm[1] = a * b1 + b * d1;
  ctm[2] = c * a1 + d * c1;
  ctm[3] = c * b1 + d * d1;
  ctm[4] = e * a1 + f * c1 + ctm[4];
  ctm[5] = e * b1 + f * d1 + ctm[5];
 
  // avoid FP exceptions on badly messed up PDF files
  for (i = 0; i < 6; ++i) {
    if (ctm[i] > 1e10) {
      ctm[i] = 1e10;
    } else if (ctm[i] < -1e10) {
      ctm[i] = -1e10;
    }
  }
}
 
void GfxState::setFillColorSpace(GfxColorSpace *colorSpace) {
  if (fillColorSpace) {
    delete fillColorSpace;
  }
  fillColorSpace = colorSpace;
}
 
void GfxState::setStrokeColorSpace(GfxColorSpace *colorSpace) {
  if (strokeColorSpace) {
    delete strokeColorSpace;
  }
  strokeColorSpace = colorSpace;
}
 
void GfxState::setFillPattern(GfxPattern *pattern) {
  if (fillPattern) {
    delete fillPattern;
  }
  fillPattern = pattern;
}
 
void GfxState::setStrokePattern(GfxPattern *pattern) {
  if (strokePattern) {
    delete strokePattern;
  }
  strokePattern = pattern;
}
 
void GfxState::setLineDash(double *dash, int length, double start) {
  if (lineDash)
    gfree(lineDash);
  lineDash = dash;
  lineDashLength = length;
  lineDashStart = start;
}
 
void GfxState::clearPath() {
  delete path;
  path = new GfxPath();
}
 
void GfxState::clip() {
  double xMin, yMin, xMax, yMax, x, y;
  GfxSubpath *subpath;
  int i, j;
 
  xMin = xMax = yMin = yMax = 0; // make gcc happy
  for (i = 0; i < path->getNumSubpaths(); ++i) {
    subpath = path->getSubpath(i);
    for (j = 0; j < subpath->getNumPoints(); ++j) {
      transform(subpath->getX(j), subpath->getY(j), &x, &y);
      if (i == 0 && j == 0) {
    xMin = xMax = x;
    yMin = yMax = y;
      } else {
    if (x < xMin) {
      xMin = x;
    } else if (x > xMax) {
      xMax = x;
    }
    if (y < yMin) {
      yMin = y;
    } else if (y > yMax) {
      yMax = y;
    }
      }
    }
  }
  if (xMin > clipXMin) {
    clipXMin = xMin;
  }
  if (yMin > clipYMin) {
    clipYMin = yMin;
  }
  if (xMax < clipXMax) {
    clipXMax = xMax;
  }
  if (yMax < clipYMax) {
    clipYMax = yMax;
  }
}
 
void GfxState::textShift(double tx, double ty) {
  double dx, dy;
 
  textTransformDelta(tx, ty, &dx, &dy);
  curX += dx;
  curY += dy;
}
 
void GfxState::shift(double dx, double dy) {
  curX += dx;
  curY += dy;
}
 
GfxState *GfxState::save() {
  GfxState *newState;
 
  newState = copy();
  newState->saved = this;
  return newState;
}
 
GfxState *GfxState::restore() {
  GfxState *oldState;
 
  if (saved) {
    oldState = saved;
 
    // these attributes aren't saved/restored by the q/Q operators
    oldState->path = path;
    oldState->curX = curX;
    oldState->curY = curY;
    oldState->lineX = lineX;
    oldState->lineY = lineY;
 
    path = NULL;
    saved = NULL;
    delete this;
 
  } else {
    oldState = this;
  }
 
  return oldState;
}