home *** CD-ROM | disk | FTP | other *** search
/ Graphics 16,000 / graphics-16000.iso / msdos / plotting / pcgplots / basicio.h < prev    next >
C/C++ Source or Header  |  1992-04-24  |  15KB  |  488 lines
  1. // C++ .h file for gplot, gdoc, gtex, basic I/O  -*-c++-*-
  2. // copyright Phil Andrews, Pittsburgh Supercomputing Center, 1992
  3. // all rights reserved
  4. // RCS revision history
  5. // $Log$
  6. #ifndef basicio_h
  7. #define basicio_h
  8. #include <stdio.h>
  9. #include <string.h>
  10. ////
  11. #if __MSDOS__
  12.   typedef unsigned char huge * HugePt;
  13. #endif
  14. // external UNIX I/O
  15. ////
  16. extern "C" {
  17.   int open(const char*, int, ...);
  18.   int close(int);
  19.   int read(int, void*, unsigned int);
  20.   int fstat(int, struct stat*);
  21. }
  22. ////
  23. // forward declarations
  24. class tokenHolder;
  25. ////
  26. // the basic output object
  27. ////
  28. class outputObject {
  29. public:
  30.   virtual outputObject *outString(const char*, int, int useInWidth = 0,
  31.                   int inWidth = 0);
  32.   virtual outputObject *outString(const char*);
  33.   virtual outputObject *outChar(char);
  34.   virtual outputObject *addSpace() {return outString(" ", 1);} // default
  35. };
  36. ////
  37. // basic file output object 
  38. ////
  39. class fileOutput : public outputObject {
  40. public:
  41.   fileOutput(const char*, int=80);
  42.   virtual ~fileOutput();
  43.   virtual int opened() { return !!fout;}
  44.   virtual outputObject *outString(const char*, int, int useInWidth = 0,
  45.                   int inWidth = 0);
  46.   virtual outputObject *flushBuffer(int noLines = 1);
  47.   virtual outputObject *addSpace();
  48. protected:
  49.   FILE *fout;
  50.   char *lineBuffer;
  51.   long bufferIndex, bufferSize;
  52. };
  53. ////
  54. // basic string output object 
  55. ////
  56. class stringOutput : public outputObject {
  57. public:
  58.   stringOutput(int inSize=1024)
  59.     {myContents = new char[mySize = inSize];
  60.      myContents[lastPos=0] = 0;}
  61.   virtual ~stringOutput() {if (mySize) delete myContents;}
  62.   virtual int opened() { return !!myContents;}
  63.   virtual outputObject *outString(const char*, int, int useInWidth = 0,
  64.                   int inWidth = 0);
  65.   virtual char *contents() {return myContents;}
  66.   virtual int size() {return mySize;}
  67.   virtual int pos() {return lastPos;}
  68. protected:
  69.   char *myContents;
  70.   int mySize, lastPos;
  71. };
  72. ////
  73. // class for storing positional information on a stack
  74. ////
  75. class posPtr {
  76. public:
  77.   posPtr(int inValue, posPtr *inNext = NULL)
  78.     {myValue = inValue; myNext = inNext;}
  79.   int value() { return myValue;}
  80.   posPtr *next() { return myNext;}
  81. private:
  82.   int myValue;
  83.   posPtr *myNext;
  84. };
  85. ////
  86. // the basic text object
  87. ////
  88. class textObject {
  89. public:
  90.   textObject();
  91.   virtual ~textObject();
  92.   // pure virtual functions, must be provided by descendants
  93.   virtual textObject *drawString(const char*, int size = -1,
  94.                  int useInWidth = 0,
  95.                  int inWidth = 0) = 0;
  96.   virtual int maxWidth() = 0;
  97.   virtual int pageHeight() = 0;
  98.   virtual int stringWidth(const char*, int size) = 0;
  99.   virtual int stringHeight(const char*, int) = 0;
  100.   // default functions
  101.   virtual textObject *outSpace();
  102.   virtual textObject *newLine(int noLines = 1);
  103.   virtual textObject *blankLine();
  104.   virtual textObject *endLine();
  105.   virtual textObject *breakLeft(tokenHolder*);
  106.   virtual textObject *breakCenter(tokenHolder*);
  107.   virtual textObject *breakRight(tokenHolder*);
  108.   virtual textObject *breakBoth(tokenHolder*);
  109.   virtual textObject *breakNone(tokenHolder*);
  110.   virtual textObject *kern(int);
  111.   virtual int descent(const char*, int) {return 0;}
  112.   virtual int lineHeight() {return stringHeight("M", 1);} 
  113.   virtual int hpos() {return myHpos;}
  114.   virtual int vpos() {return myVpos;}
  115.   virtual int pageWidth() {return maxWidth() - rightMargin();}
  116.   virtual int leftMargin() {return leftMarginPtr->value();}
  117.   virtual int rightMargin() {return rightMarginPtr->value();}
  118.   virtual void pushLeftMargin();
  119.   virtual int popLeftMargin();
  120.   virtual void pushHpos();
  121.   virtual int popHpos();
  122.   virtual void pushRightMargin();
  123.   virtual int popRightMargin();
  124.   virtual void pushVpos();
  125.   virtual int popVpos();
  126.   const char *currentFontName() {return myCurrentFontName;}
  127.   void setCurrentFontName(const char*);
  128.   virtual int setFont(const char*, int=1) {return 1;} // default
  129. protected:
  130.   int myHpos, myVpos;
  131.   posPtr *leftMarginPtr, *rightMarginPtr, *hposPtr, *vposPtr;
  132.   char *myCurrentFontName;
  133.   int myCurrentFontNameSize, maxCurrentFontNameSize;
  134. };
  135. ////
  136. // output to a named file
  137. ////
  138. class outputFile : public textObject, public fileOutput {
  139. public:
  140.   outputFile(const char *inName, int inSize=80)
  141.     : fileOutput(inName, inSize) {}
  142.   virtual textObject *newLine(int noLines = 1);
  143.   virtual int hpos() { return bufferIndex;}
  144.   virtual int maxWidth() { return bufferSize;}
  145.   virtual int pageWidth() { return maxWidth();}
  146.   virtual int pageHeight() { return 0;}
  147.   virtual int stringWidth(const char*, int size) {return size;}
  148.   virtual int stringHeight(const char*, int) {return 0;}
  149.   virtual textObject *kern(int);
  150.   virtual textObject *drawString(const char *inStr, int size = -1,
  151.                  int useInWidth = 0, int inWidth = 0);
  152.   virtual textObject *outSpace() {++bufferIndex; return this;}
  153. };
  154. ////
  155. // output to a character array
  156. ////
  157. class outputArray : public textObject, public stringOutput {
  158. public:
  159.   outputArray(int inSize=1024, int inWidth = 0) : stringOutput(inSize)
  160.     {myWidth = inWidth;}
  161.   virtual textObject *newLine(int noLines = 1);
  162.   virtual int hpos() {return lastPos;}
  163.   virtual int maxWidth() {return (myWidth) ? myWidth : mySize;}
  164.   virtual int pageWidth() {return (myWidth) ? myWidth : mySize;}
  165.   virtual int pageHeight() {return 0;}
  166.   virtual int stringWidth(const char*, int size) {return size;}
  167.   virtual int stringHeight(const char*, int) {return 0;}
  168.   virtual textObject *kern(int) {return this;}
  169.   virtual textObject *drawString(const char *inStr, int inSize = -1,
  170.                  int useInWidth = 0, int inWidth = 0)
  171.     {outString(inStr, inSize, useInWidth, inWidth); return this;}
  172.   virtual textObject *outSpace() {return drawString(" ", 1);}
  173. protected:
  174.   int myWidth;
  175. };
  176. ////
  177. // tokens to be fed to an output object
  178. ////
  179. class outputToken {
  180. public:
  181.   outputToken();
  182.   virtual ~outputToken();
  183.   virtual int width(textObject*) {return 0;}
  184.   virtual int descent(textObject*) {return 0;}
  185.   virtual int height(textObject*) {return 0;}
  186.   virtual int breakPenalty(textObject*) {return 1;}
  187.   virtual int deletable() {return 0;}
  188.   virtual void draw(textObject*) {}
  189.   outputToken *next() {return myNext;}
  190.   outputToken *prev() {return myPrev;}
  191.   tokenHolder *owner() {return myOwner;}
  192.   void unlink() { myNext = myPrev = NULL;}
  193.   virtual int newLine() {return 0;}
  194.   virtual int isFont() {return 0;}
  195.   void setNext(outputToken *inNext) {myNext = inNext;}
  196.   void setPrev(outputToken *inPrev) {myPrev = inPrev;}
  197.   void setOwner(tokenHolder *inOwner) {myOwner = inOwner;}
  198.   virtual int noLines() {return 0;} // default
  199.   virtual int noTokens() {return 1;} // default
  200.   virtual outputToken *token() {return this;}
  201.   virtual outputToken *nextToken();
  202.   virtual outputToken *prevToken();
  203.   virtual unsigned int rank() {return 0;}
  204. protected:
  205.   outputToken *myNext, *myPrev;
  206.   tokenHolder *myOwner;
  207.   int myWidth;
  208. };
  209. ////
  210. // class to contain a formatted block
  211. ////
  212. class tokenHolder : public outputToken {
  213. public:
  214.   tokenHolder();
  215.   ~tokenHolder();
  216.   void draw(textObject*);
  217.   tokenHolder *addToken(outputToken*, int canBreak = 0);
  218.   tokenHolder *addToken(const char*, int canBreak = 0);
  219.   tokenHolder *addToken(char, int canBreak = 0);
  220.   tokenHolder *addLine(const char*);
  221.   tokenHolder *addSpace(const char*);
  222.   tokenHolder *addSpace(int);
  223.   tokenHolder *addSpace(float);
  224.   tokenHolder *addSpace(char);
  225.   outputToken *start() {return contents;}
  226.   outputToken *end() {return lastToken;}
  227.   void newStart(outputToken *inToken);
  228.   void newEnd(outputToken *inToken);
  229.   virtual int noTokens();
  230.   virtual int noLines();
  231.   virtual int width(textObject*);
  232.   int linesBefore() {return myLinesBefore;}
  233.   int linesAfter() {return myLinesAfter;}
  234.   tokenHolder *setLinesBefore(int i) {myLinesBefore = i; return this;}
  235.   tokenHolder *setLinesAfter(int i) {myLinesAfter = i; return this;}
  236.   virtual outputToken *token()
  237.      {return (contents && (myToken = contents->token()))?myToken : nextToken();}
  238.   virtual outputToken *nextToken()
  239.     {return (myNext)?myNext->token():(myOwner)?myOwner->nextToken():NULL;}
  240.   virtual outputToken *prevToken()
  241.     {return (myPrev)?myPrev->token():(myOwner)?myOwner->prevToken():NULL;}
  242. private:
  243.   int myLinesBefore, myLinesAfter;
  244.   outputToken *contents;
  245.   outputToken *lastToken, *myToken;
  246. };
  247. ////
  248. // next output token
  249. ////
  250. inline outputToken *outputToken::nextToken()
  251. {
  252.   return (myNext) ? myNext->token() : (myOwner)? myOwner->nextToken() : NULL;
  253. }
  254. ////
  255. // previous output token
  256. ////
  257. inline outputToken *outputToken::prevToken()
  258. {
  259.   return (myPrev) ? myPrev->token() : (myOwner)? myOwner->prevToken() : NULL;
  260. }
  261. ////
  262. // class to output a space
  263. ////
  264. class outputSpace : public outputToken{
  265. public:
  266.   outputSpace(outputToken *inToken = NULL, int notDeletable = 0)
  267.     : outputToken() {myPrev = inToken; myDeletable = !notDeletable;}
  268.   virtual int width(textObject*);
  269.   virtual void draw(textObject*);
  270.   virtual int breakPenalty(textObject*) { return 0;}
  271.   virtual int deletable() {return myDeletable;}
  272. protected:
  273.   int myDeletable;
  274. };
  275. ////
  276. // optional break class, like a space, but no width, no drawing
  277. ////
  278. class optionalBreak : public outputSpace{
  279. public:
  280.   optionalBreak(outputToken *inToken = NULL) : outputSpace(inToken) {}
  281.   virtual int width(textObject*) {return 0;}
  282.   virtual void draw(textObject*) {}
  283. };
  284. ////
  285. // class to hold a string (conserve space with a union)
  286. ////
  287. class outputString : public outputToken{
  288. public:
  289.   outputString(const char *inptr, int inSize, outputToken *inToken = NULL);
  290.   outputString(const char inChar, outputToken *inToken = NULL);
  291.   virtual ~outputString();
  292.   virtual int width(textObject *inText);
  293.   virtual int descent(textObject *inText)
  294.     {return inText->descent(bptr(), size);}
  295.   virtual int height(textObject *inText)
  296.     {return inText->stringHeight(bptr(), size);}
  297.   virtual void draw(textObject*);
  298. protected:
  299.   union {char *bptr; char barray[sizeof(char*)];} myUnion;
  300.   char *bptr() {return (size > sizeof(char*)) ? myUnion.bptr : myUnion.barray;}
  301.   int size;
  302. };
  303. ////
  304. // class to hold a single character
  305. ////
  306. class outputChar : public outputToken{
  307. public:
  308.   outputChar(char inChar, outputToken *inToken = NULL)
  309.     {schar = inChar; myPrev = inToken;}
  310.   virtual int width(textObject *inText);
  311.   virtual int descent(textObject *inText) {return inText->descent(&schar, 1);}
  312.   virtual int height(textObject *inText)
  313.     {return inText->stringHeight(&schar, 1);}
  314.   virtual void draw(textObject*);
  315. protected:
  316.   char schar;
  317. };
  318. ////
  319. // output a new line
  320. ////
  321. class outputNL : public outputToken{
  322. public:
  323.   outputNL(outputToken* = NULL, int inBefore = 0);
  324.   outputNL(int);
  325.   virtual void draw(textObject *inText) {inText->newLine(myNoLines);}
  326.   virtual int newLine() {return 1;}
  327.   virtual int noLines() {return myNoLines;}
  328. protected:
  329.   int myNoLines;
  330. };
  331. ////
  332. // inline tokenholder functions
  333. ////
  334. inline tokenHolder *tokenHolder::addLine(const char *inStr)
  335.   {addToken(inStr); addToken(new outputNL()); return this;}
  336. inline tokenHolder *tokenHolder::addSpace(const char *inStr)
  337.   {addToken(inStr); addToken(new outputSpace()); return this;}
  338. inline tokenHolder *tokenHolder::addSpace(char inC)
  339.   {addToken(inC); addToken(new outputSpace()); return this;}
  340. ////
  341. // typedef for file positioning
  342. ////
  343. typedef long filePos;
  344. ////
  345. // basic memory class (may be used for I/O)
  346. ////
  347. class basicMem {
  348. public:
  349.   basicMem() {myIndex = mySize = 0; myMem= NULL;}
  350.   ~basicMem() {if (mySize) delete myMem;}
  351.   char *contents() {return myMem;}
  352.   unsigned int index() {return myIndex;}
  353.   unsigned int size() {return mySize;}
  354. protected:
  355.   char *myMem;
  356.   unsigned int myIndex, mySize;
  357. };
  358. ////
  359. // the basic file
  360. ////
  361. class basicFile {
  362. public:
  363.   basicFile(); // constructor
  364.   virtual ~basicFile(); // destructor
  365. #ifdef macintosh
  366.   filePos pos()
  367.      {
  368.     long file_pos;
  369.     GetFPos( frefNum, &file_pos);
  370.     return (filePos)file_pos ;
  371.     }
  372.   int openedFile() {return 1;} // always open
  373.   int goTo(filePos inPos) 
  374.     {
  375.     OSErr ret;
  376.     ret = SetFPos(frefNum,fsFromStart, (long)inPos);
  377.     if (ret == noErr) return 0;
  378.     else if (ret == eofErr) return EOF;
  379.     else   FailOSErr(ret ); 
  380.     }
  381. #elif __MSDOS__
  382.   filePos pos()
  383.      {
  384.     long file_pos;
  385.     file_pos = tell( frefHand);
  386.     return (filePos)file_pos ;
  387.     }
  388.   int openedFile() {return 1;} // always open
  389.   int goTo(filePos inPos)
  390.       {
  391.       if (lseek( frefHand, (long)inPos, SEEK_SET) == inPos) return 0;   //OK
  392.       else return 1; // failure
  393.       }
  394. #else
  395.   filePos pos() {return ftell(filePtr);}
  396.   int openedFile() {return !!filePtr;}
  397.   int goTo(filePos inPos) {return fseek(filePtr, inPos, 0);}
  398. #endif
  399.   filePos lastPos() {return myLastPos;}
  400. protected:
  401.   FILE *filePtr;
  402.   short frefHand;      /* ref # for Mac, Handle for pc */
  403.   static char *digits; // needed for both input and output
  404. #if __MSDOS__
  405.   HugePt buffer, tempBuffer;
  406.   unsigned int hGlobalBuffer;
  407. #else
  408.   unsigned char *buffer, *tempBuffer;
  409. #endif
  410.   unsigned long bufferSize, tempBufferSize, tempBufferIndex;
  411.   int doubleBuffer(long);
  412.   filePos myLastPos;
  413. };
  414. ////
  415. // general input
  416. ////
  417. class genInput {
  418. public:
  419. #if __MSDOS__
  420.   virtual int getBytes(unsigned int noBytes, HugePt) = 0;
  421. #else
  422.   virtual int getBytes(unsigned int noBytes, unsigned char*) = 0;
  423. #endif
  424. };
  425. ////
  426. // basic file input
  427. ////
  428. class basicInput : public genInput, public basicFile {
  429. public:
  430.   basicInput(const char *, short=0);
  431.   basicInput(FILE*, short=0, int=0);
  432. #if __MSDOS__
  433.   virtual int getBytes(unsigned int noBytes, HugePt);
  434. #else
  435.   virtual int getBytes(unsigned int noBytes, unsigned char*);
  436. #endif
  437.   virtual int getOffBytes(unsigned int noBytes, unsigned long offset=0)
  438.      {return getBytes(noBytes, buffer + offset);} // convenience function
  439. protected:
  440.   unsigned long aIndex, bIndex;
  441. };
  442. ////
  443. // basic memory input
  444. ////
  445. class memInput : public basicMem, public genInput {
  446. public:
  447.   memInput() : basicMem() {}
  448.   virtual int getBytes(unsigned int noBytes, unsigned char *inPtr);
  449. };
  450. ////
  451. // basic file output
  452. ////
  453. class basicOutput : public basicFile {
  454. public:
  455.   basicOutput(const char *, short=0);
  456.   int outSep();
  457.   int textIntOut(int inVal, int noSep = 0);
  458.   int textRealOut(float inVal);
  459.   int textHexDump(const unsigned char *inPtr, int);
  460.   int textHexOut(unsigned char);
  461. protected:
  462.   int outLine(const char *inStr) {return outS(inStr) && endLine();}
  463.   int outToken(const char *inStr) {return outSep() && outS(inStr);}
  464.   int outS(const char*);
  465.   int outC(char c) {return outS(&c, 1);}
  466.   int endLine() {return flushLine();}
  467.   int lineSize, lineIndex, lastSep;
  468.   int outS(const char*, int);
  469.   int putBytes(int inLen) {return putBytes(buffer, inLen);}
  470. #if __MSDOS__
  471.   int putBytes(HugePt,int);
  472. #else
  473.     int putBytes(unsigned char *, int);
  474. #endif
  475.   int flushLine(int=0);
  476. };
  477. ////
  478. // make a kern
  479. ////
  480. class outputKern : public outputToken{
  481. public:
  482.   outputKern(int, outputToken*);
  483.   virtual void draw(textObject*);
  484. private:
  485.   int myKern;
  486. };
  487. #endif
  488.