home *** CD-ROM | disk | FTP | other *** search
/ PSION CD 2 / PsionCDVol2.iso / Programs / 720 / PDF090B4-SorceCode / pdf / GfxState.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2000-09-30  |  32.2 KB  |  1,385 lines
  1. //========================================================================
  2. //
  3. // GfxState.cc
  4. //
  5. // Copyright 1996 Derek B. Noonburg
  6. //
  7. //========================================================================
  8. //
  9. // Ported to EPOC by Sander van der Wal
  10. //
  11. // $Log: GfxState.cpp $
  12. // Revision 1.4  2000-09-24 21:09:35+02  svdwal
  13. // Memory leak fixed
  14. //
  15. // Revision 1.3  2000-09-21 14:44:54+02  svdwal
  16. // Some xpdf 0.91 bugfixes added
  17. //
  18. // Revision 1.2  2000-09-17 13:38:23+02  svdwal
  19. // Ported
  20. //
  21.  
  22. #ifdef __GNUC__
  23. #pragma implementation
  24. #endif
  25.  
  26. #ifndef __E32DEF_H__
  27. #include <e32def.h> // remove warning about NULL redefinition
  28. #endif
  29.  
  30. #ifndef __E32MATH_H__
  31. #include <e32math.h>
  32. #endif
  33.  
  34. // --o C library
  35. #include <math.h>
  36.  
  37. #include "gmem.h"
  38.  
  39. #include "Error.h"
  40. #include "Object.h"
  41. #include "GfxState.h"
  42.  
  43. #include "Pdf.rsg"
  44.  
  45. static const TInt KSubpathSizeIncrement = 16;
  46. static const TInt KPathSizeIncrement = 16;
  47.  
  48. //------------------------------------------------------------------------
  49. // GfxColor
  50. //------------------------------------------------------------------------
  51. #ifdef FIXCOLOR
  52. void GfxColor::setGray(int gray) {
  53.   if (gray < 0) {
  54.     gray = 0;
  55.   } else if (gray > 255) {
  56.     gray = 255;
  57.   }
  58.   r = g = b = gray;
  59. }
  60.  
  61.  
  62. void GfxColor::setCMYK(int c, int m, int y, int k) {
  63.   if ((r = 255 - (c + k)) < 0) {
  64.     r = 0;
  65.   } else if (r > 255) {
  66.     r = 255;
  67.   }
  68.   if ((g = 255 - (m + k)) < 0) {
  69.     g = 0;
  70.   } else if (g > 255) {
  71.     g = 255;
  72.   }
  73.   if ((b = 255 - (y + k)) < 0) {
  74.     b = 0;
  75.   } else if (b > 255) {
  76.     b = 255;
  77.   }
  78. }
  79.  
  80. void GfxColor::setRGB(int r1, int g1, int b1) {
  81.   if ((r = r1) < 0) {
  82.     r = 0;
  83.   } else if (r1 > 255) {
  84.     r = 255;
  85.   }
  86.   if ((g = g1) < 0) {
  87.     g = 0;
  88.   } else if (g1 > 255) {
  89.     g = 255;
  90.   }
  91.   if ((b = b1) < 0) {
  92.     b = 0;
  93.   } else if (b1 > 255) {
  94.     b = 255;
  95.   }
  96. }
  97. #else
  98. void GfxColor::setGray(double gray) {
  99.   if (gray < 0) {
  100.     r = g = b = 0;
  101.   } else if (gray > 1) {
  102.     r = g = b = 1;
  103.   } else {
  104.     r = g = b = gray;
  105.   }
  106. }
  107.  
  108. void GfxColor::setCMYK(double c, double m, double y, double k) {
  109.   if ((r = 1 - (c + k)) < 0) {
  110.     r = 0;
  111.   } else if (r > 1) {
  112.     r = 1;
  113.   }
  114.   if ((g = 1 - (m + k)) < 0) {
  115.     g = 0;
  116.   } else if (g > 1) {
  117.     g = 1;
  118.   }
  119.   if ((b = 1 - (y + k)) < 0) {
  120.     b = 0;
  121.   } else if (b > 1) {
  122.     b = 1;
  123.   }
  124. }
  125.  
  126. void GfxColor::setRGB(double r1, double g1, double b1) {
  127.   if (r1 < 0) {
  128.     r = 0;
  129.   } else if (r1 > 1) {
  130.     r = 1;
  131.   } else {
  132.     r = r1;
  133.   }
  134.   if (g1 < 0) {
  135.     g = 0;
  136.   } else if (g1 > 1) {
  137.     g = 1;
  138.   } else {
  139.     g = g1;
  140.   }
  141.   if (b1 < 0) {
  142.     b = 0;
  143.   } else if (b1 > 1) {
  144.     b = 1;
  145.   } else {
  146.     b = b1;
  147.   }
  148. }
  149. #endif
  150.  
  151. //------------------------------------------------------------------------
  152. // GfxColorSpace
  153. //------------------------------------------------------------------------
  154.  
  155. void GfxColorSpace::ConstructL(Object *colorSpace) {
  156.   RAutoObject csObj;
  157.   RAutoObject obj, obj2;
  158.   char *s;
  159.   int x;
  160.   int i, j;
  161.  
  162.   ok = gTrue;
  163.   lookup = NULL;
  164.   
  165.   // check for Separation, DeviceN and Pattern colorspaces
  166.   colorSpace->copyL(&csObj);
  167.   sepFunc = NULL;
  168.   if (colorSpace->isArray()) {
  169.     colorSpace->arrayGetL(0, &obj);
  170.     if (obj.isName("Separation") || obj.isName("DeviceN")) {
  171.       csObj.free();
  172.       colorSpace->arrayGetL(2, &csObj);
  173.       sepFunc = new(ELeave) Function();
  174.       sepFunc->ConstructL(colorSpace->arrayGetL(3, &obj2));
  175.       obj2.free();
  176.       if (!sepFunc->isOk()) {
  177.         delete sepFunc;
  178.         sepFunc = NULL;
  179.       }
  180.     } 
  181.     else if (obj.isName("Pattern")) {
  182.       csObj.free();
  183.       colorSpace->arrayGetL(1, &csObj);
  184.     }
  185.     obj.free();
  186.   }
  187.  
  188.   // get mode
  189.   indexed = gFalse;
  190.   if (csObj.isName()) {
  191.     setMode(&csObj);
  192.   } else if (csObj.isArray()) {
  193.     csObj.arrayGetL(0, &obj);
  194.     if (obj.isName("Indexed") || obj.isName("I")) {
  195.       indexed = gTrue;
  196.       setMode(csObj.arrayGetL(1, &obj2));
  197.       obj2.free();
  198.     }
  199.     else {
  200.       setMode(&csObj);
  201.     }
  202.     obj.free();
  203.   } else {
  204.     goto err1;
  205.   }
  206.   if (!ok) {
  207.     goto err1;
  208.   }
  209.  
  210.   if (indexed) {
  211.     // get lookup table for indexed colorspace
  212.     csObj.arrayGetL(2, &obj);
  213.     if (!obj.isInt())
  214.       goto err2;
  215.     indexHigh = obj.getInt();
  216.     obj.free();
  217.     lookup = (Guchar (*)[4])User::AllocL((indexHigh + 1) * 4 * sizeof(Guchar));
  218.     csObj.arrayGetL(3, &obj);
  219.     if (obj.isStream()) {
  220.       obj.streamReset();
  221.       for (i = 0; i <= indexHigh; ++i) {
  222.         for (j = 0; j < numComps; ++j) {
  223.           if ((x = obj.streamGetChar()) == EOF)
  224.            goto err2;
  225.           lookup[i][j] = (Guchar)x;
  226.         }
  227.       }
  228.     } 
  229.     else if (obj.isString()) {
  230.       s = obj.getString()->getCString();
  231.       for (i = 0; i <= indexHigh; ++i)
  232.         for (j = 0; j < numComps; ++j)
  233.           lookup[i][j] = (Guchar)*s++;
  234.     } 
  235.     else {
  236.       goto err2;
  237.     }
  238.     obj.free();
  239.   }
  240.  
  241.   csObj.free();
  242.   return;
  243.  
  244.  err2:
  245.   obj.free();
  246.  err1:
  247.   csObj.free();
  248.   ok = gFalse;
  249. }
  250.  
  251. GfxColorSpace::GfxColorSpace(GfxColorMode mode1) {
  252.   sepFunc = NULL;
  253.   mode = mode1;
  254.   indexed = gFalse;
  255.   switch (mode) {
  256.   case colorGray: numComps = 1; break;
  257.   case colorCMYK: numComps = 4; break;
  258.   case colorRGB:  numComps = 3; break;
  259.   }
  260.   lookup = NULL;
  261.   ok = gTrue;
  262. }
  263.  
  264. GfxColorSpace::~GfxColorSpace() {
  265.   delete sepFunc;
  266.   User::Free(lookup);
  267. }
  268.  
  269.  
  270. void GfxColorSpace::ConstructL(GfxColorSpace *colorSpace) {
  271.   int size;
  272.  
  273.   if (colorSpace->sepFunc)
  274.     sepFunc = colorSpace->sepFunc->copyL();
  275.   else
  276.     sepFunc = NULL;
  277.   mode = colorSpace->mode;
  278.   indexed = colorSpace->indexed;
  279.   numComps = colorSpace->numComps;
  280.   indexHigh = colorSpace->indexHigh;
  281.   if (indexed) {
  282.     size = (indexHigh + 1) * 4 * sizeof(Guchar);
  283.     lookup = (Guchar (*)[4])User::AllocL(size);
  284.     Mem::Copy(lookup, colorSpace->lookup, size);
  285.   } else {
  286.     lookup = NULL;
  287.   }
  288.   ok = gTrue;
  289. }
  290.  
  291. GfxColorSpace *GfxColorSpace::copyL()
  292. { 
  293.   GfxColorSpace* self = new(ELeave)  GfxColorSpace();
  294.   CleanupStack::PushL(self);
  295.   self->ConstructL(this);
  296.   CleanupStack::Pop(); // self
  297.   return self;
  298. }
  299.  
  300. void GfxColorSpace::setMode(Object *colorSpace) {
  301.   RAutoObject obj;
  302.  
  303.   if (colorSpace->isName("DeviceGray") || colorSpace->isName("G")) {
  304.     mode = colorGray;
  305.     numComps = 1;
  306.   } else if (colorSpace->isName("DeviceRGB") || colorSpace->isName("RGB")) {
  307.     mode = colorRGB;
  308.     numComps = 3;
  309.   } else if (colorSpace->isName("DeviceCMYK") || colorSpace->isName("CMYK")) {
  310.     mode = colorCMYK;
  311.     numComps = 4;
  312.   } else if (colorSpace->isArray()) {
  313.     colorSpace->arrayGetL(0, &obj);
  314.     if (obj.isName("CalGray")) {
  315.       mode = colorGray;
  316.       numComps = 1;
  317.     } else if (obj.isName("CalRGB")) {
  318.       mode = colorRGB;
  319.       numComps = 3;
  320.     } else if (obj.isName("CalCMYK")) {
  321.       mode = colorCMYK;
  322.       numComps = 4;
  323.     } else if (obj.isName("ICCBased")) {
  324.       obj.free();
  325.       // try the Alternate colorspace. If there's none, use N
  326.       colorSpace->arrayGetL(1, &obj);
  327.       if (obj.isStream()) {
  328.         obj.streamReset();
  329.         RAutoObject obj2;
  330.         obj.streamGetDict()->lookupL("Alternate", &obj2);
  331.         if (obj2.isNone()) {
  332.           obj.streamGetDict()->lookupL("N", &obj2);
  333.           if (obj2.isInt()) {
  334.             switch (numComps = obj2.getInt()) {
  335.             case 1: mode = colorGray; break;
  336.             case 3: mode = colorRGB;  break;
  337.             case 4: mode = colorCMYK; break;
  338.             default:
  339.               ok = gFalse;  
  340.             }
  341.           }
  342.           else
  343.             ok = gFalse; // N is not optional
  344.         }
  345.         else       
  346.           setMode(&obj2);
  347.       } 
  348.       else
  349.         ok = gFalse; // must be a stream 
  350.     }
  351.     else {
  352.       ok = gFalse;
  353.     }
  354.     obj.free();
  355.   } else {
  356.     ok = gFalse;
  357.   }
  358. }
  359.  
  360. #ifdef FIXCOLOR
  361. void GfxColorSpace::getColor(int x[4], GfxColor *color) {
  362.   int y[4];
  363.   Guchar *p;
  364.  
  365.   if (sepFunc) {
  366.     sepFunc->transform(x, y);
  367.   } else {
  368.     y[0] = x[0];
  369.     y[1] = x[1];
  370.     y[2] = x[2];
  371.     y[3] = x[3];
  372.   }
  373.  
  374.   if (indexed) {
  375.     p = lookup[x[0]];
  376.     switch (mode) {
  377.     case colorGray:
  378.       color->setGray(p[0]);
  379.       break;
  380.     case colorCMYK:
  381.       color->setCMYK(p[0], p[1], p[2], p[3]);
  382.       break;
  383.     case colorRGB:
  384.       color->setRGB(p[0], p[1], p[2]);
  385.       break;
  386.     }
  387.   } 
  388.   else {
  389.     switch (mode) {
  390.     case colorGray:
  391.       color->setGray(x[0]);
  392.       break;
  393.     case colorCMYK:
  394.       color->setCMYK(x[0], x[1], x[2], x[3]);
  395.       break;
  396.     case colorRGB:
  397.       color->setRGB(x[0], x[1], x[2]);
  398.       break;
  399.     }
  400.   }
  401. }
  402. #else
  403. void GfxColorSpace::getColor(double x[4], GfxColor *color) {
  404.   double y[4];
  405.   Guchar *p;
  406.  
  407.   if (sepFunc) {
  408.     sepFunc->transform(x, y);
  409.   } else {
  410.     y[0] = x[0];
  411.     y[1] = x[1];
  412.     y[2] = x[2];
  413.     y[3] = x[3];
  414.   }
  415.   if (indexed) {
  416.     p = lookup[(int)(y[0] + 0.5)];
  417.     switch (mode) {
  418.     case colorGray:
  419.       color->setGray(p[0] / 255.0);
  420.       break;
  421.     case colorCMYK:
  422.       color->setCMYK(p[0] / 255.0, p[1] / 255.0, p[2] / 255.0, p[3] / 255.0);
  423.       break;
  424.     case colorRGB:
  425.       color->setRGB(p[0] / 255.0, p[1] / 255.0, p[2] / 255.0);
  426.       break;
  427.     }
  428.   } else {
  429.     switch (mode) {
  430.     case colorGray:
  431.       color->setGray(y[0]);
  432.       break;
  433.     case colorCMYK:
  434.       color->setCMYK(y[0], y[1], y[2], y[3]);
  435.       break;
  436.     case colorRGB:
  437.       color->setRGB(y[0], y[1], y[2]);
  438.       break;
  439.     }
  440.   }
  441. }
  442. #endif
  443.  
  444. //------------------------------------------------------------------------
  445. // Function
  446. //------------------------------------------------------------------------
  447.  
  448. void Function::ConstructL(Object *funcObj) 
  449. {
  450.   Stream *str;
  451.   Dict *dict;
  452.   int nSamples, sampleBits;
  453.   double sampleMul;
  454.   RAutoObject obj1, obj2;
  455.   Guint buf, bitMask;
  456.   int bits;
  457.   int s;
  458.   int i;
  459.  
  460.   ok = gFalse;
  461.   samples = NULL;
  462.  
  463.   if (!funcObj->isStream()) {
  464.     error(-1, R_EXPECTED_FUNCTION_DICTIONARY);
  465.     goto err3;
  466.   }
  467.   str = funcObj->getStream();
  468.   dict = str->getDict();
  469.  
  470.   //----- FunctionType
  471.   if (!dict->lookupL("FunctionType", &obj1)->isInt() ||
  472.       obj1.getInt() != 0) {
  473.     error(-1, R_UNKNOWN_FUNCTION_TYPE);
  474.     goto err2;
  475.   }
  476.   obj1.free();
  477.  
  478.   //----- Domain
  479.   if (!dict->lookupL("Domain", &obj1)->isArray()) {
  480.     error(-1, R_FUNCTION_IS_MISSING_DOMAIN);
  481.     goto err2;
  482.   }
  483.   m = obj1.arrayGetLength() / 2;
  484.   if (m > 1) {
  485.     error(-1, R_FUNCTIONS_WITH_MORE_THAN_1_INPUT_ARE_UNSUPPORTED);
  486.     goto err2;
  487.   }
  488.   for (i = 0; i < m; ++i) {
  489.     obj1.arrayGetL(2*i, &obj2);
  490.     if (!obj2.isNum()) {
  491.       error(-1, R_ILLEGAL_VALUE_IN_FUNCTION_DOMAIN_ARRAY);
  492.       goto err1;
  493.     }
  494.     domain[i][0] = obj2.getNum();
  495.     obj2.free();
  496.     obj1.arrayGetL(2*i+1, &obj2);
  497.     if (!obj2.isNum()) {
  498.       error(-1, R_ILLEGAL_VALUE_IN_FUNCTION_DOMAIN_ARRAY);
  499.       goto err1;
  500.     }
  501.     domain[i][1] = obj2.getNum();
  502.     obj2.free();
  503.   }
  504.   obj1.free();
  505.  
  506.   //----- Range
  507.   if (!dict->lookupL("Range", &obj1)->isArray()) {
  508.     error(-1, R_FUNCTION_IS_MISSING_RANGE);
  509.     goto err2;
  510.   }
  511.   n = obj1.arrayGetLength() / 2;
  512.   if (n > 4) {
  513.     error(-1, R_FUNCTIONS_WITH_MORE_THAN_4_OUTPUTS_ARE_UNSUPPORTED);
  514.     goto err2;
  515.   }
  516.   for (i = 0; i < n; ++i) {
  517.     obj1.arrayGetL(2*i, &obj2);
  518.     if (!obj2.isNum()) {
  519.       error(-1, R_ILLEGAL_VALUE_IN_FUNCTION_RANGE_ARRAY);
  520.       goto err1;
  521.     }
  522.     range[i][0] = obj2.getNum();
  523.     obj2.free();
  524.     obj1.arrayGetL(2*i+1, &obj2);
  525.     if (!obj2.isNum()) {
  526.       error(-1, R_ILLEGAL_VALUE_IN_FUNCTION_RANGE_ARRAY);
  527.       goto err1;
  528.     }
  529.     range[i][1] = obj2.getNum();
  530.     obj2.free();
  531.   }
  532.   obj1.free();
  533.  
  534.   //----- Size
  535.   if (!dict->lookupL("Size", &obj1)->isArray() ||
  536.       obj1.arrayGetLength() != m) {
  537.     error(-1, R_FUNCTION_HAS_MISSING_OR_INVALID_SIZE_ARRAY);
  538.     goto err2;
  539.   }
  540.   for (i = 0; i < m; ++i) {
  541.     obj1.arrayGetL(i, &obj2);
  542.     if (!obj2.isInt()) {
  543.       error(-1, R_ILLEGAL_VALUE_IN_FUNCTION_SIZE_ARRAY);
  544.       goto err1;
  545.     }
  546.     sampleSize[i] = obj2.getInt();
  547.     obj2.free();
  548.   }
  549.   obj1.free();
  550.  
  551.   //----- BitsPerSample
  552.   if (!dict->lookupL("BitsPerSample", &obj1)->isInt()) {
  553.     error(-1, R_FUNCTION_HAS_MISSING_OR_INVALID_BITSPERSAMPLE);
  554.     goto err2;
  555.   }
  556.   sampleBits = obj1.getInt();
  557.   sampleMul = 1.0 / (double)((1 << sampleBits) - 1);
  558.   obj1.free();
  559.  
  560.   //----- Encode
  561.   if (dict->lookupL("Encode", &obj1)->isArray() &&
  562.       obj1.arrayGetLength() == 2*m) {
  563.     for (i = 0; i < m; ++i) {
  564.       obj1.arrayGetL(2*i, &obj2);
  565.       if (!obj2.isNum()) {
  566.     error(-1, R_ILLEGAL_VALUE_IN_FUNCTION_ENCODE_ARRAY);
  567.     goto err1;
  568.       }
  569.       encode[i][0] = obj2.getNum();
  570.       obj2.free();
  571.       obj1.arrayGetL(2*i+1, &obj2);
  572.       if (!obj2.isNum()) {
  573.     error(-1, R_ILLEGAL_VALUE_IN_FUNCTION_ENCODE_ARRAY);
  574.     goto err1;
  575.       }
  576.       encode[i][1] = obj2.getNum();
  577.       obj2.free();
  578.     }
  579.   } else {
  580.     for (i = 0; i < m; ++i) {
  581.       encode[i][0] = 0;
  582.       encode[i][1] = sampleSize[i] - 1;
  583.     }
  584.   }
  585.   obj1.free();
  586.  
  587.   //----- Decode
  588.   if (dict->lookupL("Decode", &obj1)->isArray() &&
  589.       obj1.arrayGetLength() == 2*n) {
  590.     for (i = 0; i < n; ++i) {
  591.       obj1.arrayGetL(2*i, &obj2);
  592.       if (!obj2.isNum()) {
  593.     error(-1, R_ILLEGAL_VALUE_IN_FUNCTION_DECODE_ARRAY);
  594.     goto err1;
  595.       }
  596.       decode[i][0] = obj2.getNum();
  597.       obj2.free();
  598.       obj1.arrayGetL(2*i+1, &obj2);
  599.       if (!obj2.isNum()) {
  600.     error(-1, R_ILLEGAL_VALUE_IN_FUNCTION_DECODE_ARRAY);
  601.     goto err1;
  602.       }
  603.       decode[i][1] = obj2.getNum();
  604.       obj2.free();
  605.     }
  606.   } else {
  607.     for (i = 0; i < n; ++i) {
  608.       decode[i][0] = range[i][0];
  609.       decode[i][1] = range[i][1];
  610.     }
  611.   }
  612.   obj1.free();
  613.  
  614.   //----- samples
  615.   nSamples = n;
  616.   for (i = 0; i < m; ++i)
  617.     nSamples *= sampleSize[i];
  618.   samples = (double *)User::AllocL(nSamples * sizeof(double));
  619.   buf = 0;
  620.   bits = 0;
  621.   bitMask = (1 << sampleBits) - 1;
  622.   str->reset();
  623.   for (i = 0; i < nSamples; ++i) {
  624.     if (sampleBits == 8) {
  625.       s = str->getChar();
  626.     } else if (sampleBits == 16) {
  627.       s = str->getChar();
  628.       s = (s << 8) + str->getChar();
  629.     } else if (sampleBits == 32) {
  630.       s = str->getChar();
  631.       s = (s << 8) + str->getChar();
  632.       s = (s << 8) + str->getChar();
  633.       s = (s << 8) + str->getChar();
  634.     } else {
  635.       while (bits < sampleBits) {
  636.     buf = (buf << 8) | (str->getChar() & 0xff);
  637.     bits += 8;
  638.       }
  639.       s = (buf >> (bits - sampleBits)) & bitMask;
  640.       bits -= sampleBits;
  641.     }
  642.     samples[i] = (double)s * sampleMul;
  643.   }
  644.  
  645.   ok = gTrue;
  646.   return;
  647.  
  648.  err1:
  649.   obj2.free();
  650.  err2:
  651.   obj1.free();
  652.  err3:
  653.   return;
  654. }
  655.  
  656.  
  657. void Function::ConstructL(Function *func)
  658. {
  659.   int nSamples, i;
  660.  
  661.   m = func->m;
  662.   n = func->n;
  663.   Mem::Copy(domain, func->domain, sizeof(domain));
  664.   Mem::Copy(range, func->range, sizeof(range));
  665.   Mem::Copy(sampleSize, func->sampleSize, sizeof(sampleSize));
  666.   Mem::Copy(encode, func->encode, sizeof(encode));
  667.   Mem::Copy(decode, func->decode, sizeof(decode));
  668.  
  669.   nSamples = n;
  670.   for (i = 0; i < m; ++i)
  671.     nSamples *= sampleSize[i];
  672.   samples = (double *)User::AllocL(nSamples * sizeof(double));
  673.   Mem::Copy(samples, func->samples, nSamples * sizeof(double));
  674.  
  675.   ok = gTrue;
  676. }
  677.  
  678. Function::~Function() {
  679.   User::Free(samples);
  680. }
  681.  
  682. Function *Function::copyL()
  683. { 
  684.   Function* self = new(ELeave) Function(); 
  685.   CleanupStack::PushL(self);
  686.   self->ConstructL(this);
  687.   CleanupStack::Pop(); // self
  688.   return self;
  689. }
  690.  
  691.  
  692. #ifdef FIXCOLOR
  693. void Function::transform(int* in, int* out) {
  694.   int e[4];
  695.   double s;
  696.   double x0, x1;
  697.   int e0, e1;
  698.   double efrac;
  699.   int i;
  700.  
  701.   // map input values into sample array
  702.   for (i = 0; i < m; ++i) {
  703.     e[i] = ((in[i] - domain[i][0]) / (domain[i][1] - domain[i][0])) *
  704.            (encode[i][1] - encode[i][0]) + encode[i][0];
  705.     if (e[i] < 0)
  706.       e[i] = 0;
  707.     else if (e[i] > sampleSize[i] - 1)
  708.       e[i] = sampleSize[i] - 1;
  709.   }
  710.  
  711.   for (i = 0; i < n; ++i) {
  712.  
  713.     // m-linear interpolation
  714.     // (only m=1 is currently supported)
  715.     e0 = (int)floor(e[0]);
  716.     e1 = (int)ceil(e[0]);
  717.     efrac = e[0] - e0;
  718.     x0 = samples[e0 * n + i];
  719.     x1 = samples[e1 * n + i];
  720.     s = (1 - efrac) * x0 + efrac * x1;
  721.  
  722.     // map output values to range
  723.     out[i] = s * (decode[i][1] - decode[i][0]) + decode[i][0];
  724.     if (out[i] < range[i][0])
  725.       out[i] = range[i][0];
  726.     else if (out[i] > range[i][1])
  727.       out[i] = range[i][1];
  728.   }
  729. }
  730. #else
  731. void Function::transform(double *in, double *out) {
  732.   double e[4];
  733.   double s;
  734.   double x0, x1;
  735.   int e0, e1;
  736.   double efrac;
  737.   int i;
  738.  
  739.   // map input values into sample array
  740.   for (i = 0; i < m; ++i) {
  741.     e[i] = ((in[i] - domain[i][0]) / (domain[i][1] - domain[i][0])) *
  742.            (encode[i][1] - encode[i][0]) + encode[i][0];
  743.     if (e[i] < 0)
  744.       e[i] = 0;
  745.     else if (e[i] > sampleSize[i] - 1)
  746.       e[i] = sampleSize[i] - 1;
  747.   }
  748.  
  749.   for (i = 0; i < n; ++i) {
  750.  
  751.     // m-linear interpolation
  752.     // (only m=1 is currently supported)
  753.     e0 = (int)floor(e[0]);
  754.     e1 = (int)ceil(e[0]);
  755.     efrac = e[0] - e0;
  756.     x0 = samples[e0 * n + i];
  757.     x1 = samples[e1 * n + i];
  758.     s = (1 - efrac) * x0 + efrac * x1;
  759.  
  760.     // map output values to range
  761.     out[i] = s * (decode[i][1] - decode[i][0]) + decode[i][0];
  762.     if (out[i] < range[i][0])
  763.       out[i] = range[i][0];
  764.     else if (out[i] > range[i][1])
  765.       out[i] = range[i][1];
  766.   }
  767. }
  768. #endif
  769.  
  770. //------------------------------------------------------------------------
  771. // GfxImageColorMap
  772. //------------------------------------------------------------------------
  773. GfxImageColorMap::GfxImageColorMap(GfxColorSpace *aColorSpace): colorSpace(aColorSpace)  {}
  774.  
  775. void GfxImageColorMap::ConstructL(int bits1, Object *decode) {
  776.   GfxColor color;
  777. #ifdef FIXCOLOR
  778.   int x[4];
  779. #else
  780.   double x[4];
  781. #endif
  782.   int maxPixel;
  783.   RAutoObject obj;
  784.   int i, j;
  785.  
  786.   ok = gTrue;
  787.  
  788.   // bits per component and colorspace
  789.   bits = bits1;
  790.   maxPixel = (1 << bits) - 1;
  791.   mode = colorSpace->getMode();
  792.  
  793.   // work around a bug in Distiller (?)
  794.   if (colorSpace->isIndexed() && maxPixel > colorSpace->getIndexHigh()) {
  795.     maxPixel = colorSpace->getIndexHigh();
  796.   }
  797.  
  798.   // get decode map
  799.   if (decode->isNull()) {
  800.     if (colorSpace->isIndexed()) {
  801.       indexed = gTrue;
  802.       numComps = 1;
  803. #if defined(FIXCOLOR)
  804.       decodeLow[0] = 0;
  805.       decodeRange[0] = maxPixel * 255;
  806. #else
  807.       decodeLow[0] = 0;
  808.       decodeRange[0] = maxPixel;
  809. #endif
  810.     } else {
  811.       indexed = gFalse;
  812.       numComps = colorSpace->getNumPixelComps();
  813.       for (i = 0; i < numComps; ++i) {
  814. #if defined(FIXCOLOR)
  815.     decodeLow[i] = 0;
  816.     decodeRange[i] = 255;
  817. #else
  818.         decodeLow[i] = 0;
  819.         decodeRange[i] = 1;
  820. #endif
  821.       }
  822.     }
  823.   } 
  824.   else if (decode->isArray()) {
  825.     numComps = decode->arrayGetLength() / 2;
  826.     if (numComps != colorSpace->getNumPixelComps())
  827.       goto err1;
  828.     indexed = colorSpace->isIndexed();
  829.     for (i = 0; i < numComps; ++i) {
  830.       decode->arrayGetL(2*i, &obj);
  831.       if (!obj.isNum())
  832.         goto err2;
  833. #if defined(FIXCOLOR)
  834.       decodeLow[i] = (int)(obj.getNum() * 255.0);
  835. #else
  836.       decodeLow[i] = obj.getNum();
  837. #endif
  838.       obj.free();
  839.       decode->arrayGetL(2*i+1, &obj);
  840.       if (!obj.isNum())
  841.         goto err2;
  842. #if defined(FIXCOLOR)
  843.       decodeRange[i] = (int)(obj.getNum() * 255.0) - decodeLow[i];
  844. #else
  845.       decodeRange[i] = obj.getNum() - decodeLow[i];
  846. #endif
  847.       obj.free();
  848.     }
  849.   } else {
  850.     goto err1;
  851.   }
  852.  
  853.   // construct lookup table
  854. #ifdef FIXCOLOR
  855.   lookup = (int (*)[4])User::AllocL((maxPixel + 1) * 4 * sizeof(int));
  856. #else
  857.   lookup = (double (*)[4])User::AllocL((maxPixel + 1) * 4 * sizeof(double));
  858. #endif
  859.   if (indexed) {
  860.     for (i = 0; i <= maxPixel; ++i) {
  861. #ifdef FIXCOLOR
  862.       x[0] = i;
  863. #else
  864.       x[0] = (double)i;
  865. #endif
  866.       colorSpace->getColor(x, &color);
  867.       lookup[i][0] = color.getR();
  868.       lookup[i][1] = color.getG();
  869.       lookup[i][2] = color.getB();
  870.     }
  871.   } else {
  872.     for (i = 0; i <= maxPixel; ++i)
  873.       for (j = 0; j < numComps; ++j)
  874.     lookup[i][j] = decodeLow[j] + (i * decodeRange[j]) / maxPixel;
  875.   }
  876.  
  877.   return;
  878.  
  879.  err2:
  880.   obj.free();
  881.  err1:
  882.   ok = gFalse;
  883. }
  884.  
  885. GfxImageColorMap::~GfxImageColorMap() {
  886.   delete colorSpace;
  887.   User::Free(lookup);
  888. }
  889.  
  890. /*
  891. #if defined(FIXCOLOR)
  892. void GfxImageColorMap::getColor(Guchar x[4], GfxColor *color) {
  893.   int y[4];
  894.   int i;
  895.  
  896.   if (simpleDecode) {
  897.     for (i = 0; i < decodeComps; ++i) {
  898.       y[i] = (((int)x[i]) * 255) / maxPixel;
  899.     }
  900.   } else if (indexDecode) {
  901.     y[0] = x[0];
  902.   } else {
  903.     for (i = 0; i < decodeComps; ++i) {
  904.       y[i] = (decodeLow[i] + (((int)x[i]) * decodeRange[i]) / maxPixel) / 256;
  905. //      y[i] = decodeLow[i] + (((int)x[i]) * decodeRange[i]) / maxPixel;
  906.     }
  907.   }
  908.   colorSpace->getColor(y, color);
  909. }
  910. #else
  911. */
  912. void GfxImageColorMap::getColor(Guchar x[4], GfxColor *color) {
  913. #ifdef FIXCOLOR
  914.   int* p;
  915. #else
  916.   double *p;
  917. #endif
  918.  
  919.   if (indexed) {
  920.     p = lookup[x[0]];
  921.     color->setRGB(p[0], p[1], p[2]);
  922.   } else {
  923.     switch (mode) {
  924.     case colorGray:
  925.       color->setGray(lookup[x[0]][0]);
  926.       break;
  927.     case colorCMYK:
  928.       color->setCMYK(lookup[x[0]][0], lookup[x[1]][1],
  929.              lookup[x[2]][2], lookup[x[3]][3]);
  930.       break;
  931.     case colorRGB:
  932.       color->setRGB(lookup[x[0]][0], lookup[x[1]][1], lookup[x[2]][2]);
  933.       break;
  934.     }
  935.   }
  936. }
  937. //#endif
  938.  
  939. //------------------------------------------------------------------------
  940. // GfxSubpath and GfxPath
  941. //------------------------------------------------------------------------
  942.  
  943. void GfxSubpath::ConstructL(double x1, double y1) {
  944.   size = 16;
  945.   x = (double *)User::AllocL(size * sizeof(double));
  946.   y = (double *)User::AllocL(size * sizeof(double));
  947.   curve = (GBool *)User::AllocL(size * sizeof(GBool));
  948.   n = 1;
  949.   x[0] = x1;
  950.   y[0] = y1;
  951.   curve[0] = gFalse;
  952.   closed = gFalse;
  953. }
  954.  
  955. GfxSubpath::~GfxSubpath() {
  956.   User::Free(x);
  957.   User::Free(y);
  958.   User::Free(curve);
  959. }
  960.  
  961. // Used for copy().
  962. void GfxSubpath::ConstructL(GfxSubpath *subpath) {
  963.   size = subpath->size;
  964.   n = subpath->n;
  965.   x = (double *)User::AllocL(size * sizeof(double));
  966.   y = (double *)User::AllocL(size * sizeof(double));
  967.   curve = (GBool *)User::AllocL(size * sizeof(GBool));
  968.   Mem::Copy(x, subpath->x, n * sizeof(double));
  969.   Mem::Copy(y, subpath->y, n * sizeof(double));
  970.   Mem::Copy(curve, subpath->curve, n * sizeof(GBool));
  971.   closed = subpath->closed;
  972. }
  973.  
  974. GfxSubpath *GfxSubpath::copyL()
  975. { 
  976.   GfxSubpath* self = new(ELeave) GfxSubpath();
  977.   CleanupStack::PushL(self);
  978.   self->ConstructL(this);
  979.   CleanupStack::Pop(); // self
  980.   return self;
  981. }
  982.  
  983. void GfxSubpath::lineTo(double x1, double y1) {
  984.   if (n >= size) {
  985.     size += KSubpathSizeIncrement;
  986.     x = (double *)User::ReAllocL(x, size * sizeof(double));
  987.     y = (double *)User::ReAllocL(y, size * sizeof(double));
  988.     curve = (GBool *)User::ReAllocL(curve, size * sizeof(GBool));
  989.   }
  990.   x[n] = x1;
  991.   y[n] = y1;
  992.   curve[n] = gFalse;
  993.   ++n;
  994. }
  995.  
  996. void GfxSubpath::curveTo(double x1, double y1, double x2, double y2,
  997.              double x3, double y3) {
  998.   if (n+3 > size) {
  999.     size += KSubpathSizeIncrement;
  1000.     x = (double *)User::ReAllocL(x, size * sizeof(double));
  1001.     y = (double *)User::ReAllocL(y, size * sizeof(double));
  1002.     curve = (GBool *)User::ReAllocL(curve, size * sizeof(GBool));
  1003.   }
  1004.   x[n] = x1;
  1005.   y[n] = y1;
  1006.   x[n+1] = x2;
  1007.   y[n+1] = y2;
  1008.   x[n+2] = x3;
  1009.   y[n+2] = y3;
  1010.   curve[n] = curve[n+1] = gTrue;
  1011.   curve[n+2] = gFalse;
  1012.   n += 3;
  1013. }
  1014.  
  1015. void GfxSubpath::close() {
  1016.   if (x[n-1] != x[0] || y[n-1] != y[0]) {
  1017.     lineTo(x[0], y[0]);
  1018.   }
  1019.   closed = gTrue;
  1020. }
  1021.  
  1022. void GfxPath::ConstructL() {
  1023.   justMoved = gFalse;
  1024.   size = 16;
  1025.   n = 0;
  1026.   firstX = firstY = 0;
  1027.   subpaths = (GfxSubpath **)User::AllocL(size * sizeof(GfxSubpath *));
  1028. }
  1029.  
  1030. GfxPath::~GfxPath() {
  1031.   int i;
  1032.  
  1033.   if (subpaths)
  1034.     for (i = 0; i < n; ++i)
  1035.       delete subpaths[i];
  1036.   User::Free(subpaths);
  1037. }
  1038.  
  1039. // Used for copy().
  1040. void GfxPath::ConstructL(GBool justMoved1, double firstX1, double firstY1,
  1041.          GfxSubpath **subpaths1, int n1, int size1) {
  1042.   int i;
  1043.  
  1044.   justMoved = justMoved1;
  1045.   firstX = firstX1;
  1046.   firstY = firstY1;
  1047.   size = size1;
  1048.   n = 0;
  1049.   subpaths = (GfxSubpath **)User::AllocL(size * sizeof(GfxSubpath *));
  1050.   // init with no subpaths for cleanup
  1051.   n = n1;
  1052.   for (i = 0; i < n; ++i)
  1053.     subpaths[i] = 0;
  1054.   for (i = 0; i < n; ++i)
  1055.     subpaths[i] = subpaths1[i]->copyL();
  1056. }
  1057.  
  1058. GfxPath *GfxPath::copyL()
  1059. { 
  1060.   GfxPath* self = new(ELeave) GfxPath();
  1061.   CleanupStack::PushL(self);
  1062.   self->ConstructL(justMoved, firstX, firstY, subpaths, n, size); 
  1063.   CleanupStack::Pop(); // self
  1064.   return self;
  1065. }
  1066.  
  1067. void GfxPath::moveTo(double x, double y) {
  1068.   justMoved = gTrue;
  1069.   firstX = x;
  1070.   firstY = y;
  1071. }
  1072.  
  1073. void GfxPath::lineTo(double x, double y) {
  1074.   if (justMoved) {
  1075.     if (n >= size) {
  1076.       size += KPathSizeIncrement;
  1077.       subpaths = (GfxSubpath **) 
  1078.         User::ReAllocL(subpaths, size * sizeof(GfxSubpath *));
  1079.     }
  1080.     // increment after allocation so subpath can be cleaned up
  1081.     subpaths[n] = new(ELeave)  GfxSubpath();
  1082.     ++n;
  1083.     subpaths[n-1]->ConstructL(firstX, firstY);
  1084.     justMoved = gFalse;
  1085.   }
  1086.   subpaths[n-1]->lineTo(x, y);
  1087. }
  1088.  
  1089. void GfxPath::curveTo(double x1, double y1, double x2, double y2,
  1090.          double x3, double y3) {
  1091.   if (justMoved) {
  1092.     if (n >= size) {
  1093.       size += KPathSizeIncrement;
  1094.       subpaths = (GfxSubpath **)
  1095.         User::ReAllocL(subpaths, size * sizeof(GfxSubpath *));
  1096.     }
  1097.     // increment after allocation so subpath can be cleaned up
  1098.     subpaths[n] = new(ELeave)  GfxSubpath();
  1099.     ++n;
  1100.     subpaths[n-1]->ConstructL(firstX, firstY);
  1101.     justMoved = gFalse;
  1102.   }
  1103.   subpaths[n-1]->curveTo(x1, y1, x2, y2, x3, y3);
  1104. }
  1105.  
  1106.  
  1107. //------------------------------------------------------------------------
  1108. // GfxState
  1109. //------------------------------------------------------------------------
  1110.  
  1111. void GfxState::ConstructL(int dpi, double px1a, double py1a, double px2a, double py2a,
  1112.            int rotate, GBool upsideDown) {
  1113.   double k;
  1114.  
  1115.   px1 = px1a;
  1116.   py1 = py1a;
  1117.   px2 = px2a;
  1118.   py2 = py2a;
  1119.   k = (double)dpi / 72.0;
  1120.   if (rotate == 90) {
  1121.     ctm[0] = 0;
  1122.     ctm[1] = upsideDown ? k : -k;
  1123.     ctm[2] = k;
  1124.     ctm[3] = 0;
  1125.     ctm[4] = -k * py1;
  1126.     ctm[5] = k * (upsideDown ? -px1 : px2);
  1127.     pageWidth = (int)(k * (py2 - py1));
  1128.     pageHeight = (int)(k * (px2 - px1));
  1129.   } else if (rotate == 180) {
  1130.     ctm[0] = -k;
  1131.     ctm[1] = 0;
  1132.     ctm[2] = 0;
  1133.     ctm[3] = upsideDown ? k : -k;
  1134.     ctm[4] = k * px2;
  1135.     ctm[5] = k * (upsideDown ? -py1 : py2);
  1136.     pageWidth = (int)(k * (px2 - px1));
  1137.     pageHeight = (int)(k * (py2 - py1));
  1138.   } else if (rotate == 270) {
  1139.     ctm[0] = 0;
  1140.     ctm[1] = upsideDown ? -k : k;
  1141.     ctm[2] = -k;
  1142.     ctm[3] = 0;
  1143.     ctm[4] = k * py2;
  1144.     ctm[5] = k * (upsideDown ? px2 : -px1);
  1145.     pageWidth = (int)(k * (py2 - py1));
  1146.     pageHeight = (int)(k * (px2 - px1));
  1147.   } else {
  1148.     ctm[0] = k;
  1149.     ctm[1] = 0;
  1150.     ctm[2] = 0;
  1151.     ctm[3] = upsideDown ? -k : k;
  1152.     ctm[4] = -k * px1;
  1153.     ctm[5] = k * (upsideDown ? py2 : -py1);
  1154.     pageWidth = (int)(k * (px2 - px1));
  1155.     pageHeight = (int)(k * (py2 - py1));
  1156.   }
  1157.  
  1158.   fillColorSpace = new(ELeave)  GfxColorSpace(colorGray);
  1159.   strokeColorSpace = new(ELeave)  GfxColorSpace(colorGray);
  1160.   fillColor.setGray(0);
  1161.   strokeColor.setGray(0);
  1162.  
  1163.   lineWidth = 1;
  1164.   lineDash = NULL;
  1165.   lineDashLength = 0;
  1166.   lineDashStart = 0;
  1167.   flatness = 0;
  1168.   lineJoin = 0;
  1169.   lineCap = 0;
  1170.   miterLimit = 10;
  1171.  
  1172.   font = NULL;
  1173.   fontSize = 0;
  1174.   textMat[0] = 1; textMat[1] = 0;
  1175.   textMat[2] = 0; textMat[3] = 1;
  1176.   textMat[4] = 0; textMat[5] = 0;
  1177.   charSpace = 0;
  1178.   wordSpace = 0;
  1179.   horizScaling = 1;
  1180.   leading = 0;
  1181.   rise = 0;
  1182.   render = 0;
  1183.  
  1184.   path = new(ELeave)  GfxPath();
  1185.   path->ConstructL();
  1186.   curX = curY = 0;
  1187.   lineX = lineY = 0;
  1188.  
  1189.   saved = NULL;
  1190. }
  1191.  
  1192. GfxState::~GfxState() {
  1193.   delete fillColorSpace;
  1194.   delete strokeColorSpace;
  1195.   User::Free(lineDash);
  1196.   delete path;
  1197.   delete saved;
  1198. }
  1199.  
  1200. // Used for copy();
  1201. void GfxState::ConstructL(GfxState *state) {
  1202.   
  1203.   Mem::Copy(this, state, sizeof(GfxState));
  1204.   // clear pointers first, so cleanup won't delete vars twice
  1205.   fillColorSpace = 0;
  1206.   strokeColorSpace = 0;
  1207.   lineDash = 0;
  1208.   path = 0;
  1209.   saved = NULL;
  1210.   if (state->fillColorSpace)
  1211.     fillColorSpace = state->fillColorSpace->copyL();
  1212.   if (state->strokeColorSpace)
  1213.     strokeColorSpace = state->strokeColorSpace->copyL();
  1214.   if (lineDashLength > 0) {
  1215.     lineDash = (double *)User::AllocL(lineDashLength * sizeof(double));
  1216.     Mem::Copy(lineDash, state->lineDash, lineDashLength * sizeof(double));
  1217.   } 
  1218.   path = state->path->copyL();
  1219. }
  1220.  
  1221. GfxState *GfxState::copyL()
  1222. { 
  1223.   GfxState* self = new(ELeave) GfxState();
  1224.   CleanupStack::PushL(self);
  1225.   self->ConstructL(this); 
  1226.   CleanupStack::Pop(); // self
  1227.   return self;
  1228. }
  1229.  
  1230.  
  1231. void GfxState::transform(double x1, double y1, double *x2, double *y2)
  1232. { 
  1233.   *x2 = ctm[0] * x1 + ctm[2] * y1 + ctm[4];
  1234.   *y2 = ctm[1] * x1 + ctm[3] * y1 + ctm[5];
  1235. }
  1236.  
  1237. void GfxState::transformDelta(double x1, double y1, double *x2, double *y2)
  1238. { 
  1239.   *x2 = ctm[0] * x1 + ctm[2] * y1;
  1240.   *y2 = ctm[1] * x1 + ctm[3] * y1; 
  1241. }
  1242.  
  1243. void GfxState::textTransform(double x1, double y1, double *x2, double *y2)
  1244. { 
  1245.   *x2 = textMat[0] * x1 + textMat[2] * y1 + textMat[4];
  1246.   *y2 = textMat[1] * x1 + textMat[3] * y1 + textMat[5]; 
  1247. }
  1248.  
  1249. void GfxState::textTransformDelta(double x1, double y1, double *x2, double *y2)
  1250. { 
  1251.   *x2 = textMat[0] * x1 + textMat[2] * y1;
  1252.   *y2 = textMat[1] * x1 + textMat[3] * y1; 
  1253. }
  1254.  
  1255. // special when y1 == 0
  1256. void GfxState::textTransformDelta(double x1, double *x2, double *y2)
  1257. {
  1258.   *x2 = textMat[0] * x1;
  1259.   *y2 = textMat[1] * x1; 
  1260. }
  1261.  
  1262. double GfxState::transformWidth(double w) {
  1263.   double x, y;
  1264.  
  1265.   x = ctm[0] + ctm[2];
  1266.   y = ctm[1] + ctm[3];
  1267.   double res;
  1268.   (void)Math::Sqrt(res, 0.5 * (x * x + y * y));
  1269.   return w * res;
  1270. }
  1271.  
  1272. double GfxState::getTransformedFontSize() {
  1273.   double x1, y1, x2, y2;
  1274.   
  1275.   x1 = textMat[2] * fontSize;
  1276.   y1 = textMat[3] * fontSize;
  1277.   x2 = ctm[0] * x1 + ctm[2] * y1;
  1278.   y2 = ctm[1] * x1 + ctm[3] * y1;
  1279.   double res;
  1280.   (void)Math::Sqrt(res,x2 * x2 + y2 * y2);
  1281.   return res;
  1282. }
  1283.  
  1284. void GfxState::getFontTransMat(double *m11, double *m12,
  1285.                    double *m21, double *m22) {
  1286.   *m11 = (textMat[0] * ctm[0] + textMat[1] * ctm[2]) * fontSize;
  1287.   *m12 = (textMat[0] * ctm[1] + textMat[1] * ctm[3]) * fontSize;
  1288.   *m21 = (textMat[2] * ctm[0] + textMat[3] * ctm[2]) * fontSize;
  1289.   *m22 = (textMat[2] * ctm[1] + textMat[3] * ctm[3]) * fontSize;
  1290. }
  1291.  
  1292. void GfxState::setCTM(double a, double b, double c,
  1293.               double d, double e, double f) {
  1294.   ctm[0] = a;
  1295.   ctm[1] = b;
  1296.   ctm[2] = c;
  1297.   ctm[3] = d;
  1298.   ctm[4] = e;
  1299.   ctm[5] = f;
  1300. }
  1301.  
  1302. void GfxState::concatCTM(double a, double b, double c,
  1303.              double d, double e, double f) {
  1304.   double a1 = ctm[0];
  1305.   double b1 = ctm[1];
  1306.   double c1 = ctm[2];
  1307.   double d1 = ctm[3];
  1308.  
  1309.   ctm[0] = a * a1 + b * c1;
  1310.   ctm[1] = a * b1 + b * d1;
  1311.   ctm[2] = c * a1 + d * c1;
  1312.   ctm[3] = c * b1 + d * d1;
  1313.   ctm[4] = e * a1 + f * c1 + ctm[4];
  1314.   ctm[5] = e * b1 + f * d1 + ctm[5];
  1315. }
  1316.  
  1317. void GfxState::setTextMat(double a, double b, double c,
  1318.           double d, double e, double f)
  1319. { 
  1320.   textMat[0] = a; textMat[1] = b; textMat[2] = c;
  1321.   textMat[3] = d; textMat[4] = e; textMat[5] = f; 
  1322. }
  1323.  
  1324. void GfxState::setFillColorSpace(GfxColorSpace *colorSpace) {
  1325.   delete fillColorSpace;
  1326.   fillColorSpace = colorSpace;
  1327. }
  1328.  
  1329. void GfxState::setStrokeColorSpace(GfxColorSpace *colorSpace) {
  1330.   delete strokeColorSpace;
  1331.   strokeColorSpace = colorSpace;
  1332. }
  1333.  
  1334. void GfxState::setLineDash(double *dash, int length, double start) {
  1335.   User::Free(lineDash);
  1336.   lineDash = dash;
  1337.   lineDashLength = length;
  1338.   lineDashStart = start;
  1339. }
  1340.  
  1341. void GfxState::clearPath() {
  1342.   delete path;
  1343.   path = 0;
  1344.   path = new(ELeave)  GfxPath();
  1345.   path->ConstructL();
  1346. }
  1347.  
  1348. void GfxState::textShift(double tx) {
  1349.   double dx, dy;
  1350.  
  1351.   // faster transform with zero height
  1352.   textTransformDelta(tx, 0, &dx, &dy);
  1353.   curX += dx;
  1354.   curY += dy;
  1355. }
  1356.  
  1357. void GfxState::textShift(double tx, double ty) {
  1358.   double dx, dy;
  1359.  
  1360.   textTransformDelta(tx, ty, &dx, &dy);
  1361.   curX += dx;
  1362.   curY += dy;
  1363. }
  1364.  
  1365. GfxState *GfxState::save() {
  1366.   GfxState *newState;
  1367.  
  1368.   newState = copyL();
  1369.   newState->saved = this;
  1370.   return newState;
  1371. }
  1372.  
  1373. GfxState *GfxState::restore() {
  1374.   GfxState *oldState;
  1375.  
  1376.   if (saved) {
  1377.     oldState = saved;
  1378.     saved = NULL;
  1379.     delete this;
  1380.   } else {
  1381.     oldState = this;
  1382.   }
  1383.   return oldState;
  1384. }
  1385.