home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / pstoedit.zip / source.zip / pstoedit.2.50 / src / drvbase.cpp < prev    next >
C/C++ Source or Header  |  1996-11-22  |  18KB  |  659 lines
  1. /* 
  2.    drvbase.cpp : This file is part of pstoedit
  3.    Basic, driver independent output routines
  4.  
  5.    Copyright (C) 1993,1994,1995,1996 Wolfgang Glunz, Wolfgang.Glunz@zfe.siemens.de
  6.  
  7.     This program is free software; you can redistribute it and/or modify
  8.     it under the terms of the GNU General Public License as published by
  9.     the Free Software Foundation; either version 2 of the License, or
  10.     (at your option) any later version.
  11.  
  12.     This program is distributed in the hope that it will be useful,
  13.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.     GNU General Public License for more details.
  16.  
  17.     You should have received a copy of the GNU General Public License
  18.     along with this program; if not, write to the Free Software
  19.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20.  
  21. */
  22.  
  23. #include <stdlib.h>
  24. #include <iostream.h>
  25. #include <string.h>
  26. #if !defined(unix) && !defined(__unix__) && !defined(__unix)
  27. #include <strstrea.h>
  28. #else
  29. #include <strstream.h>
  30. #endif
  31. #include "drvbase.h"
  32.  
  33. drvbase::drvbase(const char * driveroptions_p,ostream & theoutStream, 
  34.          ostream & theerrStream,
  35.          bool backendSupportsSubPathes_p,
  36.          bool backendSupportsCurveto_p, 
  37.          bool backendSupportsMerging_p) 
  38.         : // constructor
  39.     backendSupportsSubPathes(backendSupportsSubPathes_p),
  40.     backendSupportsCurveto(backendSupportsCurveto_p),
  41.     backendSupportsMerging(backendSupportsMerging_p),
  42.  
  43.     d_argc        (0),
  44.     d_argv        (0),
  45.     page_empty          (1),
  46.     outf                (theoutStream),
  47.     errf                (theerrStream),
  48.     scale               (1.0f),
  49.     // set some common defaults
  50.     currentDeviceHeight (792.0f * scale),
  51.     x_offset            (0.0f),
  52.     y_offset            (0.0f),
  53.     currentPageNumber   (0),
  54.     pathnumber        (0),
  55.     verbose            (false),
  56.     domerge            (false),
  57.     driveroptions    (0)
  58. { 
  59.     // init segment info for first segment
  60.     // all others will be updated with each newsegment
  61.     verbose = (getenv("PSTOEDITVERBOSE") != 0);
  62.     if (verbose) { 
  63.     errf << "verbose mode turned on\n" << endl;
  64.     }
  65.     numbers = new float[maxpoints]; // The number stack
  66.     nextFreeNumber = 0;
  67.  
  68.  
  69.     // preparse driveroptions and build d_argc and d_argv
  70.     if (driveroptions_p) {
  71.         driveroptions = strdup(driveroptions_p);
  72.  
  73.     istrstream optstream(driveroptions,strlen(driveroptions));
  74.     const long startOfStream = optstream.tellg();
  75.     char currentarg[100];
  76.         // first cound number of arguments
  77.         while(!optstream.eof()) {
  78.         optstream.width(sizeof(currentarg));
  79.         optstream >> currentarg;
  80.         d_argc++;
  81.     }
  82.     d_argv = new const char *[d_argc+1];
  83.     // now fill d_args array;
  84.     optstream.seekg(startOfStream); // reposition to start
  85.     optstream.clear();
  86.     d_argc=0;
  87.         while(!optstream.eof()) {
  88.         optstream >> currentarg;
  89.         d_argv[d_argc] = strdup(currentarg);
  90.         d_argc++;
  91.     }
  92.     d_argv[d_argc] = 0;
  93.         if (verbose) { 
  94.         errf << "got " << d_argc << " driver arguments" << endl;
  95.         for (unsigned int i = 0; i < d_argc ; i++ ) {
  96.             errf << "Driver option " << i << ":" << d_argv[i] << endl;
  97.         }
  98.     }
  99.     }
  100.  
  101.     currentPath = &p1;
  102.     lastPath    = &p2;
  103.     outputPath  = currentPath;
  104.     
  105.     if ((numbers == 0) || (p1.path == 0) || (p2.path == 0) ) {
  106.     errf << "new failed in drvbase::drvbase " << endl;
  107.     exit(1);
  108.     }
  109.  
  110.     setCurrentFontName("Courier",1);
  111.     setCurrentFontFamilyName("Courier");
  112.     setCurrentFontWeight("Regular");
  113.     setCurrentFontFullName("Courier");
  114.     setCurrentFontSize(10.0f);
  115. }
  116.  
  117. drvbase::~drvbase() { 
  118.     delete [] numbers;
  119.     currentPath = 0;
  120.     lastPath    = 0;
  121.     outputPath  = 0;
  122.     for (unsigned int i = 0; i < d_argc ; i++ ) {
  123.         free((char *)d_argv[i]); // use free because of strdup uses malloc
  124.     }
  125.     delete [] d_argv;
  126.     if (driveroptions) {
  127.         free((char *) driveroptions);
  128.     }
  129.     yylexcleanup();
  130. }
  131.  
  132. void drvbase::run(bool merge)
  133. {
  134.     domerge = false; // default
  135.     if (merge) {
  136.         if ( backendSupportsMerging ) {
  137.             domerge = true;
  138.         } else {
  139.             errf << "the selected backend does not support merging, -merge ignored" << endl;
  140.         }
  141.     }
  142.     yylex();
  143.     outputPath->clear(); // define past the end path as empty
  144.     dumpPath(); // dump last path 
  145.     // close page (if no explicit showpage was done)
  146.     if (!page_empty) {
  147.         close_page();
  148.     }
  149.     page_empty = 1;
  150. }
  151.  
  152. bool drvbase::pathsCanBeMerged(const PathInfo & path1, const PathInfo & path2)
  153. {
  154. //    return 0;
  155.     // two paths can be merged if one of them is a stroke and the
  156.     // other a fill AND
  157.     // all pathelements are the same
  158. //    errf << path1.numberOfElementsInPath << " " << path2.numberOfElementsInPath << endl;
  159.     if (((path1.currentShowType == stroke && path2.currentShowType == fill)  ||
  160.          (path2.currentShowType == stroke && path1.currentShowType == fill)  )
  161.        && (path1.numberOfElementsInPath == path2.numberOfElementsInPath)  ) {
  162. //        errf << "Pathes seem to be mergeable" << endl;
  163.         for (unsigned int i = 0; i < path1.numberOfElementsInPath ; i++) {
  164.             const basedrawingelement *bd1 = path1.path[i];
  165.             const basedrawingelement *bd2 = path2.path[i];
  166. //            if (! *(path1.path[i]) == *(path2.path[i]) ) return 0;
  167.             if (! (*bd1 == *bd2) ) return 0;
  168.         }
  169. //        errf << "Pathes are mergeable" << endl;
  170.         return 1;
  171.     } else {
  172.         return 0;
  173.     }
  174. }
  175.  
  176. void drvbase::addNumber(float co)
  177. {
  178. // printf("Adding %f\n",co);
  179.  if (nextFreeNumber < maxpoints) { 
  180.          numbers[nextFreeNumber++] = co; 
  181.          // nextFreeNumber always points to the next free number
  182.  } else { 
  183.        errf << "Too many numbers on stack. Please increase maxpoints in drvbase.h \n"; 
  184.  
  185.        exit(1); 
  186.  }
  187. }
  188.  
  189. const basedrawingelement & drvbase::pathElement(unsigned int index) const 
  190. {
  191.     return *(outputPath->path[index]);
  192. }
  193. bool operator==(const basedrawingelement & bd1, const basedrawingelement & bd2) 
  194.         { 
  195.             if (bd1.getType() != bd2.getType() ) {
  196.                 return 0;
  197.             } else {
  198.                 for (unsigned int i = 0; i < bd1.size; i++ ) {
  199.                     if (! (bd1.getPoint(i) == bd2.getPoint(i)) ) return 0;
  200.                 }
  201.             }
  202.             return 1;
  203.         }
  204.  
  205. void drvbase::dumpText(const char * const thetext)
  206. {
  207.   if (strlen(thetext) > 0) {
  208.       dumpPath(); // dump last path to avoid wrong sequence of text and graphics
  209.       add_to_page();
  210.       float y = pop();
  211.       float x = pop();
  212.       textInfo_.x = x;
  213.       textInfo_.y = y;
  214.       textInfo_.thetext = thetext;
  215.       show_text(textInfo_);
  216.   }
  217. }
  218.  
  219. float drvbase::pop() 
  220. { 
  221.   if (nextFreeNumber > 0) {
  222.       nextFreeNumber--;
  223.       return numbers[nextFreeNumber]; // the value we just popped
  224.   } else {
  225.     errf << "Fatal error in drvbase::pop : nextFreeNumber would get < 0" << endl;
  226.     exit(1);
  227.   }
  228.   return 0.0f; // never reached, just to make compiler quiet
  229. }
  230.  
  231. void drvbase::setCurrentWidthParams(float ax,float ay,int Char,float cx,float cy)
  232. {
  233.     textInfo_.ax = ax;
  234.     textInfo_.ay = ay;
  235.     textInfo_.Char = Char;
  236.     textInfo_.cx = cx;
  237.     textInfo_.cy = cy;
  238. }
  239.  
  240. void drvbase::setCurrentFontName(const char * const Name,bool is_non_standard_font) 
  241. { 
  242.     textInfo_.currentFontName.copy(Name); 
  243.     textInfo_.is_non_standard_font = is_non_standard_font;
  244. }
  245.  
  246. void drvbase::setCurrentFontFamilyName(const char * const Name)
  247.     { textInfo_.currentFontFamilyName.copy(Name); }
  248.  
  249. void drvbase::setCurrentFontFullName(const char * const Name)
  250.     { textInfo_.currentFontFullName.copy(Name); }
  251.  
  252. void drvbase::setCurrentFontWeight(const char * const Name)
  253.     { textInfo_.currentFontWeight.copy(Name); }
  254.  
  255. void drvbase::setCurrentFontSize(const float Size)
  256.     { /* errf << "setting Size to " << Size << endl; */  textInfo_.currentFontSize = Size ; }
  257.  
  258. void drvbase::setCurrentFontAngle(float value)
  259.     { textInfo_.currentFontAngle = value; }
  260.  
  261. bool drvbase::is_a_rectangle()
  262. {
  263. #if 0
  264. // TODO, Not yet implemented
  265.     int     dir;        /* 1 - up/down (same x) 0 - left/right (same y) */
  266.     if (numbersInCurrentSegment() != 10)
  267.     return 0;
  268. /* it might be a  rectangle */
  269.  
  270.     if (pNumber(0) == pNumber(2)) {
  271.     /* same x */
  272.     dir = 0;
  273.     } else if (pNumber(1) == pNumber(3)) {
  274.     /* same y */
  275.     dir = 1;
  276.     } else {
  277.     /* no rectangle */
  278.     return 0;
  279.     }
  280.  
  281.     for (int i = 0; i < 8; i++, i++) {
  282.     if (dir == 1) {
  283.         if (!(pNumber(i + 1) == pNumber(i + 1 + 2)))
  284.         return 0;
  285.         dir = 0;
  286.     } else {
  287.         if (!(pNumber(i) == pNumber(i + 2)))
  288.         return 0;
  289.         dir = 1;
  290.     }
  291.     }
  292.     return 1;
  293. #else
  294.     return 0;
  295. #endif
  296. }
  297.  
  298. void drvbase::add_to_page()
  299. {
  300.     if (page_empty) {
  301.     page_empty = 0;
  302.     currentPageNumber++;
  303.     open_page();
  304.     }
  305. }
  306.  
  307. void drvbase::guess_linetype()
  308. {
  309.     const char * pattern = dashPattern();
  310.     // first count number of ' ' in pattern to determine number of entries
  311.     // we normally have one less than number of blanks
  312.     // line looks like: " [ 2.25 6.75 ] 0.0 setdash"
  313.     drvbase::linetype curtype = solid;
  314.     int nr_of_entries = -1;
  315.     while ((*pattern) && (*pattern != ']' ) ) {
  316.         if (*pattern == ' ') nr_of_entries++;
  317.         pattern++;
  318.     }
  319.     pattern = dashPattern();
  320.     // errf << nr_of_entries << " entries found in " << pattern << endl;
  321.     if (nr_of_entries > 0) {
  322.         // now get the numbers
  323.         // repeat the numbers, if number of entries is odd
  324.         int rep = nr_of_entries % 2; // rep is 1 for odd numbers 0 for even
  325.         float *d_numbers = new float[nr_of_entries *(rep + 1)];
  326.         int cur = 0;
  327. #ifndef USEISTREAM
  328.         for (int i = 0; i <= rep ; i++ ) {
  329.             pattern = dashPattern();
  330.             while ((*pattern) && (*pattern != ']' ) ) {
  331.                 if (*pattern == ' ' && ( *(pattern+1) != ']' ) ) {
  332.                     float f = (float) atof(pattern);
  333.                     d_numbers[cur] = f;
  334.                      // errf << d_numbers[cur] << endl;
  335.                     cur++;
  336.                 }
  337.                 pattern++;
  338.             }
  339.         }
  340. #else
  341.         for (int i = 0; i <= rep ; i++ ) {
  342.             // on some systems istrstreams expects a non const char *
  343.             // so we need to make a copy
  344.             char * localpattern = new char[strlen(pattern+1) + 1];
  345.             strcpy(localpattern,pattern+1); // skip leading [
  346.             istrstream instream(localpattern); 
  347.             while (!instream.fail()) {
  348.                 float f;
  349.                 instream >> f;
  350.                 if (!instream.fail() ) {
  351.                     d_numbers[cur] = f;
  352.                      // errf << d_numbers[cur] << endl;
  353.                     cur++;
  354.                 }
  355.             }
  356.             delete [] localpattern;
  357.         }
  358. #endif
  359.         // now guess a pattern from
  360.         // solid, dashed, dotted, dashdot, dashdotdot ; // corresponding to the CGM patterns
  361.         switch ( nr_of_entries *(rep + 1) ) {
  362.         case 2: 
  363.             if (d_numbers[0] < 2.0f) {
  364.                 // if on is < 2 then always dotted
  365.                 // ok we miss '.             .             .'
  366.                 curtype = drvbase::dotted;
  367.             } else {
  368.                 curtype = drvbase::dashed;
  369.             }
  370.             break;
  371.         case 4:
  372.             if ( (d_numbers[0] < 2.0f) || (d_numbers[2] < 2.0f) ) {
  373.                 curtype = drvbase::dashdot;
  374.             } else {
  375.                 curtype = drvbase::dashed;
  376.             }
  377.             break;
  378.         case 6:
  379.             if ( (d_numbers[0] < 2.0f) || (d_numbers[2] < 2.0f)  || (d_numbers[2] < 2.0f) ) {
  380.                 curtype = drvbase::dashdotdot;
  381.             } else {
  382.                 curtype = drvbase::dashed;
  383.             }
  384.             break;
  385.         default:
  386.             curtype = drvbase::dashed;
  387.             break;
  388.         }
  389.         delete [] d_numbers;
  390.     } else {
  391.         // no entry
  392.         curtype = drvbase::solid;
  393.     }
  394.     // errf << "linetype from " << dashPattern() << " is " << curtype << endl;
  395.     setCurrentLineType(curtype);
  396. }
  397.  
  398. void drvbase::dumpPath()
  399. {
  400.     guess_linetype(); // needs to be done here, because we must write to currentpath
  401.     if (currentPath->numberOfElementsInPath == 2) {
  402.         // a polygon with two points is drawn as a line
  403.         currentPath->isPolygon=false;
  404.         currentPath->currentShowType=drvbase::stroke;
  405.     }
  406.     if (currentPath->currentShowType!=drvbase::stroke)
  407.     {
  408.         /* don't show border with fill */
  409.         setCurrentLineWidth(0.0f);  
  410.     }
  411.  
  412.     if (domerge && pathsCanBeMerged(p1,p2)) {
  413.     // make p1 the outputPath and clear p2
  414.     if (verbose) {
  415.         errf << "Path " << p1.nr << " type " << (int) p1.currentShowType << endl;
  416.         errf << p1.fillR << " " << p1.fillG << " " << p1.fillB << endl;
  417.         errf << p1.edgeR << " " << p1.edgeG << " " << p1.edgeB << endl;
  418.         errf << p1.currentLineWidth << endl;
  419.  
  420.         errf << "Path " << p2.nr << " type " << (int) p2.currentShowType << endl;
  421.         errf << p2.fillR << " " << p2.fillG << " " << p2.fillB << endl;
  422.         errf << p2.edgeR << " " << p2.edgeG << " " << p2.edgeB << endl;
  423.         errf << p2.currentLineWidth << endl;
  424.         errf << " have been merged\n";
  425.     }
  426.     // merge p2 into p1
  427.     if (p1.currentShowType == stroke) {
  428.         // p2 is the fill
  429.         p1.currentShowType = p2.currentShowType;
  430.         p1.fillR = p2.fillR;
  431.         p1.fillG = p2.fillG;
  432.         p1.fillB = p2.fillB;
  433.     } else {
  434.         // p1 is the fill, so copy the line parameters from p2
  435.         p1.currentLineWidth = p2.currentLineWidth;
  436.         p1.edgeR = p2.edgeR;
  437.         p1.edgeG = p2.edgeG;
  438.         p1.edgeB = p2.edgeB;
  439.     }
  440.     if (verbose) {
  441.         errf << " result is \n";
  442.         errf << "Path " << p1.nr << " type " << (int) p1.currentShowType << endl;
  443.         errf << p1.fillR << " " << p1.fillG << " " << p1.fillB << endl;
  444.         errf << p1.edgeR << " " << p1.edgeG << " " << p1.edgeB << endl;
  445.         errf << p1.currentLineWidth << endl;
  446.  
  447.     }
  448.     outputPath = &p1;
  449.     p2.clear();
  450.     } else {
  451.     outputPath = lastPath;
  452.     }
  453.     if (numberOfElementsInPath() > 0 ) {
  454.     // nothing to do for empty pathes
  455.     // pathes may be empty due to a merge operation
  456.  
  457.     if (verbose) {
  458.         errf << "working on";
  459.         switch ( currentShowType() ) {
  460.         case  drvbase::stroke:
  461.             errf << " stroked ";
  462.             break;
  463.         case  drvbase::fill:
  464.             errf << " filled ";
  465.             break;
  466.         case  drvbase::eofill:
  467.             errf << " eofilled ";
  468.             break;
  469.         default:
  470.             break;
  471.         }
  472.     errf << "path " << currentNr()  << " with " << 
  473.         numberOfElementsInPath() << " elements" << endl;
  474.     }
  475.  
  476.     if (numberOfElementsInPath() > 1) {
  477.     // cannot draw single points 
  478.         add_to_page();
  479.         if (isPolygon()) { /* PolyGon */
  480.         if (is_a_rectangle()) {
  481.             {
  482. #if 0
  483.             float llx,lly,urx,ury;
  484.  
  485. // TODO, Not yet implemented
  486.             llx = min( min(pNumber(0),pNumber(2)), min(pNumber(4),pNumber(6)));
  487.             urx = max( max(pNumber(0),pNumber(2)), max(pNumber(4),pNumber(6)));
  488.             lly = min( min(pNumber(1),pNumber(3)), min(pNumber(5),pNumber(7)));
  489.             ury = max( max(pNumber(1),pNumber(3)), max(pNumber(5),pNumber(7)));
  490.  
  491.             show_rectangle(llx,lly,urx,ury);
  492. #endif
  493.                    }
  494.         } else {
  495.             show_path();
  496.         }
  497.         } else { /* PolyLine */
  498.         show_path();
  499.         };
  500.     }
  501.     // cleanup
  502.     outputPath->clear();
  503.     }
  504.  
  505.  
  506.     // swap current and last pointers
  507.     PathInfo *help       = currentPath; 
  508.               currentPath = lastPath;
  509.               lastPath    = help;
  510.  
  511.     currentPath->copyInfo(*help); // initialize next path with state of last path
  512.                   // currentPath is the path filled next by lexer
  513.  
  514.     outputPath = currentPath;
  515. }
  516.  
  517. void    drvbase::addtopath(basedrawingelement * newelement)
  518. {
  519.     if (newelement) {
  520.         if (currentPath->numberOfElementsInPath < maxElements) {
  521.             currentPath->path[currentPath->numberOfElementsInPath] = newelement;
  522. #ifdef DEBUG
  523.             cout << "pathelement " << currentPath->numberOfElementsInPath << " added "
  524.                  << *newelement << endl;
  525. #endif
  526.             currentPath->numberOfElementsInPath++;
  527.         } else {
  528.             errf << "Fatal: number of path elements exceeded. Increase maxElements in drvbase.h" << endl;
  529.             exit(1);
  530.         }
  531.     } else {
  532.         errf << "Fatal: newelement is NULL in addtopath " << endl;
  533.         exit(1);
  534.     }
  535. }
  536.  
  537. void drvbase::PathInfo::clear() {
  538.             for (unsigned int i = 0 ; i < numberOfElementsInPath; i++ ) {
  539.                 delete path[i];
  540.                 path[i] = 0;
  541.             }
  542.             numberOfElementsInPath = 0;
  543.         }
  544. void drvbase::PathInfo::copyInfo(const PathInfo & p){
  545.             // copies the whole path state except the path array
  546.             currentShowType = p.currentShowType;
  547.             nr = p.nr;
  548.             // Path is not copied path(0),
  549.             isPolygon = p.isPolygon;
  550.             // numberOfElementsInPath = p.numberOfElementsInPath;
  551.             currentLineWidth = p.currentLineWidth;
  552.             edgeR = p.edgeR;
  553.             edgeG = p.edgeG;
  554.             edgeB = p.edgeB;
  555.             fillR = p.fillR;
  556.             fillG = p.fillG;
  557.             fillB = p.fillB;
  558.         }
  559.  
  560. ostream & operator<<(ostream & out,const basedrawingelement &elem)
  561. {
  562.     out << "type: " << (int) elem.getType() << " params: " ;
  563.     for (unsigned int i = 0 ; i < elem.size ; i++ ) {
  564.         out << elem.getPoint(i).x_ << " "
  565.             << elem.getPoint(i).y_ << " "; 
  566.     }
  567.     out << endl;
  568.     return out;
  569. }
  570. ColorTable::ColorTable(const char * const * defaultColors,
  571.            const unsigned int numberOfDefaultColors,
  572.            makeColorNameType makeColorName)  :
  573.         defaultColors_(defaultColors),
  574.         numberOfDefaultColors_(numberOfDefaultColors),
  575.         makeColorName_(makeColorName) 
  576. { 
  577.     for (unsigned int i = 0 ; i< maxcolors; i++) newColors[i] = 0;
  578. }
  579.  
  580. ColorTable::~ColorTable() 
  581. {
  582.     unsigned int current= 0;
  583.     while (newColors[current] != 0) {
  584.         delete [] newColors[current];
  585.         current++;
  586.     }
  587. }
  588.  
  589. unsigned int ColorTable::getColorIndex(float r, float g, float b)
  590. {
  591. // registers a possibly new color and returns the index 
  592. // under which the color was registered
  593.     const char * cmp = makeColorName_(r,g,b);
  594.     for (unsigned int i = 0; i < numberOfDefaultColors_ ; i++ )
  595.     {
  596.         if (strcmp(cmp,defaultColors_[i]) == 0) {
  597.             return i;
  598.         }
  599.     }
  600. // look in new colors
  601.     unsigned int j = 0;
  602.     for (j = 0; ((j < maxcolors) && (newColors[j] != 0)) ; j++ )
  603.     {
  604.         if (strcmp(cmp,newColors[j]) == 0) {
  605.             return j+numberOfDefaultColors_;
  606.         }
  607.     }
  608. // not found so far
  609. // j is either maxcolors or the index of the next free entry
  610. // add a copy to newColors
  611.     if (j < maxcolors) {
  612.         newColors[j] = new char[strlen(cmp) +1];
  613.         strcpy(newColors[j],cmp);
  614.         return j+numberOfDefaultColors_;
  615.     } else {
  616. //        cerr << "running out of colors" << endl;
  617.         return 0;
  618.     }
  619.  
  620. }
  621.  
  622. const char * const ColorTable::getColorString(float r, float g, float b)
  623. {
  624.     return getColorString(getColorIndex(r,g,b));
  625. }
  626.  
  627. bool ColorTable::isKnownColor(float r, float g, float b) const
  628. {
  629. // Possible improvements:
  630. // could return the next free entry as negative number in case
  631. // the color is not found. This would make it possible to
  632. // use this function in getColorEntry as well, or (better)
  633. // make a pure registercolor(index,.....) instead of
  634. // getColorEntry.
  635.     const char * cmp = makeColorName_(r,g,b);
  636.     for (unsigned int i = 0; i < numberOfDefaultColors_ ; i++ )
  637.     {
  638.         if (strcmp(cmp,defaultColors_[i]) == 0) {
  639.             return true;
  640.         }
  641.     }
  642.     // look in new colors
  643.     unsigned int j = 0;
  644.     for (j = 0; ((j < maxcolors) && (newColors[j] != 0)) ; j++ )
  645.     {
  646.         if (strcmp(cmp,newColors[j]) == 0) {
  647.             return true; // j+numberOfDefaultColors_;
  648.         }
  649.     }
  650.     // not found so far
  651.     return false; 
  652. }
  653.  
  654. const char * const ColorTable::getColorString(unsigned int index) const
  655. {
  656.     return (index < numberOfDefaultColors_) ? defaultColors_[index] :
  657.                             newColors[index - numberOfDefaultColors_];
  658. }
  659.