/**************************************************************** * * * Filename : GfxL3.c * * * ***************************************************************** * * * Comment : Level 3 der Plotlibrary. Alle Funktionen für die * * Graphik welche Computer oder Compiler abhängig * * sind, müssen in dieser Datei enthalten sein. * * * * Funktionen * * ========== * * * * ScOpenGraphics() öffnet das Graphiksystem * * ScCloseGraphics() schliesst das Graphiksystem * * ScClearGraphics() löscht den Bildschirm * * ScGetMaxX() max. horiz. Auflösung * * ScGetMaxY() max. vert. Auflösung * * ScDrawText() schreibt eine Text * * ScSetLineStyle() setzt Linienattribute * * ScGetTextSize() holt Textgrösse * * ScSetTextSize() setzt 8*8 Text * * ScGetFgColor() holt Stiftfarbe * * ScSetFgColor() setzt Stiftfarbe * * ScGetBackColor() holt Hintergrundefarbe * * ScSetBackColor() setzt Hintergrundfarbe * * ScDrawLine() zeichnet eine Line * * ScDrawPolyLine() zeichnet Kurvenzug * * ScFillPolyLine() zeichnet Polygon * * ScSetFillStyle() setzt Füllmuster * * ScDrawRectangle() zeichnet ein Rechteck * * ScGetMaxColor() holt max. verfügbare Farbenanzahl * * * * #ifdef AMIGA * * openlib() öffnet Funktionslibrary * * openscreen() öffnet Graphikbildschirm * * #endif * * * * #ifdef __MSDOS__ * * #ifdef __TURBOC__ * * initdriver() initialisiert Graphiktreiber * * #endif * * #endif * * * * Rev : V1.0 * * * * History : V1.0 erstellen dieses Files 04/12/89 * * * * Doc : Plotlibrary User's Guide * * * * Bugs : keine bekannten * * * * Autor : Oesch Silvano * * * * Datum : 04/12/89 * * * ****************************************************************/ /**************************************************************** * * * Plotlibrary Includedateien * * * ****************************************************************/ #include "Plot.h" #include "GfxL3.h" /**************************************************************** * * * spezifische Includedateien * * * ****************************************************************/ /*******************/ #ifdef AMIGA /*******************/ #include #include #include #include #include #include #include #include #endif /*******************/ #ifdef __MSDOS__ #ifdef __TURBOC__ /*******************/ #include #endif #endif /**************************************************************** * * * globale statische Variablen * * * ****************************************************************/ /*******************/ #ifdef AMIGA /*******************/ extern struct IntuitionBase *IntuitionBase; /* Intuitionlibrary */ extern struct GfxBase *GfxBase; static struct IntuitionBase *IBase = NULL; /* Intuitionlibrary */ static struct GfxBase *GBase = NULL; /* Graphicslibrary */ static struct Screen *Sc=NULL; /* Screenpointer */ static struct Window *Mw=NULL; /* Windowpointer */ static struct ViewPort *Vp; /* Viewportpointer */ static struct RastPort *Rp; /* Rastportpointer Screen */ static struct RastPort *WRp; /* Rastportpointer Window */ #include "ScreenL3.h" #endif /*******************/ #ifdef __MSDOS__ #ifdef __TURBOC__ /*******************/ /**************************************************************** * * * Die Definition für die einzelnen Treiber müssen in Plotlib.h * * gemacht werden. Sie werden hier abgefragt, damit nicht alle * * Treiber dem Linker bekannt sind. Das Array DRIVERS wird in * * Plotlib.h so aufgebaut, dass all definierten Treiber darin * * enthalten sind. * * * ****************************************************************/ extern void (*DRIVERS[])(void); static int GraphDriver = DETECT; /* Graphiktreiber */ static int GraphMode = NULL; /* Graphikmode */ static int palette[MAXDEFCOL] = /* Farbdefinitionen */ { BLACK, WHITE, LIGHTGRAY, LIGHTBLUE, LIGHTGREEN, LIGHTCYAN, LIGHTRED, LIGHTMAGENTA, BLUE, GREEN, CYAN, RED, MAGENTA, BROWN, DARKGRAY, YELLOW }; #endif #endif /**************************************************************** * * * externe Variablen * * * ****************************************************************/ extern struct Plot *plot; extern int plerr; /**************************************************************** * * * Function : ScOpenGraphics() * * * ***************************************************************** * * * Input : void * * * * Output : int returnset * * != FALSE alle klar * * == FALSE Fehler * * * ***************************************************************** * * * Comment : Diese Funktion hat die Aufgabe in den Graphikmodus * * des Computers umzuschalten. Wenn ein Computer * * keine unterscheidung zwischen Graphik und Text * * macht, kann hier ein neuer Bildschirm geöffnet * * werden. Es wird nur ein Fehler GROPER gesetzt für * * die komplette Funktion. * * Der Indikator disp in der Plotstruktur ist zu * * diesem Zeitpunk mit den entsprechenden Optionen * * GRAPHSET oder GRAPHNOTSET gesetzt. Anhand dieser * * Indikation können die benötigten Resourcen * * angefordert werden. * * * * AMIGA : Wenn GRAPHSET, dann werden nur die Funktions- * * librarys geöffnet. Es werden auch nur die Library- * * pointer initialisiert, * * ACHTUNG : Die Librarys sind nur für die Plotlib * * nützbar. Das Applikationsprogramm muss * * diese Librarys auch öffnen wenn sie * * diese benötigt. * * Ansonsten wird ein Bildschirm mit einer Auflösung * * von 640*512/400 Punkte mit 16 Farben geöffnet. Ein * * entsprechendes Window wird ebenfalls auf diesem * * Screen geöffnet. * * Die folgenden static global Variablen werden * * danach initialisiert: * * * * IntuitionBase Library * * GfxBase Library * * Sc Screenpointer * * Vp ViewPort * * Rp Rastport * * Mw Windowpointer * * WRp Windowrastport * * * * MSDOS : Wenn GRAPHSET, dann wird der aktuelle Graphikmode * * geholt. Danach wird kontrolliert, ob ein Fehler * * bei dieser Funktion aufgetreten ist. Wenn dies * * zutrifft, dann wird mit einer Fehlermeldung ver- * * zweigt. * * Ansonsten wird der Graphiktreiber mit der höchsten * * Auflösung initialisiert un in diesen Mode um- * * geschaltet. * * Die folgenden static global Variablen werden * * initialisiert: * * * * GraphDriver Treiber * * GraphMode Modus * * * ****************************************************************/ int ScOpenGraphics() { int returnset; /*******************/ #ifdef AMIGA /*******************/ if ( openlib() == FALSE ) /* alle Librarys öffnen */ setreturn(FALSE); /* Fehler */ else { if (plot->disp & GRAPHNOTSET) /* muss ein Screen geöffnet */ if (openscreen() == FALSE) /* werden. Ja */ setreturn(FALSE); /* Fehler */ else setreturn(TRUE); /* alles klar für NOTSET */ else { /**************************************************************** * * * Wenn GRAPHSET gesetzt ist, wird der aktive Screen als der * * genommen. Dasselbe gilt für das Window. * * * ****************************************************************/ Sc = IntuitionBase->ActiveScreen; Vp = &Sc->ViewPort; /* Viewport initialisieren */ Rp = &Sc->RastPort; /* Rastport initialisieren */ Mw = IntuitionBase->ActiveWindow; WRp = Mw->RPort; /* Rastport initialisieren */ setreturn(TRUE); /* alles klar für SET */ } } #endif /*******************/ #ifdef __MSDOS__ #ifdef __TURBOC__ /*******************/ if (plot->disp & GRAPHNOTSET) /* Driver laden ? */ { /* Ja */ initdriver(); /* Graphiktreiber inst. */ GraphDriver = DETECT; /* welcher vorhanden ist */ setgraphbufsize(8192); /* bis ca. 1200 Eckpunkte */ initgraph(&GraphDriver,&GraphMode,""); /* laden und umschalten */ if (graphresult() != grOk) /* Fehler ? */ { seterror(GROPER); /* Ja */ setreturn(FALSE); } else setreturn(TRUE); /* Nein */ } else /* kein Diver laden */ { /* nur kontrolle */ GraphMode = getgraphmode(); /* hole Mode */ if (graphresult() != grOk) /* Fehler beim Mode */ { seterror(GROPER); /* Ja */ setreturn(FALSE); } else setreturn(TRUE); /* Nein, alles klar */ } #endif #endif return(returnset); } /**************************************************************** * * * Function : ScCloseGraphics() * * * ***************************************************************** * * * Input : void * * * * Output : void * * * ***************************************************************** * * * Comment : Diese Funktion schliesst die kompletten Graphik- * * resourcen, welche bei OpenGraphics angefordert * * wurden. Die entsprechenden statischen globalen * * Variablen werden wieder auf ihre Standartwerte * * zurückgesetzt um spätere komplikationen zu ver- * * meiden. Der Displayparameter wird ebenfalls * * zurückgesetzt. * * * * AMIGA : Wenn die Plotlibrary einen Screen geöffnet hat, * * so schliesst sie diesen wieder. Die Librarys sind * * für alle Darstellungen geöffnet worden. Sie werden * * auch immer wieder geschlossen. Alle Werte werden * * initialisiert. * * * * MSDOS : Wenn die Plotlibrary die Graphik geöffnet hat, so * * wird wieder in den Textmodus umgeschaltet. * * Alle Werte werden initialisiert. * * * ****************************************************************/ void ScCloseGraphics() { /*******************/ #ifdef AMIGA /*******************/ if (plot->disp & GRAPHNOTSET) /* Wer hat Graphik geöffnet */ { /* Ich */ if (Mw != NULL) /* also wieder schliessen */ CloseWindow(Mw); /* Mainwindow */ if (Sc != NULL) CloseScreen(Sc); /* Screen */ plot->disp &= ~GRAPHNOTSET; /* Indikator reseten */ } else /* Graphik nicht von mir */ plot->disp &= ~GRAPHSET; /* Indikator init. */ /**************************************************************** * * * alle Librarys schliessen * * * ****************************************************************/ if (GBase != NULL) CloseLibrary(GBase); /* Graphicslibrary */ if (IBase != NULL) CloseLibrary(IBase); /* Intuitionlibrary */ Mw = NULL; /* alle Pointer init. */ Sc = NULL; GBase = NULL; IBase = NULL; #endif /*******************/ #ifdef __MSDOS__ #ifdef __TURBOC__ /*******************/ if (plot->disp & GRAPHNOTSET) /* Ist Graphik von mir ? */ { /* Ja */ closegraph(); /* also schliessen */ plot->disp &= ~GRAPHNOTSET; /* Indikator init. */ } else /* Nein */ plot->disp &= ~GRAPHSET; /* Indikator reseten */ GraphDriver = DETECT; /* Werte initialisieren */ GraphMode = NULL; #endif #endif } /**************************************************************** * * * Function : ScGetMaxColor() * * * ***************************************************************** * * * Input : void * * * * Output : int maxcolor max setzbares Farbregister * * * ***************************************************************** * * * Comment : Diese computerabhängige Funktion stellt die max * * mögliche darstellbaren Farben-1 fest und schreibt * * diese in die Plotstruktur. Da 0 im Normalfall auch * * eine Farbe ist, muss 1 subtrahiert werden. * * * * AMIGA : Die Anzahl Bitplanes welche für den Screen * * definiert sind geben die Anzahl möglicher Farben * * an. * * * * MSDOS : Es wird die getmaxcolor vom Turbo C Compiler * * verwendet. * * * ****************************************************************/ int ScGetMaxColor() { /*******************/ #ifdef AMIGA /*******************/ return((int)(1<BitMap.Depth)-1); /* Planes und shiften */ #endif /*******************/ #ifdef __MSDOS__ #ifdef __TURBOC__ /*******************/ return((int)getmaxcolor()); /* color holen */ #endif #endif } /**************************************************************** * * * Function : ScGetMaxX() * * * ***************************************************************** * * * Input : void * * * * Output : int maxx max. horizontaler setzbarer Punkt * * * ***************************************************************** * * * Comment : Diese Funktion hat die Aufgabe die max. * * horizontale Koordinate der aktuellen Graphik- * * einstellung als Rückgabewert zu liefern. * * Die Bildschirmauflösung ist normalerweise um 1 * * höher. * * * * AMIGA : Es wird vom aktiven Window die max. Koordinate * * geholt. Wenn also dieses Window später verkleinert * * wird, passt sich die Graphik der neuen Grösse an. * * * * MSDOS : Es wird die getmaxx Funktion vom Turbo C Compiler * * verwendet. * * * ****************************************************************/ int ScGetMaxX() { /*******************/ #ifdef AMIGA /*******************/ return((int)(Mw->Width-1)); /* Grösse aus Window holen */ #endif /*******************/ #ifdef __MSDOS__ #ifdef __TURBOC__ /*******************/ return((int)getmaxx()); /* Na ja, dasselbe */ #endif #endif } /**************************************************************** * * * Function : ScGetMaxY() * * * ***************************************************************** * * * Input : void * * * * Output : int maxy max. vertikaler setzbarer Punkt * * * ***************************************************************** * * * Comment : Diese Funktion hat die Aufgabe die max. * * vertikale Koordinate der aktuellen Graphik- * * einstellung als Rückgabewert zu liefern. * * Die Bildschirmauflösung ist normalerweise um 1 * * höher. * * * * AMIGA : Es wird vom aktiven Window die max. Koordinate * * geholt. Wenn also dieses Window später verkleinert * * wird, passt sich die Graphik der neuen Grösse an. * * * * MSDOS : Es wird die getmaxy Funktion vom Turbo C Compiler * * verwendet. * * * ****************************************************************/ int ScGetMaxY() { /*******************/ #ifdef AMIGA /*******************/ return((int)(Mw->Height-1)); /* Grösse von Window holen */ #endif /*******************/ #ifdef __MSDOS__ #ifdef __TURBOC__ /*******************/ return((int)getmaxy()); /* dito */ #endif #endif } /**************************************************************** * * * Function : ScSetTextSize() * * * ***************************************************************** * * * Input : void * * * * Output : void * * * ***************************************************************** * * * Comment : SetTextSize() setzt einen 8*8 grossen Text. Diese * * Textgrösse sollte eingehalten werden. Sie kann * * aber auch kleiner werden. * * * * AMIGA : Es wird die ROM Schrift TOPAZ geöffnet und für * * dieses Window gesetzt. * * * * MSDOS : Es wird die Textausrichtung auf die linke untere * * Ecke gesetz, die Standartschrift gesetzt und ihre * * Ausrichtung auf horizontal gesetzt. * * * ****************************************************************/ void ScSetTextSize() { /*******************/ #ifdef AMIGA /*******************/ struct TextFont *textfont; /* Fontzeiger */ textfont = OpenFont(&TOPAZ80); /* öffne Font */ SetFont(WRp,textfont); /* und setzten */ #endif /*******************/ #ifdef __MSDOS__ #ifdef __TURBOC__ /*******************/ settextjustify(LEFT_TEXT,BOTTOM_TEXT); /* untere linke Ecke */ settextstyle(DEFAULT_FONT,HORIZ_DIR,0); /* Standartschrift */ #endif #endif } /**************************************************************** * * * Function : ScClearGraphics() * * * ***************************************************************** * * * Input : void * * * * Output : void * * * ***************************************************************** * * * Comment : Diese Funktion muss den Bildschirm löschen können * * in welchen gezeichnet wird. * * * * AMIGA : Es wird die Standartfunktion verwendet. * * * * MSDOS : Es wird die Standartfunktion verwendet. * * * ****************************************************************/ void ScClearGraphics() { /*******************/ #ifdef AMIGA /*******************/ Move(WRp,0,0); /* löschen von Anfang an */ ClearScreen(WRp); /* und löschen */ #endif /*******************/ #ifdef __MSDOS__ #ifdef __TURBOC__ /*******************/ cleardevice(); /* alles löschen */ #endif #endif } /**************************************************************** * * * Function : ScDrawText() * * * ***************************************************************** * * * Input : x,y,string * * int x horiz. Startpunkt * * int y vert. Startpunkt * * char *string Textzeiger * * * * Output : void * * * ***************************************************************** * * * Comment : ScDrawText schreibt einen Text startend mit dem * * Koordinatenpunkt (x/y). Dieser Punkt legt die * * * * AMIGA : Korrektur der Koordinate um die Basisline und * * verwenden der Standartfunktion. * * * * MSDOS : Standartfunktion von Turbo C * * * ****************************************************************/ void ScDrawText(x,y,string) int x,y; char *string; { /*******************/ #ifdef AMIGA /*******************/ Move(WRp,x,y-WRp->TxHeight+WRp->TxBaseline); /* Koordinatenkorr. */ Text(WRp,string,strlen(string)); /* schreibe Text */ #endif /*******************/ #ifdef __MSDOS__ #ifdef __TURBOC__ /*******************/ outtextxy(x,y,string); /* schreibe Text */ #endif #endif } /**************************************************************** * * * Function : ScGetFgColor() * * * ***************************************************************** * * * Input : void * * * * Output : int color aktuelle Stiftfarbe * * * ***************************************************************** * * * Comment : ScGetFgColor gibt die aktuelle Stiftfarbe zurück * * mit welcher gezeichnet wird. * * * * AMIGA : Stiftfarbe aus Rastport holen. * * * * MSDOS : Standartfunktion von Turbo C * * * ****************************************************************/ int ScGetFgColor() { /*******************/ #ifdef AMIGA /*******************/ return((int)WRp->FgPen); /* Vordergrund holen */ #endif /*******************/ #ifdef __MSDOS__ #ifdef __TURBOC__ /*******************/ return(convcolor(getcolor())); /* Farbe holen und konv. */ #endif #endif } /**************************************************************** * * * Function : ScSetFgColor() * * * ***************************************************************** * * * Input : int color neuer Stiftfarbe * * * * Output : void * * * ***************************************************************** * * * Comment : Diese Funktion setzt die angegebene Farbe als * * neuen Stift. * * * * AMIGA : Verwendung der Standartfunktion für das setzten * * der Vodergrundfarbe. * * * * MSDOS : Turbo C Standartfunktion * * * ****************************************************************/ void ScSetFgColor(color) int color; { /*******************/ #ifdef AMIGA /*******************/ SetAPen(WRp,color); /* Farbe setzten */ #endif /*******************/ #ifdef __MSDOS__ #ifdef __TURBOC__ /*******************/ if (color < MAXDEFCOL) /* konvertieren */ color = palette[color]; setcolor(color); /* Farbe setzen */ #endif #endif } /**************************************************************** * * * Function : ScGetBackColor() * * * ***************************************************************** * * * Input : void * * * * Output : int color aktuelle Stiftfarbe * * * ***************************************************************** * * * Comment : ScGetBackColor holt die aktuelle Hintergrundfarbe. * * * * AMIGA : Aus Rastport BackgroundPen holen * * * * MSDOS : Verwenden von Turbo C Standartfunktion * * * ****************************************************************/ int ScGetBackColor() { /*******************/ #ifdef AMIGA /*******************/ return((int)WRp->BgPen); /* hole Background */ #endif /*******************/ #ifdef __MSDOS__ #ifdef __TURBOC__ /*******************/ return(convcolor(getbkcolor())); /* Farbe holen und konv. */ #endif #endif } /**************************************************************** * * * Function : ScSetBackColor() * * * ***************************************************************** * * * Input : int color setzt neue Hintergrundfarbe * * * * Output : void * * * ***************************************************************** * * * Comment : Diese Funktion setzt eine neue Hintergrundfarbe * * für die aktuelle Ausgabe. * * * * AMIGA : Standartfunktion der graphics.library * * * * MSDOS : Turbo C Funktion * * * ****************************************************************/ void ScSetBackColor(color) int color; { /*******************/ #ifdef AMIGA /*******************/ SetBPen(WRp,color); /* Farbe setzten */ #endif /*******************/ #ifdef __MSDOS__ #ifdef __TURBOC__ /*******************/ if (color < MAXDEFCOL) /* konvertieren */ color = palette[color]; setbkcolor(color); /* Farbe setzten */ #endif #endif } /**************************************************************** * * * Function : ScDrawLine() * * * ***************************************************************** * * * Input : x1,y1,x2,y2 * * int x1 horiz. Startwert * * int y1 vert. Startwert * * int x2 horiz. Endtwert * * int y2 vert. Emdwert * * * * Output : void * * * ***************************************************************** * * * Comment : ScDrawLine zeichnet eine Linie von dem Punkt * * (x1/y1) nach (x2/y2) in der aktuellen Stiftfarbe. * * * * AMIGA : Standartfunktionen aus graphics.library * * * * MSDOS : Turbo C Funktionen * * * ****************************************************************/ void ScDrawLine(x1,y1,x2,y2) int x1, y1, x2, y2; { /*******************/ #ifdef AMIGA /*******************/ Move(WRp,x1,y1); /* Startposition */ Draw(WRp,x2,y2); /* zeichne Linie */ #endif /*******************/ #ifdef __MSDOS__ #ifdef __TURBOC__ /*******************/ line(x1,y1,x2,y2); /* zeichne Linie */ #endif #endif } /**************************************************************** * * * Function : ScDrawPolyLine() * * * ***************************************************************** * * * Input : counter,array * * int counter Anzahl Koordinatenpunkte * * GPT *array Zeiger auf Koordinatenpaare * * * * Output : void * * * ***************************************************************** * * * Comment : Diese Funktion zeichnet ein Kurvenzug in der * * aktuellen Stiftfarbe. Es werden alle Punkte * * in dem Array nacheinander verbunden. * * * * AMIGA : Standartfunktion in graphics.library * * * * MSDOS : Verwenden der drawpolyfunktion. * * * ****************************************************************/ void ScDrawPolyLine(counter,array) int counter; GPT *array; { /*******************/ #ifdef AMIGA /*******************/ Move(WRp,*array++,*array++); /* Startkoordinate */ PolyDraw(WRp,counter-1,array); /* und zeichnen */ #endif /*******************/ #ifdef __MSDOS__ #ifdef __TURBOC__ /*******************/ drawpoly(counter,array); /* zeichene Kurve */ #endif #endif } /**************************************************************** * * * Function : ScFillPolyLine() * * * ***************************************************************** * * * Input : counter,array * * int counter Anzahl Koordinatenpunkte * * GPT *array Zeiger auf Koordinatenpaare * * * * Output : int returnset Rückgabewert * * returnset != FALSE alles klar * * returnset == FALSE Fehler beim zeichnen des * * Polygones * * * ***************************************************************** * * * Comment : Diese Funktion zeichnet ein Polygon in der * * aktuellen Stiftfarbe. Zusätzlich wird dieses * * mit dem aktuellen Muster ausgefüllt. Wenn das * * Muster 0 angewählt wurde, dann soll kein aus- * * füllen geschehen. Die Abfrage für das Muster 0 * * kann über die Plotstruktur geschehen. Wenn in * * plot->style == NOSTYLE steht, ist kein Muster * * ewrwünscht. * * * * * * AMIGA : Wenn kein Muster erwünscht ist, verwenden der * * einfachen Zeichnungsfunktion. * * Sonst verwenden der Area-Funktionen mit ihrem * * komplexen Handling. * * * * MSDOS : Verwenden der fillpolyfunktion. Für den Rückgabe- * * wird graphresult aufgerufen. * * * ****************************************************************/ int ScFillPolyLine(counter,array) int counter; GPT *array; { int returnset = TRUE; /*******************/ #ifdef AMIGA /*******************/ PLANEPTR araster; /* TempRastPortpointer */ struct TmpRas myTmpRas; /* Rastportstruktur */ struct AreaInfo myareainfo; /* Areastruktur */ WORD *datas; /* Zeiger auf neue Daten */ int i; /* Schleifenzähler */ if (plot->style == NOSTYLE) /* mit Muster */ { /* Nein */ Move(WRp,*array++,*array++); /* Startkoordinate */ PolyDraw(WRp,counter-1,array); /* und zeichnen */ } else /* Ja */ { SetOPen(WRp,WRp->FgPen); /* setzte Umrandung */ datas = malloc((counter+1)*5*sizeof(WORD)); /* Speicher für Areabefehle */ if (!datas) /* Speicher bekommen */ { seterror(GRAPHFILL); /* Nein setzte Fehler */ return(FALSE); /* zurück mit Fehler */ } araster = AllocRaster(640,512); /* neuer TempRastport holen */ if (!araster) /* bekommen ? */ { seterror(GRAPHFILL); /* Nein setzte Fehler */ return(FALSE); /* zurück mit Fehler */ } InitArea(&myareainfo,datas,counter+1); InitTmpRas(&myTmpRas,araster,RASSIZE(640,512)); /* Speicher init. */ WRp->TmpRas = &myTmpRas; /* und Werte einsetzten */ WRp->AreaInfo = &myareainfo; AreaMove(WRp,(WORD)*array++,(WORD)*array++); /* Startkoordinate */ for (i=1;iAreaInfo = NULL; /* Zeiger rücksetzten */ WRp->TmpRas = NULL; } #endif /*******************/ #ifdef __MSDOS__ #ifdef __TURBOC__ /*******************/ fillpoly(counter,array); /* zeichene Polygon */ if (graphresult() != grOk) /* ist alles klar */ { seterror(GRAPHFILL); /* Nein setzte Fehler */ setreturn(FALSE); /* und Rückgabewert */ } #endif #endif return(returnset); } /**************************************************************** * * * Function : ScSetFillStyle() * * * ***************************************************************** * * * Input : style * * int style neues Muster * * * * Output : void * * * ***************************************************************** * * * Comment : Diese Funktion setzt eine neuse Füllmuster welches * * bei ScFillPolyLine verwendet wird. Der Aufbau der * * Muster ist folgende : * * * * - Es müssen mindestens 12 Muster definiert werden * * - Das Muster 0 darf nicht gezeichnet werden, d.h. * * der Hintergrund wird mit diesem Muster nicht * * verändert. * * - Die Vorlage für die def. Muster wurde aus dem * * Turbo C Compiler entnommen. * * * * AMIGA : definieren aller 12 Muster und verwenden der * * Standartfunktion in der graphics.library * * * * MSDOS : Verwenden der Standartfunktionen des Turbo C * * Compilers. * * * ****************************************************************/ void ScSetFillStyle(style) int style; { /*******************/ #ifdef AMIGA /*******************/ static WORD stylearray[12][8] = /* Füllmuster */ { { 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000 }, { 0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF }, { 0xFFFF,0xFFFF,0x0000,0x0000,0xFFFF,0xFFFF,0x0000,0x0000 }, { 0x0101,0x0202,0x0404,0x0808,0x1010,0x2020,0x4040,0x8080 }, { 0x8181,0x0303,0x0606,0x0C0C,0x1818,0x3030,0x6060,0xC0C0 }, { 0xC0C0,0x6060,0x3030,0x1818,0x0C0C,0x0606,0x0303,0x8181 }, { 0x8080,0x4040,0x2020,0x1010,0x0808,0x0404,0x0202,0x0101 }, { 0x1111,0x1111,0x1111,0xFFFF,0x1111,0x1111,0x1111,0xFFFF }, { 0x9090,0x6060,0x6060,0x9090,0x0909,0x0606,0x0606,0x0909 }, { 0xAAAA,0x7777,0xAAAA,0x7777,0xAAAA,0x7777,0xAAAA,0x7777 }, { 0x8080,0x0000,0x0404,0x0000,0x8080,0x0000,0x0404,0x0000 }, { 0xAAAA,0x0000,0x6666,0x0000,0xAAAA,0x0000,0x6666,0x0000 } }; SetAfPt(WRp,&stylearray[style][0],3); /* Muster setzten */ #endif /*******************/ #ifdef __MSDOS__ #ifdef __TURBOC__ /*******************/ setfillstyle(style,getcolor()); /* Muster setzen */ #endif #endif } /**************************************************************** * * * Function : ScDrawRectangle() * * * ***************************************************************** * * * Input : x1,y1,x2,y2 * * int x1 linke obere Ecke * * int y1 linke obere Ecke * * int x2 rechte untere Ecke * * int y2 rechte untere Ecke * * * * Output : void * * * ***************************************************************** * * * Comment : Diese Funktion zeichnet ein Rechteck welches nicht * * nicht ausgefüllt ist. * * * * AMIGA : Anwendung der Line-Befehle * * * * MSDOS : Turbo C Standartfunktion * * * ****************************************************************/ void ScDrawRectangle(x1,y1,x2,y2) int x1, y1, x2, y2; { /*******************/ #ifdef AMIGA /*******************/ Move(WRp,x1,y1); /* Startkoordinate */ Draw(WRp,x2,y1); /* rechte obere Ecke */ Draw(WRp,x2,y2); /* rechte untere Ecke */ Draw(WRp,x1,y2); /* linke untere Ecke */ Draw(WRp,x1,y1); /* linke obere Ecke */ #endif /*******************/ #ifdef __MSDOS__ #ifdef __TURBOC__ /*******************/ rectangle(x1,y1,x2,y2); /* Rechteck zeichnen */ #endif #endif } /**************************************************************** * * * Function : ScGetTextSize() * * * ***************************************************************** * * * Input : int axis Breite oder Höhe * * * * Output : int size Grösse in Punkten * * * ***************************************************************** * * * Comment : Diese Funktion gibt die Grösse des eingestellten * * Zeichensatzes zurück. Für die Achsen können die * * Variablen XSIZE und YSIZE verwendet werden. * * * * AMIGA : holen der entsprechenden Grösse aus dem Rastport * * * * MSDOS : Turbo C Standartfunktionen * * * ****************************************************************/ int ScGetTextSize(axis) int axis; { int returnset; /*******************/ #ifdef AMIGA /*******************/ switch(axis) { case XSIZE: setreturn(WRp->TxWidth); /* Textlänge */ break; case YSIZE: setreturn(WRp->TxHeight); /* Texthöhe */ break; } #endif /*******************/ #ifdef __MSDOS__ #ifdef __TURBOC__ /*******************/ switch (axis) { case XSIZE: setreturn(textwidth(" ")); /* Textlänge */ break; case YSIZE: setreturn(textheight(" ")); /* Texthöhe */ break; } #endif #endif return(returnset); } /**************************************************************** * * * Function : ScSetLineStyle() * * * ***************************************************************** * * * Input : int typ Linienmuster * * * * Output : void * * * ***************************************************************** * * * Comment : Diese Funktion setzt ein neues Muster für eine * * Linie. Die folgenden Bedingungen müssen erfüllt * * werden. * * * * - Es müssen mindeseten 4 Muster vorhanden sein * * - Muster 0 muss eine ausgezogene Linie zeichen * * - Muster 1 sollte eine fein gestrichelte Line * * zeichnen * * * * AMIGA : definieren der Muster und verwenden der Standart- * * funktion ind grahics.library. * * * * MSDOS : definieren der Muster und verwenden der Standart- * * funktion von Turbo C. * * * ****************************************************************/ void ScSetLineStyle(typ) int typ; { unsigned int style[] = /* Musterdefinition */ { 0xFFFF,0xCCCC,0xF0F0,0xFCFC,0xE8E8 }; /*******************/ #ifdef AMIGA /*******************/ SetDrPt(WRp,(UWORD)style[typ]); /* setzten des Musters */ #endif /*******************/ #ifdef __MSDOS__ #ifdef __TURBOC__ /*******************/ setlinestyle(USERBIT_LINE,style[typ],NORM_WIDTH); /* setzten des Musters */ #endif #endif } /**************************************************************** * * * Nachfolgend sind Funktionen aufgeführt, welche nur für einen * * Rechner verwendet werden. Es sind dies Hilfsfunktionen von * * den Level 3 Funktionen. * * * ****************************************************************/ /*******************/ #ifdef AMIGA /*******************/ /**************************************************************** * * * Function : openlib() * * * ***************************************************************** * * * Input : void * * * * Output : int returnset * * != FALSE alle klar * * == FALSE Fehler * * * ***************************************************************** * * * Comment : Diese Funktion öffnet die notwendigen Librarys. * * Sie wird nur benützt für AMIGA! * * * ****************************************************************/ static int openlib() { int returnset; /* allg Rückgabewert */ IBase = (struct IntuitionBase *) OpenLibrary ("intuition.library",NULL); if (IBase == NULL) /* Fehler ? */ { /* IntuitionBase = NULL */ seterror(GROPER); /* setzte Fehler */ setreturn(FALSE); } else { if (IntuitionBase != IBase) /* schon geöffnet ? */ IntuitionBase = IBase; /* Nein, setzten */ GBase = (struct GfxBase *) OpenLibrary("graphics.library",NULL); if (GBase == NULL) /* Fehler ? */ { /* GfxBase = NULL */ seterror(GROPER); /* Fehler */ setreturn(FALSE); } else { if (GfxBase != GBase) /* schon geöffnet */ GfxBase = GBase; /* Nein, setzten */ setreturn(TRUE); } } return(returnset); /* und zurück */ } /**************************************************************** * * * Function : openscreen() * * * ***************************************************************** * * * Input : void * * * * Output : int returnset * * != FALSE alle klar * * == FALSE Fehler * * * ***************************************************************** * * * Comment : Oeffnet einen Screen und ein entsprechendes * * Window. Es werden auch Defaultfarben gesetzt. * * Diese Funktion wird nur benützt für AMIGA! * * * ****************************************************************/ static int openscreen() { int returnset, /* allg. Rückgabewert */ i; /* Schleifenzähler */ int rot, /* Farbanteile */ gruen, blau; if (GfxBase->DisplayFlags & PAL) /* Version bestimmen */ newscreen.Height = 512; /* PAL Auflösung */ else newscreen.Height = 400; /* NTSC Auflösung */ Sc = (struct Screen *)OpenScreen(&newscreen); /* Öffnen des Screens */ if ( Sc == NULL ) /* Fehler ? */ { /* Sc = NULL */ seterror(GROPER); /* setzte Fehler */ setreturn(FALSE); } else { Vp = &Sc->ViewPort; /* Viewport initialisieren */ Rp = &Sc->RastPort; /* Rastport initialisieren */ ShowTitle(Sc,FALSE); /* kein Titel */ for (i=0;i<16;i++) /* setzten aller Farben */ { rot = ROT(Palette[i]); gruen = GRUEN(Palette[i]); blau = BLAU(Palette[i]); SetRGB4(Vp,i,rot,gruen,blau); /* Farbe setzten */ } window.Screen = Sc; /* Init. Windowstruktur */ window.Height = newscreen.Height; Mw = (struct Window *)OpenWindow(&window); /* Öffne Mainwindow */ if ( Mw == NULL ) /* Fehler ? */ { /* Mw = NULL */ seterror(GROPER); /* Fehler setzten */ setreturn(FALSE); } else WRp = Mw->RPort; /* Rastport initialisieren */ } return(returnset); } #endif /*******************/ #ifdef __MSDOS__ #ifdef __TURBOC__ /*******************/ /**************************************************************** * * * Function : initdriver() * * * ***************************************************************** * * * Input : void * * * * Output : void * * * ***************************************************************** * * * Comment : Registriert die gelinkten Graphiktreiber, sodass * * diese nicht mehr von der Disk gelesen werden * * müssen. * * * ****************************************************************/ static void initdriver() { int i; for (i=0;i