home *** CD-ROM | disk | FTP | other *** search
/ Graphics 16,000 / graphics-16000.iso / msdos / plotting / pcgplots / cgm.cpp < prev    next >
C/C++ Source or Header  |  1992-04-24  |  107KB  |  4,539 lines
  1. // C++ .cc file for gplot, CGM-specific classes  -*-c++-*-
  2. // copyright Phil Andrews, Pittsburgh Supercomputing Center, 1992
  3. // all rights reserved
  4. #include <string.h>
  5. #include <ctype.h>
  6. #include "cgm.h"
  7. #include "cgmio.h"
  8. #if __MSDOS__
  9. #include "cgmdisp.h"
  10. #else
  11. #include "cgmdisplay.h"
  12. #endif
  13. #ifdef macintosh
  14.  #include <UMacApp.h>
  15.  #pragma segment CGM1
  16. #endif
  17. // error handling function
  18. extern void myError(const char *inMsg, const char *inMsg2=NULL,
  19.             int severity=1);
  20.  
  21.  
  22. ////
  23. // direct colour class
  24. ////
  25. // constructor
  26. ////
  27. dColr::dColr(int inR, int inG, int inB)
  28. {
  29.   values[0] = inR;
  30.   values[1] = inG;
  31.   values[2] = inB;
  32. }
  33. ////
  34. // general colour class
  35. ////
  36. // indexed colour constructor
  37. ////
  38. genColr::genColr(int inIndex, const colrValueExtent *inExtent,
  39.          const colrTable *inTable) 
  40. {
  41.   myIndex = inIndex;
  42.   myType = 0;
  43.   myExtent = inExtent;
  44.   myTable = inTable;
  45. }
  46. ////
  47. // direct colour constructor
  48. ////
  49. genColr::genColr(int inRed, int inGreen, int inBlue,
  50.          const colrValueExtent *inExtent, const colrTable *inTable) 
  51. { // direct colour constructor
  52.   myDC.setValue(0,inRed);    // myDC[0] = inRed;
  53.   myDC.setValue(1,inGreen);  //myDC[1] = inGreen;
  54.   myDC.setValue(2,inBlue);   //myDC[2] = inBlue;
  55.   myIndex = 1;
  56.   myType = 1;
  57.   myExtent = inExtent;
  58.   myTable = inTable;
  59. }
  60. ////
  61. // another direct colour constructor
  62. ////
  63. genColr::genColr(const dColr &inDC,
  64.          const colrValueExtent *inExtent, const colrTable *inTable) 
  65. { // direct colour constructor
  66.   myDC = inDC;
  67.   myIndex = 1;
  68.   myType = 1;
  69.   myExtent = inExtent;
  70.   myTable = inTable;
  71. }
  72. ////
  73. // get float values for the colours
  74. ////
  75. float genColr::r(unsigned i) const
  76. {
  77.   if (i>2) i = 0; // greater than blue ?
  78. //  int useVal = type() ? myDC[i] : myTable->val(myIndex)[i];
  79.   int useVal = type() ? myDC.getValue(i) : myTable->val(myIndex).getValue(i);
  80. //  if (useVal >= myExtent->white[i]) return 1; // max possible
  81. //  if (useVal <= myExtent->black[i]) return 0; // min possible
  82.   if (useVal >= myExtent->white.getValue(i)) return 1; // max possible
  83.   if (useVal <= myExtent->black.getValue(i)) return 0; // min possible
  84.  
  85. // ***  return (float) (useVal - myExtent->black[i]) /
  86. // ***   (myExtent->white[i] - myExtent->black[i]);
  87.   return (float) (useVal - myExtent->black.getValue(i)) /
  88.     (myExtent->white.getValue(i) - myExtent->black.getValue(i));
  89. }
  90. ////
  91. // colour table class
  92. ////
  93. colrTable::colrTable(unsigned int inSize, const colrValueExtent *inExtent,
  94.              unsigned int inStart)
  95. {
  96.   mySize = inSize;
  97.   myExtent = inExtent;
  98.   myStart = inStart;
  99.   myNo = 0;
  100.   values = new dColr[size()];
  101.   initialize(values, mySize);
  102. }
  103. ////
  104. // add one colour
  105. ////
  106. void colrTable::addColr(dColr &inDColr)
  107. {
  108.   if (no() < size()) {
  109.     values[no()] = inDColr; // should check that this works
  110.     ++myNo;
  111.   }
  112. }
  113. ////
  114. // extend the table
  115. ////
  116. void colrTable::extendTable(int newSize)
  117. {
  118.   if (newSize < mySize) return; // nothing to do
  119.   // need more room
  120.   dColr *oldValues = values;
  121.   int oldSize = mySize;
  122.   mySize = newSize;
  123.   values = new dColr[mySize];
  124.   for (int i=0; i<oldSize; ++i) values[i] = oldValues[i];
  125.   initialize(values + i, mySize - oldSize);
  126.   delete oldValues;
  127. }
  128. ////
  129. // initialize values
  130. ////
  131. void colrTable::initialize(dColr *inPtr, int size)
  132. {
  133. //  int rmin = myExtent->black[0]; // min red
  134. //  int gmin = myExtent->black[1]; // min green
  135. //  int bmin = myExtent->black[2]; // min blue
  136. //  int rmax = myExtent->white[0]; // max red
  137. //  int gmax = myExtent->white[1]; // max green
  138. //  int bmax = myExtent->white[2]; // max blue
  139.  
  140.   int rmin = myExtent->black.getValue(0); // min red
  141.   int gmin = myExtent->black.getValue(1); // min green
  142.   int bmin = myExtent->black.getValue(2); // min blue
  143.   int rmax = myExtent->white.getValue(0); // max red
  144.   int gmax = myExtent->white.getValue(1); // max green
  145.   int bmax = myExtent->white.getValue(2); // max blue
  146.  
  147.   int index = 0;
  148.   if (index < size) {inPtr->set(rmax, gmax, bmax); ++index; ++inPtr;} // white
  149.   if (index < size) {inPtr->set(rmin, gmin, bmin); ++index; ++inPtr;} // black
  150.   if (index < size) {inPtr->set(rmax, gmin, bmin); ++index; ++inPtr;} // red
  151.   if (index < size) {inPtr->set(rmin, gmax, bmin); ++index; ++inPtr;} // green
  152.   if (index < size) {inPtr->set(rmin, gmin, bmax); ++index; ++inPtr;} // blue
  153.   if (index < size) {inPtr->set(rmax, gmax, bmin); ++index; ++inPtr;} // yellow
  154.   if (index < size) {inPtr->set(rmax, gmin, bmax); ++index; ++inPtr;} // magent
  155.   if (index < size) {inPtr->set(rmin, gmax, bmax); ++index; ++inPtr;} // cyan
  156.   if (index < size) {inPtr->set(rmax, gmax/2, bmin); ++index; ++inPtr;} // or
  157.   if (index < size) {inPtr->set(rmax, gmin, bmax/2); ++index; ++inPtr;}
  158.   for (int i=index; i<size; ++i) {
  159.     inPtr->set(rmin, gmin, bmin); // black
  160.     ++inPtr;
  161.   }
  162. }
  163. ////
  164. // incorporate a new table
  165. ////
  166. void colrTable::addTable(colrTable *inTable)
  167. {
  168.   if ((inTable->start() + inTable->no()) > (start() + size())) { // need room
  169.     extendTable(inTable->start() + inTable->no() - start());
  170.   }
  171.   for (int i=0; i<inTable->no(); ++i) {
  172.     values[inTable->start() - start() + i] = inTable->val(i);
  173.   }
  174. }
  175. ////
  176. // get float values for the colours
  177. ////
  178. const float *colrTable::r(unsigned index) const
  179. {
  180.   int i, useVal;
  181.   static float rValues[3];
  182.   if (index>=mySize) index = 0; // off the end
  183.   ////
  184.   // fill out the r, g, b values
  185.   for (i=0; i<3; ++i) {
  186. //    useVal = values[index][i];
  187.     useVal = values[index].getValue(i);
  188. //    if (useVal >= myExtent->white[i]) {
  189.     if (useVal >= myExtent->white.getValue(i)) {
  190.       rValues[i] = 1; // max possible
  191. //    } else if (useVal <= myExtent->black[i]) {
  192.     } else if (useVal <= myExtent->black.getValue(i)) {
  193.       rValues[i] = 0; // min possible
  194.     } else {
  195. //      rvalues[i] = (float) (useVal - myExtent->black[i]) /
  196. //    (myExtent->white[i] - myExtent->black[i]);
  197.       rValues[i] = (float) (useVal - myExtent->black.getValue(i)) /
  198.     (myExtent->white.getValue(i) - myExtent->black.getValue(i));
  199.     }
  200.   }
  201.   return rValues;
  202. }
  203. ////
  204. // vdc pts class
  205. ////
  206. // constructor for 2 integer points (used for rectangles)
  207. ////
  208. vdcPts::vdcPts(int x1, int y1, int x2, int y2) 
  209. {
  210.   int *intPtr = new int[4];
  211.   intPtr[0] = x1;
  212.   intPtr[1] = y1;
  213.   intPtr[2] = x2;
  214.   intPtr[3] = y2;
  215.   noPts = 2;
  216.   myType = 0; // integer
  217.   myPtr = intPtr;
  218.   next=NULL;
  219. }
  220. ////
  221. // constructor for 2 float points (used for rectangles)
  222. ////
  223. vdcPts::vdcPts(double x1, double y1, double x2, double y2) 
  224. {
  225.   float *floatPtr = new float[4];
  226.   floatPtr[0] = x1;
  227.   floatPtr[1] = y1;
  228.   floatPtr[2] = x2;
  229.   floatPtr[3] = y2;
  230.   noPts = 2;
  231.   myType = 1; // float
  232.   myPtr = floatPtr;
  233.   next=NULL;
  234. }
  235. ////
  236. // return the width of the points
  237. ////
  238. float vdcPts::width() const
  239. {
  240.   float minX, maxX;
  241.   int i;
  242.   if (!noPts) return 0; // no points
  243.  
  244.   if (myType) { // real vdc's
  245.     float *floatPtr = (float *) myPtr;
  246.     minX = maxX = floatPtr[0];
  247.     for (i=2; i<2 * noPts; i += 2) {
  248.       if (minX > floatPtr[i]) minX = floatPtr[i];
  249.       if (maxX < floatPtr[i]) maxX = floatPtr[i];
  250.     }
  251.   } else { // integer VDC's
  252.     int *intPtr = (int *) myPtr;
  253.     minX = maxX = intPtr[0];
  254.     for (i=2; i<2 * noPts; i += 2) {
  255.       if (minX > intPtr[i]) minX = intPtr[i];
  256.       if (maxX < intPtr[i]) maxX = intPtr[i];
  257.     }
  258.   }
  259.     return maxX - minX;
  260. }
  261. ////
  262. // return the height of the points
  263. ////
  264. float vdcPts::height()  const
  265. {
  266.   float maxY, minY;
  267.   int i;
  268.   if (!noPts) return 0; // no points
  269.  
  270.   if (myType) { // real vdc's
  271.     float *floatPtr = (float *) myPtr;
  272.     minY = maxY = floatPtr[1];
  273.     for (i=3; i<2 * noPts; i += 2) {
  274.       if (minY > floatPtr[i]) minY = floatPtr[i];
  275.       if (maxY < floatPtr[i]) maxY = floatPtr[i];
  276.     }
  277.   } else { // integer VDC's
  278.     int *intPtr = (int *) myPtr;
  279.     minY = maxY = intPtr[1];
  280.     for (i=3; i<2 * noPts; i += 2) {
  281.       if (minY > intPtr[i]) minY = intPtr[i];
  282.       if (maxY < intPtr[i]) maxY = intPtr[i];
  283.     }
  284.   }
  285.   return maxY - minY;
  286. }
  287. ////
  288. // return the max Y of the points
  289. ////
  290. float vdcPts::maxY()  const
  291. {
  292.   float myMax;
  293.   int i;
  294.   if (!noPts) return 0; // no points
  295.  
  296.   if (myType) { // real vdc's
  297.     float *floatPtr = (float *) myPtr;
  298.     myMax = floatPtr[1];
  299.     for (i=3; i<2 * noPts; i += 2) {
  300.       if (myMax < floatPtr[i]) myMax = floatPtr[i];
  301.     }
  302.   } else { // integer VDC's
  303.     int *intPtr = (int *) myPtr;
  304.     myMax = intPtr[1];
  305.     for (i=3; i<2 * noPts; i += 2) {
  306.       if (myMax < intPtr[i]) myMax = intPtr[i];
  307.     }
  308.   }
  309.   return myMax;
  310. }
  311. ////
  312. // return the min Y of the points
  313. ////
  314. float vdcPts::minY()  const
  315. {
  316.   float myMin;
  317.   int i;
  318.   if (!noPts) return 0; // no points
  319.  
  320.   if (myType) { // real vdc's
  321.     float *floatPtr = (float *) myPtr;
  322.     myMin = floatPtr[1];
  323.     for (i=3; i<2 * noPts; i += 2) {
  324.       if (myMin > floatPtr[i]) myMin = floatPtr[i];
  325.     }
  326.   } else { // integer VDC's
  327.     int *intPtr = (int *) myPtr;
  328.     myMin = intPtr[1];
  329.     for (i=3; i<2 * noPts; i += 2) {
  330.       if (myMin > intPtr[i]) myMin = intPtr[i];
  331.     }
  332.   }
  333.   return myMin;
  334. }
  335. ////
  336. // return the max X of the points
  337. ////
  338. float vdcPts::maxX()  const
  339. {
  340.   float myMax;
  341.   int i;
  342.   if (!noPts) return 0; // no points
  343.  
  344.   if (myType) { // real vdc's
  345.     float *floatPtr = (float *) myPtr;
  346.     myMax = floatPtr[0];
  347.     for (i=2; i<2 * noPts; i += 2) {
  348.       if (myMax < floatPtr[i]) myMax = floatPtr[i];
  349.     }
  350.   } else { // integer VDC's
  351.     int *intPtr = (int *) myPtr;
  352.     myMax = intPtr[0];
  353.     for (i=2; i<2 * noPts; i += 2) {
  354.       if (myMax < intPtr[i]) myMax = intPtr[i];
  355.     }
  356.   }
  357.   return myMax;
  358. }
  359. ////
  360. // return the min X of the points
  361. ////
  362. float vdcPts::minX()  const
  363. {
  364.   float myMin;
  365.   int i;
  366.   if (!noPts) return 0; // no points
  367.  
  368.   if (myType) { // real vdc's
  369.     float *floatPtr = (float *) myPtr;
  370.     myMin = floatPtr[0];
  371.     for (i=2; i<2 * noPts; i += 2) {
  372.       if (myMin > floatPtr[i]) myMin = floatPtr[i];
  373.     }
  374.   } else { // integer VDC's
  375.     int *intPtr = (int *) myPtr;
  376.     myMin = intPtr[0];
  377.     for (i=2; i<2 * noPts; i += 2) {
  378.       if (myMin > intPtr[i]) myMin = intPtr[i];
  379.     }
  380.   }
  381.   return myMin;
  382. }
  383. ////
  384. // scale the points by a constant factor
  385. ////
  386. void vdcPts::scale(float inScale)
  387. {
  388.   int i;
  389.   if (myType) {
  390.     float *floatPtr = (float *) myPtr;
  391.     for (i=0; i<2*noPts; ++i) floatPtr[i] *= inScale;
  392.   } else {
  393.     int *intPtr = (int *) myPtr;
  394.     for (i=0; i<2*noPts; ++i) intPtr[i] = (int) (inScale * intPtr[i]);
  395.   }
  396. }
  397. ////
  398. // shift the points in x and y direction
  399. ////
  400. void vdcPts::shift(float xShift, float yShift)
  401. {
  402.   int i;
  403.   if (myType) {
  404.     float *floatPtr = (float *) myPtr;
  405.     for (i=0; i<noPts; ++i) {
  406.       floatPtr[2*i] += xShift;
  407.       floatPtr[2*i+1] += yShift;
  408.     }
  409.   } else {
  410.     int *intPtr = (int *) myPtr;
  411.     for (i=0; i<noPts; ++i) {
  412.       intPtr[2*i] += (int) xShift;
  413.       intPtr[2*i+1] += (int) yShift;
  414.     }
  415.   }
  416. }
  417. ////
  418. // the basic text class
  419. ////
  420. const int genText::finalFlag = 1;
  421. const int genText::restrictedFlag = 1<<1;
  422. const int genText::appendFlag = 1<<2;
  423. ////
  424. // basic cgm class
  425. ////
  426. // constructor
  427. ////
  428. baseCGM::baseCGM(cgmContainer *inOwner, baseCGM *inPrev, baseCGM *inNext)
  429. {
  430.   prev = inPrev; // inititalize pointers
  431.   next = inNext;
  432.   owner = inOwner;
  433.   if (prev) prev->next = this; // link pointers
  434.   if (next) next->prev = this;
  435. }
  436. ////
  437. // destructor
  438. ////
  439. baseCGM::~baseCGM() 
  440. {
  441.   if (prev) prev->next = next; // relink pointers
  442.   if (next) next->prev = prev;
  443. }
  444. ////
  445. // output in a CGM format
  446. ////
  447. int baseCGM::cgmOut(cgmOutput *inOut)
  448. {
  449.   inOut->startCmd(this);
  450.   inOut->endCmd();
  451.   return 1;
  452. }
  453. ////
  454. // default output to a display
  455. ////
  456. int baseCGM::display(baseDisplay*)
  457. {
  458.   return 1;
  459. }
  460. ////
  461. // the Delimiter class
  462. ////
  463. const int cgmDelimiter::myClass = 0;
  464. ////
  465. // Begin Metafile
  466. ////
  467. const int cgmBeginMetafile::myElement = 1;
  468. const char *cgmBeginMetafile::myName = "BegMf";
  469. ////
  470. // constructor
  471. ////
  472. cgmBeginMetafile::cgmBeginMetafile(cgmContainer *inOwner, cgmInput *cgmIn,
  473.                    baseCGM *inPrev, baseCGM *inNext)
  474. : cgmDelimiter(inOwner, inPrev, inNext)
  475. {
  476.   mfName = cgmIn->getString(mfNameSize);
  477. }
  478. ////
  479. // destructor
  480. ////
  481. cgmBeginMetafile::~cgmBeginMetafile()
  482. {
  483.   if (mfNameSize) delete mfName;
  484. }
  485. ////
  486. // output in a CGM format
  487. ////
  488. int cgmBeginMetafile::cgmOut(cgmOutput *inOut)
  489. {
  490.   inOut->startCmd(this);
  491.   inOut->outString(mfNameSize ? mfName : "");
  492.   inOut->endCmd();
  493.   return 1;
  494. }
  495. ////
  496. // display output
  497. ////
  498. int cgmBeginMetafile::display(baseDisplay *inDisplay)
  499. {
  500.   inDisplay->newMF();
  501.   if (inDisplay->fileDefaults() && mfOwner()->defaults()) {
  502.     // display wants to get defaults replacement at beginning of metafile
  503.     mfOwner()->displayDefaults(inDisplay);
  504.   }
  505.   return 1;
  506. }
  507. /////
  508. // End Metafile
  509. ////
  510. const int cgmEndMetafile::myElement = 2;
  511. const int cgmEndMetafileMyElement =2;
  512. const char *cgmEndMetafile::myName = "EndMf";
  513. ////
  514. // constructor
  515. ////
  516. cgmEndMetafile::cgmEndMetafile(cgmContainer *inOwner, cgmInput*,
  517.                    baseCGM *inPrev, baseCGM *inNext)
  518. : cgmDelimiter(inOwner, inPrev, inNext) // constructor
  519. {
  520. }
  521. int cgmEndMetafile::cgmOut(cgmOutput *inOut) // output in a CGM format
  522. {
  523.   return inOut->startCmd(this) && inOut->endCmd();
  524. }
  525. ////
  526. // display output
  527. ////
  528. int cgmEndMetafile::display(baseDisplay *inDisplay)
  529. {
  530.   inDisplay->endMF();
  531.   return 1;
  532. }
  533. ////
  534. // Begin Picture
  535. ////
  536. const int cgmBeginPicture::myElement = 3;
  537. const int cgmBeginPictureMyElement = 3;
  538. const char *cgmBeginPicture::myName = "BegPic";
  539. ////
  540. // constructor
  541. ////
  542. cgmBeginPicture::cgmBeginPicture(cgmContainer *inOwner, cgmInput *cgmIn,
  543.                  baseCGM *inPrev, baseCGM *inNext)
  544. : cgmDelimiter(inOwner, inPrev, inNext) // constructor
  545. {
  546.   picName = cgmIn->getString(picNameSize);
  547. }
  548. ////
  549. // alternate constructor
  550. ////
  551. cgmBeginPicture::cgmBeginPicture(cgmContainer *inOwner, const char *inStr,
  552.                  int strSize, baseCGM *inPrev, baseCGM *inNext)
  553. : cgmDelimiter(inOwner, inPrev, inNext) // constructor
  554. {
  555.   picNameSize = strSize;
  556.   if (picNameSize) {
  557.     picName = new char [picNameSize + 1];
  558.     for (int i=0; i<picNameSize; ++i) picName[i] = inStr[i];
  559.     picName[i] = 0;
  560.   } else picName = NULL;
  561. }
  562. ////
  563. // destructor
  564. ////
  565. cgmBeginPicture::~cgmBeginPicture()
  566. {
  567.   if (picNameSize) delete picName;
  568. }
  569. ////
  570. // output in a CGM format
  571. ////
  572. int cgmBeginPicture::cgmOut(cgmOutput *inOut) 
  573. {
  574.   inOut->startCmd(this);
  575.   inOut->outString(picNameSize ? picName : "");
  576.   inOut->endCmd();
  577.   return 1;
  578. }
  579. ////
  580. // display output
  581. ////
  582. int cgmBeginPicture::display(baseDisplay *inDisplay)
  583. {
  584.   inDisplay->newPic();
  585.   inDisplay->startPic();
  586.   if (inDisplay->picDefaults() && mfOwner()->defaults()) {
  587.     // display wants to get defaults replacement at each picture
  588.     mfOwner()->displayDefaults(inDisplay);
  589.   }
  590.   return 1;
  591. }
  592. ////
  593. // Begin Picture Body
  594. ////
  595. const int cgmBeginPictureBody::myElement = 4;
  596. const char *cgmBeginPictureBody::myName = "BegPicBody";
  597. ////
  598. // constructor
  599. ////
  600. cgmBeginPictureBody::cgmBeginPictureBody(cgmContainer *inOwner, cgmInput*,
  601.                      baseCGM *inPrev, baseCGM *inNext)
  602. : cgmDelimiter(inOwner, inPrev, inNext)
  603. {
  604. }
  605. ////
  606. // output in a CGM format
  607. ////
  608. int cgmBeginPictureBody::cgmOut(cgmOutput *inOut)
  609. {
  610.   inOut->startCmd(this);
  611.   inOut->endCmd();
  612.   return 1;
  613. }
  614. ////
  615. // display output
  616. ////
  617. int cgmBeginPictureBody::display(baseDisplay *inDisplay)
  618. {
  619.   inDisplay->newPicBody
  620.     (owner->vdcExtent()->width(), owner->vdcExtent()->height(),
  621.     -owner->vdcExtent()->minX(), -owner->vdcExtent()->minY());
  622.   inDisplay->clearScreen();
  623.   return 1;
  624. }
  625. ////
  626. // End Picture
  627. ////
  628. const int cgmEndPicture::myElement = 5;
  629. const int cgmEndPictureMyElement = 5;
  630.  
  631. const char *cgmEndPicture::myName = "EndPic";
  632. ////
  633. // constructor
  634. ////
  635. cgmEndPicture::cgmEndPicture(cgmContainer *inOwner, cgmInput*,
  636.                  baseCGM *inPrev, baseCGM *inNext)
  637. : cgmDelimiter(inOwner, inPrev, inNext)
  638. {
  639. }
  640. ////
  641. // output in a CGM format
  642. ////
  643. int cgmEndPicture::cgmOut(cgmOutput *inOut)
  644. {
  645.   inOut->startCmd(this);
  646.   inOut->endCmd();
  647.   return 1;
  648. }
  649. ////
  650. // display output
  651. ////
  652. int cgmEndPicture::display(baseDisplay *inDisplay)
  653. {
  654.   inDisplay->endPic();
  655.   return 1;
  656. }
  657. ////
  658. // the Metafile Descriptor class
  659. ////
  660. const int cgmMetafileDescriptor::myClass = 1;
  661. ////
  662. // Metafile Version
  663. ////
  664. const int cgmMetafileVersion::myElement = 1;
  665. const char *cgmMetafileVersion::myName = "MFVersion";
  666. ////
  667. // constructor
  668. ////
  669. cgmMetafileVersion::cgmMetafileVersion(cgmContainer *inOwner, cgmInput *cgmIn,
  670.                        baseCGM *inPrev, baseCGM *inNext)
  671. : cgmMetafileDescriptor(inOwner, inPrev, inNext)
  672. {
  673.   versionNumber = cgmIn->getInt();
  674.   mfOwner()->versionCmd = this;
  675. }
  676. ////
  677. // output in a CGM format
  678. ////
  679. int cgmMetafileVersion::cgmOut(cgmOutput *inOut)
  680. {
  681.   inOut->startCmd(this);
  682.   inOut->outInt(versionNumber);
  683.   inOut->endCmd();
  684.   return 1;
  685. }
  686. #ifdef macintosh
  687.  #pragma segment CGM2
  688. #endif
  689. ////
  690. // Metafile Description
  691. ////
  692. const int cgmMetafileDescription::myElement = 2;
  693. const char *cgmMetafileDescription::myName = "MFDesc";
  694. ////
  695. // constructor
  696. ////
  697. cgmMetafileDescription::
  698. cgmMetafileDescription(cgmContainer *inOwner, cgmInput *cgmIn,
  699.                baseCGM *inPrev, baseCGM *inNext)
  700. : cgmMetafileDescriptor(inOwner, inPrev, inNext)
  701. {
  702.   mfDescription = cgmIn->getString(mfDescriptionSize);
  703.   mfOwner()->descriptionCmd = this;
  704. }
  705. ////
  706. // destructor
  707. ////
  708. cgmMetafileDescription::~cgmMetafileDescription()
  709. {
  710.   if (mfDescriptionSize) delete mfDescription;
  711. }
  712. ////
  713. // output in a CGM format
  714. ////
  715. int cgmMetafileDescription::cgmOut(cgmOutput *inOut)
  716. {
  717.   inOut->startCmd(this);
  718.   inOut->outString(mfDescriptionSize ? mfDescription : "");
  719.   inOut->endCmd();
  720.   return 1;
  721. }
  722. ////
  723. // VDC Type
  724. ////
  725. const int cgmVdcType::myElement = 3;
  726. const int cgmVdcTypeMyElement = 3;
  727.  
  728. const char *cgmVdcType::myName = "VDCType";
  729. //// 
  730. // aids for parsing
  731. //// 
  732. const char *tmpVdcTypeList[] = {"INTEGER", "REAL"};
  733. const char **cgmVdcType::typeList = tmpVdcTypeList;
  734. const int cgmVdcType::typeListSize =
  735. sizeof(tmpVdcTypeList) / sizeof(tmpVdcTypeList[0]);
  736. //// 
  737. // constructor
  738. ////
  739. cgmVdcType::cgmVdcType(cgmContainer *inOwner, cgmInput *cgmIn,
  740.                baseCGM *inPrev, baseCGM *inNext)
  741. : cgmMetafileDescriptor(inOwner, inPrev, inNext)
  742. {
  743.   mfOwner()->vdcTypeCmd = this;
  744.   myType = cgmIn->getType(typeList, typeListSize);
  745. }
  746. //// 
  747. // output in a CGM format
  748. //// 
  749. int cgmVdcType::cgmOut(cgmOutput *inOut)
  750. {
  751.   inOut->startCmd(this);
  752.   inOut->outType(typeList, myType);
  753.   inOut->endCmd();
  754.   return 1;
  755. }
  756. //// 
  757. // Integer Precision
  758. //// 
  759. const int cgmIntegerPrec::myElement = 4;
  760. const int cgmIntegerPrecMyElement = 4;
  761. const char *cgmIntegerPrec::myName = "IntegerPrec";
  762. //// 
  763. // constructor
  764. //// 
  765. cgmIntegerPrec::cgmIntegerPrec(cgmContainer *inOwner, cgmInput *cgmIn,
  766.                    baseCGM *inPrev, baseCGM *inNext)
  767. : cgmMetafileDescriptor(inOwner, inPrev, inNext)
  768. {
  769.   cgmIn->getIntPrec(&thisPrec);
  770. }
  771. //// 
  772. // output in a CGM format
  773. //// 
  774. int cgmIntegerPrec::cgmOut(cgmOutput *inOut)
  775. {
  776.   inOut->startCmd(this);
  777.   inOut->outIntPrec(&thisPrec);
  778.   inOut->endCmd();
  779.   return 1;
  780. }
  781. //// 
  782. // Real Precision
  783. //// 
  784. const int cgmRealPrec::myElement = 5;
  785. const int cgmRealPrecMyElement = 5;
  786. const char *cgmRealPrec::myName = "RealPrec";
  787. //// 
  788. // constructor
  789. //// 
  790. cgmRealPrec::cgmRealPrec(cgmContainer *inOwner, cgmInput *cgmIn,
  791.              baseCGM *inPrev, baseCGM *inNext)
  792. : cgmMetafileDescriptor(inOwner, inPrev, inNext)
  793. {
  794.   cgmIn->getRealPrec(&thisPrec);
  795. }
  796. //// 
  797. // output in a CGM format
  798. //// 
  799. int cgmRealPrec::cgmOut(cgmOutput *inOut)
  800. {
  801.   inOut->startCmd(this);
  802.   inOut->outRealPrec(&thisPrec);
  803.   inOut->endCmd();
  804.   return 1;
  805. }
  806. //// 
  807. // Index Precision
  808. //// 
  809. const int cgmIndexPrec::myElement = 6;
  810. const int cgmIndexPrecMyElement = 6;
  811. const char *cgmIndexPrec::myName = "IndexPrec";
  812. //// 
  813. // constructor
  814. //// 
  815. cgmIndexPrec::cgmIndexPrec(cgmContainer *inOwner, cgmInput *cgmIn,
  816.                baseCGM *inPrev, baseCGM *inNext)
  817. : cgmMetafileDescriptor(inOwner, inPrev, inNext)
  818. {
  819.   cgmIn->getIntPrec(&thisPrec);
  820. }
  821. //// 
  822. // output in a CGM format
  823. //// 
  824. int cgmIndexPrec::cgmOut(cgmOutput *inOut)
  825. {
  826.   inOut->startCmd(this);
  827.   inOut->outIntPrec(&thisPrec);
  828.   inOut->endCmd();
  829.   return 1;
  830. }
  831. //// 
  832. // Colour Precision
  833. //// 
  834. const int cgmColrPrec::myElement = 7;
  835. const int cgmColrPrecMyElement = 7;
  836. const char *cgmColrPrec::myName = "ColrPrec";
  837. //// 
  838. // constructor
  839. //// 
  840. cgmColrPrec::cgmColrPrec(cgmContainer *inOwner, cgmInput *cgmIn,
  841.              baseCGM *inPrev, baseCGM *inNext)
  842. : cgmMetafileDescriptor(inOwner, inPrev, inNext)
  843. {
  844.   cgmIn->getIntPrec(&thisPrec);
  845. }
  846. //// 
  847. // output in a CGM format
  848. //// 
  849. int cgmColrPrec::cgmOut(cgmOutput *inOut)
  850. {
  851.   inOut->startCmd(this);
  852.   inOut->outIntPrec(&thisPrec);
  853.   inOut->endCmd();
  854.   return 1;
  855. }
  856. //// 
  857. // Colour Index Precision
  858. //// 
  859. const int cgmColrIndexPrec::myElement = 8;
  860. const int cgmColrIndexPrecMyElement = 8;
  861. const char *cgmColrIndexPrec::myName = "ColrIndexPrec";
  862. //// 
  863. // constructor
  864. //// 
  865. cgmColrIndexPrec::cgmColrIndexPrec(cgmContainer *inOwner, cgmInput *cgmIn,
  866.                    baseCGM *inPrev, baseCGM *inNext) 
  867. : cgmMetafileDescriptor(inOwner, inPrev, inNext)
  868. {
  869.   cgmIn->getIntPrec(&thisPrec);
  870. }
  871. //// 
  872. // output in a CGM format
  873. //// 
  874. int cgmColrIndexPrec::cgmOut(cgmOutput *inOut)
  875. {
  876.   inOut->startCmd(this);
  877.   inOut->outIntPrec(&thisPrec);
  878.   inOut->endCmd();
  879.   return 1;
  880. }
  881. //// 
  882. // Max Colour Index
  883. //// 
  884. const int cgmMaxColrIndex::myElement = 9;
  885. const char *cgmMaxColrIndex::myName = "MaxColrIndex";
  886. //// 
  887. // constructor
  888. //// 
  889. cgmMaxColrIndex::cgmMaxColrIndex(cgmContainer *inOwner, cgmInput *cgmIn,
  890.                  baseCGM *inPrev, baseCGM *inNext) 
  891. : cgmMetafileDescriptor(inOwner, inPrev, inNext)
  892. {
  893.   mfOwner()->maxColrIndexCmd = this;
  894.   // maxIndexValue = cgmIn->getInt();
  895.   maxIndexValue = cgmIn->getCI();
  896. }
  897. //// 
  898. // output in a CGM format
  899. //// 
  900. int cgmMaxColrIndex::cgmOut(cgmOutput *inOut)
  901. {
  902.   inOut->startCmd(this);
  903.   inOut->outInt(maxIndexValue);
  904.   inOut->endCmd();
  905.   return 1;
  906. }
  907. //// 
  908. // Colour Value Extent
  909. //// 
  910. const int cgmColrValueExtent::myElement = 10;
  911. const char *cgmColrValueExtent::myName = "ColrValueExt";
  912. //// 
  913. // constructor
  914. //// 
  915. cgmColrValueExtent::cgmColrValueExtent(cgmContainer *inOwner,cgmInput *cgmIn,
  916.                        baseCGM *inPrev, baseCGM *inNext) 
  917. : cgmMetafileDescriptor(inOwner, inPrev, inNext)
  918. {
  919.   mfOwner()->colrValueExtentCmd = this;
  920.   cgmIn->getDColr(myExtent.black);
  921.   cgmIn->getDColr(myExtent.white);
  922. }
  923. //// 
  924. // output in a CGM format
  925. //// 
  926. int cgmColrValueExtent::cgmOut(cgmOutput *inOut)
  927. {
  928.   inOut->startCmd(this);
  929.   inOut->outDColr(myExtent.white);
  930.   inOut->outDColr(myExtent.black);
  931.   inOut->endCmd();
  932.   return 1;
  933. }
  934. //// 
  935. // Metafile Element List
  936. //// 
  937. const int cgmMetafileElementList::myElement = 11;
  938. const char *cgmMetafileElementList::myName = "MFElemList";
  939. //// 
  940. // constructor
  941. //// 
  942. cgmMetafileElementList::
  943. cgmMetafileElementList(cgmContainer *inOwner, cgmInput *cgmIn,
  944.                baseCGM *inPrev, baseCGM *inNext) 
  945. : cgmMetafileDescriptor(inOwner, inPrev, inNext)
  946. {
  947.   // fix later
  948. }
  949. //// 
  950. // output in a CGM format
  951. //// 
  952. int cgmMetafileElementList::cgmOut(cgmOutput *inOut)
  953. {
  954.   inOut->startCmd(this);
  955.   inOut->endCmd();
  956.   return 1;
  957. }
  958. //// 
  959. // Metafile Defaults Replacement
  960. //// 
  961. const int cgmMetafileDefaultsReplacement::myElement = 12;
  962. const char *cgmMetafileDefaultsReplacement::myName = "BegMFDefaults";
  963. const char *cgmMetafileDefaultsReplacement::endName = "EndMFDefaults";
  964. //// 
  965. // constructor
  966. //// 
  967. cgmMetafileDefaultsReplacement::
  968. cgmMetafileDefaultsReplacement(cgmContainer *inOwner, cgmInput *cgmIn,
  969.                    baseCGM *inPrev, baseCGM *inNext)
  970. : cgmMetafileDescriptor(inOwner, inPrev, inNext)
  971. {
  972.   myDefaults = cgmIn->getDefaults(mfOwner()); // get the set of defaults
  973.   ////
  974.   // add them to the metafile list, 
  975.   mfOwner()->addDefaults(myDefaults); 
  976. }
  977. //// 
  978. // output in a CGM format
  979. //// 
  980. int cgmMetafileDefaultsReplacement::cgmOut(cgmOutput *inOut)
  981. { // output in a CGM format
  982.   inOut->startCmd(this);
  983.   inOut->outDefaults(myDefaults);
  984.   inOut->endCmd();
  985.   return 1;
  986. }
  987. ////
  988. // Font List
  989. ////
  990. const int cgmFontList::myElement = 13;
  991. const char *cgmFontList::myName = "FontList";
  992. ////
  993. // constructor
  994. ////
  995. cgmFontList::cgmFontList(cgmContainer *inOwner, cgmInput *cgmIn,
  996.              baseCGM *inPrev,  baseCGM *inNext)
  997. : cgmMetafileDescriptor(inOwner, inPrev, inNext)
  998. {
  999.   noFonts = 0;
  1000. }
  1001. ////
  1002. // output in a CGM format
  1003. ////
  1004. int cgmFontList::cgmOut(cgmOutput *inOut)
  1005. { 
  1006.   inOut->startCmd(this);
  1007.   inOut->endCmd();
  1008.   return 1;
  1009. }
  1010. ////
  1011. // Character Set List
  1012. ////
  1013. const int cgmCharacterSetList::myElement = 14;
  1014. const char *cgmCharacterSetList::myName = "CharSetList";
  1015. ////
  1016. // constructor
  1017. ////
  1018. cgmCharacterSetList::
  1019. cgmCharacterSetList(cgmContainer *inOwner, cgmInput *cgmIn,
  1020.             baseCGM *inPrev, baseCGM *inNext)
  1021. : cgmMetafileDescriptor(inOwner, inPrev, inNext)
  1022. {
  1023.   noSets = 0;
  1024. }
  1025. ////
  1026. // output in a CGM format
  1027. ////
  1028. int cgmCharacterSetList::cgmOut(cgmOutput *inOut)
  1029. { 
  1030.   inOut->startCmd(this);
  1031.   inOut->endCmd();
  1032.   return 1;
  1033. }
  1034. ////
  1035. // Character Coding Announcer
  1036. ////
  1037. const int cgmCharacterCodingAnnouncer::myElement = 15;
  1038. const char *cgmCharacterCodingAnnouncer::myName = "CharCoding";
  1039. ////
  1040. // aids for parsing
  1041. //// 
  1042. const char *tmpCodingList[] = {"BASIC7BIT", "BASIC8BIT", "EXTD7BIT",
  1043. "EXTD8BIT"};
  1044. const char **cgmCharacterCodingAnnouncer::typeList = tmpCodingList;
  1045. const int cgmCharacterCodingAnnouncer::typeListSize =
  1046. sizeof(tmpCodingList) / sizeof(tmpCodingList[0]);
  1047. ////
  1048. // constructor
  1049. ////
  1050. cgmCharacterCodingAnnouncer::
  1051. cgmCharacterCodingAnnouncer(cgmContainer *inOwner, cgmInput *cgmIn,
  1052.                 baseCGM *inPrev, baseCGM *inNext)
  1053. : cgmMetafileDescriptor(inOwner, inPrev, inNext)
  1054. {
  1055.   announcer = cgmIn->getType(typeList, typeListSize);
  1056. }
  1057. ////
  1058. // output CGM format
  1059. ////
  1060. int cgmCharacterCodingAnnouncer::cgmOut(cgmOutput *inOut)
  1061. { 
  1062.   inOut->startCmd(this);
  1063.   inOut->outType(typeList, announcer);
  1064.   inOut->endCmd();
  1065.   return 1;
  1066. }
  1067. ////
  1068. // the Picture Descriptor class
  1069. ////
  1070. const int cgmPictureDescriptor::myClass = 2;
  1071. ////
  1072. // Scaling Mode
  1073. ////
  1074. const int cgmScalingMode::myElement = 1;
  1075. const char *cgmScalingMode::myName = "ScaleMode";
  1076. ////
  1077. // aids for parsing
  1078. //// 
  1079. const char *tmpScalingList[] = {"ABSTRACT", "METRIC"};
  1080. const char **cgmScalingMode::typeList = tmpScalingList;
  1081. const int cgmScalingMode::typeListSize =
  1082. sizeof(tmpScalingList) / sizeof(tmpScalingList[0]);
  1083. //// 
  1084. // constructor
  1085. ////
  1086. cgmScalingMode::cgmScalingMode(cgmContainer *inOwner, cgmInput *cgmIn,
  1087.                    baseCGM *inPrev, baseCGM *inNext)
  1088. : cgmPictureDescriptor(inOwner, inPrev, inNext)
  1089. {
  1090.   owner->scalingCmd = this;
  1091.   mode = cgmIn->getType(typeList, typeListSize);
  1092.   if (mode) factor = cgmIn->getFP(); // always floating point
  1093.   else factor = 1; // for safety
  1094. }
  1095. ////
  1096. // output CGM format
  1097. ////
  1098. int cgmScalingMode::cgmOut(cgmOutput *inOut) 
  1099. { 
  1100.   inOut->startCmd(this);
  1101.   inOut->outType(typeList, mode);
  1102.   if (mode) inOut->outReal(factor);
  1103.   inOut->endCmd();
  1104.   return 1;
  1105. }
  1106. ////
  1107. // Colour Selection Mode
  1108. ////
  1109. const int cgmColrMode::myElement = 2;
  1110. const char *cgmColrMode::myName = "ColrMode";
  1111. ////
  1112. // aids for parsing
  1113. //// 
  1114. const char *tmpColrList[] = {"INDEXED", "DIRECT"};
  1115. const char **cgmColrMode::typeList = tmpColrList;
  1116. const int cgmColrMode::typeListSize =
  1117. sizeof(tmpColrList) / sizeof(tmpColrList[0]);
  1118. //// 
  1119. // constructor
  1120. //// 
  1121. cgmColrMode::cgmColrMode(cgmContainer *inOwner, cgmInput *cgmIn,
  1122.              baseCGM *inPrev, baseCGM *inNext)
  1123. : cgmPictureDescriptor(inOwner, inPrev, inNext)
  1124. {
  1125.   owner->colrModeCmd = this;
  1126.   mode = cgmIn->getType(typeList, typeListSize);
  1127. }
  1128. //// 
  1129. // output CGM format
  1130. //// 
  1131. int cgmColrMode::cgmOut(cgmOutput *inOut)
  1132. { 
  1133.   inOut->startCmd(this);
  1134.   inOut->outType(typeList, mode);
  1135.   inOut->endCmd();
  1136.   return 1;
  1137. }
  1138. ////
  1139. // Line Width Specification Mode
  1140. ////
  1141. const int cgmLineWidthMode::myElement = 3;
  1142. const char *cgmLineWidthMode::myName = "LineWidthMode";
  1143. ////
  1144. // aids for parsing
  1145. //// 
  1146. const char *tmpAbS[] = {"ABSTRACT", "SCALED"};
  1147. const char **cgmLineWidthMode::typeList = tmpAbS;
  1148. const int cgmLineWidthMode::typeListSize =
  1149. sizeof(tmpAbS) / sizeof(tmpAbS[0]);
  1150. ////
  1151. // constructor
  1152. ////
  1153. cgmLineWidthMode::cgmLineWidthMode(cgmContainer *inOwner, cgmInput *cgmIn,
  1154.                    baseCGM *inPrev, baseCGM *inNext)
  1155. : cgmPictureDescriptor(inOwner, inPrev, inNext)
  1156. {
  1157.   owner->lineModeCmd = this;
  1158.   mode = cgmIn->getType(typeList, typeListSize);
  1159. }
  1160. int cgmLineWidthMode::cgmOut(cgmOutput *inOut) // output CGM format
  1161. { 
  1162.   inOut->startCmd(this);
  1163.   inOut->outType(typeList, mode);
  1164.   inOut->endCmd();
  1165.   return 1;
  1166. }
  1167. ////
  1168. // Marker Size Specification Mode
  1169. ////
  1170. const int cgmMarkerSizeMode::myElement = 4;
  1171. const char *cgmMarkerSizeMode::myName = "MarkerSizeMode";
  1172. ////
  1173. // aids for parsing
  1174. //// 
  1175. const char **cgmMarkerSizeMode::typeList = tmpAbS;
  1176. const int cgmMarkerSizeMode::typeListSize =
  1177. sizeof(tmpAbS) / sizeof(tmpAbS[0]);
  1178. ////
  1179. // constructor
  1180. ////
  1181. cgmMarkerSizeMode::cgmMarkerSizeMode(cgmContainer *inOwner, cgmInput *cgmIn,
  1182.                      baseCGM *inPrev, baseCGM *inNext)
  1183. : cgmPictureDescriptor(inOwner, inPrev, inNext)
  1184. {
  1185.   mode = cgmIn->getType(typeList, typeListSize);
  1186.   owner->markerModeCmd = this;
  1187. }
  1188. ////
  1189. // output CGM format
  1190. ////
  1191. int cgmMarkerSizeMode::cgmOut(cgmOutput *inOut)
  1192. { 
  1193.   inOut->startCmd(this);
  1194.   inOut->outType(typeList, mode);
  1195.   inOut->endCmd();
  1196.   return 1;
  1197. }
  1198. ////
  1199. // Edge Width Specification Mode
  1200. ////
  1201. const int cgmEdgeWidthMode::myElement = 5;
  1202. const char *cgmEdgeWidthMode::myName = "EdgeWidthMode";
  1203. ////
  1204. // aids for parsing
  1205. //// 
  1206. const char **cgmEdgeWidthMode::typeList = tmpAbS;
  1207. const int cgmEdgeWidthMode::typeListSize =
  1208. sizeof(tmpAbS) / sizeof(tmpAbS[0]);
  1209. ////
  1210. // constructor
  1211. ////
  1212. cgmEdgeWidthMode::cgmEdgeWidthMode(cgmContainer *inOwner, cgmInput *cgmIn,
  1213.                    baseCGM *inPrev, baseCGM *inNext)
  1214. : cgmPictureDescriptor(inOwner, inPrev, inNext)
  1215. {
  1216.   mode = cgmIn->getType(typeList, typeListSize);
  1217.   owner->edgeModeCmd = this;
  1218. }
  1219. ////
  1220. // output CGM format
  1221. ////
  1222. int cgmEdgeWidthMode::cgmOut(cgmOutput *inOut) 
  1223. { 
  1224.   inOut->startCmd(this);
  1225.   inOut->outType(typeList, mode);
  1226.   inOut->endCmd();
  1227.   return 1;
  1228. }
  1229. ////
  1230. // VDC extent
  1231. ////
  1232. const int cgmVdcExtent::myElement = 6;
  1233. const char *cgmVdcExtent::myName = "VDCExt";
  1234. ////
  1235. // constructor
  1236. ////
  1237. cgmVdcExtent::cgmVdcExtent(cgmContainer *inOwner, cgmInput *cgmIn,
  1238.                baseCGM *inPrev, baseCGM *inNext)
  1239. : cgmPictureDescriptor(inOwner, inPrev, inNext) 
  1240. {
  1241.   myPts = cgmIn->getVdcPts(2);
  1242.   owner->vdcExtentCmd = this;
  1243. }
  1244. ////
  1245. // destructor
  1246. ////
  1247. cgmVdcExtent::~cgmVdcExtent() { 
  1248.   if (myPts) delete myPts;
  1249. }
  1250. ////
  1251. // output CGM format
  1252. ////
  1253. int cgmVdcExtent::cgmOut(cgmOutput *inOut) 
  1254. { 
  1255.   inOut->startCmd(this);
  1256.   inOut->outVdcPts(myPts);
  1257.   inOut->endCmd();
  1258.   return 1;
  1259. }
  1260. ////
  1261. // Background Colour
  1262. ////
  1263. const int cgmBackgroundColr::myElement = 7;
  1264. const char *cgmBackgroundColr::myName = "BackColr";
  1265. ////
  1266. // constructor
  1267. ////
  1268. cgmBackgroundColr::cgmBackgroundColr(cgmContainer *inOwner, cgmInput *cgmIn, baseCGM *inPrev,
  1269.                      baseCGM *inNext)
  1270. : cgmPictureDescriptor(inOwner, inPrev, inNext) 
  1271. {
  1272.   cgmIn->getDColr(background);
  1273. }
  1274. ////
  1275. // output CGM format
  1276. ////
  1277. int cgmBackgroundColr::cgmOut(cgmOutput *inOut) 
  1278. { 
  1279.   inOut->startCmd(this);
  1280.   inOut->outDColr(background);
  1281.   inOut->endCmd();
  1282.   return 1;
  1283. }
  1284. ////
  1285. // display output
  1286. ////
  1287. int cgmBackgroundColr::display(baseDisplay *inDisplay)
  1288. {
  1289.   genColr genBack(background, owner->colrExtent(), owner->colrs());
  1290.   ////
  1291.   // send a general colour for convenience
  1292.   inDisplay->backColr(genBack);
  1293.   return 1;
  1294. }
  1295. #ifdef macintosh
  1296.  #pragma segment CGM3
  1297. #endif
  1298. ////
  1299. // the Control class
  1300. ////
  1301. const int cgmControl::myClass = 3;
  1302. ////
  1303. // VDC Integer Precision
  1304. ////
  1305. const int cgmVdcInteger::myElement = 1;
  1306. const int cgmVdcIntegerMyElement = 1;
  1307. const char *cgmVdcInteger::myName = "VDCIntegerPrec";
  1308. ////
  1309. // constructor
  1310. ////
  1311. cgmVdcInteger::cgmVdcInteger(cgmContainer *inOwner, cgmInput *cgmIn,
  1312.                  baseCGM *inPrev, baseCGM *inNext) 
  1313. : cgmControl(inOwner, inPrev, inNext)
  1314. {
  1315.   cgmIn->getIntPrec(&thisPrec);
  1316. }
  1317. ////
  1318. // output CGM format
  1319. ////
  1320. int cgmVdcInteger::cgmOut(cgmOutput *inOut)
  1321. { 
  1322.   inOut->startCmd(this);
  1323.   inOut->outIntPrec(&thisPrec);
  1324.   inOut->endCmd();
  1325.   return 1;
  1326. }
  1327. ////
  1328. // VDC Real Precision
  1329. ////
  1330. const int cgmVdcReal::myElement = 2;
  1331. const int cgmVdcRealMyElement = 2;
  1332. const char *cgmVdcReal::myName = "VDCRealPrec";
  1333. ////
  1334. // constructor
  1335. ////
  1336. cgmVdcReal::cgmVdcReal(cgmContainer *inOwner, cgmInput *cgmIn,
  1337.                baseCGM *inPrev, baseCGM *inNext) 
  1338. : cgmControl(inOwner, inPrev, inNext)
  1339. {
  1340.   cgmIn->getRealPrec(&thisPrec);
  1341. }
  1342. ////
  1343. // output CGM format
  1344. ////
  1345. int cgmVdcReal::cgmOut(cgmOutput *inOut) 
  1346. { 
  1347.   inOut->startCmd(this);
  1348.   inOut->outRealPrec(&thisPrec);
  1349.   inOut->endCmd();
  1350.   return 1;
  1351. }
  1352. ////
  1353. // auxiliary colour
  1354. ////
  1355. const int cgmAuxColr::myElement = 3;
  1356. const char *cgmAuxColr::myName = "AuxColr";
  1357. ////
  1358. // constructor
  1359. ////
  1360. cgmAuxColr::cgmAuxColr(cgmContainer *inOwner, cgmInput *cgmIn,
  1361.                baseCGM *inPrev, baseCGM *inNext)
  1362. : cgmControl(inOwner, inPrev, inNext)
  1363. {
  1364.   myColr = cgmIn->getColr(owner->colrMode(), owner->colrExtent(),
  1365.               owner->colrs());
  1366. }
  1367. ////
  1368. // output in a CGM format
  1369. ////
  1370. int cgmAuxColr::cgmOut(cgmOutput *inOut)
  1371. {
  1372.   inOut->startCmd(this);
  1373.   inOut->outColr(myColr);
  1374.   inOut->endCmd();
  1375.   return 1;
  1376. }
  1377. ////
  1378. // transparency
  1379. ////
  1380. const int cgmTransparency::myElement = 4;
  1381. const char *cgmTransparency::myName = "Transparency";
  1382. //// 
  1383. // aids for parsing
  1384. //// 
  1385. const char *tmpTransparencyList[] = {"OFF", "ON"};
  1386. const char **cgmTransparency::typeList = tmpTransparencyList;
  1387. const int cgmTransparency::typeListSize =
  1388. sizeof(tmpTransparencyList) / sizeof(tmpTransparencyList[0]);
  1389. //// 
  1390. // constructor
  1391. ////
  1392. cgmTransparency::cgmTransparency(cgmContainer *inOwner, cgmInput *cgmIn,
  1393.                  baseCGM *inPrev, baseCGM *inNext)
  1394. : cgmControl(inOwner, inPrev, inNext)
  1395. {
  1396.   myType = cgmIn->getType(typeList, typeListSize);
  1397. }
  1398. //// 
  1399. // output in a CGM format
  1400. //// 
  1401. int cgmTransparency::cgmOut(cgmOutput *inOut)
  1402. {
  1403.   inOut->startCmd(this);
  1404.   inOut->outType(typeList, myType);
  1405.   inOut->endCmd();
  1406.   return 1;
  1407. }
  1408. ////
  1409. // display output
  1410. ////
  1411. int cgmTransparency::display(baseDisplay *inDisplay)
  1412. {
  1413.   inDisplay->transparency(myType);
  1414.   return 1;
  1415. }
  1416. ////
  1417. // clip rectangle
  1418. ////
  1419. const int cgmClipRect::myElement = 5;
  1420. const char *cgmClipRect::myName = "ClipRect";
  1421. ////
  1422. // constructor
  1423. ////
  1424. cgmClipRect::cgmClipRect(cgmContainer *inOwner, cgmInput *cgmIn,
  1425.              baseCGM *inPrev, baseCGM *inNext)
  1426. : cgmControl(inOwner, inPrev, inNext)
  1427. {
  1428.   myPts = cgmIn->getVdcPts(2);
  1429. }
  1430. ////
  1431. // output in a CGM format
  1432. ////
  1433. int cgmClipRect::cgmOut(cgmOutput *inOut)
  1434. {
  1435.   inOut->startCmd(this);
  1436.   inOut->outVdcPts(myPts);
  1437.   inOut->endCmd();
  1438.   return 1;
  1439. }
  1440. ////
  1441. // display output
  1442. ////
  1443. int cgmClipRect::display(baseDisplay *inDisplay)
  1444. {
  1445.   inDisplay->clipRect(myPts);
  1446.   return 1;
  1447. }
  1448. ////
  1449. // clip indicator
  1450. ////
  1451. const int cgmClip::myElement = 6;
  1452. const char *cgmClip::myName = "Clip";
  1453. //// 
  1454. // aids for parsing
  1455. //// 
  1456. const char *tmpClipList[] = {"OFF", "ON"};
  1457. const char **cgmClip::typeList = tmpClipList;
  1458. const int cgmClip::typeListSize =
  1459. sizeof(tmpClipList) / sizeof(tmpClipList[0]);
  1460. //// 
  1461. // constructor
  1462. ////
  1463. cgmClip::cgmClip(cgmContainer *inOwner, cgmInput *cgmIn,
  1464.                  baseCGM *inPrev, baseCGM *inNext)
  1465. : cgmControl(inOwner, inPrev, inNext)
  1466. {
  1467.   myType = cgmIn->getType(typeList, typeListSize);
  1468. }
  1469. //// 
  1470. // output in a CGM format
  1471. //// 
  1472. int cgmClip::cgmOut(cgmOutput *inOut)
  1473. {
  1474.   inOut->startCmd(this);
  1475.   inOut->outType(typeList, myType);
  1476.   inOut->endCmd();
  1477.   return 1;
  1478. }
  1479. ////
  1480. // display output
  1481. ////
  1482. int cgmClip::display(baseDisplay *inDisplay)
  1483. {
  1484.   inDisplay->clip(myType);
  1485.   return 1;
  1486. }
  1487. ////
  1488. // the Graphical Primitive class
  1489. ////
  1490. const int cgmGraphicalPrimitive::myClass = 4;
  1491. ////
  1492. // Polyline
  1493. ////
  1494. const int cgmPolyline::myElement = 1;
  1495. const char *cgmPolyline::myName = "Line";
  1496. ////
  1497. // constructor
  1498. ////
  1499. cgmPolyline::cgmPolyline(cgmContainer *inOwner, cgmInput *cgmIn,
  1500.              baseCGM *inPrev, baseCGM *inNext)
  1501. : cgmGraphicalPrimitive(inOwner, inPrev, inNext) 
  1502. {
  1503.   myPts = cgmIn->getVdcPts();
  1504. }
  1505. ////
  1506. // destructor
  1507. ////
  1508. cgmPolyline::~cgmPolyline() { 
  1509.   if (myPts) delete myPts;
  1510. }
  1511. ////
  1512. // output in a CGM format
  1513. ////
  1514. int cgmPolyline::cgmOut(cgmOutput *inOut) 
  1515. {
  1516.   inOut->startCmd(this);
  1517.   inOut->outVdcPts(myPts);
  1518.   inOut->endCmd();
  1519.   return 1;
  1520. }
  1521. ////
  1522. // display output
  1523. ////
  1524. int cgmPolyline::display(baseDisplay *inDisplay)
  1525. {
  1526.   inDisplay->polyline(myPts);
  1527.   return 1;
  1528. }
  1529. ////
  1530. // Disjoint Polyline
  1531. ////
  1532. const int cgmDisPolyline::myElement = 2;
  1533. const char *cgmDisPolyline::myName = "Disjtline";
  1534. ////
  1535. // constructor
  1536. ////
  1537. cgmDisPolyline::cgmDisPolyline(cgmContainer *inOwner, cgmInput *cgmIn,
  1538.                    baseCGM *inPrev, baseCGM *inNext)
  1539. : cgmGraphicalPrimitive(inOwner, inPrev, inNext) 
  1540. {
  1541.   myPts = cgmIn->getVdcPts();
  1542. }
  1543. ////
  1544. // destructor
  1545. ////
  1546. cgmDisPolyline::~cgmDisPolyline() { 
  1547.   if (myPts) delete myPts;
  1548. }
  1549. ////
  1550. // output in a CGM format
  1551. ////
  1552. int cgmDisPolyline::cgmOut(cgmOutput *inOut)
  1553. {
  1554.   inOut->startCmd(this);
  1555.   inOut->outVdcPts(myPts);
  1556.   inOut->endCmd();
  1557.   return 1;
  1558. }
  1559. ////
  1560. // display output
  1561. ////
  1562. int cgmDisPolyline::display(baseDisplay *inDisplay)
  1563. {
  1564.   inDisplay->disPolyline(myPts);
  1565.   return 1;
  1566. }
  1567. ////
  1568. // Polymarker
  1569. ////
  1570. const int cgmPolymarker::myElement = 3;
  1571. const char *cgmPolymarker::myName = "Marker";
  1572. ////
  1573. // constructor
  1574. ////
  1575. cgmPolymarker::cgmPolymarker(cgmContainer *inOwner, cgmInput *cgmIn,
  1576.                  baseCGM *inPrev, baseCGM *inNext)
  1577. : cgmGraphicalPrimitive(inOwner, inPrev, inNext)
  1578. {
  1579.   myPts = cgmIn->getVdcPts();
  1580. }
  1581. ////
  1582. // destructor
  1583. ////
  1584. cgmPolymarker::~cgmPolymarker() {
  1585.   if (myPts) delete myPts;
  1586. }
  1587. ////
  1588. // output in a CGM format
  1589. ////
  1590. int cgmPolymarker::cgmOut(cgmOutput *inOut) 
  1591. {
  1592.   inOut->startCmd(this);
  1593.   inOut->outVdcPts(myPts);
  1594.   inOut->endCmd();
  1595.   return 1;
  1596. }
  1597. ////
  1598. // display output
  1599. ////
  1600. int cgmPolymarker::display(baseDisplay *inDisplay)
  1601. {
  1602.   inDisplay->polymarker(myPts);
  1603.   return 1;
  1604. }
  1605. ////
  1606. // text
  1607. ////
  1608. const int cgmText::myElement = 4;
  1609. const char *cgmText::myName = "Text";
  1610. //// 
  1611. // aids for parsing
  1612. //// 
  1613. const char *tmpTextList[] = {"NOTFINAL", "FINAL"};
  1614. const char **cgmText::typeList = tmpTextList;
  1615. const int cgmText::typeListSize =
  1616. sizeof(tmpTextList) / sizeof(tmpTextList[0]);
  1617. ////
  1618. // constructor
  1619. ////
  1620. cgmText::cgmText(cgmContainer *inOwner, cgmInput *cgmIn,
  1621.          baseCGM *inPrev, baseCGM *inNext)
  1622. : cgmGraphicalPrimitive(inOwner, inPrev, inNext)
  1623. {
  1624.   int textSize;
  1625.   vdcPts *myPts = cgmIn->getVdcPts(1);
  1626.   int final = cgmIn->getType(typeList, typeListSize);
  1627.   char *text = cgmIn->getString(textSize);
  1628.   myText = new genText(&(owner->tInfo), final, text, textSize, myPts);
  1629. }
  1630. ////
  1631. // output in a CGM format
  1632. ////
  1633. int cgmText::cgmOut(cgmOutput *inOut)
  1634. {
  1635.   inOut->startCmd(this);
  1636.   inOut->outVdcPts(myText->pos());
  1637.   inOut->outType(typeList, myText->final());
  1638.   inOut->outString(myText->size() ? myText->contents() : "");
  1639.   inOut->endCmd();
  1640.   return 1;
  1641. }
  1642. ////
  1643. // display output
  1644. ////
  1645. int cgmText::display(baseDisplay *inDisplay)
  1646. {
  1647.   inDisplay->text(myText);
  1648.   return 1;
  1649. }
  1650. ////
  1651. // restricted text
  1652. ////
  1653. const int cgmRestrText::myElement = 5;
  1654. const char *cgmRestrText::myName = "RestrText";
  1655. //// 
  1656. // aids for parsing
  1657. //// 
  1658. const char **cgmRestrText::typeList = tmpTextList;
  1659. const int cgmRestrText::typeListSize =
  1660. sizeof(tmpTextList) / sizeof(tmpTextList[0]);
  1661. ////
  1662. // constructor
  1663. ////
  1664. cgmRestrText::cgmRestrText(cgmContainer *inOwner, cgmInput *cgmIn,
  1665.          baseCGM *inPrev, baseCGM *inNext)
  1666. : cgmGraphicalPrimitive(inOwner, inPrev, inNext)
  1667. {
  1668.   int textSize;
  1669.   maxWidth = cgmIn->getVdc();
  1670.   maxHeight = cgmIn->getVdc();
  1671.   vdcPts *myPts = cgmIn->getVdcPts(1);
  1672.   int final = cgmIn->getType(typeList, typeListSize);
  1673.   char *text = cgmIn->getString(textSize);
  1674.   myText = new genText(&(owner->tInfo), final, text, textSize,
  1675.                myPts, 0, maxHeight, maxWidth);
  1676. }
  1677. ////
  1678. // output in a CGM format
  1679. ////
  1680. int cgmRestrText::cgmOut(cgmOutput *inOut)
  1681. {
  1682.   inOut->startCmd(this);
  1683. //  inOut->outVdc(myText->width());
  1684. //  inOut->outVdc(myText->height());
  1685.   inOut->outVdc(maxWidth);
  1686.   inOut->outVdc(maxHeight);
  1687.   inOut->outVdcPts(myText->pos());
  1688.   inOut->outType(typeList, myText->final());
  1689.   inOut->outString(myText->size() ? myText->contents() : "");
  1690.   inOut->endCmd();
  1691.   return 1;
  1692. }
  1693. ////
  1694. // display output
  1695. ////
  1696. int cgmRestrText::display(baseDisplay *inDisplay)
  1697. {
  1698.   inDisplay->text(myText);
  1699.   return 1;
  1700. }
  1701. ////
  1702. // appended text
  1703. ////
  1704. const int cgmApndText::myElement = 6;
  1705. const char *cgmApndText::myName = "ApndText";
  1706. //// 
  1707. // aids for parsing
  1708. //// 
  1709. const char **cgmApndText::typeList = tmpTextList;
  1710. const int cgmApndText::typeListSize =
  1711. sizeof(tmpTextList) / sizeof(tmpTextList[0]);
  1712. ////
  1713. // constructor
  1714. ////
  1715. cgmApndText::cgmApndText(cgmContainer *inOwner, cgmInput *cgmIn,
  1716.          baseCGM *inPrev, baseCGM *inNext)
  1717. : cgmGraphicalPrimitive(inOwner, inPrev, inNext)
  1718. {
  1719.   int textSize;
  1720.   int final = cgmIn->getType(typeList, typeListSize);
  1721.   char *text = cgmIn->getString(textSize);
  1722.   myText = new genText(&(owner->tInfo), final, text, textSize);
  1723. }
  1724. ////
  1725. // output in a CGM format
  1726. ////
  1727. int cgmApndText::cgmOut(cgmOutput *inOut)
  1728. {
  1729.   inOut->startCmd(this);
  1730.   inOut->outType(typeList, myText->final());
  1731.   inOut->outString(myText->size() ? myText->contents() : "");
  1732.   inOut->endCmd();
  1733.   return 1;
  1734. }
  1735. ////
  1736. // display output
  1737. ////
  1738. int cgmApndText::display(baseDisplay *inDisplay)
  1739. {
  1740.   inDisplay->text(myText);
  1741.   return 1;
  1742. }
  1743. ////
  1744. // Polygon
  1745. ////
  1746. const int cgmPolygon::myElement = 7;
  1747. const char *cgmPolygon::myName = "Polygon";
  1748. cgmPolygon::cgmPolygon(cgmContainer *inOwner, cgmInput *cgmIn,
  1749.                baseCGM *inPrev, baseCGM *inNext)
  1750. : cgmGraphicalPrimitive(inOwner, inPrev, inNext) // constructor
  1751. {
  1752.   myPts = cgmIn->getVdcPts();
  1753. }
  1754. ////
  1755. // destructor
  1756. ////
  1757. cgmPolygon::~cgmPolygon() {
  1758.   if (myPts) delete myPts;
  1759. }
  1760. ////
  1761. // output in a CGM format
  1762. ////
  1763. int cgmPolygon::cgmOut(cgmOutput *inOut) 
  1764. {
  1765.   inOut->startCmd(this);
  1766.   inOut->outVdcPts(myPts);
  1767.   inOut->endCmd();
  1768.   return 1;
  1769. }
  1770. ////
  1771. // display output
  1772. ////
  1773. int cgmPolygon::display(baseDisplay *inDisplay)
  1774. {
  1775.   inDisplay->polygon(myPts);
  1776.   return 1;
  1777. }
  1778. ////
  1779. // Polygon Set
  1780. ////
  1781. // aids for parsing
  1782. //// 
  1783. const char *tmpPolygonSetList[] = {"INVIS", "VIS", "CLOSEINVIS", "CLOSEVIS"};
  1784. const char **cgmPolygonSet::typeList = tmpPolygonSetList;
  1785. const int cgmPolygonSet::typeListSize =
  1786. sizeof(tmpPolygonSetList) / sizeof(tmpPolygonSetList[0]);
  1787. //// 
  1788. const int cgmPolygonSet::myElement = 8;
  1789. const char *cgmPolygonSet::myName = "PolygonSet";
  1790. cgmPolygonSet::cgmPolygonSet(cgmContainer *inOwner, cgmInput *cgmIn,
  1791.                baseCGM *inPrev, baseCGM *inNext)
  1792. : cgmGraphicalPrimitive(inOwner, inPrev, inNext) // constructor
  1793. {
  1794.   cgmIn->polygonSet(myPts, myFlags);
  1795. }
  1796. ////
  1797. // output in a CGM format
  1798. ////
  1799. int cgmPolygonSet::cgmOut(cgmOutput *inOut) 
  1800. {
  1801.   inOut->startCmd(this);
  1802.   inOut->polygonSet(myPts, myFlags);
  1803.   inOut->endCmd();
  1804.   return 1;
  1805. }
  1806. ////
  1807. // display output
  1808. ////
  1809. int cgmPolygonSet::display(baseDisplay *inDisplay)
  1810. {
  1811.   inDisplay->polygonSet(myPts, myFlags);
  1812.   return 1;
  1813. }
  1814.  
  1815. ////
  1816. // Cell Array class
  1817. ////
  1818. // constructor
  1819. ////
  1820. cellArray::cellArray(int inColMode, const colrValueExtent *inExtent,
  1821.               vdcPts *inCorners, int inNx, int inNy,
  1822.               int inPrec, int inRepMode,
  1823.               const colrTable *inTable)
  1824. {
  1825.   char myString[40];
  1826.   // assign the private variables
  1827.   myColMode = inColMode;
  1828.   myExtent = inExtent;
  1829.   myCorners = inCorners;
  1830.   myNx = inNx;
  1831.   myNy = inNy;
  1832.   ////
  1833.   // check the legality of the precision
  1834.   if ((inPrec != 1) && (inPrec != 2) && (inPrec != 4) && (inPrec != 8) &&
  1835.         (inPrec != 16) && (inPrec != 24) && (inPrec != 32)) {
  1836.      sprintf(myString, "%d", inPrec);
  1837.      myError("illegal cell array precision", myString);
  1838.      myPrec = 8; // default
  1839.   } else myPrec = inPrec;
  1840.   myRepMode = inRepMode;
  1841.   myTable = inTable;
  1842.   ////
  1843.   // how much memory do we need (real men don't pad -- or deal with a pc!!!!)
  1844.   totalBits = (long)inNy * inNx * ((inColMode) ? 3 : 1) * inPrec;
  1845.   totalBytes = (totalBits + 7) / 8;
  1846.  
  1847. #if __MSDOS__
  1848.   if (totalBytes < (long)66000) totalBytes = 66000;
  1849.   hContentsBuffer = GlobalAlloc(GPTR,totalBytes);
  1850.   if (hContentsBuffer)   myContents = (HugePt)GlobalLock(hContentsBuffer);
  1851.   else myContents = NULL;
  1852. #else
  1853.   myContents = new unsigned char[totalBytes];
  1854.   for (int i=0; i<totalBytes; ++i) myContents[i] = 0;
  1855. #endif
  1856.   ////
  1857.   bitsAdded = 0; // no input values yet
  1858. }
  1859.  
  1860. cellArray::~cellArray()
  1861.     {
  1862.     delete myCorners;
  1863. #if __MSDOS__
  1864.   if (hContentsBuffer)
  1865.       {
  1866.       GlobalUnlock(hContentsBuffer);
  1867.       GlobalFree(hContentsBuffer);
  1868.       myContents = NULL;
  1869.       }
  1870. #endif
  1871.  
  1872.   if (myContents)    delete myContents;
  1873.     }
  1874. ////
  1875. // add one value
  1876. ////
  1877. int cellArray::addValue(unsigned int inVal)
  1878. {
  1879.   if ((bitsAdded + myPrec) > totalBits) return 0; // too many bits
  1880.   ////
  1881.   // note that since only valid values of prec are 1,2,4,8,16,24,32
  1882.   // value either fits within one byte or spans several whole bytes
  1883.   // hence we use the most convenient storage format
  1884.   int startByte = (int) (bitsAdded / 8);
  1885.   ////
  1886.   // note use of fallthru in switch statement
  1887.   switch (myPrec) {
  1888.   case 32:
  1889.      myContents[startByte] = 255 & ((inVal & (255 << 24)) >> 24); ++startByte;
  1890.   case 24:
  1891.      myContents[startByte] = 255 & ((inVal & (255 << 16)) >> 16); ++startByte;
  1892.   case 16:
  1893.      myContents[startByte] = 255 & ((inVal & (255 << 8)) >> 8); ++startByte;
  1894.   case 8:
  1895.      myContents[startByte] = 255 & inVal; break;  // end fallthru
  1896.   case 4:
  1897.      myContents[startByte] |= (15 & inVal) << (int) (bitsAdded % 8); break;
  1898.   case 2:
  1899.      myContents[startByte] |= (3 & inVal) << (int) (bitsAdded % 8); break;
  1900.   case 1:
  1901.      myContents[startByte] |= (1 & inVal) << (int) (bitsAdded % 8); break;
  1902.   }
  1903.   bitsAdded += myPrec;
  1904.   return 1;
  1905. }
  1906. ////
  1907. // add multiple values
  1908. ////
  1909. #if __MSDOS__
  1910. int cellArray::addValues(HugePt inPtr, int bitsAlong,  int noValues)
  1911. #else
  1912. int cellArray::addValues(unsigned char *inPtr, int bitsAlong,  int noValues)
  1913. #endif
  1914. {
  1915.   if ((bitsAdded + noValues * myPrec) > totalBits) return 0; // too many bits
  1916.   ////
  1917.   unsigned int inVal;
  1918.   unsigned long inByte, startByte, bitOffset;
  1919.   ////
  1920.   // note use of fallthru in switch statements
  1921.   for (int i=0; i<noValues; ++i) {
  1922.      inVal = 0;
  1923.      inByte = bitsAlong / (long)8;
  1924.      bitOffset = 8 - (myPrec + (bitsAlong % (long)8)); // only used if myprec < 8
  1925.      ////
  1926.      // first get the input value
  1927.      switch (myPrec) {
  1928.      case 32:
  1929.         inVal |= ((unsigned int) inPtr[inByte]) << 24; ++inByte;
  1930.      case 24:
  1931.         inVal |= ((unsigned int) inPtr[inByte]) << 16; ++inByte;
  1932.      case 16:
  1933.         inVal |= ((unsigned int) inPtr[inByte]) << 8; ++inByte;
  1934.      case 8:
  1935.         inVal |= inPtr[inByte]; // end fallthru
  1936.         break;
  1937.      case 4:
  1938.         inVal |= (inPtr[inByte] & (int) (15 << bitOffset)) >> (int) bitOffset;
  1939.         break;
  1940.      case 2:
  1941.         inVal |= (inPtr[inByte] & (int) (3 << bitOffset)) >> (int) bitOffset;
  1942.         break;
  1943.      case 1:
  1944.         inVal |= (inPtr[inByte] & (int) (1 << bitOffset)) >> (int) bitOffset;
  1945.         break;
  1946.      }
  1947.      bitsAlong += myPrec;
  1948.      // now put value into local memory
  1949.      startByte = bitsAdded / (long)8;
  1950.      switch (myPrec) {
  1951.      case 32:
  1952.         myContents[startByte] = 255 & ((inVal & (255 << 24)) >> 24); ++startByte;
  1953.      case 24:
  1954.         myContents[startByte] = 255 & ((inVal & (255 << 16)) >> 16); ++startByte;
  1955.      case 16:
  1956.         myContents[startByte] = 255 & ((inVal & (255 << 8)) >> 8); ++startByte;
  1957.      case 8:
  1958.         myContents[startByte] |= 255 & inVal;  // end fallthru
  1959.      break;
  1960.      case 4:
  1961.         myContents[startByte] |= (15 & inVal) << (int) (bitsAdded % 8);
  1962.         break;
  1963.      case 2:
  1964.         myContents[startByte] |= (3 & inVal) << (int) (bitsAdded % 8);
  1965.         break;
  1966.      case 1:
  1967.         myContents[startByte] |= (1 & inVal) << (int) (bitsAdded % 8);
  1968.         break;
  1969.      }
  1970.      bitsAdded += myPrec;
  1971.   }
  1972.   return 1;
  1973. }
  1974. ////
  1975. // get a single value as set of 3 floats
  1976. ////
  1977. float *cellArray::getFloats(unsigned long inIndex) const
  1978. {
  1979.   static float rValues[3];
  1980.   int i;
  1981.   if (inIndex >= (long)((long)myNx * myNy)) { // outside scope
  1982. //    for (i=0; i<3; ++i) rvalues[i] = 0;
  1983.      for (i=0; i<3; ++i) rValues[i] = 0;
  1984.      return rValues;
  1985.   }
  1986.   int useVal;
  1987.   if (myColMode) { // r,g,b format
  1988.      for (i=0; i<3; ++i) {
  1989.         useVal = getValue(inIndex * 3 + i);
  1990. //      if (useVal >= myExtent->white[i]) {
  1991.         if (useVal >= myExtent->white.getValue(i)) {
  1992.     rValues[i] = 1; // max possible
  1993. //      } else if (useVal <= myExtent->black[i]) {
  1994.         } else if (useVal <= myExtent->black.getValue(i)) {
  1995.     rValues[i] = 0; // min possible
  1996.         } else {
  1997. //    rValues[i] = (float) (useVal - myExtent->black[i]) /
  1998. //      (myExtent->white[i] - myExtent->black[i]);
  1999.     rValues[i] = (float) (useVal - myExtent->black.getValue(i)) /
  2000.       (myExtent->white.getValue(i) - myExtent->black.getValue(i));
  2001.         }
  2002.      }
  2003.   } else { // indexed
  2004.      int useIndex = getValue(inIndex);
  2005.      for (i=0; i<3; ++i) {
  2006. //      useVal = myTable->val(useIndex)[i];
  2007.         useVal = myTable->val(useIndex).getValue(i);
  2008. //      if (useVal >= myExtent->white[i]) {
  2009.         if (useVal >= myExtent->white.getValue(i)) {
  2010.     rValues[i] = 1; // max possible
  2011. //      } else if (useVal <= myExtent->black[i]) {
  2012.         } else if (useVal <= myExtent->black.getValue(i)) {
  2013.     rValues[i] = 0; // min possible
  2014.         } else {
  2015. //    rValues[i] = (float) (useVal - myExtent->black[i]) /
  2016. //      (myExtent->white[i] - myExtent->black[i]);
  2017.     rValues[i] = (float) (useVal - myExtent->black.getValue(i)) /
  2018.       (myExtent->white.getValue(i) - myExtent->black.getValue(i));
  2019.         }
  2020.      }
  2021.   }
  2022.   return rValues;
  2023. }
  2024. ////
  2025. // get one integer value
  2026. ////
  2027. unsigned int cellArray::getValue(unsigned long inIndex) const
  2028. {
  2029.   if (inIndex * myPrec > totalBits) { // outside scope
  2030.      return 0;
  2031.   }
  2032.   unsigned int outInt = 0;
  2033.   unsigned long bitsAlong = inIndex * myPrec;
  2034.   unsigned int bitOffset = (unsigned int) (bitsAlong & 7); // (bitsAlong % 8)
  2035.   unsigned long startByte = bitsAlong / 8;
  2036.   ////
  2037.   // note use of fallthru in switch statement
  2038.   switch (myPrec) {
  2039.   case 32:
  2040.      outInt |= ((unsigned int) myContents[startByte]) << 24; ++startByte;
  2041.   case 24:
  2042.      outInt |= ((unsigned int) myContents[startByte]) << 16; ++startByte;
  2043.   case 16:
  2044.      outInt |= ((unsigned int) myContents[startByte]) << 8; ++startByte;
  2045.   case 8:
  2046.      outInt |= myContents[startByte]; // end fallthru
  2047.      break;
  2048.   case 4:
  2049.      outInt |= (myContents[startByte] & (15 << bitOffset)) >> bitOffset;
  2050.      break;
  2051.   case 2:
  2052.      outInt |= (myContents[startByte] & (3 << bitOffset)) >> bitOffset;
  2053.      break;
  2054.   case 1:
  2055.      outInt |= (myContents[startByte] & (1 << bitOffset)) >> bitOffset;
  2056.      break;
  2057.   }
  2058.   return outInt;
  2059. }
  2060.  
  2061. // decompress
  2062. ////
  2063. void cellArray::decompress()
  2064. {
  2065. }
  2066. ////
  2067. // dump out as a set of grey values
  2068. ////
  2069. void cellArray::fillGrey(unsigned char* &inPtr) const
  2070. {
  2071.   float *myColrs;
  2072.   unsigned char *myPtr = inPtr = new unsigned char [nx() * ny()];
  2073.   for (int i=0; i<ny(); ++i) {
  2074.     for (int j=0; j<nx(); ++j) {
  2075.       myColrs = getFloats(j, i);
  2076.       *(myPtr++) = (unsigned char)
  2077.     (255.99 * (0.3 * myColrs[0] + 0.59 * myColrs[1] + 0.11 * myColrs[2]));
  2078.     }
  2079.   }
  2080. }
  2081. ////
  2082. // dump out as a set of colours
  2083. ////
  2084. void cellArray::fillColr(unsigned char* &inPtr) const
  2085. {
  2086.   float *myColrs;
  2087.   unsigned char *myPtr = inPtr = new unsigned char [nx() * ny() * 3];
  2088.   for (int i=0; i<ny(); ++i) {
  2089.      for (int j=0; j<nx(); ++j) {
  2090.       myColrs = getFloats(j, i);
  2091.       for (int k=0; k<3; ++k) {
  2092.     *(myPtr++) = (unsigned char) (255.99 * myColrs[k]);
  2093.       }
  2094.     }
  2095.   }
  2096. }
  2097.  
  2098. ////
  2099. // Cell Array element
  2100. ////
  2101. const int cgmCellArray::myElement = 9;
  2102. const char *cgmCellArray::myName = "CellArray";
  2103. cgmCellArray::cgmCellArray(cgmContainer *inOwner, cgmInput *cgmIn,
  2104.                baseCGM *inPrev, baseCGM *inNext)
  2105. : cgmGraphicalPrimitive(inOwner, inPrev, inNext) // constructor
  2106. {
  2107.   myCell = cgmIn->getCellArray(owner->colrMode(), owner->colrExtent(),
  2108.                    owner->colrs());
  2109. }
  2110. ////
  2111. // destructor
  2112. ////
  2113. cgmCellArray::~cgmCellArray() {
  2114.   if (myCell) delete myCell;
  2115. }
  2116. ////
  2117. // output in a CGM format
  2118. ////
  2119. int cgmCellArray::cgmOut(cgmOutput *inOut) 
  2120. {
  2121.   inOut->startCmd(this);
  2122.   inOut->outCellArray(myCell);
  2123.   inOut->endCmd();
  2124.   return 1;
  2125. }
  2126. ////
  2127. // display output
  2128. ////
  2129. int cgmCellArray::display(baseDisplay *inDisplay)
  2130. {
  2131.   inDisplay->cells(myCell);
  2132.   return 1;
  2133. }
  2134.  
  2135.  
  2136. ////
  2137. // Generalized Drawing Primitive
  2138. ////
  2139. const int cgmGDP::myElement = 10;
  2140. const char *cgmGDP::myName = "GDP";
  2141. cgmGDP::cgmGDP(cgmContainer *inOwner, cgmInput *cgmIn,
  2142.                baseCGM *inPrev, baseCGM *inNext)
  2143. : cgmGraphicalPrimitive(inOwner, inPrev, inNext) // constructor
  2144. {
  2145. }
  2146. ////
  2147. // output in a CGM format
  2148. ////
  2149. int cgmGDP::cgmOut(cgmOutput *inOut) 
  2150. {
  2151.   inOut->startCmd(this);
  2152.   inOut->endCmd();
  2153.   return 1;
  2154. }
  2155. ////
  2156. // display output
  2157. ////
  2158. int cgmGDP::display(baseDisplay *inDisplay)
  2159. {
  2160. //   inDisplay->GDP(myPts); // fix later
  2161.   return 1;
  2162. }
  2163. ////
  2164. // Rectangle
  2165. ////
  2166. const int cgmRectangle::myElement = 11;
  2167. const char *cgmRectangle::myName = "Rect";
  2168. ////
  2169. // constructor
  2170. ////
  2171. cgmRectangle::cgmRectangle(cgmContainer *inOwner, cgmInput *cgmIn,
  2172.                baseCGM *inPrev, baseCGM *inNext)
  2173. : cgmGraphicalPrimitive(inOwner, inPrev, inNext)
  2174. {
  2175.   myPts = cgmIn->getVdcPts(2);
  2176.   if (myPts->no() != 2) myError("not enough points for rectangle");
  2177. }
  2178. ////
  2179. // destructor
  2180. ////
  2181. cgmRectangle::~cgmRectangle() {
  2182.   if (myPts) delete myPts;
  2183. }
  2184. ////
  2185. // output in a CGM format
  2186. ////
  2187. int cgmRectangle::cgmOut(cgmOutput *inOut)
  2188. {
  2189.   inOut->startCmd(this);
  2190.   inOut->outVdcPts(myPts);
  2191.   inOut->endCmd();
  2192.   return 1;
  2193. }
  2194. ////
  2195. // display output
  2196. ////
  2197. int cgmRectangle::display(baseDisplay *inDisplay)
  2198. {
  2199.   inDisplay->rectangle(myPts);
  2200.   return 1;
  2201. }
  2202. ////
  2203. // Circle
  2204. ////
  2205. const int cgmCircle::myElement = 12;
  2206. const char *cgmCircle::myName = "Circle";
  2207. ////
  2208. // constructor
  2209. ////
  2210. cgmCircle::cgmCircle(cgmContainer *inOwner, cgmInput *cgmIn,
  2211.              baseCGM *inPrev, baseCGM *inNext)
  2212. : cgmGraphicalPrimitive(inOwner, inPrev, inNext)
  2213. {
  2214.   centre = cgmIn->getVdcPts(1);
  2215.   radius = cgmIn->getVdc();
  2216. }
  2217. ////
  2218. // destructor
  2219. ////
  2220. cgmCircle::~cgmCircle() {
  2221.   if (centre) delete centre;
  2222.   if (radius) delete radius;
  2223. }
  2224. ////
  2225. // output in a CGM format
  2226. ////
  2227. int cgmCircle::cgmOut(cgmOutput *inOut)
  2228. {
  2229.   inOut->startCmd(this);
  2230.   inOut->outVdcPts(centre);
  2231.   inOut->outVdc(radius);
  2232.   inOut->endCmd();
  2233.   return 1;
  2234. }
  2235. ////
  2236. // display output
  2237. ////
  2238. int cgmCircle::display(baseDisplay *inDisplay)
  2239. {
  2240.   inDisplay->circle(centre, radius);
  2241.   return 1;
  2242. }
  2243. ////
  2244. // Circular arc, 3 pts
  2245. ////
  2246. const int cgmArc3Pt::myElement = 13;
  2247. const char *cgmArc3Pt::myName = "Arc3Pt";
  2248. ////
  2249. // constructor
  2250. ////
  2251. cgmArc3Pt::cgmArc3Pt(cgmContainer *inOwner, cgmInput *cgmIn,
  2252.              baseCGM *inPrev, baseCGM *inNext)
  2253. : cgmGraphicalPrimitive(inOwner, inPrev, inNext)
  2254. {
  2255.   myPts = cgmIn->getVdcPts(3);
  2256. }
  2257. ////
  2258. // output in a CGM format
  2259. ////
  2260. int cgmArc3Pt::cgmOut(cgmOutput *inOut)
  2261. {
  2262.   inOut->startCmd(this);
  2263.   inOut->outVdcPts(myPts);
  2264.   inOut->endCmd();
  2265.   return 1;
  2266. }
  2267. ////
  2268. // display output
  2269. ////
  2270. int cgmArc3Pt::display(baseDisplay *inDisplay)
  2271. {
  2272.   inDisplay->arc3Pt(myPts, -1); // -1 -> not closed
  2273.   return 1;
  2274. }
  2275. ////
  2276. // Circular arc, 3 pts, closed
  2277. ////
  2278. const int cgmArc3PtClose::myElement = 14;
  2279. const char *cgmArc3PtClose::myName = "Arc3PtClose";
  2280. //// 
  2281. // aids for parsing
  2282. //// 
  2283. const char *tmpCloseList[] = {"PIE", "CHORD"};
  2284. const char **cgmArc3PtClose::typeList = tmpCloseList;
  2285. const int cgmArc3PtClose::typeListSize =
  2286. sizeof(tmpCloseList) / sizeof(tmpCloseList[0]);
  2287. ////
  2288. // constructor
  2289. ////
  2290. cgmArc3PtClose::cgmArc3PtClose(cgmContainer *inOwner, cgmInput *cgmIn,
  2291.              baseCGM *inPrev, baseCGM *inNext)
  2292. : cgmGraphicalPrimitive(inOwner, inPrev, inNext)
  2293. {
  2294.   myPts = cgmIn->getVdcPts(3);
  2295.   myType = cgmIn->getType(typeList, typeListSize);
  2296. }
  2297. ////
  2298. // output in a CGM format
  2299. ////
  2300. int cgmArc3PtClose::cgmOut(cgmOutput *inOut)
  2301. {
  2302.   inOut->startCmd(this);
  2303.   inOut->outVdcPts(myPts);
  2304.   inOut->outType(typeList, myType);
  2305.   inOut->endCmd();
  2306.   return 1;
  2307. }
  2308. ////
  2309. // display output
  2310. ////
  2311. int cgmArc3PtClose::display(baseDisplay *inDisplay)
  2312. {
  2313.   inDisplay->arc3Pt(myPts, myType);
  2314.   return 1;
  2315. }
  2316. ////
  2317. // Circular arc, centre, 2 vectors and a radius
  2318. ////
  2319. const int cgmArcCtr::myElement = 15;
  2320. const char *cgmArcCtr::myName = "ArcCtr";
  2321. ////
  2322. // constructor
  2323. ////
  2324. cgmArcCtr::cgmArcCtr(cgmContainer *inOwner, cgmInput *cgmIn,
  2325.              baseCGM *inPrev, baseCGM *inNext)
  2326. : cgmGraphicalPrimitive(inOwner, inPrev, inNext)
  2327. {
  2328.   myPts = cgmIn->getVdcPts(3);
  2329.   radius =  cgmIn->getVdc();
  2330. }
  2331. ////
  2332. // output in a CGM format
  2333. ////
  2334. int cgmArcCtr::cgmOut(cgmOutput *inOut)
  2335. {
  2336.   inOut->startCmd(this);
  2337.   inOut->outVdcPts(myPts);
  2338.   inOut->outVdc(radius);
  2339.   inOut->endCmd();
  2340.   return 1;
  2341. }
  2342. ////
  2343. // display output
  2344. ////
  2345. int cgmArcCtr::display(baseDisplay *inDisplay)
  2346. {
  2347.   inDisplay->arcCtr(myPts, radius, -1); // -1 -> not closed
  2348.   return 1;
  2349. }
  2350. ////
  2351. // Circular arc, centre, 2 vectors and a radius, closed
  2352. ////
  2353. const int cgmArcCtrClose::myElement = 16;
  2354. const char *cgmArcCtrClose::myName = "ArcCtrClose";
  2355. //// 
  2356. // aids for parsing
  2357. //// 
  2358. const char **cgmArcCtrClose::typeList = tmpCloseList;
  2359. const int cgmArcCtrClose::typeListSize =
  2360. sizeof(tmpCloseList) / sizeof(tmpCloseList[0]);
  2361. ////
  2362. // constructor
  2363. ////
  2364. cgmArcCtrClose::cgmArcCtrClose(cgmContainer *inOwner, cgmInput *cgmIn,
  2365.              baseCGM *inPrev, baseCGM *inNext)
  2366. : cgmGraphicalPrimitive(inOwner, inPrev, inNext)
  2367. {
  2368.   myPts = cgmIn->getVdcPts(3);
  2369.   radius =  cgmIn->getVdc();
  2370.   myType = cgmIn->getType(typeList, typeListSize);
  2371. }
  2372. ////
  2373. // output in a CGM format
  2374. ////
  2375. int cgmArcCtrClose::cgmOut(cgmOutput *inOut)
  2376. {
  2377.   inOut->startCmd(this);
  2378.   inOut->outVdcPts(myPts);
  2379.   inOut->outVdc(radius);
  2380.   inOut->outType(typeList, myType);
  2381.   inOut->endCmd();
  2382.   return 1;
  2383. }
  2384. ////
  2385. // display output
  2386. ////
  2387. int cgmArcCtrClose::display(baseDisplay *inDisplay)
  2388. {
  2389.   inDisplay->arcCtr(myPts, radius, myType); 
  2390.   return 1;
  2391. }
  2392. ////
  2393. // Ellipse, specified by 3 pts
  2394. ////
  2395. const int cgmEllipse::myElement = 17;
  2396. const char *cgmEllipse::myName = "Ellipse";
  2397. ////
  2398. // constructor
  2399. ////
  2400. cgmEllipse::cgmEllipse(cgmContainer *inOwner, cgmInput *cgmIn,
  2401.              baseCGM *inPrev, baseCGM *inNext)
  2402. : cgmGraphicalPrimitive(inOwner, inPrev, inNext)
  2403. {
  2404.   myPts = cgmIn->getVdcPts(3);
  2405. }
  2406. ////
  2407. // output in a CGM format
  2408. ////
  2409. int cgmEllipse::cgmOut(cgmOutput *inOut)
  2410. {
  2411.   inOut->startCmd(this);
  2412.   inOut->outVdcPts(myPts);
  2413.   inOut->endCmd();
  2414.   return 1;
  2415. }
  2416. ////
  2417. // display output
  2418. ////
  2419. int cgmEllipse::display(baseDisplay *inDisplay)
  2420. {
  2421.   inDisplay->ellipse(myPts);
  2422.   return 1;
  2423. }
  2424. ////
  2425. // Elliptical arc, specified by 5 pts
  2426. ////
  2427. const int cgmEllipArc::myElement = 18;
  2428. const char *cgmEllipArc::myName = "EllipArc";
  2429. ////
  2430. // constructor
  2431. ////
  2432. cgmEllipArc::cgmEllipArc(cgmContainer *inOwner, cgmInput *cgmIn,
  2433.              baseCGM *inPrev, baseCGM *inNext)
  2434. : cgmGraphicalPrimitive(inOwner, inPrev, inNext)
  2435. {
  2436.   myPts = cgmIn->getVdcPts(5);
  2437. }
  2438. ////
  2439. // output in a CGM format
  2440. ////
  2441. int cgmEllipArc::cgmOut(cgmOutput *inOut)
  2442. {
  2443.   inOut->startCmd(this);
  2444.   inOut->outVdcPts(myPts);
  2445.   inOut->endCmd();
  2446.   return 1;
  2447. }
  2448. ////
  2449. // display output
  2450. ////
  2451. int cgmEllipArc::display(baseDisplay *inDisplay)
  2452. {
  2453.   inDisplay->ellipArc(myPts, -1);
  2454.   return 1;
  2455. }
  2456. ////
  2457. // Elliptical arc, specified by 5 pts, closed
  2458. ////
  2459. const int cgmEllipArcClose::myElement = 19;
  2460. const char *cgmEllipArcClose::myName = "EllipArcClose";
  2461. //// 
  2462. // aids for parsing
  2463. //// 
  2464. const char **cgmEllipArcClose::typeList = tmpCloseList;
  2465. const int cgmEllipArcClose::typeListSize =
  2466. sizeof(tmpCloseList) / sizeof(tmpCloseList[0]);
  2467. ////
  2468. // constructor
  2469. ////
  2470. cgmEllipArcClose::cgmEllipArcClose(cgmContainer *inOwner, cgmInput *cgmIn,
  2471.              baseCGM *inPrev, baseCGM *inNext)
  2472. : cgmGraphicalPrimitive(inOwner, inPrev, inNext)
  2473. {
  2474.   myPts = cgmIn->getVdcPts(5);
  2475.   myType = cgmIn->getType(typeList, typeListSize);
  2476. }
  2477. ////
  2478. // output in a CGM format
  2479. ////
  2480. int cgmEllipArcClose::cgmOut(cgmOutput *inOut)
  2481. {
  2482.   inOut->startCmd(this);
  2483.   inOut->outVdcPts(myPts);
  2484.   inOut->outType(typeList, myType);
  2485.   inOut->endCmd();
  2486.   return 1;
  2487. }
  2488. ////
  2489. // display output
  2490. ////
  2491. int cgmEllipArcClose::display(baseDisplay *inDisplay)
  2492. {
  2493.   inDisplay->ellipArc(myPts, myType);
  2494.   return 1;
  2495. }
  2496. ////
  2497. // the Attribute class
  2498. ////
  2499. const int cgmAttribute::myClass = 5;
  2500. ////
  2501. // line bundle index
  2502. ////
  2503. const int cgmLineIndex::myElement = 1;
  2504. const char *cgmLineIndex::myName = "LineIndex";
  2505. ////
  2506. // constructor
  2507. ////
  2508. cgmLineIndex::cgmLineIndex(cgmContainer *inOwner, cgmInput *cgmIn,
  2509.                baseCGM *inPrev, baseCGM *inNext)
  2510. : cgmAttribute(inOwner, inPrev, inNext)
  2511. {
  2512.   myIndex = cgmIn->getInt();
  2513. }
  2514. ////
  2515. // output in a CGM format
  2516. ////
  2517. int cgmLineIndex::cgmOut(cgmOutput *inOut)
  2518. {
  2519.   inOut->startCmd(this);
  2520.   inOut->outInt(myIndex);
  2521.   inOut->endCmd();
  2522.   return 1;
  2523. }
  2524. ////
  2525. // display output
  2526. ////
  2527. int cgmLineIndex::display(baseDisplay *inDisplay)
  2528. {
  2529.   inDisplay->lineIndex(myIndex);
  2530.   return 1;
  2531. }
  2532. #ifdef macintosh
  2533.  #pragma segment CGM4
  2534. #endif
  2535. ////
  2536. // line type
  2537. ////
  2538. const int cgmLineType::myElement = 2;
  2539. const char *cgmLineType::myName = "LineType";
  2540. ////
  2541. // constructor
  2542. ////
  2543. cgmLineType::cgmLineType(cgmContainer *inOwner, cgmInput *cgmIn,
  2544.              baseCGM *inPrev, baseCGM *inNext)
  2545. : cgmAttribute(inOwner, inPrev, inNext)
  2546. {
  2547.   myType = cgmIn->getInt();
  2548. }
  2549. ////
  2550. // output in a CGM format
  2551. ////
  2552. int cgmLineType::cgmOut(cgmOutput *inOut)
  2553. {
  2554.   inOut->startCmd(this);
  2555.   inOut->outInt(myType);
  2556.   inOut->endCmd();
  2557.   return 1;
  2558. }
  2559. ////
  2560. // display output
  2561. ////
  2562. int cgmLineType::display(baseDisplay *inDisplay)
  2563. {
  2564.   inDisplay->lineType(myType);
  2565.   return 1;
  2566. }
  2567. ////
  2568. // line width
  2569. ////
  2570. const int cgmLineWidth::myElement = 3;
  2571. const char *cgmLineWidth::myName = "LineWidth";
  2572. ////
  2573. // constructor
  2574. ////
  2575. cgmLineWidth::cgmLineWidth(cgmContainer *inOwner, cgmInput *cgmIn,
  2576.                baseCGM *inPrev, baseCGM *inNext)
  2577. : cgmAttribute(inOwner, inPrev, inNext)
  2578. {
  2579.   myVdcR = (owner->lineMode()) ? new vdcR(cgmIn->getReal()) // scaled
  2580.     : new vdcR(cgmIn->getVdc()); // absolute
  2581. }
  2582. ////
  2583. // destructor
  2584. ////
  2585. cgmLineWidth::~cgmLineWidth()
  2586. {
  2587.   if (myVdcR) delete myVdcR;
  2588. }
  2589. ////
  2590. // output in a CGM format
  2591. ////
  2592. int cgmLineWidth::cgmOut(cgmOutput *inOut)
  2593. {
  2594.   inOut->startCmd(this);
  2595.   if (myVdcR->type()) inOut->outReal(myVdcR->f()); // scaled
  2596.   else inOut->outVdc(myVdcR->v()); // absolute
  2597.   inOut->endCmd();
  2598.   return 1;
  2599. }
  2600. ////
  2601. // display output
  2602. ////
  2603. int cgmLineWidth::display(baseDisplay *inDisplay)
  2604. {
  2605.   inDisplay->lineWidth(myVdcR);
  2606.   return 1;
  2607. }
  2608. ////
  2609. // line colour
  2610. ////
  2611. const int cgmLineColr::myElement = 4;
  2612. const char *cgmLineColr::myName = "LineColr";
  2613. ////
  2614. // constructor
  2615. ////
  2616. cgmLineColr::cgmLineColr(cgmContainer *inOwner, cgmInput *cgmIn,
  2617.                baseCGM *inPrev, baseCGM *inNext)
  2618. : cgmAttribute(inOwner, inPrev, inNext)
  2619. {
  2620.   myColr = cgmIn->getColr(owner->colrMode(), owner->colrExtent(),
  2621.               owner->colrs());
  2622. }
  2623. ////
  2624. // output in a CGM format
  2625. ////
  2626. int cgmLineColr::cgmOut(cgmOutput *inOut)
  2627. {
  2628.   inOut->startCmd(this);
  2629.   inOut->outColr(myColr);
  2630.   inOut->endCmd();
  2631.   return 1;
  2632. }
  2633. ////
  2634. // display output
  2635. ////
  2636. int cgmLineColr::display(baseDisplay *inDisplay)
  2637. {
  2638.   if (myColr) inDisplay->lineColr(*myColr);
  2639.   return 1;
  2640. }
  2641. ////
  2642. // Marker bundle index
  2643. ////
  2644. const int cgmMarkerIndex::myElement = 5;
  2645. const char *cgmMarkerIndex::myName = "MarkerIndex";
  2646. ////
  2647. // constructor
  2648. ////
  2649. cgmMarkerIndex::cgmMarkerIndex(cgmContainer *inOwner, cgmInput *cgmIn,
  2650.                baseCGM *inPrev, baseCGM *inNext)
  2651. : cgmAttribute(inOwner, inPrev, inNext)
  2652. {
  2653.   myIndex = cgmIn->getInt();
  2654. }
  2655. ////
  2656. // output in a CGM format
  2657. ////
  2658. int cgmMarkerIndex::cgmOut(cgmOutput *inOut)
  2659. {
  2660.   inOut->startCmd(this);
  2661.   inOut->outInt(myIndex);
  2662.   inOut->endCmd();
  2663.   return 1;
  2664. }
  2665. ////
  2666. // display output
  2667. ////
  2668. int cgmMarkerIndex::display(baseDisplay *inDisplay)
  2669. {
  2670.   inDisplay->markerIndex(myIndex);
  2671.   return 1;
  2672. }
  2673. ////
  2674. // marker type
  2675. ////
  2676. const int cgmMarkerType::myElement = 6;
  2677. const char *cgmMarkerType::myName = "MarkerType";
  2678. ////
  2679. // constructor
  2680. ////
  2681. cgmMarkerType::cgmMarkerType(cgmContainer *inOwner, cgmInput *cgmIn,
  2682.              baseCGM *inPrev, baseCGM *inNext)
  2683. : cgmAttribute(inOwner, inPrev, inNext)
  2684. {
  2685.   myType = cgmIn->getInt();
  2686. }
  2687. ////
  2688. // output in a CGM format
  2689. ////
  2690. int cgmMarkerType::cgmOut(cgmOutput *inOut)
  2691. {
  2692.   inOut->startCmd(this);
  2693.   inOut->outInt(myType);
  2694.   inOut->endCmd();
  2695.   return 1;
  2696. }
  2697. ////
  2698. // display output
  2699. ////
  2700. int cgmMarkerType::display(baseDisplay *inDisplay)
  2701. {
  2702.   inDisplay->markerType(myType);
  2703.   return 1;
  2704. }
  2705. ////
  2706. // marker size
  2707. ////
  2708. const int cgmMarkerSize::myElement = 7;
  2709. const char *cgmMarkerSize::myName = "MarkerSize";
  2710. ////
  2711. // constructor
  2712. ////
  2713. cgmMarkerSize::cgmMarkerSize(cgmContainer *inOwner, cgmInput *cgmIn,
  2714.                  baseCGM *inPrev, baseCGM *inNext)
  2715. : cgmAttribute(inOwner, inPrev, inNext)
  2716. {
  2717.   myVdcR = (owner->markerMode()) ? new vdcR(cgmIn->getReal()) // scaled
  2718.     : new vdcR(cgmIn->getVdc()); // absolute
  2719. }
  2720. ////
  2721. // destructor
  2722. ////
  2723. cgmMarkerSize::~cgmMarkerSize()
  2724. {
  2725.   if (myVdcR) delete myVdcR;
  2726. }
  2727. ////
  2728. // output in a CGM format
  2729. ////
  2730. int cgmMarkerSize::cgmOut(cgmOutput *inOut)
  2731. {
  2732.   inOut->startCmd(this);
  2733.   if (myVdcR->type()) inOut->outReal(myVdcR->f()); // scaled
  2734.   else inOut->outVdc(myVdcR->v()); // absolute
  2735.   inOut->endCmd();
  2736.   return 1;
  2737. }
  2738. ////
  2739. // display output
  2740. ////
  2741. int cgmMarkerSize::display(baseDisplay *inDisplay)
  2742. {
  2743.   inDisplay->markerSize(myVdcR);
  2744.   return 1;
  2745. }
  2746. ////
  2747. // marker colour
  2748. ////
  2749. const int cgmMarkerColr::myElement = 8;
  2750. const char *cgmMarkerColr::myName = "MarkerColr";
  2751. ////
  2752. // constructor
  2753. ////
  2754. cgmMarkerColr::cgmMarkerColr(cgmContainer *inOwner, cgmInput *cgmIn,
  2755.                baseCGM *inPrev, baseCGM *inNext)
  2756. : cgmAttribute(inOwner, inPrev, inNext)
  2757. {
  2758.   myColr = cgmIn->getColr(owner->colrMode(), owner->colrExtent(),
  2759.               owner->colrs());
  2760. }
  2761. ////
  2762. // output in a CGM format
  2763. ////
  2764. int cgmMarkerColr::cgmOut(cgmOutput *inOut)
  2765. {
  2766.   inOut->startCmd(this);
  2767.   inOut->outColr(myColr);
  2768.   inOut->endCmd();
  2769.   return 1;
  2770. }
  2771. ////
  2772. // display output
  2773. ////
  2774. int cgmMarkerColr::display(baseDisplay *inDisplay)
  2775. {
  2776.   if (myColr) inDisplay->markerColr(*myColr);
  2777.   return 1;
  2778. }
  2779. ////
  2780. // text bundle index
  2781. ////
  2782. const int cgmTextIndex::myElement = 9;
  2783. const char *cgmTextIndex::myName = "TextIndex";
  2784. ////
  2785. // constructor
  2786. ////
  2787. cgmTextIndex::cgmTextIndex(cgmContainer *inOwner, cgmInput *cgmIn,
  2788.                baseCGM *inPrev, baseCGM *inNext)
  2789. : cgmAttribute(inOwner, inPrev, inNext)
  2790. {
  2791.   myIndex = cgmIn->getInt();
  2792. }
  2793. ////
  2794. // output in a CGM format
  2795. ////
  2796. int cgmTextIndex::cgmOut(cgmOutput *inOut)
  2797. {
  2798.   inOut->startCmd(this);
  2799.   inOut->outInt(myIndex);
  2800.   inOut->endCmd();
  2801.   return 1;
  2802. }
  2803. ////
  2804. // display output
  2805. ////
  2806. int cgmTextIndex::display(baseDisplay *inDisplay)
  2807. {
  2808.   inDisplay->textIndex(myIndex);
  2809.   return 1;
  2810. }
  2811. ////
  2812. // text font index
  2813. ////
  2814. const int cgmFontIndex::myElement = 10;
  2815. const char *cgmFontIndex::myName = "TextFontIndex";
  2816. ////
  2817. // constructor
  2818. ////
  2819. cgmFontIndex::cgmFontIndex(cgmContainer *inOwner, cgmInput *cgmIn,
  2820.                baseCGM *inPrev, baseCGM *inNext)
  2821. : cgmAttribute(inOwner, inPrev, inNext)
  2822. {
  2823.   myIndex = cgmIn->getInt();
  2824. }
  2825. ////
  2826. // output in a CGM format
  2827. ////
  2828. int cgmFontIndex::cgmOut(cgmOutput *inOut)
  2829. {
  2830.   inOut->startCmd(this);
  2831.   inOut->outInt(myIndex);
  2832.   inOut->endCmd();
  2833.   return 1;
  2834. }
  2835. ////
  2836. // display output
  2837. ////
  2838. int cgmFontIndex::display(baseDisplay *inDisplay)
  2839. {
  2840.   inDisplay->fontIndex(myIndex);
  2841.   owner->tInfo.setFont(myIndex);
  2842.   return 1;
  2843. }
  2844. ////
  2845. // Text Precision
  2846. ////
  2847. const int cgmTextPrec::myElement = 11;
  2848. const char *cgmTextPrec::myName = "TextPrec";
  2849. //// 
  2850. // aids for parsing
  2851. //// 
  2852. const char *tmpTextPrecList[] = {"STRING", "CHAR", "STROKE"};
  2853. const char **cgmTextPrec::typeList = tmpTextPrecList;
  2854. const int cgmTextPrec::typeListSize =
  2855. sizeof(tmpTextPrecList) / sizeof(tmpTextPrecList[0]);
  2856. //// 
  2857. // constructor
  2858. ////
  2859. cgmTextPrec::cgmTextPrec(cgmContainer *inOwner, cgmInput *cgmIn,
  2860.                baseCGM *inPrev, baseCGM *inNext)
  2861. : cgmAttribute(inOwner, inPrev, inNext)
  2862. {
  2863.   myType = cgmIn->getType(typeList, typeListSize);
  2864. }
  2865. //// 
  2866. // output in a CGM format
  2867. //// 
  2868. int cgmTextPrec::cgmOut(cgmOutput *inOut)
  2869. {
  2870.   inOut->startCmd(this);
  2871.   inOut->outType(typeList, myType);
  2872.   inOut->endCmd();
  2873.   return 1;
  2874. }
  2875. ////
  2876. // display output
  2877. ////
  2878. int cgmTextPrec::display(baseDisplay *inDisplay)
  2879. {
  2880.   inDisplay->textPrec(myType);
  2881.   owner->tInfo.setPrec(myType);
  2882.   return 1;
  2883. }
  2884. ////
  2885. // character expansion factor
  2886. ////
  2887. const int cgmCharExpan::myElement = 12;
  2888. const char *cgmCharExpan::myName = "CharExpan";
  2889. //// 
  2890. // constructor
  2891. ////
  2892. cgmCharExpan::cgmCharExpan(cgmContainer *inOwner, cgmInput *cgmIn,
  2893.                baseCGM *inPrev, baseCGM *inNext)
  2894. : cgmAttribute(inOwner, inPrev, inNext)
  2895. {
  2896.   factor = cgmIn->getReal();
  2897.   owner->tInfo.setExpan(factor);
  2898. }
  2899. //// 
  2900. // output in a CGM format
  2901. //// 
  2902. int cgmCharExpan::cgmOut(cgmOutput *inOut)
  2903. {
  2904.   inOut->startCmd(this);
  2905.   inOut->outReal(factor);
  2906.   inOut->endCmd();
  2907.   return 1;
  2908. }
  2909. ////
  2910. // display output
  2911. ////
  2912. int cgmCharExpan::display(baseDisplay *inDisplay)
  2913. {
  2914.   inDisplay->charExpan(factor);
  2915.   owner->tInfo.setExpan(factor);
  2916.   return 1;
  2917. }
  2918. ////
  2919. // character spacing
  2920. ////
  2921. const int cgmCharSpace::myElement = 13;
  2922. const char *cgmCharSpace::myName = "CharSpace";
  2923. //// 
  2924. // constructor
  2925. ////
  2926. cgmCharSpace::cgmCharSpace(cgmContainer *inOwner, cgmInput *cgmIn,
  2927.                baseCGM *inPrev, baseCGM *inNext)
  2928. : cgmAttribute(inOwner, inPrev, inNext)
  2929. {
  2930.   spacing = cgmIn->getReal();
  2931. }
  2932. //// 
  2933. // output in a CGM format
  2934. //// 
  2935. int cgmCharSpace::cgmOut(cgmOutput *inOut)
  2936. {
  2937.   inOut->startCmd(this);
  2938.   inOut->outReal(spacing);
  2939.   inOut->endCmd();
  2940.   return 1;
  2941. }
  2942. ////
  2943. // display output
  2944. ////
  2945. int cgmCharSpace::display(baseDisplay *inDisplay)
  2946. {
  2947.   inDisplay->charSpace(spacing);
  2948.   owner->tInfo.setSpace(spacing);
  2949.   return 1;
  2950. }
  2951. ////
  2952. // text colour
  2953. ////
  2954. const int cgmTextColr::myElement = 14;
  2955. const char *cgmTextColr::myName = "TextColr";
  2956. ////
  2957. // constructor
  2958. ////
  2959. cgmTextColr::cgmTextColr(cgmContainer *inOwner, cgmInput *cgmIn,
  2960.                baseCGM *inPrev, baseCGM *inNext)
  2961. : cgmAttribute(inOwner, inPrev, inNext)
  2962. {
  2963.   myColr = cgmIn->getColr(owner->colrMode(), owner->colrExtent(),
  2964.               owner->colrs());
  2965. }
  2966. ////
  2967. // output in a CGM format
  2968. ////
  2969. int cgmTextColr::cgmOut(cgmOutput *inOut)
  2970. {
  2971.   inOut->startCmd(this);
  2972.   inOut->outColr(myColr);
  2973.   inOut->endCmd();
  2974.   return 1;
  2975. }
  2976. ////
  2977. // display output
  2978. ////
  2979. int cgmTextColr::display(baseDisplay *inDisplay)
  2980. {
  2981.   if (myColr) {
  2982.     inDisplay->textColr(*myColr);
  2983.     owner->tInfo.setColr(myColr);
  2984.   }
  2985.   return 1;
  2986. }
  2987. ////
  2988. // character height
  2989. ////
  2990. const int cgmCharHeight::myElement = 15;
  2991. const char *cgmCharHeight::myName = "CharHeight";
  2992. //// 
  2993. // constructor
  2994. ////
  2995. cgmCharHeight::cgmCharHeight(cgmContainer *inOwner, cgmInput *cgmIn,
  2996.                baseCGM *inPrev, baseCGM *inNext)
  2997. : cgmAttribute(inOwner, inPrev, inNext)
  2998. {
  2999.   height = cgmIn->getVdc();
  3000. }
  3001. //// 
  3002. // output in a CGM format
  3003. //// 
  3004. int cgmCharHeight::cgmOut(cgmOutput *inOut)
  3005. {
  3006.   inOut->startCmd(this);
  3007.   inOut->outVdc(height);
  3008.   inOut->endCmd();
  3009.   return 1;
  3010. }
  3011. ////
  3012. // display output
  3013. ////
  3014. int cgmCharHeight::display(baseDisplay *inDisplay)
  3015. {
  3016.   owner->tInfo.setHeight(height->f());
  3017.   inDisplay->charHeight(height);
  3018.   return 1;
  3019. }
  3020. ////
  3021. // character orientation
  3022. ////
  3023. const int cgmCharOri::myElement = 16;
  3024. const char *cgmCharOri::myName = "CharOri";
  3025. //// 
  3026. // constructor
  3027. ////
  3028. cgmCharOri::cgmCharOri(cgmContainer *inOwner, cgmInput *cgmIn,
  3029.                baseCGM *inPrev, baseCGM *inNext)
  3030. : cgmAttribute(inOwner, inPrev, inNext)
  3031. {
  3032.  orientation = cgmIn->getVdcPts(2);
  3033. }
  3034. //// 
  3035. // output in a CGM format
  3036. //// 
  3037. int cgmCharOri::cgmOut(cgmOutput *inOut)
  3038. {
  3039.   inOut->startCmd(this);
  3040.   inOut->outVdcPts(orientation);
  3041.   inOut->endCmd();
  3042.   return 1;
  3043. }
  3044. ////
  3045. // display output
  3046. ////
  3047. int cgmCharOri::display(baseDisplay *inDisplay)
  3048. {
  3049.   owner->tInfo.setOrientation(orientation);
  3050.   inDisplay->charOri(orientation);
  3051.   return 1;
  3052. }
  3053. ////
  3054. // Text Path
  3055. ////
  3056. const int cgmTextPath::myElement = 17;
  3057. const char *cgmTextPath::myName = "TextPath";
  3058. //// 
  3059. // aids for parsing
  3060. //// 
  3061. const char *tmpTextPathList[] = {"RIGHT", "LEFT", "UP", "DOWN"};
  3062. const char **cgmTextPath::typeList = tmpTextPathList;
  3063. const int cgmTextPath::typeListSize =
  3064. sizeof(tmpTextPathList) / sizeof(tmpTextPathList[0]);
  3065. //// 
  3066. // constructor
  3067. ////
  3068. cgmTextPath::cgmTextPath(cgmContainer *inOwner, cgmInput *cgmIn,
  3069.                baseCGM *inPrev, baseCGM *inNext)
  3070. : cgmAttribute(inOwner, inPrev, inNext)
  3071. {
  3072.   myType = cgmIn->getType(typeList, typeListSize);
  3073. }
  3074. //// 
  3075. // output in a CGM format
  3076. //// 
  3077. int cgmTextPath::cgmOut(cgmOutput *inOut)
  3078. {
  3079.   inOut->startCmd(this);
  3080.   inOut->outType(typeList, myType);
  3081.   inOut->endCmd();
  3082.   return 1;
  3083. }
  3084. ////
  3085. // display output
  3086. ////
  3087. int cgmTextPath::display(baseDisplay *inDisplay)
  3088. {
  3089.   inDisplay->textPath(myType);
  3090.   owner->tInfo.setPath(myType);
  3091.   return 1;
  3092. }
  3093. ////
  3094. // Text alignment
  3095. ////
  3096. const int cgmTextAlign::myElement = 18;
  3097. const char *cgmTextAlign::myName = "TextAlign";
  3098. //// 
  3099. // aids for parsing
  3100. //// 
  3101. const char *tmpTextAlignList1[] = {"NORMHORIZ", "LEFT", "CTR", "RIGHT",
  3102.                  "CONTHORIZ"};
  3103. const char **cgmTextAlign::typeList1 = tmpTextAlignList1;
  3104. const int cgmTextAlign::typeListSize1 =
  3105. sizeof(tmpTextAlignList1) / sizeof(tmpTextAlignList1[0]);
  3106. const char *tmpTextAlignList2[] = {"NORMVERT", "TOP", "CAP", "HALF",
  3107.                  "BASE", "BOTTOM", "CONTVERT"};
  3108. const char **cgmTextAlign::typeList2 = tmpTextAlignList2;
  3109. const int cgmTextAlign::typeListSize2 =
  3110. sizeof(tmpTextAlignList2) / sizeof(tmpTextAlignList2[0]);
  3111. //// 
  3112. // constructor
  3113. ////
  3114. cgmTextAlign::cgmTextAlign(cgmContainer *inOwner, cgmInput *cgmIn,
  3115.                baseCGM *inPrev, baseCGM *inNext)
  3116. : cgmAttribute(inOwner, inPrev, inNext)
  3117. {
  3118.   int inH = cgmIn->getType(typeList1, typeListSize1);
  3119.   int inV = cgmIn->getType(typeList2, typeListSize2);
  3120.   float inCH = cgmIn->getReal();
  3121.   float inCV = cgmIn->getReal();
  3122.   myAlign = new alignment(inH, inV, inCH, inCV);
  3123. }
  3124. //// 
  3125. // output in a CGM format
  3126. //// 
  3127. int cgmTextAlign::cgmOut(cgmOutput *inOut)
  3128. {
  3129.   inOut->startCmd(this);
  3130.   inOut->outType(typeList1, myAlign->h());
  3131.   inOut->outType(typeList2, myAlign->v());
  3132.   inOut->outReal(myAlign->cH());
  3133.   inOut->outReal(myAlign->cV());
  3134.   inOut->endCmd();
  3135.   return 1;
  3136. }
  3137. ////
  3138. // display output
  3139. ////
  3140. int cgmTextAlign::display(baseDisplay *inDisplay)
  3141. {
  3142.   owner->tInfo.setAlign(myAlign);
  3143.   inDisplay->textAlign(myAlign);
  3144.   return 1;
  3145. }
  3146. ////
  3147. // character set index
  3148. ////
  3149. const int cgmCharSetIndex::myElement = 19;
  3150. const char *cgmCharSetIndex::myName = "CharSetIndex";
  3151. ////
  3152. // constructor
  3153. ////
  3154. cgmCharSetIndex::cgmCharSetIndex(cgmContainer *inOwner, cgmInput *cgmIn,
  3155.                baseCGM *inPrev, baseCGM *inNext)
  3156. : cgmAttribute(inOwner, inPrev, inNext)
  3157. {
  3158.   myIndex = cgmIn->getInt();
  3159. }
  3160. ////
  3161. // output in a CGM format
  3162. ////
  3163. int cgmCharSetIndex::cgmOut(cgmOutput *inOut)
  3164. {
  3165.   inOut->startCmd(this);
  3166.   inOut->outInt(myIndex);
  3167.   inOut->endCmd();
  3168.   return 1;
  3169. }
  3170. ////
  3171. // display output
  3172. ////
  3173. int cgmCharSetIndex::display(baseDisplay *inDisplay)
  3174. {
  3175.   inDisplay->charSetIndex(myIndex);
  3176.   return 1;
  3177. }
  3178. ////
  3179. // alternate character set index
  3180. ////
  3181. const int cgmAltCharSetIndex::myElement = 20;
  3182. const char *cgmAltCharSetIndex::myName = "AltCharSetIndex";
  3183. ////
  3184. // constructor
  3185. ////
  3186. cgmAltCharSetIndex::cgmAltCharSetIndex(cgmContainer *inOwner, cgmInput *cgmIn,
  3187.                baseCGM *inPrev, baseCGM *inNext)
  3188. : cgmAttribute(inOwner, inPrev, inNext)
  3189. {
  3190.   myIndex = cgmIn->getInt();
  3191. }
  3192. ////
  3193. // output in a CGM format
  3194. ////
  3195. int cgmAltCharSetIndex::cgmOut(cgmOutput *inOut)
  3196. {
  3197.   inOut->startCmd(this);
  3198.   inOut->outInt(myIndex);
  3199.   inOut->endCmd();
  3200.   return 1;
  3201. }
  3202. ////
  3203. // display output
  3204. ////
  3205. int cgmAltCharSetIndex::display(baseDisplay *inDisplay)
  3206. {
  3207.   inDisplay->altCharSetIndex(myIndex);
  3208.   return 1;
  3209. }
  3210. ////
  3211. // fill bundle index
  3212. ////
  3213. const int cgmFillIndex::myElement = 21;
  3214. const char *cgmFillIndex::myName = "FillIndex";
  3215. ////
  3216. // constructor
  3217. ////
  3218. cgmFillIndex::cgmFillIndex(cgmContainer *inOwner, cgmInput *cgmIn,
  3219.                baseCGM *inPrev, baseCGM *inNext)
  3220. : cgmAttribute(inOwner, inPrev, inNext)
  3221. {
  3222.   myIndex = cgmIn->getInt();
  3223. }
  3224. ////
  3225. // output in a CGM format
  3226. ////
  3227. int cgmFillIndex::cgmOut(cgmOutput *inOut)
  3228. {
  3229.   inOut->startCmd(this);
  3230.   inOut->outInt(myIndex);
  3231.   inOut->endCmd();
  3232.   return 1;
  3233. }
  3234. ////
  3235. // display output
  3236. ////
  3237. int cgmFillIndex::display(baseDisplay *inDisplay)
  3238. {
  3239.   inDisplay->fillIndex(myIndex);
  3240.   return 1;
  3241. }
  3242. ////
  3243. // interior style
  3244. ////
  3245. const int cgmIntStyle::myElement = 22;
  3246. const char *cgmIntStyle::myName = "IntStyle";
  3247. //// 
  3248. // aids for parsing
  3249. //// 
  3250. const char *tmpIntStyleList[] = {"HOLLOW", "SOLID", "PAT",
  3251.                    "HATCH", "EMPTY"};
  3252. const char **cgmIntStyle::typeList = tmpIntStyleList;
  3253. const int cgmIntStyle::typeListSize =
  3254. sizeof(tmpIntStyleList) / sizeof(tmpIntStyleList[0]);
  3255. //// 
  3256. // constructor
  3257. ////
  3258. cgmIntStyle::cgmIntStyle(cgmContainer *inOwner, cgmInput *cgmIn,
  3259.                baseCGM *inPrev, baseCGM *inNext)
  3260. : cgmAttribute(inOwner, inPrev, inNext)
  3261. {
  3262.   myType = cgmIn->getType(typeList, typeListSize);
  3263. }
  3264. //// 
  3265. // output in a CGM format
  3266. //// 
  3267. int cgmIntStyle::cgmOut(cgmOutput *inOut)
  3268. {
  3269.   inOut->startCmd(this);
  3270.   inOut->outType(typeList, myType);
  3271.   inOut->endCmd();
  3272.   return 1;
  3273. }
  3274. ////
  3275. // display output
  3276. ////
  3277. int cgmIntStyle::display(baseDisplay *inDisplay)
  3278. {
  3279.   inDisplay->intStyle(myType);
  3280.   return 1;
  3281. }
  3282. ////
  3283. // fill colour
  3284. ////
  3285. const int cgmFillColr::myElement = 23;
  3286. const char *cgmFillColr::myName = "FillColr";
  3287. ////
  3288. // constructor
  3289. ////
  3290. cgmFillColr::cgmFillColr(cgmContainer *inOwner, cgmInput *cgmIn,
  3291.                baseCGM *inPrev, baseCGM *inNext)
  3292. : cgmAttribute(inOwner, inPrev, inNext)
  3293. {
  3294.   myColr = cgmIn->getColr(owner->colrMode(), owner->colrExtent(),
  3295.               owner->colrs());
  3296. }
  3297. ////
  3298. // output in a CGM format
  3299. ////
  3300. int cgmFillColr::cgmOut(cgmOutput *inOut)
  3301. {
  3302.   inOut->startCmd(this);
  3303.   inOut->outColr(myColr);
  3304.   inOut->endCmd();
  3305.   return 1;
  3306. }
  3307. ////
  3308. // display output
  3309. ////
  3310. int cgmFillColr::display(baseDisplay *inDisplay)
  3311. {
  3312.   if (myColr) inDisplay->fillColr(*myColr);
  3313.   return 1;
  3314. }
  3315. ////
  3316. // hatch index
  3317. ////
  3318. const int cgmHatchIndex::myElement = 24;
  3319. const char *cgmHatchIndex::myName = "HatchIndex";
  3320. ////
  3321. // constructor
  3322. ////
  3323. cgmHatchIndex::cgmHatchIndex(cgmContainer *inOwner, cgmInput *cgmIn,
  3324.                baseCGM *inPrev, baseCGM *inNext)
  3325. : cgmAttribute(inOwner, inPrev, inNext)
  3326. {
  3327.   myIndex = cgmIn->getInt();
  3328. }
  3329. ////
  3330. // output in a CGM format
  3331. ////
  3332. int cgmHatchIndex::cgmOut(cgmOutput *inOut)
  3333. {
  3334.   inOut->startCmd(this);
  3335.   inOut->outInt(myIndex);
  3336.   inOut->endCmd();
  3337.   return 1;
  3338. }
  3339. ////
  3340. // display output
  3341. ////
  3342. int cgmHatchIndex::display(baseDisplay *inDisplay)
  3343. {
  3344.   inDisplay->hatchIndex(myIndex);
  3345.   return 1;
  3346. }
  3347. ////
  3348. // pattern index
  3349. ////
  3350. const int cgmPatIndex::myElement = 24;
  3351. const char *cgmPatIndex::myName = "PatIndex";
  3352. ////
  3353. // constructor
  3354. ////
  3355. cgmPatIndex::cgmPatIndex(cgmContainer *inOwner, cgmInput *cgmIn,
  3356.                baseCGM *inPrev, baseCGM *inNext)
  3357. : cgmAttribute(inOwner, inPrev, inNext)
  3358. {
  3359.   myIndex = cgmIn->getInt();
  3360. }
  3361. ////
  3362. // output in a CGM format
  3363. ////
  3364. int cgmPatIndex::cgmOut(cgmOutput *inOut)
  3365. {
  3366.   inOut->startCmd(this);
  3367.   inOut->outInt(myIndex);
  3368.   inOut->endCmd();
  3369.   return 1;
  3370. }
  3371. ////
  3372. // display output
  3373. ////
  3374. int cgmPatIndex::display(baseDisplay *inDisplay)
  3375. {
  3376.   inDisplay->patIndex(myIndex);
  3377.   return 1;
  3378. }
  3379. ////
  3380. // Edge bundle index
  3381. ////
  3382. const int cgmEdgeIndex::myElement = 26;
  3383. const char *cgmEdgeIndex::myName = "EdgeIndex";
  3384. ////
  3385. // constructor
  3386. ////
  3387. cgmEdgeIndex::cgmEdgeIndex(cgmContainer *inOwner, cgmInput *cgmIn,
  3388.                baseCGM *inPrev, baseCGM *inNext)
  3389. : cgmAttribute(inOwner, inPrev, inNext)
  3390. {
  3391.   myIndex = cgmIn->getInt();
  3392. }
  3393. ////
  3394. // output in a CGM format
  3395. ////
  3396. int cgmEdgeIndex::cgmOut(cgmOutput *inOut)
  3397. {
  3398.   inOut->startCmd(this);
  3399.   inOut->outInt(myIndex);
  3400.   inOut->endCmd();
  3401.   return 1;
  3402. }
  3403. ////
  3404. // display output
  3405. ////
  3406. int cgmEdgeIndex::display(baseDisplay *inDisplay)
  3407. {
  3408.   inDisplay->edgeIndex(myIndex);
  3409.   return 1;
  3410. }
  3411. ////
  3412. // edge type
  3413. ////
  3414. const int cgmEdgeType::myElement = 27;
  3415. const char *cgmEdgeType::myName = "EdgeType";
  3416. ////
  3417. // constructor
  3418. ////
  3419. cgmEdgeType::cgmEdgeType(cgmContainer *inOwner, cgmInput *cgmIn,
  3420.              baseCGM *inPrev, baseCGM *inNext)
  3421. : cgmAttribute(inOwner, inPrev, inNext)
  3422. {
  3423.   myType = cgmIn->getInt();
  3424. }
  3425. ////
  3426. // output in a CGM format
  3427. ////
  3428. int cgmEdgeType::cgmOut(cgmOutput *inOut)
  3429. {
  3430.   inOut->startCmd(this);
  3431.   inOut->outInt(myType);
  3432.   inOut->endCmd();
  3433.   return 1;
  3434. }
  3435. ////
  3436. // display output
  3437. ////
  3438. int cgmEdgeType::display(baseDisplay *inDisplay)
  3439. {
  3440.   inDisplay->edgeType(myType);
  3441.   return 1;
  3442. }
  3443. #ifdef macintosh
  3444.  #pragma segment CGM5
  3445. #endif
  3446. ////
  3447. // edge width
  3448. ////
  3449. const int cgmEdgeWidth::myElement = 28;
  3450. const char *cgmEdgeWidth::myName = "EdgeWidth";
  3451. ////
  3452. // constructor
  3453. ////
  3454. cgmEdgeWidth::cgmEdgeWidth(cgmContainer *inOwner, cgmInput *cgmIn,
  3455.                baseCGM *inPrev, baseCGM *inNext)
  3456. : cgmAttribute(inOwner, inPrev, inNext)
  3457. {
  3458.   myVdcR = (owner->edgeMode()) ? new vdcR(cgmIn->getReal()) // scaled
  3459.     : new vdcR(cgmIn->getVdc()); // absolute
  3460. }
  3461. ////
  3462. // destructor
  3463. ////
  3464. cgmEdgeWidth::~cgmEdgeWidth()
  3465. {
  3466.   if (myVdcR) delete myVdcR;
  3467. }
  3468. ////
  3469. // output in a CGM format
  3470. ////
  3471. int cgmEdgeWidth::cgmOut(cgmOutput *inOut)
  3472. {
  3473.   inOut->startCmd(this);
  3474.   if (myVdcR->type()) inOut->outReal(myVdcR->f()); // scaled
  3475.   else inOut->outVdc(myVdcR->v()); // absolute
  3476.   inOut->endCmd();
  3477.   return 1;
  3478. }
  3479. ////
  3480. // display output
  3481. ////
  3482. int cgmEdgeWidth::display(baseDisplay *inDisplay)
  3483. {
  3484.   inDisplay->edgeWidth(myVdcR);
  3485.   return 1;
  3486. }
  3487. ////
  3488. // edge colour
  3489. ////
  3490. const int cgmEdgeColr::myElement = 29;
  3491. const char *cgmEdgeColr::myName = "EdgeColr";
  3492. ////
  3493. // constructor
  3494. ////
  3495. cgmEdgeColr::cgmEdgeColr(cgmContainer *inOwner, cgmInput *cgmIn,
  3496.                baseCGM *inPrev, baseCGM *inNext)
  3497. : cgmAttribute(inOwner, inPrev, inNext)
  3498. {
  3499.   myColr = cgmIn->getColr(owner->colrMode(), owner->colrExtent(),
  3500.               owner->colrs());
  3501. }
  3502. ////
  3503. // output in a CGM format
  3504. ////
  3505. int cgmEdgeColr::cgmOut(cgmOutput *inOut)
  3506. {
  3507.   inOut->startCmd(this);
  3508.   inOut->outColr(myColr);
  3509.   inOut->endCmd();
  3510.   return 1;
  3511. }
  3512. ////
  3513. // display output
  3514. ////
  3515. int cgmEdgeColr::display(baseDisplay *inDisplay)
  3516. {
  3517.   if (myColr) inDisplay->edgeColr(*myColr);
  3518.   return 1;
  3519. }
  3520. ////
  3521. // edge visibility
  3522. ////
  3523. const int cgmEdgeVis::myElement = 30;
  3524. const char *cgmEdgeVis::myName = "EdgeVis";
  3525. //// 
  3526. // aids for parsing
  3527. //// 
  3528. const char *tmpEdgeVisList[] = {"OFF", "ON"};
  3529. const char **cgmEdgeVis::typeList = tmpEdgeVisList;
  3530. const int cgmEdgeVis::typeListSize =
  3531. sizeof(tmpEdgeVisList) / sizeof(tmpEdgeVisList[0]);
  3532. //// 
  3533. // constructor
  3534. ////
  3535. cgmEdgeVis::cgmEdgeVis(cgmContainer *inOwner, cgmInput *cgmIn,
  3536.                baseCGM *inPrev, baseCGM *inNext)
  3537. : cgmAttribute(inOwner, inPrev, inNext)
  3538. {
  3539.   myType = cgmIn->getType(typeList, typeListSize);
  3540. }
  3541. //// 
  3542. // output in a CGM format
  3543. //// 
  3544. int cgmEdgeVis::cgmOut(cgmOutput *inOut)
  3545. {
  3546.   inOut->startCmd(this);
  3547.   inOut->outType(typeList, myType);
  3548.   inOut->endCmd();
  3549.   return 1;
  3550. }
  3551. ////
  3552. // display output
  3553. ////
  3554. int cgmEdgeVis::display(baseDisplay *inDisplay)
  3555. {
  3556.   inDisplay->edgeVis(myType);
  3557.   return 1;
  3558. }
  3559. ////
  3560. // fill reference point
  3561. ////
  3562. const int cgmFillRefPt::myElement = 31;
  3563. const char *cgmFillRefPt::myName = "FillRefPt";
  3564. //// 
  3565. // constructor
  3566. ////
  3567. cgmFillRefPt::cgmFillRefPt(cgmContainer *inOwner, cgmInput *cgmIn,
  3568.                baseCGM *inPrev, baseCGM *inNext)
  3569. : cgmAttribute(inOwner, inPrev, inNext)
  3570. {
  3571.  myPts = cgmIn->getVdcPts(1);
  3572. }
  3573. //// 
  3574. // output in a CGM format
  3575. //// 
  3576. int cgmFillRefPt::cgmOut(cgmOutput *inOut)
  3577. {
  3578.   inOut->startCmd(this);
  3579.   inOut->outVdcPts(myPts);
  3580.   inOut->endCmd();
  3581.   return 1;
  3582. }
  3583. ////
  3584. // display output
  3585. ////
  3586. int cgmFillRefPt::display(baseDisplay *inDisplay)
  3587. {
  3588.   inDisplay->fillRefPt(myPts);
  3589.   return 1;
  3590. }
  3591. ////
  3592. // pattern size
  3593. ////
  3594. const int cgmPatSize::myElement = 33;
  3595. const char *cgmPatSize::myName = "PatSize";
  3596. //// 
  3597. // constructor
  3598. ////
  3599. cgmPatSize::cgmPatSize(cgmContainer *inOwner, cgmInput *cgmIn,
  3600.                baseCGM *inPrev, baseCGM *inNext)
  3601. : cgmAttribute(inOwner, inPrev, inNext)
  3602. {
  3603.  myPts = cgmIn->getVdcPts(2);
  3604. }
  3605. //// 
  3606. // output in a CGM format
  3607. //// 
  3608. int cgmPatSize::cgmOut(cgmOutput *inOut)
  3609. {
  3610.   inOut->startCmd(this);
  3611.   inOut->outVdcPts(myPts);
  3612.   inOut->endCmd();
  3613.   return 1;
  3614. }
  3615. ////
  3616. // display output
  3617. ////
  3618. int cgmPatSize::display(baseDisplay *inDisplay)
  3619. {
  3620.   // nothing for now
  3621.   return 1;
  3622. }
  3623. ////
  3624. // pattern table
  3625. ////
  3626. const int cgmPatTable::myElement = 32;
  3627. const char *cgmPatTable::myName = "PatTable";
  3628. //// 
  3629. // constructor
  3630. ////
  3631. cgmPatTable::cgmPatTable(cgmContainer *inOwner, cgmInput *cgmIn,
  3632.                baseCGM *inPrev, baseCGM *inNext)
  3633. : cgmAttribute(inOwner, inPrev, inNext)
  3634. {
  3635.   // fixlater
  3636. }
  3637. //// 
  3638. // output in a CGM format
  3639. //// 
  3640. int cgmPatTable::cgmOut(cgmOutput *inOut)
  3641. {
  3642.   inOut->startCmd(this);
  3643.   // fix later
  3644.   inOut->endCmd();
  3645.   return 1;
  3646. }
  3647. ////
  3648. // display output
  3649. ////
  3650. int cgmPatTable::display(baseDisplay *inDisplay)
  3651. {
  3652.   // fix later
  3653.   return 1;
  3654. }
  3655. ////
  3656. // colour table
  3657. ////
  3658. const int cgmColrTable::myElement = 34;
  3659. const char *cgmColrTable::myName = "ColrTable";
  3660. //// 
  3661. // constructor
  3662. ////
  3663. cgmColrTable::cgmColrTable(cgmContainer *inOwner, cgmInput *cgmIn,
  3664.                baseCGM *inPrev, baseCGM *inNext)
  3665. : cgmAttribute(inOwner, inPrev, inNext)
  3666. {
  3667.  myTable = cgmIn->getColrTable(owner->colrExtent());
  3668.  owner->colrs()->addTable(myTable);
  3669. }
  3670. //// 
  3671. // output in a CGM format
  3672. //// 
  3673. int cgmColrTable::cgmOut(cgmOutput *inOut)
  3674. {
  3675.   inOut->startCmd(this);
  3676.   inOut->outColrTable(myTable);
  3677.   inOut->endCmd();
  3678.   return 1;
  3679. }
  3680. ////
  3681. // display output
  3682. ////
  3683. int cgmColrTable::display(baseDisplay *inDisplay)
  3684. {
  3685.   inDisplay->colrs(myTable);
  3686.   return 1;
  3687. }
  3688. #ifdef macintosh
  3689.  #pragma segment CGM6
  3690. #endif
  3691. ////
  3692. // aspect source flags
  3693. ////
  3694. const int cgmASF::myElement = 35;
  3695. const char *cgmASF::myName = "ASF";
  3696. //// 
  3697. // constructor
  3698. ////
  3699. cgmASF::cgmASF(cgmContainer *inOwner, cgmInput *cgmIn,
  3700.         baseCGM *inPrev, baseCGM *inNext)
  3701. : cgmAttribute(inOwner, inPrev, inNext)
  3702. {
  3703.   // fill out later
  3704. }
  3705. //// 
  3706. // output in a CGM format
  3707. //// 
  3708. int cgmASF::cgmOut(cgmOutput *inOut)
  3709. {
  3710.   inOut->startCmd(this);
  3711.   // fill out later
  3712.   inOut->endCmd();
  3713.   return 1;
  3714. }
  3715. ////
  3716. // the Escape class
  3717. ////
  3718. const int cgmEscape::myClass = 6;
  3719. ////
  3720. // escape element
  3721. ////
  3722. const int cgmEscapeElement::myElement = 1;
  3723. const char *cgmEscapeElement::myName = "Escape";
  3724. const int cgmEscapeElement::indexFlag = -64;
  3725. //// 
  3726. // constructor
  3727. ////
  3728. cgmEscapeElement::cgmEscapeElement(cgmContainer *inOwner, cgmInput *cgmIn,
  3729.         baseCGM *inPrev, baseCGM *inNext)
  3730. : cgmEscape(inOwner, inPrev, inNext)
  3731. {
  3732.   myId = cgmIn->getInt();
  3733.   myData = cgmIn->getString(dataSize);
  3734.   if ((myId = indexFlag) && !mfOwner()->indexed() &&
  3735.       (cgmIn->isa() != clearCGM)) { // don't trust on clear text
  3736.     mfOwner()->setIndexed(); // so as not recurse indefinitely
  3737.     filePos startPos = cgmIn->pos(); // mark our spot
  3738.     makeIndex(mfOwner(), cgmIn);
  3739.     if (cgmIn->pos() != startPos) cgmIn->goTo(startPos); // safety
  3740.   }
  3741. }
  3742. ////
  3743. // construct an index using our index blocks
  3744. ////
  3745. void cgmEscapeElement::makeIndex(cgmMetafile *inMF, cgmInput *cgmIn)
  3746. {
  3747.   // have to assume filepos is a long here in order to use sscanf
  3748.   long myAddress, nextPos, nextPtr;
  3749.   baseCGM *myCGM;
  3750.   cgmBeginPicture *myBeginPic;
  3751.   cgmPicture *myPic, *lastPic;
  3752.   cgmEscapeElement *myEscape;
  3753.   int noPages, done = 0, i, strLen;
  3754.   char *strPtr;
  3755.   // get ready for the loop
  3756.   myEscape = this;
  3757.   // get the last picture that we already know
  3758.   for (lastPic = inMF->firstPic; lastPic && lastPic->next;
  3759.        lastPic = lastPic->next);
  3760.   do {
  3761.     strPtr = myEscape->data();
  3762.     while (*strPtr == ' ') ++strPtr; // skip spaces
  3763.     if (sscanf(strPtr, "%d", &noPages) != 1) { // how many pages ?
  3764.       myError("couldn't read noPages");
  3765.       return;
  3766.     }
  3767.     while (haveNumber(*strPtr)) ++strPtr; // skip number
  3768.     ////
  3769.     for (i=0; i<noPages; ++i) { // entry for each page
  3770.       while (*strPtr == ' ') ++strPtr; // skip spaces
  3771.       if (sscanf(strPtr, "%ld", &myAddress) != 1) { // get the address
  3772.     myError("couldn't get byte address");
  3773.     return;
  3774.       }
  3775.       while (haveNumber(*strPtr)) ++strPtr; // skip number
  3776.       while (*strPtr == ' ') ++strPtr; // skip spaces
  3777.       if (sscanf(strPtr, "%ld", &strLen) != 1) { // get the string length
  3778.     myError("couldn't get string length");
  3779.     return;
  3780.       }
  3781.       while (haveNumber(*strPtr)) ++strPtr; // skip number
  3782.       // now have the picture name
  3783.       ++strPtr;    // one-char gap
  3784.       // get new begin picture and cgm picture
  3785.       myBeginPic = new cgmBeginPicture(inMF, strPtr, strLen);
  3786.       myPic = new cgmPicture(inMF, cgmIn, myBeginPic, lastPic,
  3787.                    cgmIn->lastPos() + myAddress);
  3788.       if (!lastPic) inMF->firstPic = myPic;
  3789.       lastPic = myPic;
  3790.  
  3791.       strPtr += strLen; // skip over the string
  3792.     }
  3793.     // now need pointer to next index block
  3794.     if (sscanf(strPtr, " %d", &nextPtr) != 1) {
  3795.       myError("couldn't read pointer to next index block");
  3796.       return;
  3797.     }
  3798.     if (nextPtr) {
  3799.       nextPos = cgmIn->lastPos() + nextPtr;
  3800.       cgmIn->goTo(nextPos);
  3801.       if (!cgmIn->getCmd()) {
  3802.     myError("couldn't get next index block");
  3803.     return;
  3804.       }
  3805.       if (!(myCGM = cgmIn->doCmd(inMF, NULL))) {
  3806.     myError("couldn't parse next index block");
  3807.     return;
  3808.       }
  3809.       if ((myCGM->cgmClass() != myClass)||(myCGM->cgmElement() != myElement)) {
  3810.     myError("next index block not in an escape element",
  3811.         myCGM->cgmName());
  3812.     return;
  3813.       }
  3814.       // now know we have an escape element
  3815.       myEscape = (cgmEscapeElement *) myCGM;
  3816.       if (myEscape->myId != indexFlag) {
  3817.     myError("index block escape element has wrong id");
  3818.     return;
  3819.       }
  3820.     }
  3821.     else done = 1;
  3822.   } while (!done);
  3823. }
  3824. //// 
  3825. // output in a CGM format
  3826. //// 
  3827. int cgmEscapeElement::cgmOut(cgmOutput *inOut)
  3828. {
  3829.   // strip out escapes for now, may do more harm than good
  3830.   // inOut->startCmd(this);
  3831.   // fill out later
  3832.   // inOut->endCmd();
  3833.   return 1;
  3834. }
  3835. ////
  3836. // the External class
  3837. ////
  3838. const int cgmExternal::myClass = 7;
  3839. ////
  3840. // message element
  3841. ////
  3842. const int cgmMessage::myElement = 1;
  3843. const char *cgmMessage::myName = "Message";
  3844. //// 
  3845. // constructor
  3846. ////
  3847. cgmMessage::cgmMessage(cgmContainer *inOwner, cgmInput *cgmIn,
  3848.         baseCGM *inPrev, baseCGM *inNext)
  3849. : cgmExternal(inOwner, inPrev, inNext)
  3850. {
  3851.   // fill out later
  3852. }
  3853. //// 
  3854. // output in a CGM format
  3855. //// 
  3856. int cgmMessage::cgmOut(cgmOutput *inOut)
  3857. {
  3858.   inOut->startCmd(this);
  3859.   // fill out later
  3860.   inOut->endCmd();
  3861.   return 1;
  3862. }
  3863. ////
  3864. // application data
  3865. ////
  3866. const int cgmApplData::myElement = 2;
  3867. const char *cgmApplData::myName = "ApplData";
  3868. //// 
  3869. // constructor
  3870. ////
  3871. cgmApplData::cgmApplData(cgmContainer *inOwner, cgmInput *cgmIn,
  3872.              baseCGM *inPrev, baseCGM *inNext)
  3873. : cgmExternal(inOwner, inPrev, inNext)
  3874. {
  3875.   // fill out later
  3876. }
  3877. //// 
  3878. // output in a CGM format
  3879. //// 
  3880. int cgmApplData::cgmOut(cgmOutput *inOut)
  3881. {
  3882.   inOut->startCmd(this);
  3883.   // fill out later
  3884.   inOut->endCmd();
  3885.   return 1;
  3886. }
  3887. ////
  3888. // the containing classes
  3889. ////
  3890. ////
  3891. // container for one metafile
  3892. ////
  3893. // constructor
  3894. ////
  3895. cgmMetafile::cgmMetafile(cgmBeginMetafile *inStart, cgmInput *inInput)
  3896. {
  3897.   contents = inStart;
  3898.   myInput = inInput;
  3899.   myStart = myInput->pos();
  3900.   if (inStart) inStart->setOwner(this); // get off on the right foot
  3901.   myDefaults = NULL;
  3902.   firstPic = NULL;
  3903.   versionCmd = NULL;
  3904.   descriptionCmd = NULL;
  3905.   vdcTypeCmd = NULL;
  3906.   maxColrIndexCmd = NULL;
  3907.   colrValueExtentCmd = NULL;
  3908.   vdcExtentCmd = NULL;
  3909.   intDefVdcExtent = new vdcPts(0, 0, 32767, 32767);
  3910.   // double for macintosh
  3911.   floatDefVdcExtent = new vdcPts((double)0.0, (double)0.0,
  3912.                  (double)1.0, (double) 1.0);
  3913.   myColrTable = new colrTable(64, colrExtent());
  3914.   myIndexed = 0; // not indexed yet
  3915. }
  3916. ////
  3917. // destructor
  3918. ////
  3919. cgmMetafile::~cgmMetafile() 
  3920. {
  3921.   delete intDefVdcExtent;
  3922.   delete floatDefVdcExtent;
  3923.   for (cgmPicture *myPic = firstPic; myPic; myPic = firstPic) {
  3924.     firstPic = myPic->next;
  3925.     delete myPic;
  3926.   }
  3927. }
  3928. ////
  3929. // add one set of defaults to the metafile
  3930. ////
  3931. void cgmMetafile::addDefaults(cgmDefaults *inDefaults) 
  3932. {
  3933.   if (!myDefaults) myDefaults = inDefaults; // first set
  3934.   else {
  3935.     cgmDefaults *myPtr = myDefaults;
  3936.     while (myPtr->next()) myPtr = myPtr->next(); // find last one
  3937.     myPtr->addNext(inDefaults);
  3938.   }
  3939. }
  3940. ////
  3941. // output the whole metafile to a cgm format
  3942. ////
  3943. cgmMetafile::cgmOut(cgmOutput *inOut) 
  3944. {
  3945.   for (baseCGM *myCGM = contents; myCGM; myCGM = myCGM->next) {
  3946.     myCGM->cgmOut(inOut); // metafile specifics
  3947.   }
  3948.   // now do the pages
  3949.   for (cgmPicture *myPic = firstPic; myPic; myPic = myPic->next) {
  3950.     if (myPic->want()) { // want this one
  3951.       myPic->readIn();
  3952.       myPic->cgmOut(inOut);
  3953.       myPic->setAside();
  3954.     } else if (!indexed()) { // don't already have all of their positions
  3955.       myPic->readIn(); // just to get next picture position
  3956.       myPic->setAside();
  3957.     }
  3958.   }
  3959.   return 1;
  3960. }
  3961. ////
  3962. // display the whole file
  3963. ////
  3964. void cgmMetafile::display(baseDisplay *inDisplay)
  3965. {
  3966.   for (baseCGM *myCGM = contents; myCGM; myCGM = myCGM->next) {
  3967.     myCGM->display(inDisplay); // metafile specifics
  3968.   }
  3969. }
  3970. ////
  3971. // index the file (if we can)
  3972. ////
  3973. int cgmMetafile::makeIndex()
  3974. {
  3975.   if (!indexed() && myInput) myInput->makeIndex(this);
  3976.   myIndexed = 1; // mark as done
  3977.   return 1;
  3978. }
  3979. ////
  3980. // return the version
  3981. ////
  3982. int cgmMetafile::version() 
  3983. {
  3984.   return versionCmd ? versionCmd->versionNumber : 1;
  3985. }
  3986. ////
  3987. // return the description
  3988. ////
  3989. const char *cgmMetafile::description() 
  3990. {
  3991.   return descriptionCmd ? descriptionCmd->mfDescription : NULL;
  3992. }
  3993. ////
  3994. // return the colour value extent
  3995. ////
  3996. const colrValueExtent *cgmMetafile::colrExtent() 
  3997. {
  3998.   return colrValueExtentCmd ? &(colrValueExtentCmd->myExtent) : &defExtent;
  3999. }
  4000. ////
  4001. // now access to the picture state defaults
  4002. ////
  4003. // return the scaling mode
  4004. ////
  4005. int cgmMetafile::scalingMode() 
  4006. {
  4007.   return scalingCmd ? scalingCmd->mode : 0;
  4008. }
  4009. ////
  4010. // return the scaling factor
  4011. ////
  4012. float cgmMetafile::scalingFactor() 
  4013. {
  4014.   return scalingCmd ? scalingCmd->factor : 1.0;
  4015. }
  4016. ////
  4017. // return the colour selection mode
  4018. ////
  4019. int cgmMetafile::colrMode() 
  4020. {
  4021.   return colrModeCmd ? colrModeCmd->mode : 0;
  4022. }
  4023. ////
  4024. // return the line width specification mode
  4025. ////
  4026. int cgmMetafile::lineMode() 
  4027. {
  4028.   return lineModeCmd ? lineModeCmd->mode : 1;
  4029. }
  4030. ////
  4031. // return the marker size specification mode
  4032. ////
  4033. int cgmMetafile::markerMode() 
  4034. {
  4035.   return markerModeCmd ? markerModeCmd->mode : 1;
  4036. }
  4037. ////
  4038. // return the edge width specification mode
  4039. ////
  4040. int cgmMetafile::edgeMode() 
  4041. {
  4042.   return edgeModeCmd ? edgeModeCmd->mode : 1;
  4043. }
  4044.  
  4045.  
  4046. ////
  4047. // return the vdc extent
  4048. ////
  4049.  
  4050. const vdcPts *cgmMetafile::vdcExtent() const
  4051. {
  4052.   return vdcExtentCmd ? vdcExtentCmd->myPts : myVdcType() ?
  4053.     floatDefVdcExtent : intDefVdcExtent;
  4054. }
  4055. ////
  4056. // container for a single picture
  4057. ////
  4058. cgmPicture::cgmPicture(cgmMetafile *inMetafile, cgmInput *inInput,
  4059.                cgmBeginPicture *inPicture, cgmPicture *inPrev,
  4060.                filePos inPos)
  4061. { 
  4062.   myColrTable = NULL; // get when we read in data
  4063.   contents = NULL;
  4064.   prev = next = NULL;
  4065.   metafile = inMetafile;
  4066.   if (!metafile) myError("no metafile for cgmPicture", "exiting", 0);
  4067.   prev = inPrev;
  4068.   if (prev) prev->next = this; // link pointers
  4069.   myInput = inInput;
  4070.   // do we already have the position ?
  4071.   myPos = (inPos) ? inPos : myInput->pos(); 
  4072.   myBeginPicture = inPicture;
  4073.   if (!myBeginPicture) myError("no beginPicture for cgmPicture", "exiting", 0);
  4074.   setWant(1); // default is to want it
  4075. }
  4076. ////
  4077. // destructor
  4078. ////
  4079. cgmPicture::~cgmPicture()
  4080. {
  4081.   delete myBeginPicture;
  4082.   for (baseCGM *myCGM = contents; myCGM; myCGM = contents) {
  4083.     contents = myCGM->next;
  4084.     delete myCGM;
  4085.   }
  4086. }
  4087. ////
  4088. // output to cgm format
  4089. ////
  4090. cgmPicture::cgmOut(cgmOutput *inOut) 
  4091. {
  4092.   myBeginPicture->cgmOut(inOut); // the begin picture element
  4093.   for (baseCGM *myCGM = contents; myCGM && myCGM->cgmOut(inOut);
  4094.        myCGM = myCGM->next);
  4095.   return !myCGM;
  4096. }
  4097. ////
  4098. // display one picture
  4099. ////
  4100. void cgmPicture::display(baseDisplay *inDisplay) 
  4101. {
  4102.   if (!inDisplay) myError("no inDisplay for cgmPicture", "exiting", 0); 
  4103.   if (!myBeginPicture) myError("no myBeginPicture for cgmPicture display",
  4104.                    "exiting", 0);
  4105.   myBeginPicture->display(inDisplay); // the begin picture body
  4106.  
  4107.   if (!contents) { 
  4108.     myError("no contents in this picture");
  4109.     return;
  4110.   }
  4111.   baseCGM *myCGM = contents;
  4112.   // go to begin picture body
  4113.   while (myCGM &&
  4114.      !((myCGM->cgmClass() == cgmDelimiter::myClass) &&
  4115.        (myCGM->cgmElement() == cgmBeginPictureBody::myElement))) {
  4116.     myCGM->display(inDisplay); // for control elements, etc.
  4117.     myCGM = myCGM->next;
  4118.   }
  4119.   ////
  4120.   // have a chance to adjust things before picture body
  4121.   ////
  4122.   if (tInfo.height() == 0) { // never set text height
  4123.     tInfo.setHeight(vdcExtent()->height() * 0.01); // default
  4124.   }
  4125.   ////
  4126.   // display everything up to the end picture
  4127.   while (myCGM &&
  4128.      !((myCGM->cgmClass() == cgmDelimiter::myClass) &&
  4129.         (myCGM->cgmElement() == cgmEndPicture::myElement))
  4130.      ) {
  4131.     myCGM->display(inDisplay); // for graphical primitives attributes, etc.
  4132.     myCGM = myCGM->next; 
  4133.   }
  4134.   if (myCGM) myCGM->display(inDisplay); // the end picture
  4135.   // done
  4136. }
  4137. ////
  4138. // read in one picture
  4139. ////
  4140. int cgmPicture::readIn()
  4141. {
  4142.   if (contents) return 1; // already read in
  4143.   baseCGM *gotCmd, *lastPtr = NULL;
  4144.   // set up defaults
  4145.   tInfo = metafile->tInfo; // bit wise copy
  4146.   myColrTable = new colrTable(64, colrExtent());
  4147.   if (myInput->goTo(myPos)) { // go to the correct position
  4148.     myError("couldn't goTo beginning of picture");
  4149.     return 0;
  4150.   }
  4151.   // loop thru commands
  4152.   while(myInput->getCmd()) { // have input
  4153.     // is this an unknown command ?
  4154.     if (!(gotCmd = myInput->doCmd(this, lastPtr))) continue;
  4155.     // is this a delimiter ?
  4156.     if (gotCmd->cgmClass() == cgmDelimiter::myClass) {
  4157.         switch(gotCmd->cgmElement()) {
  4158.         case cgmBeginPictureMyElement: // begin picture
  4159. //        case cgmBeginPicture::myElement: // begin picture
  4160.  
  4161.     if (!contents) continue; // first element, OK
  4162.     else if (!next) { // new next picture
  4163.       next = new cgmPicture(metafile, myInput,
  4164.                 (cgmBeginPicture *) gotCmd, this);
  4165.       if (lastPtr) lastPtr->next = NULL;
  4166.       return 1; // done
  4167.     } else {
  4168.       myError("unexpected begin picture"); // should never happen
  4169.       return 0;
  4170.     }
  4171.         case cgmEndPictureMyElement: // end picture
  4172.     if (next) return 1; // don't need to go any farther
  4173.     else break;
  4174.         case cgmEndMetafileMyElement:
  4175.     if (lastPtr) lastPtr->next = NULL;
  4176.     return 1; // done
  4177.       } 
  4178.     }
  4179.     if (!contents) contents = gotCmd;
  4180.     lastPtr = gotCmd;
  4181.   } 
  4182.   if (lastPtr) lastPtr->next = NULL;
  4183.   return 0; // ran out of commands
  4184. }
  4185. ////
  4186. // set it aside as we go on to another picture
  4187. ////
  4188. void cgmPicture::setAside()
  4189. {
  4190.   baseCGM *myPtr, *nextPtr; // delete the main contents (save the BP)
  4191.   for (myPtr = contents; myPtr; myPtr = nextPtr) {
  4192.     nextPtr = myPtr->next;
  4193.     delete myPtr;
  4194.   }
  4195.   contents = NULL; // nothing there
  4196. }
  4197. ////
  4198. // now access to the state variables
  4199. ////
  4200. // the colour value extent
  4201. ////
  4202. const colrValueExtent *cgmPicture::colrExtent()
  4203. {
  4204.   return metafile->colrExtent();
  4205. }
  4206. ////
  4207. // return the scaling mode
  4208. ////
  4209. int cgmPicture::scalingMode() 
  4210. {
  4211.   return scalingCmd ? scalingCmd->mode : metafile->scalingMode();
  4212. }
  4213. ////
  4214. // return the scaling factor
  4215. ////
  4216. float cgmPicture::scalingFactor() 
  4217. {
  4218.   return scalingCmd ? scalingCmd->factor : metafile->scalingFactor();
  4219. }
  4220. ////
  4221. // return the colour selection mode
  4222. ////
  4223. int cgmPicture::colrMode() 
  4224. {
  4225.   return colrModeCmd ? colrModeCmd->mode : metafile->colrMode();
  4226. }
  4227. ////
  4228. // return the line width specification mode
  4229. ////
  4230. int cgmPicture::lineMode() 
  4231. {
  4232.   return lineModeCmd ? lineModeCmd->mode : metafile->lineMode();
  4233. }
  4234. ////
  4235. // return the marker size specification mode
  4236. ////
  4237. int cgmPicture::markerMode() 
  4238. {
  4239.   return markerModeCmd ? markerModeCmd->mode : metafile->markerMode();
  4240. }
  4241. ////
  4242. // return the edge width specification mode
  4243. ////
  4244. int cgmPicture::edgeMode() 
  4245. {
  4246.   return edgeModeCmd ? edgeModeCmd->mode : metafile->edgeMode();
  4247. }
  4248. ////
  4249. // return the vdc extent
  4250. ////
  4251. const vdcPts *cgmPicture::vdcExtent() const
  4252. {
  4253.   return vdcExtentCmd ? vdcExtentCmd->myPts : metafile->vdcExtent();
  4254. }
  4255. ////
  4256. // particular classes for the cgm state
  4257. ////
  4258. // the cgm file object, refHand usd as file ref#/handle by the mac/pc
  4259. // must be in this file since it needs case label constants at compile time
  4260. ////
  4261. cgmFile::cgmFile(const char *inName, short refHand) : basicInput(inName, refHand)
  4262. {
  4263.   metafile = NULL;
  4264.   inputHandler = NULL;
  4265.   if (inName) { // got a name, store
  4266.     nameSize = strlen(inName);
  4267.     inputName = new char[nameSize + 1];
  4268.     strcpy(inputName, inName);
  4269.   } else { // no name
  4270.     inputName = NULL;
  4271.     nameSize = 0;
  4272.   }
  4273.   if (!openedFile()) return; 
  4274.   ////
  4275.   // get the input handler
  4276.   if (!(inputHandler = getCgmInput())) return;
  4277. #if __MSDOS__
  4278.   if (hGlobalBuffer)
  4279.       {
  4280.       GlobalUnlock(hGlobalBuffer);
  4281.       GlobalFree(hGlobalBuffer);
  4282.       buffer = NULL;
  4283.       hGlobalBuffer = NULL;
  4284.       }
  4285. #endif
  4286.   ////
  4287.   // get the first command and parse it
  4288.   if (!inputHandler->getCmd()) { // no commands at all
  4289.     myError("no commands in file", inputName);
  4290.     return;
  4291.   }
  4292.   baseCGM *gotCmd = inputHandler->doCmd(NULL, NULL); // parse it
  4293.   if (!gotCmd) { // couldn't parse it
  4294.     myError("couldn't parse first command in", inputName);
  4295.     return;
  4296.   }
  4297.   ////
  4298.   // make sure it's a begin metafile
  4299.   if (!((gotCmd->cgmClass() == cgmDelimiter::myClass) &&
  4300.     (gotCmd->cgmElement() == cgmBeginMetafile::myElement))) { 
  4301.     myError("illegal first command", gotCmd->cgmName());
  4302.     return;
  4303.   }
  4304.   ////
  4305.   // create the metafile
  4306.   metafile = new cgmMetafile((cgmBeginMetafile *) gotCmd, inputHandler);
  4307.   ////
  4308.   // parse to the first begin picture
  4309.   baseCGM *lastPtr = gotCmd; // for initialization
  4310.   while(inputHandler->getCmd()) { // while we have commands
  4311.     gotCmd = inputHandler->doCmd(metafile, lastPtr); // parse it
  4312.     if (gotCmd) { // successfully parsed
  4313.       if ((gotCmd->cgmClass() == cgmDelimiter::myClass) &&
  4314.       (gotCmd->cgmElement() == cgmBeginPicture::myElement)) {
  4315.     if (lastPtr) lastPtr->next = NULL;
  4316.     gotCmd->prev = NULL; // terminate chain
  4317.     break; // done
  4318.       } else {
  4319.     if ((gotCmd->cgmClass() != cgmMetafileDescriptor::myClass) &&
  4320.         (gotCmd->cgmClass() != cgmEscape::myClass) &&
  4321.         (gotCmd->cgmClass() != cgmExternal::myClass))  {
  4322.       myError("illegal command in metafile descriptor area",
  4323.           gotCmd->cgmName());
  4324.     } 
  4325.       }
  4326.       lastPtr = gotCmd;
  4327.     } // successfully parsed
  4328.   } // successfully got
  4329.   // might have got first picture from index block
  4330.   if (!metafile->firstPic) {
  4331.     ////
  4332.     // get the first picture
  4333.     if (gotCmd && (gotCmd->cgmClass() == cgmDelimiter::myClass) &&
  4334.     (gotCmd->cgmElement() == cgmBeginPicture::myElement)) { // picture
  4335.       metafile->firstPic = new cgmPicture(metafile, inputHandler,
  4336.                       (cgmBeginPicture *)gotCmd);
  4337.     } else {
  4338.       myError("no first picture", inName);
  4339.       return;
  4340.     }
  4341.   }
  4342.   metafile->firstPic->readIn(); // read in first picture
  4343. }
  4344. ////
  4345. // destructor
  4346. ////
  4347. cgmFile::~cgmFile()
  4348. {
  4349.   if (inputName) delete inputName;
  4350.   if (inputHandler) delete inputHandler;
  4351. }
  4352. ////
  4353. // function to return the correct input handler
  4354. ////
  4355. cgmInput *cgmFile::getCgmInput()
  4356. {
  4357.   // try to figure out what type of file we have
  4358.   if (!getOffBytes(4)) { // need 4 bytes to identify NCAR files
  4359.     myError("couldn't get file header");
  4360.     return NULL;
  4361.   }
  4362.   // now see if we recognize them, try binary types first
  4363.   if ((((binaryInput *)this)->bufferClass()==cgmDelimiter::myClass) &&
  4364.       (((binaryInput *)this)->bufferElement()==cgmBeginMetafile::myElement)) {
  4365.      return new binaryInput(filePtr, frefHand); // regular binary
  4366.   } else if (buffer[0] == 1) {
  4367.      return new LANLInput(filePtr, frefHand); // LANL-style
  4368.   } else if ((buffer[0] == 's') && (buffer[1] == 'r')) {
  4369.      return new MilInput(filePtr, frefHand); // military-style
  4370.   } else if ((buffer[0] < 128) && (isprint(buffer[0])||isspace(buffer[0])) &&
  4371.          (buffer[1] < 128) && (isprint(buffer[1])||isspace(buffer[1]))) {
  4372.      return new clearInput(filePtr, frefHand); // clear text
  4373.   } else if ((buffer[2] == 52) && (buffer[3] == 0)) { // 52 = 3 << 4 + 4
  4374.      return new NCARInput(filePtr, frefHand); // NCAR file
  4375.   }
  4376.   else { // unknown
  4377.     char myString[60]; // should be enough
  4378.     sprintf(myString,  "header = [%d, %d, %d, %d]\n", (int) buffer[0],
  4379.         (int) buffer[1], (int) buffer[2], (int) buffer[3]);
  4380.     myError("unknown format CGM file", myString);
  4381.     return NULL;
  4382.   }
  4383. }
  4384. ////
  4385. // interpret the command in memory and return appropriate  CGM object
  4386. // this function needs to know some cgm constants
  4387. ////
  4388. baseCGM *cgmInput::doCmd(cgmContainer *inOwner, baseCGM *inPrev)
  4389. {
  4390.   baseCGM *gotCmd;
  4391.   for (int i=0; (i<cgmNoClasses) && !sameCmd(cgmNameArray[i]);  ++i);
  4392.   if (i>=cgmNoClasses) {
  4393.     if (!padCmd()) myError("unknown command", cmdSignature());
  4394.     return NULL;
  4395.   } 
  4396.   // only the begin metafile command can have no owner
  4397.   if (!inOwner &&
  4398.       !((cgmNameArray[i].myClass == cgmDelimiter::myClass) &&
  4399.     (cgmNameArray[i].myElement  == cgmBeginMetafile::myElement))) {
  4400.     myError("illegal first command", *cgmNameArray[i].myName);
  4401.     return NULL;
  4402.   } else gotCmd = cgmNameArray[i].fp(inOwner, this, inPrev);
  4403.   //
  4404.   // may need to mark this command for use in interpretation
  4405.   if (gotCmd->cgmClass() == cgmMetafileDescriptor::myClass) {
  4406.     switch (gotCmd->cgmElement()) {
  4407.      case cgmVdcTypeMyElement:
  4408.       vdcTypeCmd = (cgmVdcType *) gotCmd;
  4409.       break;
  4410.      case cgmIntegerPrecMyElement:
  4411.       intPrecCmd = (cgmIntegerPrec *) gotCmd;
  4412.       break;
  4413.      case cgmRealPrecMyElement:
  4414.       realPrecCmd = (cgmRealPrec *) gotCmd;
  4415.       break;
  4416.      case cgmIndexPrecMyElement:
  4417.       indexPrecCmd = (cgmIndexPrec *) gotCmd;
  4418.       break;
  4419.      case cgmColrPrecMyElement:
  4420.       colrPrecCmd = (cgmColrPrec *) gotCmd;
  4421.       break;
  4422.      case cgmColrIndexPrecMyElement:
  4423.       colrIndexPrecCmd = (cgmColrIndexPrec *) gotCmd;
  4424.       break;
  4425.     }
  4426.   } else if (gotCmd->cgmClass() == cgmControl::myClass) {
  4427.     switch (gotCmd->cgmElement()) {
  4428.      case cgmVdcIntegerMyElement:
  4429.         if (inOwner->mf()) { // metafile owner, set defaults
  4430.     defVdcIntPrecCmd = (cgmVdcInteger *) gotCmd;
  4431.         } else vdcIntPrecCmd = (cgmVdcInteger *) gotCmd;
  4432.      case cgmVdcRealMyElement:
  4433.       if (inOwner->mf()) { // metafile owner, set defaults
  4434.     defVdcRealPrecCmd = (cgmVdcReal *) gotCmd;
  4435.       } else vdcRealPrecCmd = (cgmVdcReal *) gotCmd;
  4436.     }
  4437.   } else if ((gotCmd->cgmClass() == cgmDelimiter::myClass) &&
  4438.           (gotCmd->cgmElement() == cgmBeginPicture::myElement)) {
  4439.     vdcIntPrecCmd = NULL;
  4440.     vdcRealPrecCmd = NULL;
  4441.   }
  4442.   return gotCmd;
  4443. }
  4444. ////
  4445. // binary input
  4446. ////
  4447. // get a set of defaults (the whole set is in the buffer aleady)
  4448. ////
  4449. cgmDefaults *binaryInput::getDefaults(cgmMetafile *inOwner)
  4450. {
  4451.   // make some room and copy over the contained commands
  4452.   if (tempBufferIndex || tempBufferSize) {
  4453.     myError("tempBuffer already in use");
  4454.     return NULL;
  4455.   }
  4456.   tempBufferSize = bIndex - aIndex;
  4457.   tempBufferIndex = 0;
  4458.   if (tempBufferSize <= 0) { // screwed up somewhere
  4459.     myError("no contents to binary Metafile Defaults");
  4460.     tempBufferSize = 0;
  4461.     return NULL; 
  4462.   }
  4463.   // move over the data
  4464.   tempBuffer = new unsigned char[tempBufferSize];
  4465.   for (int i=0; i<tempBufferSize; ++i) tempBuffer[i] = buffer[i + aIndex];
  4466.   baseCGM *lastPtr = NULL, *firstPtr = NULL, *gotCmd;
  4467.   ////
  4468.   // loop thru commands until end of defaults
  4469.   while((tempBufferIndex < tempBufferSize) && getCmd()) {
  4470.     gotCmd = doCmd(inOwner, lastPtr); // parse it
  4471.     ////
  4472.     if (!gotCmd) continue; // go on to next command
  4473.     ////
  4474.     // legal command for defaults replacement ?
  4475.     if ((gotCmd->cgmClass() != cgmPictureDescriptor::myClass) &&
  4476.     (gotCmd->cgmClass() != cgmControl::myClass) &&
  4477.     (gotCmd->cgmClass() != cgmAttribute::myClass)) {
  4478.       myError("illegal defaults replacement", gotCmd->cgmName());
  4479.       break; // maybe lost end of command
  4480.     } else {
  4481.       // take care of first, last ptr
  4482.       if (!firstPtr) firstPtr = gotCmd;
  4483.       lastPtr = gotCmd;
  4484.     }
  4485.   }
  4486.   delete tempBuffer;
  4487.   tempBuffer = NULL;
  4488.   tempBufferIndex = 0;
  4489.   tempBufferSize = 0;
  4490.   return new cgmDefaults(firstPtr);
  4491. }
  4492. ////
  4493. // clear text input
  4494. ////
  4495. // get a set of defaults
  4496. ////
  4497. cgmDefaults *clearInput::getDefaults(cgmMetafile *inOwner)
  4498. {
  4499.   baseCGM *lastPtr = NULL, *firstPtr = NULL, *gotCmd;
  4500.   ////
  4501.   // loop thru commands until end of defaults
  4502.   while(*getCmd() && !same(cgmMetafileDefaultsReplacement::endName)) { 
  4503.     gotCmd = doCmd(inOwner, lastPtr); // parse it
  4504.     ////
  4505.     if (!gotCmd) continue; // go on to next command
  4506.     ////
  4507.     // legal command for defaults replacement ?
  4508.     if ((gotCmd->cgmClass() != cgmPictureDescriptor::myClass) &&
  4509.     (gotCmd->cgmClass() != cgmControl::myClass) &&
  4510.     (gotCmd->cgmClass() != cgmAttribute::myClass)) {
  4511.       myError("illegal defaults replacement", gotCmd->cgmName());
  4512.       break; // maybe lost end of command
  4513.     } else {
  4514.       // take care of first, last ptr
  4515.       if (!firstPtr) firstPtr = gotCmd;
  4516.       lastPtr = gotCmd;
  4517.     }
  4518.   }
  4519.   return new cgmDefaults(firstPtr);
  4520. }
  4521. ////
  4522. // parsing info
  4523. ////
  4524. // set the size of the parsing table, has to be here for the MAC
  4525. ////
  4526. const int cgmInput::cgmNoClasses = 
  4527. cgmEndPicture::myElement + cgmCharacterCodingAnnouncer::myElement +
  4528. cgmBackgroundColr::myElement + cgmClip::myElement +
  4529. cgmEllipArcClose::myElement + cgmASF::myElement +
  4530. cgmEscapeElement::myElement + cgmApplData::myElement;
  4531.  
  4532. void cgmDefaults::display(baseDisplay *inDisplay) // display the elements
  4533.      {for (baseCGM *myPtr=contents(); myPtr; myPtr=myPtr->next)
  4534.          myPtr->display(inDisplay);}
  4535.  
  4536. void cgmMetafile::displayDefaults(baseDisplay *inDisplay) const // display the defaults
  4537.      {for (cgmDefaults *myPtr=myDefaults; myPtr; myPtr=myPtr->next())
  4538.          myPtr->display(inDisplay);}
  4539.