home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_progs / libs / plotlib.lha / Plot_1.lzh / Source / GfxL3.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-02-17  |  48.9 KB  |  1,566 lines
  1. /****************************************************************
  2. *                                                                                                                                *
  3. *     Filename : GfxL3.c                                                                                        *
  4. *                                                                                                                                *
  5. *****************************************************************
  6. *                                                                                                                                *
  7. *        Comment : Level 3 der Plotlibrary. Alle Funktionen für die    *
  8. *                            Graphik welche Computer oder Compiler abhängig        *
  9. *                            sind, müssen in dieser Datei enthalten sein.            *
  10. *                                                                                                                                *
  11. *                                Funktionen                                                        *
  12. *                            ==========                                                        *
  13. *                                                                                                                                *
  14. *            ScOpenGraphics()            öffnet das Graphiksystem                        *
  15. *            ScCloseGraphics()            schliesst das Graphiksystem                    *
  16. *            ScClearGraphics()            löscht den Bildschirm                                *
  17. *            ScGetMaxX()                        max. horiz. Auflösung                                *
  18. *            ScGetMaxY()                        max. vert. Auflösung                                *
  19. *            ScDrawText()                    schreibt eine Text                                    *
  20. *            ScSetLineStyle()            setzt Linienattribute                                *
  21. *            ScGetTextSize()                holt Textgrösse                                            *
  22. *            ScSetTextSize()                setzt 8*8 Text                                            *
  23. *            ScGetFgColor()                holt Stiftfarbe                                            *
  24. *            ScSetFgColor()                setzt Stiftfarbe                                        *
  25. *            ScGetBackColor()            holt Hintergrundefarbe                            *
  26. *            ScSetBackColor()            setzt Hintergrundfarbe                            *
  27. *            ScDrawLine()                    zeichnet eine Line                                    *
  28. *            ScDrawPolyLine()            zeichnet Kurvenzug                                    *
  29. *            ScFillPolyLine()            zeichnet Polygon                                        *
  30. *            ScSetFillStyle()            setzt Füllmuster                                        *
  31. *            ScDrawRectangle()            zeichnet ein Rechteck                                *
  32. *            ScGetMaxColor()                holt max. verfügbare Farbenanzahl        *
  33. *                                                                                                                                *
  34. *            #ifdef AMIGA                                                                                            *
  35. *            openlib()                        öffnet Funktionslibrary                                *
  36. *            openscreen()                öffnet Graphikbildschirm                            *
  37. *            #endif                                                                                                        *
  38. *                                                                                                                                *
  39. *            #ifdef __MSDOS__                                                                                    *
  40. *            #ifdef __TURBOC__                                                                                    *
  41. *            initdriver()                initialisiert Graphiktreiber                    *
  42. *            #endif                                                                                                        *
  43. *            #endif                                                                                                        *
  44. *                                                                                                                                *
  45. *                Rev : V1.0                                                                                            *
  46. *                                                                                                                                *
  47. *        History : V1.0 erstellen dieses Files                            04/12/89    *
  48. *                                                                                                                                *
  49. *                Doc : Plotlibrary User's Guide                                                    *
  50. *                                                                                                                                *
  51. *             Bugs : keine bekannten                                                                        *
  52. *                                                                                                                                *
  53. *            Autor : Oesch Silvano                                                                            *
  54. *                                                                                                                                *
  55. *            Datum : 04/12/89                                                                                    *
  56. *                                                                                                                                *
  57. ****************************************************************/
  58.  
  59. /****************************************************************
  60. *                                                                                                                                *
  61. *    Plotlibrary Includedateien                                                                        *
  62. *                                                                                                                                *
  63. ****************************************************************/
  64.  
  65. #include "Plot.h"
  66. #include "GfxL3.h"
  67.  
  68. /****************************************************************
  69. *                                                                                                                                *
  70. *    spezifische Includedateien                                                                        *
  71. *                                                                                                                                *
  72. ****************************************************************/
  73.  
  74. /*******************/
  75. #ifdef AMIGA
  76. /*******************/
  77. #include <proto/intuition.h>
  78. #include <proto/graphics.h>
  79. #include <exec/types.h>
  80. #include <intuition/intuition.h>
  81. #include <intuition/intuitionbase.h>
  82. #include <intuition/screens.h>
  83. #include <graphics/gfxbase.h>
  84. #include <graphics/gfxmacros.h>
  85. #endif
  86.  
  87. /*******************/
  88. #ifdef __MSDOS__
  89. #ifdef __TURBOC__
  90. /*******************/
  91. #include <graphics.h>
  92. #endif
  93. #endif
  94.  
  95. /****************************************************************
  96. *                                                                                                                                *
  97. *    globale statische Variablen                                                                        *
  98. *                                                                                                                                *
  99. ****************************************************************/
  100.  
  101. /*******************/
  102. #ifdef AMIGA
  103. /*******************/
  104.  
  105. extern struct IntuitionBase *IntuitionBase;
  106.                                                                         /* Intuitionlibrary                    */
  107. extern struct GfxBase *GfxBase;
  108. static struct IntuitionBase *IBase = NULL;
  109.                                                                         /* Intuitionlibrary                    */
  110. static struct GfxBase *GBase = NULL;
  111.                                                                         /* Graphicslibrary                    */
  112. static struct Screen *Sc=NULL;            /* Screenpointer                        */
  113. static struct Window *Mw=NULL;            /* Windowpointer                        */
  114. static struct ViewPort *Vp;                    /* Viewportpointer                    */
  115. static struct RastPort *Rp;                    /* Rastportpointer Screen        */
  116. static struct RastPort *WRp;                /* Rastportpointer Window        */
  117.  
  118. #include "ScreenL3.h"
  119.  
  120. #endif
  121.  
  122. /*******************/
  123. #ifdef __MSDOS__
  124. #ifdef __TURBOC__
  125. /*******************/
  126.  
  127. /****************************************************************
  128. *                                                                                                                                *
  129. *    Die Definition für die einzelnen Treiber müssen in Plotlib.h    *
  130. *    gemacht werden. Sie werden hier abgefragt, damit nicht alle        *
  131. *    Treiber dem Linker bekannt sind. Das Array DRIVERS wird in        *
  132. *    Plotlib.h so aufgebaut, dass all definierten Treiber darin        *
  133. *    enthalten sind.                                                                                                *
  134. *                                                                                                                                *
  135. ****************************************************************/
  136.  
  137. extern void (*DRIVERS[])(void);
  138.  
  139. static int GraphDriver = DETECT;        /* Graphiktreiber                        */
  140. static int GraphMode = NULL;                /* Graphikmode                            */
  141.  
  142. static int palette[MAXDEFCOL] =            /* Farbdefinitionen                    */
  143. {
  144.     BLACK,
  145.     WHITE,
  146.     LIGHTGRAY,
  147.     LIGHTBLUE,
  148.     LIGHTGREEN,
  149.     LIGHTCYAN,
  150.     LIGHTRED,
  151.     LIGHTMAGENTA,
  152.     BLUE,
  153.     GREEN,
  154.     CYAN,
  155.     RED,
  156.     MAGENTA,
  157.     BROWN,
  158.     DARKGRAY,
  159.     YELLOW
  160. };
  161.  
  162. #endif
  163. #endif
  164.  
  165. /****************************************************************
  166. *                                                                                                                                *
  167. *    externe Variablen                                                                                            *
  168. *                                                                                                                                *
  169. ****************************************************************/
  170.  
  171. extern struct Plot *plot;
  172. extern int plerr;
  173.  
  174. /****************************************************************
  175. *                                                                                                                                *
  176. *    Function : ScOpenGraphics()                                                                        *
  177. *                                                                                                                                *
  178. *****************************************************************
  179. *                                                                                                                                *
  180. *         Input : void                                                                                                *
  181. *                                                                                                                                *
  182. *        Output : int returnset                                                                            *
  183. *                            != FALSE        alle klar                                                        *
  184. *                            == FALSE            Fehler                                                            *
  185. *                                                                                                                                *
  186. *****************************************************************
  187. *                                                                                                                                *
  188. *     Comment : Diese Funktion hat die Aufgabe in den Graphikmodus    *
  189. *                         des Computers umzuschalten. Wenn ein Computer            *
  190. *                         keine unterscheidung zwischen Graphik und Text            *
  191. *                         macht, kann hier ein neuer Bildschirm geöffnet            *
  192. *                         werden. Es wird nur ein Fehler GROPER gesetzt für    *
  193. *                         die komplette Funktion.                                                        *
  194. *                         Der Indikator disp in der Plotstruktur ist zu            *
  195. *                         diesem Zeitpunk mit den entsprechenden Optionen        *
  196. *                         GRAPHSET oder GRAPHNOTSET gesetzt. Anhand dieser        *
  197. *                         Indikation können die benötigten Resourcen                    *
  198. *                         angefordert werden.                                                                *
  199. *                                                                                                                                *
  200. *         AMIGA : Wenn GRAPHSET, dann werden nur die Funktions-            *
  201. *                         librarys geöffnet. Es werden auch nur die Library-    *
  202. *                         pointer initialisiert,                                                            *
  203. *                         ACHTUNG : Die Librarys sind nur für die Plotlib        *
  204. *                                             nützbar. Das Applikationsprogramm muss        *
  205. *                                             diese Librarys auch öffnen wenn sie             *
  206. *                                             diese benötigt.                                                    *
  207. *                         Ansonsten wird ein Bildschirm mit einer Auflösung    *
  208. *                         von 640*512/400 Punkte mit 16 Farben geöffnet. Ein    *
  209. *                         entsprechendes Window wird ebenfalls auf diesem        *
  210. *                         Screen geöffnet.                                                                        *
  211. *                         Die folgenden static global Variablen werden                *
  212. *                         danach initialisiert:                                                            *
  213. *                                                                                                                                *
  214. *                                IntuitionBase        Library                                                    *
  215. *                                GfxBase                    Library                                                    *
  216. *                                Sc                            Screenpointer                                        *
  217. *                                Vp                            ViewPort                                                *
  218. *                                Rp                            Rastport                                                *
  219. *                                Mw                            Windowpointer                                        *
  220. *                                WRp                            Windowrastport                                    *
  221. *                                                                                                                                *
  222. *         MSDOS : Wenn GRAPHSET, dann wird der aktuelle Graphikmode    *
  223. *                         geholt. Danach wird kontrolliert, ob ein Fehler        *
  224. *                         bei dieser Funktion aufgetreten ist. Wenn dies            *
  225. *                         zutrifft, dann wird mit einer Fehlermeldung ver-        *
  226. *                         zweigt.                                                                                        *
  227. *                         Ansonsten wird der Graphiktreiber mit der höchsten    *
  228. *                         Auflösung initialisiert un in diesen Mode um-            *
  229. *                         geschaltet.                                                                                *
  230. *                         Die folgenden static global Variablen werden                *
  231. *                         initialisiert:                                                                            *
  232. *                                                                                                                                *
  233. *                                GraphDriver            Treiber                                                    *
  234. *                                GraphMode                Modus                                                        *
  235. *                                                                                                                                *
  236. ****************************************************************/
  237.  
  238. int ScOpenGraphics()
  239. {
  240.  
  241.     int returnset;
  242.  
  243.  
  244. /*******************/
  245. #ifdef AMIGA
  246. /*******************/
  247.  
  248.     if ( openlib() == FALSE )                    /* alle Librarys öffnen            */
  249.         setreturn(FALSE);                                /* Fehler                                        */
  250.     else
  251.     {
  252.         if (plot->disp & GRAPHNOTSET)        /* muss ein Screen geöffnet    */
  253.             if (openscreen() == FALSE)        /* werden. Ja                                */
  254.                 setreturn(FALSE);                        /* Fehler                                        */
  255.             else
  256.                 setreturn(TRUE);                        /* alles klar für NOTSET        */
  257.         else
  258.         {
  259. /****************************************************************
  260. *                                                                                                                                *
  261. *    Wenn GRAPHSET gesetzt ist, wird der aktive Screen als der            *
  262. *    genommen. Dasselbe gilt für das Window.                                                *
  263. *                                                                                                                                *
  264. ****************************************************************/
  265.  
  266.             Sc = IntuitionBase->ActiveScreen;
  267.             Vp = &Sc->ViewPort;                            /* Viewport initialisieren    */
  268.             Rp = &Sc->RastPort;                            /* Rastport initialisieren    */
  269.             Mw = IntuitionBase->ActiveWindow;
  270.             WRp = Mw->RPort;                            /* Rastport initialisieren    */
  271.             setreturn(TRUE);                            /* alles klar für SET                */
  272.         }
  273.     }
  274.  
  275. #endif
  276.  
  277. /*******************/
  278. #ifdef __MSDOS__
  279. #ifdef __TURBOC__
  280. /*******************/
  281.  
  282.     if (plot->disp & GRAPHNOTSET)            /* Driver laden ?                        */
  283.     {                                                                    /* Ja                                                */
  284.         initdriver();                                        /* Graphiktreiber inst.            */
  285.         GraphDriver = DETECT;                        /* welcher vorhanden ist        */
  286.         setgraphbufsize(8192);                    /* bis ca. 1200 Eckpunkte        */
  287.         initgraph(&GraphDriver,&GraphMode,"");
  288.                                                                         /* laden und umschalten            */
  289.         if (graphresult() != grOk)            /* Fehler ?                                    */
  290.         {
  291.             seterror(GROPER);                            /* Ja                                                */
  292.             setreturn(FALSE);
  293.         }
  294.         else
  295.             setreturn(TRUE);                            /* Nein                                            */
  296.     }
  297.     else                                                            /* kein Diver laden                    */
  298.     {                                                                    /* nur kontrolle                        */
  299.         GraphMode = getgraphmode();            /* hole Mode                                */
  300.         if (graphresult() != grOk)            /* Fehler beim Mode                    */
  301.         {
  302.             seterror(GROPER);                            /* Ja                                                */
  303.             setreturn(FALSE);
  304.         }
  305.         else
  306.             setreturn(TRUE);                            /* Nein, alles klar                    */
  307.     }
  308.  
  309. #endif
  310. #endif
  311.  
  312.     return(returnset);
  313. }
  314.  
  315. /****************************************************************
  316. *                                                                                                                                *
  317. *    Function : ScCloseGraphics()                                                                    *
  318. *                                                                                                                                *
  319. *****************************************************************
  320. *                                                                                                                                *
  321. *         Input : void                                                                                                *
  322. *                                                                                                                                *
  323. *        Output : void                                                                                                *
  324. *                                                                                                                                *
  325. *****************************************************************
  326. *                                                                                                                                *
  327. *     Comment : Diese Funktion schliesst die kompletten Graphik-        *
  328. *                         resourcen, welche bei OpenGraphics angefordert            *
  329. *                         wurden. Die entsprechenden statischen globalen            *
  330. *                         Variablen werden wieder auf ihre Standartwerte            *
  331. *                         zurückgesetzt um spätere komplikationen zu ver-        *
  332. *                         meiden. Der Displayparameter wird ebenfalls                *
  333. *                         zurückgesetzt.                                                                            *
  334. *                                                                                                                                *
  335. *         AMIGA : Wenn die Plotlibrary einen Screen geöffnet hat,        *
  336. *                         so schliesst sie diesen wieder. Die Librarys sind    *
  337. *                         für alle Darstellungen geöffnet worden. Sie werden    *
  338. *                         auch immer wieder geschlossen. Alle Werte werden        *
  339. *                         initialisiert.                                                                            *
  340. *                                                                                                                                *
  341. *         MSDOS : Wenn die Plotlibrary die Graphik geöffnet hat, so    *
  342. *                         wird wieder in den Textmodus umgeschaltet.                    *
  343. *                         Alle Werte werden initialisiert.                                        *
  344. *                                                                                                                                *
  345. ****************************************************************/
  346.  
  347. void ScCloseGraphics()
  348. {
  349.  
  350. /*******************/
  351. #ifdef AMIGA
  352. /*******************/
  353.  
  354.  
  355.     if (plot->disp & GRAPHNOTSET)            /* Wer hat Graphik geöffnet    */
  356.     {                                                                    /* Ich                                            */
  357.         if (Mw != NULL)                                    /* also wieder schliessen        */
  358.             CloseWindow(Mw);                            /* Mainwindow                                */
  359.         if (Sc != NULL)
  360.             CloseScreen(Sc);                            /* Screen                                        */
  361.         plot->disp &= ~GRAPHNOTSET;            /* Indikator reseten                */
  362.     }
  363.     else                                                            /* Graphik nicht von mir        */
  364.         plot->disp &= ~GRAPHSET;                /* Indikator init.                    */
  365.  
  366. /****************************************************************
  367. *                                                                                                                                *
  368. *    alle Librarys schliessen                                                                            *
  369. *                                                                                                                                *
  370. ****************************************************************/
  371.  
  372.     if (GBase != NULL)
  373.         CloseLibrary(GBase);                        /* Graphicslibrary                    */
  374.     if (IBase != NULL)
  375.         CloseLibrary(IBase);                        /* Intuitionlibrary                    */
  376.  
  377.     Mw = NULL;                                                /* alle Pointer init.                */
  378.     Sc = NULL;
  379.     GBase = NULL;
  380.     IBase = NULL;
  381.  
  382. #endif
  383.  
  384. /*******************/
  385. #ifdef __MSDOS__
  386. #ifdef __TURBOC__
  387. /*******************/
  388.  
  389.     if (plot->disp & GRAPHNOTSET)            /* Ist Graphik von mir ?        */
  390.     {                                                                    /* Ja                                                */
  391.         closegraph();                                        /* also schliessen                    */
  392.         plot->disp &= ~GRAPHNOTSET;            /* Indikator init.                    */
  393.     }
  394.     else                                                            /* Nein                                            */
  395.         plot->disp &= ~GRAPHSET;                /* Indikator reseten                */
  396.  
  397.         GraphDriver = DETECT;                        /* Werte initialisieren            */
  398.         GraphMode = NULL;
  399.  
  400. #endif
  401. #endif
  402.  
  403. }
  404.  
  405. /****************************************************************
  406. *                                                                                                                                *
  407. *    Function : ScGetMaxColor()                                                                        *
  408. *                                                                                                                                *
  409. *****************************************************************
  410. *                                                                                                                                *
  411. *         Input : void                                                                                                *
  412. *                                                                                                                                *
  413. *        Output : int maxcolor                max setzbares Farbregister            *
  414. *                                                                                                                                *
  415. *****************************************************************
  416. *                                                                                                                                *
  417. *     Comment : Diese computerabhängige Funktion stellt die max        *
  418. *                         mögliche darstellbaren Farben-1 fest und schreibt    *
  419. *                         diese in die Plotstruktur. Da 0 im Normalfall auch    *
  420. *                         eine Farbe ist, muss 1 subtrahiert werden.                    *
  421. *                                                                                                                                *
  422. *         AMIGA : Die Anzahl Bitplanes welche für den Screen                 *
  423. *                         definiert sind geben die Anzahl möglicher Farben        *
  424. *                         an.                                                                                                *
  425. *                                                                                                                                *
  426. *         MSDOS : Es wird die getmaxcolor vom Turbo C Compiler                *
  427. *                         verwendet.                                                                                    *
  428. *                                                                                                                                *
  429. ****************************************************************/
  430.  
  431. int ScGetMaxColor()
  432. {
  433.  
  434. /*******************/
  435. #ifdef AMIGA
  436. /*******************/
  437.  
  438.         return((int)(1<<Sc->BitMap.Depth)-1);
  439.                                                                         /* Planes und shiften                */
  440. #endif
  441.  
  442. /*******************/
  443. #ifdef __MSDOS__
  444. #ifdef __TURBOC__
  445. /*******************/
  446.  
  447.     return((int)getmaxcolor());                /* color holen                            */
  448.  
  449. #endif
  450. #endif
  451.  
  452. }
  453.  
  454. /****************************************************************
  455. *                                                                                                                                *
  456. *    Function : ScGetMaxX()                                                                                *
  457. *                                                                                                                                *
  458. *****************************************************************
  459. *                                                                                                                                *
  460. *         Input : void                                                                                                *
  461. *                                                                                                                                *
  462. *        Output : int maxx                max. horizontaler setzbarer Punkt        *
  463. *                                                                                                                                *
  464. *****************************************************************
  465. *                                                                                                                                *
  466. *     Comment : Diese Funktion hat die Aufgabe die max.                        *
  467. *                         horizontale Koordinate der aktuellen Graphik-            *
  468. *                         einstellung als Rückgabewert zu liefern.                        *
  469. *                         Die Bildschirmauflösung ist normalerweise um 1            *
  470. *                         höher.                                                                                            *
  471. *                                                                                                                                *
  472. *         AMIGA : Es wird vom aktiven Window die max. Koordinate            *
  473. *                         geholt. Wenn also dieses Window später verkleinert    *
  474. *                         wird, passt sich die Graphik der neuen Grösse an.    *
  475. *                                                                                                                                *
  476. *         MSDOS : Es wird die getmaxx Funktion vom Turbo C Compiler    *
  477. *                         verwendet.                                                                                    *
  478. *                                                                                                                                *
  479. ****************************************************************/
  480.  
  481. int ScGetMaxX()
  482. {
  483.  
  484. /*******************/
  485. #ifdef AMIGA
  486. /*******************/
  487.  
  488.         return((int)(Mw->Width-1));            /* Grösse aus Window holen    */
  489.  
  490. #endif
  491.  
  492. /*******************/
  493. #ifdef __MSDOS__
  494. #ifdef __TURBOC__
  495. /*******************/
  496.  
  497.     return((int)getmaxx());                        /* Na ja, dasselbe                    */
  498.  
  499. #endif
  500. #endif
  501.  
  502. }
  503.  
  504. /****************************************************************
  505. *                                                                                                                                *
  506. *    Function : ScGetMaxY()                                                                                *
  507. *                                                                                                                                *
  508. *****************************************************************
  509. *                                                                                                                                *
  510. *         Input : void                                                                                                *
  511. *                                                                                                                                *
  512. *        Output : int maxy                max. vertikaler setzbarer Punkt            *
  513. *                                                                                                                                *
  514. *****************************************************************
  515. *                                                                                                                                *
  516. *     Comment : Diese Funktion hat die Aufgabe die max.                        *
  517. *                         vertikale Koordinate der aktuellen Graphik-                *
  518. *                         einstellung als Rückgabewert zu liefern.                        *
  519. *                         Die Bildschirmauflösung ist normalerweise um 1            *
  520. *                         höher.                                                                                            *
  521. *                                                                                                                                *
  522. *         AMIGA : Es wird vom aktiven Window die max. Koordinate            *
  523. *                         geholt. Wenn also dieses Window später verkleinert    *
  524. *                         wird, passt sich die Graphik der neuen Grösse an.    *
  525. *                                                                                                                                *
  526. *         MSDOS : Es wird die getmaxy Funktion vom Turbo C Compiler    *
  527. *                         verwendet.                                                                                    *
  528. *                                                                                                                                *
  529. ****************************************************************/
  530.  
  531. int ScGetMaxY()
  532. {
  533.  
  534. /*******************/
  535. #ifdef AMIGA
  536. /*******************/
  537.  
  538.         return((int)(Mw->Height-1));        /* Grösse von Window holen    */
  539.  
  540. #endif
  541.  
  542. /*******************/
  543. #ifdef __MSDOS__
  544. #ifdef __TURBOC__
  545. /*******************/
  546.  
  547.     return((int)getmaxy());                        /* dito                                                */
  548.  
  549. #endif
  550. #endif
  551.  
  552. }
  553.  
  554. /****************************************************************
  555. *                                                                                                                                *
  556. *    Function : ScSetTextSize()                                                                        *
  557. *                                                                                                                                *
  558. *****************************************************************
  559. *                                                                                                                                *
  560. *         Input : void                                                                                                *
  561. *                                                                                                                                *
  562. *        Output : void                                                                                                *
  563. *                                                                                                                                *
  564. *****************************************************************
  565. *                                                                                                                                *
  566. *     Comment : SetTextSize() setzt einen 8*8 grossen Text. Diese    *
  567. *                         Textgrösse sollte eingehalten werden. Sie kann            *
  568. *                         aber auch kleiner werden.                                                    *
  569. *                                                                                                                                *
  570. *         AMIGA : Es wird die ROM Schrift TOPAZ geöffnet und für            *
  571. *                         dieses Window gesetzt.                                                            *
  572. *                                                                                                                                *
  573. *         MSDOS : Es wird die Textausrichtung auf die linke untere        *
  574. *                         Ecke gesetz, die Standartschrift gesetzt und ihre    *
  575. *                         Ausrichtung auf horizontal gesetzt.                                *
  576. *                                                                                                                                *
  577. ****************************************************************/
  578.  
  579. void ScSetTextSize()
  580. {
  581.  
  582. /*******************/
  583. #ifdef AMIGA
  584. /*******************/
  585.  
  586.     struct TextFont *textfont;                /* Fontzeiger                                */
  587.  
  588.     textfont = OpenFont(&TOPAZ80);        /* öffne Font                                */
  589.     SetFont(WRp,textfont);                        /* und setzten                            */
  590.  
  591. #endif
  592.  
  593. /*******************/
  594. #ifdef __MSDOS__
  595. #ifdef __TURBOC__
  596. /*******************/
  597.  
  598.     settextjustify(LEFT_TEXT,BOTTOM_TEXT);
  599.                                                                         /* untere linke Ecke                */
  600.     settextstyle(DEFAULT_FONT,HORIZ_DIR,0);
  601.                                                                         /* Standartschrift                    */
  602.  
  603. #endif
  604. #endif
  605.  
  606. }
  607.  
  608. /****************************************************************
  609. *                                                                                                                                *
  610. *    Function : ScClearGraphics()                                                                    *
  611. *                                                                                                                                *
  612. *****************************************************************
  613. *                                                                                                                                *
  614. *         Input : void                                                                                                *
  615. *                                                                                                                                *
  616. *        Output : void                                                                                                *
  617. *                                                                                                                                *
  618. *****************************************************************
  619. *                                                                                                                                *
  620. *     Comment : Diese Funktion muss den Bildschirm löschen können    *
  621. *                         in welchen gezeichnet wird.                                                *
  622. *                                                                                                                                *
  623. *         AMIGA : Es wird die Standartfunktion verwendet.                        *
  624. *                                                                                                                                *
  625. *         MSDOS : Es wird die Standartfunktion verwendet.                        *
  626. *                                                                                                                                *
  627. ****************************************************************/
  628.  
  629. void ScClearGraphics()
  630. {
  631.  
  632. /*******************/
  633. #ifdef AMIGA
  634. /*******************/
  635.  
  636.     Move(WRp,0,0);                                        /* löschen von Anfang an        */
  637.     ClearScreen(WRp);                                    /* und löschen                            */
  638.  
  639. #endif
  640.  
  641. /*******************/
  642. #ifdef __MSDOS__
  643. #ifdef __TURBOC__
  644. /*******************/
  645.  
  646.     cleardevice();                                        /* alles löschen                        */
  647.  
  648. #endif
  649. #endif
  650.  
  651. }
  652.  
  653. /****************************************************************
  654. *                                                                                                                                *
  655. *    Function : ScDrawText()                                                                                *
  656. *                                                                                                                                *
  657. *****************************************************************
  658. *                                                                                                                                *
  659. *         Input : x,y,string                                                                                    *
  660. *                            int x                        horiz. Startpunkt                                    *
  661. *                            int y                        vert. Startpunkt                                    *
  662. *                            char *string        Textzeiger                                                *
  663. *                                                                                                                                *
  664. *        Output : void                                                                                                *
  665. *                                                                                                                                *
  666. *****************************************************************
  667. *                                                                                                                                *
  668. *     Comment : ScDrawText schreibt einen Text startend mit dem        *
  669. *                         Koordinatenpunkt (x/y). Dieser Punkt legt die            *
  670. *                                                                                                                                *
  671. *         AMIGA : Korrektur der Koordinate um die Basisline und            *
  672. *                         verwenden der Standartfunktion.                                        *
  673. *                                                                                                                                *
  674. *         MSDOS : Standartfunktion von Turbo C                                                *
  675. *                                                                                                                                *
  676. ****************************************************************/
  677.  
  678. void ScDrawText(x,y,string)
  679. int x,y;
  680. char *string;
  681. {
  682.  
  683. /*******************/
  684. #ifdef AMIGA
  685. /*******************/
  686.  
  687.     Move(WRp,x,y-WRp->TxHeight+WRp->TxBaseline);
  688.                                                                         /* Koordinatenkorr.                    */
  689.     Text(WRp,string,strlen(string));    /* schreibe Text                        */
  690.  
  691. #endif
  692.  
  693. /*******************/
  694. #ifdef __MSDOS__
  695. #ifdef __TURBOC__
  696. /*******************/
  697.  
  698.     outtextxy(x,y,string);                        /* schreibe Text                        */
  699.  
  700. #endif
  701. #endif
  702.  
  703. }
  704.  
  705. /****************************************************************
  706. *                                                                                                                                *
  707. *    Function : ScGetFgColor()                                                                            *
  708. *                                                                                                                                *
  709. *****************************************************************
  710. *                                                                                                                                *
  711. *         Input : void                                                                                                *
  712. *                                                                                                                                *
  713. *        Output : int color                aktuelle Stiftfarbe                                *
  714. *                                                                                                                                *
  715. *****************************************************************
  716. *                                                                                                                                *
  717. *     Comment : ScGetFgColor gibt die aktuelle Stiftfarbe zurück        *
  718. *                         mit welcher gezeichnet wird.                                                *
  719. *                                                                                                                                *
  720. *         AMIGA : Stiftfarbe aus Rastport holen.                                            *
  721. *                                                                                                                                *
  722. *         MSDOS : Standartfunktion von Turbo C                                                *
  723. *                                                                                                                                *
  724. ****************************************************************/
  725.  
  726. int ScGetFgColor()
  727. {
  728.  
  729. /*******************/
  730. #ifdef AMIGA
  731. /*******************/
  732.  
  733.     return((int)WRp->FgPen);                    /* Vordergrund holen                */
  734.  
  735. #endif
  736.  
  737. /*******************/
  738. #ifdef __MSDOS__
  739. #ifdef __TURBOC__
  740. /*******************/
  741.  
  742.     return(convcolor(getcolor()));        /* Farbe holen und konv.        */
  743.  
  744. #endif
  745. #endif
  746.  
  747. }
  748.  
  749. /****************************************************************
  750. *                                                                                                                                *
  751. *    Function : ScSetFgColor()                                                                            *
  752. *                                                                                                                                *
  753. *****************************************************************
  754. *                                                                                                                                *
  755. *         Input : int color                    neuer Stiftfarbe                                *
  756. *                                                                                                                                *
  757. *        Output : void                                                                                                *
  758. *                                                                                                                                *
  759. *****************************************************************
  760. *                                                                                                                                *
  761. *     Comment : Diese Funktion setzt die angegebene Farbe als            *
  762. *                         neuen Stift.                                                                                *
  763. *                                                                                                                                *
  764. *         AMIGA : Verwendung der Standartfunktion für das setzten        *
  765. *                         der Vodergrundfarbe.                                                                *
  766. *                                                                                                                                *
  767. *         MSDOS : Turbo C Standartfunktion                                                        *
  768. *                                                                                                                                *
  769. ****************************************************************/
  770.  
  771. void ScSetFgColor(color)
  772. int color;
  773. {
  774.  
  775. /*******************/
  776. #ifdef AMIGA
  777. /*******************/
  778.  
  779.     SetAPen(WRp,color);                                /* Farbe setzten                        */
  780.  
  781. #endif
  782.  
  783. /*******************/
  784. #ifdef __MSDOS__
  785. #ifdef __TURBOC__
  786. /*******************/
  787.  
  788.     if (color < MAXDEFCOL)                        /* konvertieren                            */
  789.         color = palette[color];
  790.     setcolor(color);                                    /* Farbe setzen                            */
  791.  
  792. #endif
  793. #endif
  794.  
  795. }
  796.  
  797. /****************************************************************
  798. *                                                                                                                                *
  799. *    Function : ScGetBackColor()                                                                        *
  800. *                                                                                                                                *
  801. *****************************************************************
  802. *                                                                                                                                *
  803. *         Input : void                                                                                                *
  804. *                                                                                                                                *
  805. *        Output : int color                        aktuelle Stiftfarbe                        *
  806. *                                                                                                                                *
  807. *****************************************************************
  808. *                                                                                                                                *
  809. *     Comment : ScGetBackColor holt die aktuelle Hintergrundfarbe.    *
  810. *                                                                                                                                *
  811. *         AMIGA : Aus Rastport BackgroundPen holen                                        *
  812. *                                                                                                                                *
  813. *         MSDOS : Verwenden von Turbo C Standartfunktion                            *
  814. *                                                                                                                                *
  815. ****************************************************************/
  816.  
  817. int ScGetBackColor()
  818. {
  819.  
  820. /*******************/
  821. #ifdef AMIGA
  822. /*******************/
  823.  
  824.     return((int)WRp->BgPen);                    /* hole Background                    */
  825.  
  826. #endif
  827.  
  828. /*******************/
  829. #ifdef __MSDOS__
  830. #ifdef __TURBOC__
  831. /*******************/
  832.  
  833.     return(convcolor(getbkcolor()));    /* Farbe holen und konv.        */
  834.  
  835. #endif
  836. #endif
  837.  
  838. }
  839.  
  840. /****************************************************************
  841. *                                                                                                                                *
  842. *    Function : ScSetBackColor()                                                                        *
  843. *                                                                                                                                *
  844. *****************************************************************
  845. *                                                                                                                                *
  846. *         Input : int color                setzt neue Hintergrundfarbe                *
  847. *                                                                                                                                *
  848. *        Output : void                                                                                                *
  849. *                                                                                                                                *
  850. *****************************************************************
  851. *                                                                                                                                *
  852. *     Comment : Diese Funktion setzt eine neue Hintergrundfarbe        *
  853. *                         für die aktuelle Ausgabe.                                                    *
  854. *                                                                                                                                *
  855. *         AMIGA : Standartfunktion der graphics.library                            *
  856. *                                                                                                                                *
  857. *         MSDOS : Turbo C Funktion                                                                        *
  858. *                                                                                                                                *
  859. ****************************************************************/
  860.  
  861. void ScSetBackColor(color)
  862. int color;
  863. {
  864.  
  865. /*******************/
  866. #ifdef AMIGA
  867. /*******************/
  868.  
  869.     SetBPen(WRp,color);                                /* Farbe setzten                        */
  870.  
  871. #endif
  872.  
  873. /*******************/
  874. #ifdef __MSDOS__
  875. #ifdef __TURBOC__
  876. /*******************/
  877.  
  878.     if (color < MAXDEFCOL)                        /* konvertieren                            */
  879.         color = palette[color];
  880.     setbkcolor(color);                                /* Farbe setzten                        */
  881.  
  882. #endif
  883. #endif
  884.  
  885. }
  886.  
  887. /****************************************************************
  888. *                                                                                                                                *
  889. *    Function : ScDrawLine()                                                                                *
  890. *                                                                                                                                *
  891. *****************************************************************
  892. *                                                                                                                                *
  893. *         Input : x1,y1,x2,y2                                                                                *
  894. *                            int x1                    horiz. Startwert                                    *
  895. *                            int y1                    vert. Startwert                                        *
  896. *                            int x2                    horiz. Endtwert                                        *
  897. *                            int y2                    vert. Emdwert                                            *
  898. *                                                                                                                                *
  899. *        Output : void                                                                                                *
  900. *                                                                                                                                *
  901. *****************************************************************
  902. *                                                                                                                                *
  903. *     Comment : ScDrawLine zeichnet eine Linie von dem Punkt                *
  904. *                         (x1/y1) nach (x2/y2) in der aktuellen Stiftfarbe.    *
  905. *                                                                                                                                *
  906. *         AMIGA : Standartfunktionen aus graphics.library                        *
  907. *                                                                                                                                *
  908. *         MSDOS : Turbo C Funktionen                                                                    *
  909. *                                                                                                                                *
  910. ****************************************************************/
  911.  
  912. void ScDrawLine(x1,y1,x2,y2)
  913. int x1,
  914.         y1,
  915.         x2,
  916.         y2;
  917. {
  918.  
  919. /*******************/
  920. #ifdef AMIGA
  921. /*******************/
  922.  
  923.     Move(WRp,x1,y1);                                    /* Startposition                        */
  924.     Draw(WRp,x2,y2);                                    /* zeichne Linie                        */
  925.  
  926. #endif
  927.  
  928. /*******************/
  929. #ifdef __MSDOS__
  930. #ifdef __TURBOC__
  931. /*******************/
  932.  
  933.     line(x1,y1,x2,y2);                                /* zeichne Linie                        */
  934.  
  935. #endif
  936. #endif
  937.  
  938. }
  939.  
  940. /****************************************************************
  941. *                                                                                                                                *
  942. *    Function : ScDrawPolyLine()                                                                        *
  943. *                                                                                                                                *
  944. *****************************************************************
  945. *                                                                                                                                *
  946. *         Input : counter,array                                                                            *
  947. *                            int counter                        Anzahl Koordinatenpunkte        *
  948. *                            GPT *array                        Zeiger auf Koordinatenpaare    *
  949. *                                                                                                                                *
  950. *        Output : void                                                                                                *
  951. *                                                                                                                                *
  952. *****************************************************************
  953. *                                                                                                                                *
  954. *     Comment : Diese Funktion zeichnet ein Kurvenzug in der                *
  955. *                         aktuellen Stiftfarbe. Es werden alle Punkte                *
  956. *                         in dem Array nacheinander verbunden.                                *
  957. *                                                                                                                                *
  958. *         AMIGA : Standartfunktion in graphics.library                                *
  959. *                                                                                                                                *
  960. *         MSDOS : Verwenden der drawpolyfunktion.                                         *
  961. *                                                                                                                                *
  962. ****************************************************************/
  963.  
  964. void ScDrawPolyLine(counter,array)
  965. int counter;
  966. GPT    *array;
  967. {
  968.  
  969. /*******************/
  970. #ifdef AMIGA
  971. /*******************/
  972.  
  973.         Move(WRp,*array++,*array++);        /* Startkoordinate                    */
  974.         PolyDraw(WRp,counter-1,array);    /* und zeichnen                            */
  975.  
  976. #endif
  977.  
  978. /*******************/
  979. #ifdef __MSDOS__
  980. #ifdef __TURBOC__
  981. /*******************/
  982.  
  983.     drawpoly(counter,array);                    /* zeichene Kurve                        */
  984.  
  985. #endif
  986. #endif
  987.  
  988. }
  989.  
  990. /****************************************************************
  991. *                                                                                                                                *
  992. *    Function : ScFillPolyLine()                                                                        *
  993. *                                                                                                                                *
  994. *****************************************************************
  995. *                                                                                                                                *
  996. *         Input : counter,array                                                                            *
  997. *                            int counter                        Anzahl Koordinatenpunkte        *
  998. *                            GPT *array                        Zeiger auf Koordinatenpaare    *
  999. *                                                                                                                                *
  1000. *        Output : int returnset                    Rückgabewert                                *
  1001. *                            returnset != FALSE        alles klar                                    *
  1002. *                            returnset == FALSE        Fehler beim zeichnen des        *
  1003. *                                                                        Polygones                                        *
  1004. *                                                                                                                                *
  1005. *****************************************************************
  1006. *                                                                                                                                *
  1007. *     Comment : Diese Funktion zeichnet ein Polygon in der                    *
  1008. *                         aktuellen Stiftfarbe. Zusätzlich wird dieses                *
  1009. *                         mit dem aktuellen Muster ausgefüllt. Wenn das            *
  1010. *                         Muster 0 angewählt wurde, dann soll kein aus-            *
  1011. *                         füllen geschehen. Die Abfrage für das Muster 0            *
  1012. *                         kann über die Plotstruktur geschehen. Wenn in            *
  1013. *                         plot->style == NOSTYLE steht, ist kein Muster            *
  1014. *                         ewrwünscht.                                                                                *
  1015. *                                                                                                                                *
  1016. *                                                                                                                                *
  1017. *         AMIGA : Wenn kein Muster erwünscht ist, verwenden der            *
  1018. *                         einfachen Zeichnungsfunktion.                                            *
  1019. *                         Sonst verwenden der Area-Funktionen mit ihrem            *
  1020. *                         komplexen Handling.                                                                *
  1021. *                                                                                                                                *
  1022. *         MSDOS : Verwenden der fillpolyfunktion. Für den Rückgabe-    *
  1023. *                         wird graphresult aufgerufen.                                                *
  1024. *                                                                                                                                *
  1025. ****************************************************************/
  1026.  
  1027. int ScFillPolyLine(counter,array)
  1028. int counter;
  1029. GPT    *array;
  1030. {
  1031.  
  1032.     int returnset = TRUE;
  1033.  
  1034. /*******************/
  1035. #ifdef AMIGA
  1036. /*******************/
  1037.  
  1038. PLANEPTR araster;                                        /* TempRastPortpointer            */
  1039. struct TmpRas myTmpRas;                            /* Rastportstruktur                    */
  1040. struct AreaInfo myareainfo;                    /* Areastruktur                            */
  1041. WORD *datas;                                                /* Zeiger auf neue Daten        */
  1042. int i;                                                            /* Schleifenzähler                    */
  1043.  
  1044.     if (plot->style == NOSTYLE)                /* mit Muster                                */
  1045.     {                                                                    /* Nein                                            */
  1046.         Move(WRp,*array++,*array++);        /* Startkoordinate                    */
  1047.         PolyDraw(WRp,counter-1,array);    /* und zeichnen                            */
  1048.     }
  1049.     else                                                            /* Ja                                                */
  1050.     {
  1051.         SetOPen(WRp,WRp->FgPen);                /* setzte Umrandung                    */
  1052.         datas = malloc((counter+1)*5*sizeof(WORD));
  1053.                                                                         /* Speicher für Areabefehle    */
  1054.  
  1055.         if (!datas)                                            /* Speicher bekommen                */
  1056.         {
  1057.             seterror(GRAPHFILL);                    /* Nein setzte Fehler                */
  1058.             return(FALSE);                                /* zurück mit Fehler                */
  1059.         }
  1060.  
  1061.         araster = AllocRaster(640,512);    /* neuer TempRastport holen    */
  1062.         if (!araster)                                        /* bekommen ?                                */
  1063.         {
  1064.             seterror(GRAPHFILL);                    /* Nein setzte Fehler                */
  1065.             return(FALSE);                                /* zurück mit Fehler                */
  1066.         }
  1067.  
  1068.         InitArea(&myareainfo,datas,counter+1);
  1069.         InitTmpRas(&myTmpRas,araster,RASSIZE(640,512));
  1070.                                                                         /* Speicher init.                        */
  1071.         WRp->TmpRas = &myTmpRas;                /* und Werte einsetzten            */
  1072.         WRp->AreaInfo = &myareainfo;
  1073.         AreaMove(WRp,(WORD)*array++,(WORD)*array++);
  1074.                                                                         /* Startkoordinate                    */
  1075.         for (i=1;i<counter;i++)                    /* und alle Punkte                    */
  1076.             AreaDraw(WRp,(WORD)*array++,(WORD)*array++);
  1077.         AreaEnd(WRp);                                        /* zeichnen                                    */
  1078.         BNDRYOFF(WRp);                                    /* Umrandung ausschalten        */
  1079.  
  1080.         free(datas);                                        /* Speicher freigeben                */
  1081.         FreeRaster(araster,640,512);        /* RastPort freigeben                */
  1082.         WRp->AreaInfo = NULL;                        /* Zeiger rücksetzten                */
  1083.         WRp->TmpRas = NULL;
  1084.     }
  1085.  
  1086. #endif
  1087.  
  1088. /*******************/
  1089. #ifdef __MSDOS__
  1090. #ifdef __TURBOC__
  1091. /*******************/
  1092.  
  1093.     fillpoly(counter,array);                    /* zeichene Polygon                    */
  1094.     if (graphresult() != grOk)                /* ist alles klar                        */
  1095.     {
  1096.         seterror(GRAPHFILL);                        /* Nein setzte Fehler                */
  1097.         setreturn(FALSE);                                /* und Rückgabewert                    */
  1098.     }
  1099.  
  1100. #endif
  1101. #endif
  1102.  
  1103.     return(returnset);
  1104.  
  1105. }
  1106.  
  1107. /****************************************************************
  1108. *                                                                                                                                *
  1109. *    Function : ScSetFillStyle()                                                                        *
  1110. *                                                                                                                                *
  1111. *****************************************************************
  1112. *                                                                                                                                *
  1113. *         Input : style                                                                                            *
  1114. *                            int style                neues Muster                                            *
  1115. *                                                                                                                                *
  1116. *        Output : void                                                                                                *
  1117. *                                                                                                                                *
  1118. *****************************************************************
  1119. *                                                                                                                                *
  1120. *     Comment : Diese Funktion setzt eine neuse Füllmuster welches    *
  1121. *                         bei ScFillPolyLine verwendet wird. Der Aufbau der    *
  1122. *                         Muster ist folgende :                                                            *
  1123. *                                                                                                                                *
  1124. *                            -    Es müssen mindestens 12 Muster definiert werden    *
  1125. *                            -    Das Muster 0 darf nicht gezeichnet werden, d.h.    *
  1126. *                                der Hintergrund wird mit diesem Muster nicht        *
  1127. *                                verändert.                                                                            *
  1128. *                            - Die Vorlage für die def. Muster wurde aus dem        *
  1129. *                                Turbo C Compiler entnommen.                                            *
  1130. *                                                                                                                                *
  1131. *         AMIGA : definieren aller 12 Muster und verwenden der                *
  1132. *                         Standartfunktion in der graphics.library                        *
  1133. *                                                                                                                                *
  1134. *         MSDOS : Verwenden der Standartfunktionen des Turbo C                *
  1135. *                         Compilers.                                                                                    *
  1136. *                                                                                                                                *
  1137. ****************************************************************/
  1138.  
  1139. void ScSetFillStyle(style)
  1140. int style;
  1141. {
  1142.  
  1143. /*******************/
  1144. #ifdef AMIGA
  1145. /*******************/
  1146.  
  1147. static WORD stylearray[12][8] =            /* Füllmuster                                */
  1148. {
  1149.     { 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000 },
  1150.     {    0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF    },
  1151.     {    0xFFFF,0xFFFF,0x0000,0x0000,0xFFFF,0xFFFF,0x0000,0x0000    },
  1152.     {    0x0101,0x0202,0x0404,0x0808,0x1010,0x2020,0x4040,0x8080    },
  1153.     {    0x8181,0x0303,0x0606,0x0C0C,0x1818,0x3030,0x6060,0xC0C0    },
  1154.     {    0xC0C0,0x6060,0x3030,0x1818,0x0C0C,0x0606,0x0303,0x8181    },
  1155.     {    0x8080,0x4040,0x2020,0x1010,0x0808,0x0404,0x0202,0x0101    },
  1156.     {    0x1111,0x1111,0x1111,0xFFFF,0x1111,0x1111,0x1111,0xFFFF    },
  1157.     {    0x9090,0x6060,0x6060,0x9090,0x0909,0x0606,0x0606,0x0909    },
  1158.     {    0xAAAA,0x7777,0xAAAA,0x7777,0xAAAA,0x7777,0xAAAA,0x7777    },
  1159.     {    0x8080,0x0000,0x0404,0x0000,0x8080,0x0000,0x0404,0x0000    },
  1160.     {    0xAAAA,0x0000,0x6666,0x0000,0xAAAA,0x0000,0x6666,0x0000    }
  1161. };
  1162.  
  1163.     SetAfPt(WRp,&stylearray[style][0],3);
  1164.                                                                         /* Muster setzten                        */
  1165. #endif
  1166.  
  1167. /*******************/
  1168. #ifdef __MSDOS__
  1169. #ifdef __TURBOC__
  1170. /*******************/
  1171.  
  1172.     setfillstyle(style,getcolor());        /* Muster setzen                        */
  1173.  
  1174. #endif
  1175. #endif
  1176.  
  1177. }
  1178.  
  1179. /****************************************************************
  1180. *                                                                                                                                *
  1181. *    Function : ScDrawRectangle()                                                                    *
  1182. *                                                                                                                                *
  1183. *****************************************************************
  1184. *                                                                                                                                *
  1185. *         Input : x1,y1,x2,y2                                                                                *
  1186. *                            int x1                linke obere Ecke                                        *
  1187. *                            int y1                linke obere Ecke                                        *
  1188. *                            int x2                rechte untere Ecke                                    *
  1189. *                            int y2                rechte untere Ecke                                    *
  1190. *                                                                                                                                *
  1191. *        Output : void                                                                                                *
  1192. *                                                                                                                                *
  1193. *****************************************************************
  1194. *                                                                                                                                *
  1195. *     Comment : Diese Funktion zeichnet ein Rechteck welches nicht    *
  1196. *                         nicht ausgefüllt ist.                                                            *
  1197. *                                                                                                                                *
  1198. *         AMIGA : Anwendung der Line-Befehle                                                    *
  1199. *                                                                                                                                *
  1200. *         MSDOS : Turbo C Standartfunktion                                                        *
  1201. *                                                                                                                                *
  1202. ****************************************************************/
  1203.  
  1204. void ScDrawRectangle(x1,y1,x2,y2)
  1205. int x1,
  1206.         y1,
  1207.         x2,
  1208.         y2;
  1209. {
  1210.  
  1211. /*******************/
  1212. #ifdef AMIGA
  1213. /*******************/
  1214.  
  1215.     Move(WRp,x1,y1);                                    /* Startkoordinate                    */
  1216.     Draw(WRp,x2,y1);                                    /* rechte obere Ecke                */
  1217.     Draw(WRp,x2,y2);                                    /* rechte untere Ecke                */
  1218.     Draw(WRp,x1,y2);                                    /* linke untere Ecke                */
  1219.     Draw(WRp,x1,y1);                                    /* linke obere Ecke                    */
  1220.  
  1221. #endif
  1222.  
  1223. /*******************/
  1224. #ifdef __MSDOS__
  1225. #ifdef __TURBOC__
  1226. /*******************/
  1227.  
  1228.     rectangle(x1,y1,x2,y2);                        /* Rechteck zeichnen                */
  1229.  
  1230. #endif
  1231. #endif
  1232.  
  1233. }
  1234.  
  1235. /****************************************************************
  1236. *                                                                                                                                *
  1237. *    Function : ScGetTextSize()                                                                        *
  1238. *                                                                                                                                *
  1239. *****************************************************************
  1240. *                                                                                                                                *
  1241. *         Input : int axis                Breite oder Höhe                                        *
  1242. *                                                                                                                                *
  1243. *        Output : int size                Grösse in Punkten                                        *
  1244. *                                                                                                                                *
  1245. *****************************************************************
  1246. *                                                                                                                                *
  1247. *     Comment : Diese Funktion gibt die Grösse des eingestellten        *
  1248. *                         Zeichensatzes zurück. Für die Achsen können die        *
  1249. *                         Variablen XSIZE und YSIZE verwendet werden.                *
  1250. *                                                                                                                                *
  1251. *         AMIGA : holen der entsprechenden Grösse aus dem Rastport        *
  1252. *                                                                                                                                *
  1253. *         MSDOS : Turbo C Standartfunktionen                                                    *
  1254. *                                                                                                                                *
  1255. ****************************************************************/
  1256.  
  1257. int ScGetTextSize(axis)
  1258. int axis;
  1259. {
  1260.  
  1261.     int returnset;
  1262.  
  1263. /*******************/
  1264. #ifdef AMIGA
  1265. /*******************/
  1266.  
  1267.     switch(axis)
  1268.     {
  1269.         case XSIZE:
  1270.             setreturn(WRp->TxWidth);            /* Textlänge                                */
  1271.             break;
  1272.  
  1273.         case YSIZE:
  1274.             setreturn(WRp->TxHeight);            /* Texthöhe                                    */
  1275.             break;
  1276.     }
  1277.  
  1278. #endif
  1279.  
  1280. /*******************/
  1281. #ifdef __MSDOS__
  1282. #ifdef __TURBOC__
  1283. /*******************/
  1284.  
  1285.     switch (axis)
  1286.     {
  1287.         case XSIZE:
  1288.             setreturn(textwidth(" "));        /* Textlänge                                */
  1289.             break;
  1290.  
  1291.         case YSIZE:
  1292.             setreturn(textheight(" "));        /* Texthöhe                                    */
  1293.             break;
  1294.     }
  1295.  
  1296. #endif
  1297. #endif
  1298.  
  1299.     return(returnset);
  1300.  
  1301. }
  1302.  
  1303. /****************************************************************
  1304. *                                                                                                                                *
  1305. *    Function : ScSetLineStyle()                                                                        *
  1306. *                                                                                                                                *
  1307. *****************************************************************
  1308. *                                                                                                                                *
  1309. *         Input : int typ            Linienmuster                                                    *
  1310. *                                                                                                                                *
  1311. *        Output : void                                                                                                *
  1312. *                                                                                                                                *
  1313. *****************************************************************
  1314. *                                                                                                                                *
  1315. *     Comment : Diese Funktion setzt ein neues Muster für eine            *
  1316. *                         Linie. Die folgenden Bedingungen müssen erfüllt        *
  1317. *                         werden.                                                                                        *
  1318. *                                                                                                                                *
  1319. *                                - Es müssen mindeseten 4 Muster vorhanden sein    *
  1320. *                                - Muster 0 muss eine ausgezogene Linie zeichen    *
  1321. *                                - Muster 1 sollte eine fein gestrichelte Line        *
  1322. *                                    zeichnen                                                                            *
  1323. *                                                                                                                                *
  1324. *         AMIGA : definieren der Muster und verwenden der Standart-    *
  1325. *                         funktion ind grahics.library.                                            *
  1326. *                                                                                                                                *
  1327. *         MSDOS : definieren der Muster und verwenden der Standart-    *
  1328. *                         funktion von Turbo C.                                                            *
  1329. *                                                                                                                                *
  1330. ****************************************************************/
  1331.  
  1332. void ScSetLineStyle(typ)
  1333. int typ;
  1334. {
  1335.     unsigned int style[] =                        /* Musterdefinition                    */
  1336.     {
  1337.         0xFFFF,0xCCCC,0xF0F0,0xFCFC,0xE8E8
  1338.     };
  1339.  
  1340. /*******************/
  1341. #ifdef AMIGA
  1342. /*******************/
  1343.  
  1344.     SetDrPt(WRp,(UWORD)style[typ]);        /* setzten des Musters            */
  1345.  
  1346. #endif
  1347.  
  1348. /*******************/
  1349. #ifdef __MSDOS__
  1350. #ifdef __TURBOC__
  1351. /*******************/
  1352.  
  1353.     setlinestyle(USERBIT_LINE,style[typ],NORM_WIDTH);
  1354.                                                                         /* setzten des Musters            */
  1355. #endif
  1356. #endif
  1357.  
  1358. }
  1359.  
  1360. /****************************************************************
  1361. *                                                                                                                                *
  1362. *    Nachfolgend sind Funktionen aufgeführt, welche nur für einen    *
  1363. *    Rechner verwendet werden. Es sind dies Hilfsfunktionen von        *
  1364. *    den Level 3 Funktionen.                                                                                *
  1365. *                                                                                                                                *
  1366. ****************************************************************/
  1367.  
  1368. /*******************/
  1369. #ifdef AMIGA
  1370. /*******************/
  1371.  
  1372. /****************************************************************
  1373. *                                                                                                                                *
  1374. *    Function : openlib()                                                                                    *
  1375. *                                                                                                                                *
  1376. *****************************************************************
  1377. *                                                                                                                                *
  1378. *         Input : void                                                                                                *
  1379. *                                                                                                                                *
  1380. *        Output : int returnset                                                                            *
  1381. *                            != FALSE        alle klar                                                        *
  1382. *                            == FALSE            Fehler                                                            *
  1383. *                                                                                                                                *
  1384. *****************************************************************
  1385. *                                                                                                                                *
  1386. *     Comment : Diese Funktion öffnet die notwendigen Librarys.        *
  1387. *                         Sie wird nur benützt für AMIGA!                                        *
  1388. *                                                                                                                                *
  1389. ****************************************************************/
  1390.  
  1391. static int openlib()
  1392. {
  1393.  
  1394.     int returnset;                                        /* allg Rückgabewert                */
  1395.  
  1396.     IBase = (struct IntuitionBase *)
  1397.         OpenLibrary ("intuition.library",NULL);
  1398.     if (IBase == NULL)                                /* Fehler ?                                    */
  1399.     {                                                                    /* IntuitionBase = NULL            */
  1400.         seterror(GROPER);                                /* setzte Fehler                        */
  1401.         setreturn(FALSE);
  1402.     }
  1403.     else
  1404.     {
  1405.         if (IntuitionBase != IBase)            /* schon geöffnet ?                    */
  1406.             IntuitionBase = IBase;                /* Nein, setzten                        */
  1407.         GBase = (struct GfxBase *)
  1408.             OpenLibrary("graphics.library",NULL);
  1409.         if (GBase == NULL)                            /* Fehler ?                                    */
  1410.         {                                                                /* GfxBase = NULL                        */
  1411.             seterror(GROPER);                            /* Fehler                                        */
  1412.             setreturn(FALSE);
  1413.         }
  1414.         else
  1415.         {
  1416.             if (GfxBase != GBase)                    /* schon geöffnet                        */
  1417.                 GfxBase = GBase;                        /* Nein, setzten                        */
  1418.             setreturn(TRUE);
  1419.         }
  1420.     }
  1421.     return(returnset);                                /* und zurück                                */
  1422. }
  1423.  
  1424. /****************************************************************
  1425. *                                                                                                                                *
  1426. *    Function : openscreen()                                                                                *
  1427. *                                                                                                                                *
  1428. *****************************************************************
  1429. *                                                                                                                                *
  1430. *        Input : void                                                                                                *
  1431. *                                                                                                                                *
  1432. *     Output : int returnset                                                                                *
  1433. *                            != FALSE        alle klar                                                        *
  1434. *                            == FALSE            Fehler                                                            *
  1435. *                                                                                                                                *
  1436. *****************************************************************
  1437. *                                                                                                                                *
  1438. *    Comment : Oeffnet einen Screen und ein entsprechendes                    *
  1439. *                        Window. Es werden auch Defaultfarben gesetzt.                *
  1440. *                        Diese Funktion wird nur benützt für AMIGA!                    *
  1441. *                                                                                                                                *
  1442. ****************************************************************/
  1443.  
  1444. static int openscreen()
  1445. {
  1446.     int returnset,                                    /* allg. Rückgabewert                    */
  1447.             i;                                                    /* Schleifenzähler                        */
  1448.     int    rot,                                                /* Farbanteile                                */
  1449.             gruen,
  1450.             blau;
  1451.  
  1452.     if (GfxBase->DisplayFlags & PAL)    /* Version bestimmen                */
  1453.         newscreen.Height = 512;                    /* PAL Auflösung                        */
  1454.     else
  1455.         newscreen.Height = 400;                    /* NTSC Auflösung                        */
  1456.  
  1457.     Sc = (struct Screen *)OpenScreen(&newscreen);
  1458.                                                                         /* Öffnen des Screens                */
  1459.     if ( Sc == NULL )                                    /* Fehler ?                                    */
  1460.     {                                                                    /* Sc = NULL                                */
  1461.         seterror(GROPER);                                /* setzte Fehler                        */
  1462.         setreturn(FALSE);
  1463.     }
  1464.     else
  1465.     {
  1466.         Vp = &Sc->ViewPort;                            /* Viewport initialisieren    */
  1467.         Rp = &Sc->RastPort;                            /* Rastport initialisieren    */
  1468.  
  1469.         ShowTitle(Sc,FALSE);                        /* kein Titel                                */
  1470.  
  1471.         for (i=0;i<16;i++)                            /* setzten aller Farben            */
  1472.         {
  1473.             rot = ROT(Palette[i]);
  1474.             gruen = GRUEN(Palette[i]);
  1475.             blau = BLAU(Palette[i]);
  1476.             SetRGB4(Vp,i,rot,gruen,blau);    /* Farbe setzten                        */
  1477.         }
  1478.  
  1479.         window.Screen = Sc;                            /* Init. Windowstruktur            */
  1480.         window.Height = newscreen.Height;
  1481.  
  1482.         Mw = (struct Window *)OpenWindow(&window);
  1483.                                                                         /* Öffne Mainwindow                    */
  1484.         if ( Mw == NULL )                                /* Fehler ?                                    */
  1485.         {                                                                /* Mw = NULL                                */
  1486.             seterror(GROPER);                            /* Fehler setzten                        */
  1487.             setreturn(FALSE);
  1488.         }
  1489.         else
  1490.             WRp = Mw->RPort;                            /* Rastport initialisieren    */
  1491.     }
  1492.     return(returnset);
  1493. }
  1494.  
  1495. #endif
  1496.  
  1497. /*******************/
  1498. #ifdef __MSDOS__
  1499. #ifdef __TURBOC__
  1500. /*******************/
  1501.  
  1502. /****************************************************************
  1503. *                                                                                                                                *
  1504. *    Function : initdriver()                                                                                *
  1505. *                                                                                                                                *
  1506. *****************************************************************
  1507. *                                                                                                                                *
  1508. *         Input : void                                                                                                *
  1509. *                                                                                                                                *
  1510. *        Output : void                                                                                                *
  1511. *                                                                                                                                *
  1512. *****************************************************************
  1513. *                                                                                                                                *
  1514. *     Comment : Registriert die gelinkten Graphiktreiber, sodass        *
  1515. *                         diese nicht mehr von der Disk gelesen werden             *
  1516. *                         müssen.                                                                                        *
  1517. *                                                                                                                                *
  1518. ****************************************************************/
  1519.  
  1520. static void initdriver()
  1521. {
  1522.  
  1523.     int i;
  1524.  
  1525.     for (i=0;i<MAXDRIVERS;i++)
  1526.     {
  1527.         if (DRIVERS[i] != NULL)                    /* Wenn Treiber definiert        */
  1528.             registerbgidriver(DRIVERS[i]);
  1529.     }
  1530.  
  1531. }
  1532.  
  1533. /****************************************************************
  1534. *                                                                                                                                *
  1535. *    Function : convcolor()                                                                                *
  1536. *                                                                                                                                *
  1537. *****************************************************************
  1538. *                                                                                                                                *
  1539. *         Input : int color                    Farbwert                                                *
  1540. *                                                                                                                                *
  1541. *        Output : int convcolor            konvert. Farbwert                                *
  1542. *                                                                                                                                *
  1543. *****************************************************************
  1544. *                                                                                                                                *
  1545. *     Comment : Konvertiert Farbwerte auf einen gemeinsamen                 *
  1546. *                         Nenner.                                                                                        *
  1547. *                                                                                                                                *
  1548. ****************************************************************/
  1549.  
  1550. static int convcolor(color)
  1551. int color;
  1552. {
  1553.     int i;
  1554.  
  1555.     for (i=0;i<MAXDEFCOL;i++)
  1556.         if (color == palette[i])
  1557.             break;
  1558.     if (i == MAXDEFCOL)
  1559.         return(color);
  1560.     else
  1561.         return(i);
  1562. }
  1563.  
  1564. #endif
  1565. #endif
  1566.