home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / sonderh1 / gsxlib1.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1986-11-25  |  20.1 KB  |  506 lines
  1. {---------------------------------------------------------------------------}
  2. {                      gsxlib1.pas - GSX Bibliothek:                        }
  3. {        Geraete-, einf. Grafik-, Text- und Attribut-Funktionen             }
  4. {---------------------------------------------------------------------------}
  5.  
  6. { Inhalt:
  7.   Open_Workstation, Close_Workstation, Clear_Workstation, Update_Workstation,
  8.   Enter_Graphics, Exit_Graphics,
  9.   Set_Turtle, Hide_Turtle, Ploy_Line, Ploy_Marker, Ploy_Fill, Graph_Text,
  10.   Cell_Array,
  11.   Text_Resolution, Cursor, Goto_XY, Where_XY, Write_Text,
  12.   Draw_Mode, Video, Text_Height, Text_Direction, Set_Color, Line_Type,
  13.   Line_Width, Line_Color, Marker_Type, Marker_Height, Marker_Color,
  14.   Marker_Color, Text_Font, Text_Color, Fill_Style, Fill_Index, Fill_Color   }
  15.  
  16. {---------------------------------------------------------------------------}
  17. {                      geraetespez. Funktionen:                             }
  18. {---------------------------------------------------------------------------}
  19. { Ein Grafik-Geraet als Ausgabemedium waehlen. Es wird entsprechend den Pa-
  20.   rametern im Eingabefeld initialisiert. Gearaetespez. Informationen werden
  21.   in den globalen Variablen zur Auswertung durch das Anwendungsprogramm be-
  22.   reitgestellt. Der Grafik-Modus wird gewaehlt und, bei einem Monitor, der
  23.   Bildschirm geloescht.                                                     }
  24.  
  25. PROCEDURE Open_Workstation (Device: INTEGER);
  26.  
  27. BEGIN
  28.   VDI_Error := TRUE;
  29.   IF Device IN [Screen, Plotter, Printer] THEN
  30.   BEGIN
  31.     contrl[1] := 1;    contrl[2] := 0;    contrl[4] := 10;
  32.     intin[1] := Device;
  33.     { Vorbesetzung der Geraeteeigenschaften: }
  34.     intin[2] := Solid;                                          { Linestyle }
  35.     intin[3] := Red;               { Linecolor: Monochrom = weiss, Drucker/
  36.                                              Plotter = Schwarz, Farbe = Rot }
  37.     intin[4] := Dot;                                           { Markertype }
  38.     intin[5] := Red;                            { Markercolor, s. Linecolor }
  39.     intin[6] := Standard;                                        { TextFont }
  40.     intin[7] := Red;                              { Textcolor, s. Linecolor }
  41.     intin[8] := Hollow;                                         { Fuell-Art }
  42.     intin[9] := Vertical;                                    { Fuell-Muster }
  43.     intin[10] := Red;                             { Fillcolor, s. Linecolor }
  44.  
  45.     VDI_Call(contrl, intin, intout, ptsin, ptsout);
  46.     VDI_Error := (contrl[3] <> 6);
  47.  
  48.     HRes := intout[1];                  VRes := intout[2];
  49.     Scaling := (intout[3] = 0);
  50.     PixWidth := intout[4];              PixHeight := intout[5];
  51.     CharHeights := intout[6];
  52.     Lines := intout[7];                 LineWidths := intout[8];
  53.     Markers := intout[9];               MarkerSizes := intout[10];
  54.     Fonts := intout[11];                Patterns := intout[12];
  55.     HatchStyles := intout[13];          GDPs := intout[15];
  56.     ColorDevice := (intout[36] = 1);
  57.     Colors := intout[14];               ColorsAvail := intout[40];
  58.     TextRotation := (intout[37] = 1);   AreaFill := (intout[38] = 1);
  59.     CellArrays := (intout[39] = 1);     InputLocators := intout[41];
  60.     InputValuators := intout[42];       InputChoices := intout[43];
  61.     InputStrings := intout[44];         WorkstationType := intout[45];
  62.     MinCharHeight := ptsout[2];         MaxCharHeight := ptsout[4];
  63.     MinLineWidth := ptsout[5];          MaxLineWidth := ptsout[7];
  64.     MinMarkHeight := ptsout[10];        MaxMarkHeight := ptsout[12];
  65.   END;
  66. END;
  67.  
  68. {---------------------------------------------------------------------------}
  69. { Verbindung zum Grafik-Gereat aufheben und weitere Ausgaben zu diesem ver-
  70.   hindern. Bei Monitoren wird der Textmodus gewaehlt und der Bildschirm ge-
  71.   loescht. Bei einem Drucker wird vorher ein 'update' (s.u.) ausgefuehrt.   }
  72.  
  73. PROCEDURE Close_Workstation;
  74.  
  75. BEGIN
  76.   contrl[1] := 2;  contrl[2] := 0;
  77.   VDI_Call(contrl, intin, intout, ptsin, ptsout);
  78. END;
  79.  
  80. {---------------------------------------------------------------------------}
  81. { Monitor: Bildschirm wird geloescht. Drucker: Papiervorschub mit nachfol-
  82.   gendem 'update'. Plotter: Es wird ein neues Blatt verlangt.               }
  83.  
  84. PROCEDURE Clear_Workstation;
  85.  
  86. BEGIN
  87.   contrl[1] := 3;  contrl[2] := 0;
  88.   VDI_Call(contrl, intin, intout, ptsin, ptsout);
  89. END;
  90.  
  91. {---------------------------------------------------------------------------}
  92. { Es wird die Ausfuehrung aller noch nicht vom Geraet ausgefuehrten Grafik-
  93.   Befehle bewirkt. Bei Druckern muss diese Prozedur aufgerufen werden, um
  94.   die Ausgabe zu starten.                                                   }
  95.  
  96. PROCEDURE Update_Workstation;
  97.  
  98. BEGIN
  99.   contrl[1] := 4;  contrl[2] := 0;
  100.   VDI_Call(contrl, intin, intout, ptsin, ptsout);
  101. END;
  102.  
  103. {---------------------------------------------------------------------------}
  104. { Unterscheidet das Grafik-Geraet zwischen Text- und Grafik-Modus, wird mit
  105.   dieser Prozedur explizit der Grafik-Modus aktiviert. Dabei wird das Geraet
  106.   'geloescht'.                                                              }
  107.  
  108. PROCEDURE Enter_Graphics;
  109.  
  110. BEGIN
  111.   contrl[1] := 5;  contrl[2] := 0;  contrl[6] := 2;
  112.   VDI_Call(contrl, intin, intout, ptsin, ptsout);
  113. END;
  114.  
  115. {---------------------------------------------------------------------------}
  116. { Wie Enter_Graphics, jedoch wird wieder in den Text-Modus umgeschaltet.    }
  117.  
  118. PROCEDURE Exit_Graphics;
  119.  
  120. BEGIN
  121.   contrl[1] := 5;  contrl[2] := 0;  contrl[6] := 3;
  122.   VDI_Call(contrl, intin, intout, ptsin, ptsout);
  123. END;
  124.  
  125. {---------------------------------------------------------------------------}
  126. {                           Grafik-Funktionen:                              }
  127. {---------------------------------------------------------------------------}
  128. { Grafik-Cursor positionieren und darstellen. Die Darstellung des Grafik-
  129.   Cursors ist geraeteabhaengig.                                             }
  130.  
  131. PROCEDURE Set_Turtle  (xpos, ypos: INTEGER);
  132.  
  133. BEGIN
  134.   contrl[1] := 5;  contrl[2] := 2;  contrl[6] := 18;
  135.   ptsin[1] := xpos;  ptsin[2] := ypos;
  136.   VDI_Call(contrl, intin, intout, ptsin, ptsout);
  137. END;
  138.  
  139. {---------------------------------------------------------------------------}
  140. { Den zuletzt mit 'Set_Turtle' gesetzten Grafik-Cursor wieder entfernen.    }
  141.  
  142. PROCEDURE Hide_Turtle;
  143.  
  144. BEGIN
  145.   contrl[1] := 5;  contrl[2] := 2;  contrl[6] := 19;
  146.   VDI_Call(contrl, intin, intout, ptsin, ptsout);
  147. END;
  148.  
  149. {---------------------------------------------------------------------------}
  150. { Polygonzug mit 'n' Punkten Zeichnen. Die Koordinaten der einzelnen Punkte
  151.   werden im Parameter 'ptsin' vom Typ 'VDI_ptsin' erwartet. Anordnung der
  152.   Koordinaten in 'ptsin':
  153.     ptsin[1]: xpos1, ptsin[2]: ypos1;  ptsin[3]: xpos2, ptsin[4]: ypos2;
  154.     ptsin[5]: xpos3, ptsin[6]: ypos3;  usw.
  155.   Die Linien werden in den aktuellen 'Line'-Attributen gezeichnet.
  156.   Bei einem einzelnen Koordinatenpaar wird nichts gezeichnet; eine Linie
  157.   der Laenge 0 (d.h. zwei identische Koordinatenpaare) wird gezeichnet.     }
  158.  
  159. PROCEDURE Poly_Line (n: INTEGER; VAR ptsin: VDI_ptsin);
  160.  
  161. BEGIN
  162.   contrl[1] := 6;  contrl[2] := n;
  163.   VDI_Call(contrl, intin, intout, ptsin, ptsout);
  164. END;
  165.  
  166. {---------------------------------------------------------------------------}
  167. { Wie 'Poly_Line', jedoch werden an den Koordinaten nur Markierungen in den
  168.   aktuellen 'Marker'-Attributen gesetzt.                                    }
  169.  
  170. PROCEDURE Poly_Marker (n: INTEGER; VAR ptsin: VDI_ptsin);
  171.  
  172. BEGIN
  173.   contrl[1] := 7;  contrl[2] := n;
  174.   VDI_Call(contrl, intin, intout, ptsin, ptsout);
  175. END;
  176.  
  177. {---------------------------------------------------------------------------}
  178. { Wie 'Poly_Line', jedoch wird der Polygonzug automatisch geschlossen und in
  179.   den aktuellen 'Fill'-Attributen ausgefuellt.                              }
  180.  
  181. PROCEDURE Poly_Fill (n: INTEGER; VAR ptsin: VDI_ptsin);
  182.  
  183. BEGIN
  184.   contrl[1] := 9;  contrl[2] := n;
  185.   VDI_Call(contrl, intin, intout, ptsin, ptsout);
  186. END;
  187.  
  188. {---------------------------------------------------------------------------}
  189. { Text ab der Position x,y in den aktuellen 'Text'-Attributen schreiben. Die
  190.   x,y-Position bezeichnet die linke, untere Ecke des ersten Zeichens. Der
  191.   String-Parameter ist ev. anzupassen.                                      }
  192.  
  193. PROCEDURE Graph_Text (x, y: INTEGER; s: VDI_STRING);
  194.  
  195. BEGIN
  196.   contrl[1] := 8;  contrl[2] := 1;  contrl[4] := Length(s);
  197.   ptsin[1] := x;   ptsin[2] := y;
  198.   FOR x := 1 TO Length(s) DO
  199.     intin[x] := Ord(s[x]);
  200.   VDI_Call(contrl, intin, intout, ptsin, ptsout);
  201. END;
  202.  
  203. {---------------------------------------------------------------------------}
  204. { Zeichnen eines durch zwei Eckpunkte begrenzten Rechtecks. Dieses wird mit
  205.   einem Farbmuster gefuellt, das durch das Feld 'ColorIndexArray' vom Typ
  206.   'VDI_intin' bestimmt wird. In diesem sind die zu verwendenten Farben zum
  207.   Fuellen der Flaeche zeilenweise einzutragen. Ausserdem wird die Laenge
  208.   einer Zeile 'Columns' desselben (d.h. wieviel Farben fuer 'eine Zeile'
  209.   des Rechtecks vorgesehen sind), wieviel davon schliesslich benutzt werden
  210.   sollen, wieviel solcher Zeilen 'Rows' es insgesamt im 'ColorIndexArray'
  211.   gibt, sowie der Zeichen-Modus, verlangt (s. Begleitartikel).              }
  212.  
  213. PROCEDURE Cell_Array (xlb, ylb,                    { linke, untere Ecke }
  214.                       xrt, yrt:   INTEGER;         { rechte, obere Ecke }
  215.                       VAR ColorIndexArray: VDI_intin;
  216.                       Rows, Columns,
  217.                       Elements: INTEGER;
  218.                       DrawMode: Draw_Modes);
  219.  
  220. BEGIN
  221.   contrl[1] := 10;            contrl[2] := 2;
  222.   contrl[4] := Rows*Columns;  contrl[6] := Columns;  contrl[7] := Elements;
  223.   contrl[8] := Rows;          contrl[9] := DrawMode;
  224.   ptsin[1] := xlb;  ptsin[2] := ylb;
  225.   ptsin[3] := xrt;  ptsin[4] := yrt;
  226.   VDI_Call(contrl, ColorIndexArray, intout, ptsin, ptsout);
  227. END;
  228.  
  229. {---------------------------------------------------------------------------}
  230. {                            Text-Funktionen:                               }
  231. {---------------------------------------------------------------------------}
  232. { Anzahl von adressierbaren Text-Zeilen und -Spalten des Ausgabegeraets
  233.   ermitteln. -1 in Zeilen oder Spalten bedeutet, dass direkte Cursor-
  234.   Adressierung nicht moeglich ist.                                          }
  235.  
  236. PROCEDURE Text_Resolution (Var Rows, Columns: INTEGER);
  237.  
  238. BEGIN
  239.   contrl[1] := 5;  contrl[2] := 0;  contrl[6] := 1;
  240.   VDI_Call(contrl, intin, intout, ptsin, ptsout);
  241.   Rows := intout[1];                                    { meisten 24 Zeilen }
  242.   Columns := intout[2];                                { meisten 80 Spalten }
  243. END;
  244.  
  245. {---------------------------------------------------------------------------}
  246. { Mit dieser Prozedur kann der Textcursor manoeveriert werden.
  247.   Parameter siehe Cursor_Operations.                                        }
  248.  
  249. PROCEDURE Cursor (Op: Cursor_Operations);
  250.  
  251. BEGIN
  252.   contrl[1] := 5;  contrl[2] := 0;  contrl[6] := Op;
  253.   VDI_Call(contrl, intin, intout, ptsin, ptsout);
  254. END;
  255.  
  256. {---------------------------------------------------------------------------}
  257. { Textcursor an die Position x,y setzen. x = Spalte, y = Zeile              }
  258.  
  259. PROCEDURE Goto_XY (x, y: INTEGER);
  260.  
  261. BEGIN
  262.   contrl[1] := 5;  contrl[2] := 0;  contrl[6] := 11;
  263.   intin[1] := y;   intin[2] := x;
  264.   VDI_Call(contrl, intin, intout, ptsin, ptsout);
  265. END;
  266.  
  267. {---------------------------------------------------------------------------}
  268. { Ermittelt Zeile und Spalte, in der der Textcursor steht.                  }
  269.  
  270. PROCEDURE Where_XY (VAR x, y: INTEGER);
  271.  
  272. BEGIN
  273.   contrl[1] := 5;  contrl[2] := 0;  contrl[6] := 15;
  274.   VDI_Call(contrl, intin, intout, ptsin, ptsout);
  275.   y := intout[1];  x := intout[2];
  276. END;
  277.  
  278. {---------------------------------------------------------------------------}
  279. { Gibt eine Zeichenkette ab der aktuellen Textcursor-Position in dem akt.
  280.   'Video'-Attribut aus.                                                     }
  281.  
  282. PROCEDURE Write_Text (s: VDI_STRING);
  283.  
  284. VAR i: INTEGER;
  285.  
  286. BEGIN
  287.   contrl[1] := 5;  contrl[2] := 0;  contrl[4] := Length(s);  contrl[6] := 12;
  288.   FOR i := 1 TO Length(s) DO
  289.     intin[i] := Ord(s[i]);
  290.   VDI_Call(contrl, intin, intout, ptsin, ptsout);
  291. END;
  292.  
  293. {---------------------------------------------------------------------------}
  294. {                        Attribut-Funktionen:                               }
  295. {---------------------------------------------------------------------------}
  296. { Zeichenmodus festlegen: Replace, Transparent, Complement, Erase           }
  297.  
  298. FUNCTION Draw_Mode (Mode: Draw_Modes): INTEGER;
  299.  
  300. BEGIN
  301.   contrl[1] := 32;  contrl[2] := 0;  contrl[3] := Mode;
  302.   VDI_Call(contrl, intin, intout, ptsin, ptsout);
  303.   Draw_Mode := intout[1];
  304. END;
  305.  
  306. {---------------------------------------------------------------------------}
  307. { Darstellung von folgenden Textausgaben im Textmodus 'Reverse' oder
  308.   'Normal' setzen.                                                          }
  309.  
  310. PROCEDURE Video (Attribute: Video_Attributes);
  311.  
  312. BEGIN
  313.   contrl[1] := 5;  contrl[2] := 0;  contrl[6] := Attribute;
  314.   VDI_Call(contrl, intin, intout, ptsin, ptsout);
  315. END;
  316.  
  317. {---------------------------------------------------------------------------}
  318. { Zeichenhoehe in Geraeteeinheiten (Punkte, Plotter-Schrittweite) setzen.
  319.   Zurueckgegeben wird die tatsaechlich eingestellte Zeichenbreite, -hoehe,
  320.   Zeichenzellenbreite und -hoehe. Die Zeichenzelle stellt hierbei eine 8x8
  321.   Matrix dar, in der das Zeichen 7 Einheiten hoch ist. Die unterste Zellen-
  322.   zeile ist leer. Als Drehpunkt fuer Schriftdrehung (s.u.) dient das Zellen-
  323.   element in der zweiten Zeile von unten links. Die zurueckgegebene Zeichen-
  324.   groesse bezieht sich auf ein grosses "W".                                 }
  325.  
  326. PROCEDURE Text_Height (Height: INTEGER;
  327.                        VAR CharWidth, CharHeight,
  328.                            CellWidth, CellHeight: INTEGER);
  329.  
  330. BEGIN
  331.   contrl[1] := 12;  contrl[2] := 1;
  332.   ptsin[1] := 0;    ptsin[2] := Height;
  333.   VDI_Call(contrl, intin, intout, ptsin, ptsout);
  334.   CharWidth := ptsout[1];  CharHeight := ptsout[2];
  335.   CellWidth := ptsout[3];  CellHeight := ptsout[4];
  336.   VDI_Error := (contrl[3] <> 2);
  337. END;
  338.  
  339. {---------------------------------------------------------------------------}
  340. { Schreibrichtung (Winkel) setzen, so gut es das angewaehlte Geraet zu-
  341.   laesst. Der tatsaechlich eingestellte Winkel wird von der Funktion in
  342.   Grad zurueckgegeben.                                                      }
  343.  
  344. FUNCTION Text_Direction (angle: REAL): REAL;
  345.  
  346. BEGIN
  347.   contrl[1] := 13;  contrl[2] := 0;
  348.   intin[1] := Trunc(angle*10.0);
  349.   intin[2] := Round(cos(angle)*100.0);
  350.   intin[3] := Round(sin(angle)*100.0);
  351.   VDI_Call(contrl, intin, intout, ptsin, ptsout);
  352.   Text_Direction := intout[1] / 10;
  353. END;
  354.  
  355. {---------------------------------------------------------------------------}
  356. { Representation der Farbe 'ColorNr' durch die Farbanteile Rot, Gruen und
  357.   Blau bestimmen. Die Farbanteile muessen in 1/10 Prozent (0..1000) ange-
  358.   geben werden. Der Erfolg dieser Procedur ist geraeteabhaengig. Wenigsten
  359.   zwei Farben sind durch 'Open_Workstation' schon initialisiert.            }
  360.  
  361. PROCEDURE Set_Color (Color: Color_Index; Red, Green, Blue: INTEGER);
  362.  
  363. BEGIN
  364.   contrl[1] := 14;  contrl[2] := 0;
  365.   intin[1] := Color;
  366.   intin[2] := Red;  intin[3] := Green;  intin[4] := Blue;
  367.   VDI_Call(contrl, intin, intout, ptsin, ptsout);
  368. END;
  369.  
  370. {---------------------------------------------------------------------------}
  371. { Linientyp fuer kuenftige Zeichenoperatioenen bestimmen. Es wird der
  372.   wirklich eingestellte Linientyp (geraetabhaengig) zurueck gegeben.        }
  373.  
  374. FUNCTION Line_Type (LType: Line_Types ): INTEGER;
  375.  
  376. BEGIN
  377.   contrl[1] := 15;  contrl[2] := 0;  intin[1] := LType;
  378.   VDI_Call(contrl, intin, intout, ptsin, ptsout);
  379.   Line_Type := intout[1];
  380. END;
  381.  
  382. {---------------------------------------------------------------------------}
  383. { Linienbreite festlegen und zurueckmelden.                                 }
  384.  
  385. FUNCTION Line_Width (LWidth: INTEGER): INTEGER;
  386.  
  387. BEGIN
  388.   contrl[1] := 16;     contrl[2] := 1;
  389.   ptsin[1] := LWidth;  ptsin[2] := 0;
  390.   VDI_Call(contrl, intin, intout, ptsin, ptsout);
  391.   VDI_Error := (contrl[3] <> 1) OR (ptsout[2] <> 0);
  392.   Line_Width := ptsout[1]
  393. END;
  394.  
  395. {---------------------------------------------------------------------------}
  396. { Farbe von zu zeichnenden Linien bestimmen und Ergebnis melden.            }
  397.  
  398. FUNCTION Line_Color (Color: Color_Index): INTEGER;
  399.  
  400. BEGIN
  401.   contrl[1] := 17;  contrl[2] := 0;  intin[1] := Color;
  402.   VDI_Call(contrl, intin, intout, ptsin, ptsout);
  403.   VDI_Error := (contrl[3] <> 1);
  404.   Line_Color := intout[1]
  405. END;
  406.  
  407. {---------------------------------------------------------------------------}
  408. { Markierungszeichen festlegen (s. gsxconst.pas)                            }
  409.  
  410. FUNCTION Marker_Type (MType: Marker_Types): INTEGER;
  411.  
  412. BEGIN
  413.   contrl[1] := 18;  contrl[2] := 0;  intin[1] := MType;
  414.   VDI_Call(contrl, intin, intout, ptsin, ptsout);
  415.   Marker_Type := intout[1];
  416. END;
  417.  
  418. {---------------------------------------------------------------------------}
  419. { Groesse (Hoehe) der Markierungszeichen festlegen.                         }
  420.  
  421. FUNCTION Marker_Heigth (Heigth: INTEGER): INTEGER;
  422.  
  423. BEGIN
  424.   contrl[1] := 19;  contrl[2] := 1;  ptsin[1] := 0;  ptsin[2] := Heigth;
  425.   VDI_Call(contrl, intin, intout, ptsin, ptsout);
  426.   VDI_Error := (contrl[3] <> 1) OR (ptsout[1] <> 0);
  427.   Marker_Heigth := ptsout[2]
  428. END;
  429.  
  430. {---------------------------------------------------------------------------}
  431. { Farbe der Markierungszeichen...                                           }
  432.  
  433. FUNCTION Marker_Color (Color: INTEGER): INTEGER;
  434.  
  435. BEGIN
  436.   contrl[1] := 20;  contrl[2] := 0;  intin[1] := Color;
  437.   VDI_Call(contrl, intin, intout, ptsin, ptsout);
  438.   Marker_Color := intout[1]
  439. END;
  440.  
  441. {---------------------------------------------------------------------------}
  442. { Zeichensatz fuer zukuenftige Text-Funktionen waehlen. Diese sind Geraete-
  443.   abhaengig und von 1 bis ??? numeriert (s. gsxconst, gsxtype u. gsxvar)    }
  444.  
  445. FUNCTION Text_Font (Font: INTEGER): INTEGER;
  446.  
  447. BEGIN
  448.   contrl[1] := 21;  contrl[2] := 0;  intin[1] := Font;
  449.   VDI_Call(contrl, intin, intout, ptsin, ptsout);
  450.   Text_Font := intout[1];
  451. END;
  452.  
  453. {---------------------------------------------------------------------------}
  454. { Textfarbe...                                                              }
  455.  
  456. FUNCTION Text_Color (Color: Color_Index): INTEGER;
  457.  
  458. BEGIN
  459.   contrl[1] := 22;  contrl[2] := 0;  intin[1] := Color;
  460.   VDI_Call(contrl, intin, intout, ptsin, ptsout);
  461.   Text_Color := intout[1];
  462. END;
  463.  
  464. {---------------------------------------------------------------------------}
  465. { Setzt die Fuellart fuer Polygone. Modifizierbar mit Fill_Index. Steht die
  466.   gewuenschte Fuellart nicht zur Verfuegung, sollte 'Hollow' benutzt werden }
  467.  
  468. FUNCTION Fill_Style (Style: Fill_Styles): INTEGER;
  469.  
  470. BEGIN
  471.   contrl[1] := 23;  contrl[2] := 0;  intin[1] := Style;
  472.   VDI_Call(contrl, intin, intout, ptsin, ptsout);
  473.   Fill_Style := intout[1];
  474. END;
  475.  
  476. {---------------------------------------------------------------------------}
  477. { Die Funktion modifiziert die mit Fill_Style festgelegte Fuellart. Sie
  478.   zeigt keine Wirkung, wenn Fill_Style 'Hollow' oder 'Solid' ist. Der Index
  479.   geht von 1 bis zu einem geraeteabhaengigen Maximum. Bei Fill_Style =
  480.   Hatch (Schraffur) entsprechen die in gsxconst.pas definierten Konstanten
  481.   dem erzielten Effekt. Bei Fill_Style = Pattern (Halbton-Muster) werden
  482.   Grautoene mit dem Index 1-6 benutzt (1: hell, 6: dunkel).                 }
  483.  
  484. FUNCTION Fill_Index (Index: INTEGER): INTEGER;
  485.  
  486. BEGIN
  487.   contrl[1] := 24;  contrl[2] := 0;  intin[1] := Index;
  488.   VDI_Call(contrl, intin, intout, ptsin, ptsout);
  489.   Fill_Index := intout[1];
  490. END;
  491.  
  492. {---------------------------------------------------------------------------}
  493. { Fuellfarbe waehlen...                                                     }
  494.  
  495. FUNCTION Fill_Color (Color: Color_Index): INTEGER;
  496.  
  497. BEGIN
  498.   contrl[1] := 25;  contrl[2] := 0;  intin[1] := Color;
  499.   VDI_Call(contrl, intin, intout, ptsin, ptsout);
  500.   Fill_Color := intout[1]
  501. END;
  502.  
  503. {---------------------------------------------------------------------------}
  504.                            { Ende von gsxlib1.pas }
  505.  
  506.