{$ifndef unix}
{$A+,B-,D+,E+,F-,G+,I+,L+,N+,O-,P+,Q-,R-,S+,T-,V-,X+,Y+}
{$else}
{$B-,I+,S-,T-,X+}
{$endif}
unit vbios;
interface
{ Alle Werte ab 0, falls nicht anders angegeben

H=Hercules
C=CGA
E=EGA
e=EGA mit Hercules-Bildschirm
V=VGA

 Standardvideomodi:
 ~~~~~~~~~~~~~~~~~~
Modus Karte Typ Pixel/Zeichen Pixel   Zeichen Farben Bildseiten
 $0,1 C	     T  8*8	      320*200 40*25     16	  4
 $0,1 E	     T  8*14	      320*350 40*25     16	  8
 $0,1 V	     T  9*16	      360*400 40*25     16	  8
 $2,3 C	     T  8*8 	      640*400 80*25     16	  4
 $2,3 E	     T  8*14	      640*400 80*25     16	  8
 $2,3 V	     T  9*16	      720*400 80*25     16	  8
 $4,5 CEV    G  8*8	      320*200 40*25      4	  1
 $6   CEV    G  8*8	      320*200 40*25      2	  1
 $7   H	     T  9*14	      720*350 80*25      %	  8
 $7   V	     T  9*16	      720*400 80*25      %	  8
 $D   EV     G  8*8	      320*200 40*25     16	  8
 $E   EV     G  8*8	      640*200 80*25     16	  4
 $F   eV     G  8*14	      640*350 80*25      *	  2
$10   EV     G  8*14	      640*350 80*25     16	  2
$11   V	     G  8*16	      640*480 80*30     16	  1
$12   V	     G  8*16	      640*480 80*30     16	  1
$13   V	     G  8*8	      320*200 40*25    256	  1
% 16 Farben: 0,8:Schwarz 1:normal unterstrichen 2-7:normal
	     9:hell unterstrichen $a-$f:hell
* Adressierung wie bei 16 Farben, aber nur 0. & 2. Farbebene
  genutzt. Farben: 0=schwarz, 1=normal 4=blinken 5=hell

Farbe in den Textmodi:
Bit     :7 6 5 4 3 2 1 0
Funktion:b h h h v v v v
Die v-Bits geben die Vordergrundfarbe an, h die
Hintergrundfarbe. Ist b=1, so blinken die Zeichen.
b kann auch zum 4. h-Bit umgeschaltet werden.

Farbe in den Grafikmodi:
Bit	  :7 6 5 4 3 2 1 0
  2 Farben:x / / / / / / v
  4 Farben:x / / / / / v v
 16 Farben:x / / / v v v v
256 Farben:v v v v v v v v
Ist x=1, so wird der neue Farbwert mit dem altem
Farbwert XOR-verknüpft.

Farbauswahl:
CGA   :Farbnummer->Monitor
EGA   :Farbnummer->Palettenregister->Monitor
VGA16 :Farbnummer->PalettenregisterÂ>Farbregister->Monitor
		   FarbsetiennummerÙ
  Farbseitenmodus 0:Palettenwert mod $3f+Farbseitennummer shl 6
  Farbseitenmodus 1:Palettenwert mod $0f+Farbseitennummer shl 4
VGA256:Farbnummer->                  Farbregister->Monitor

}

const
{ Die Standardfarben für 16-Farb-Modi: }
 CBlack       =$0;
 CDarkBlue    =$1;
 CDarkGreen   =$2;
 CDarkCyan    =$3;
 CDarkRed     =$4;
 CDarkMagenta =$5;
 CBrown       =$6;
 CLightGray   =$7;
 CDarkGray    =$8;
 CLightBlue   =$9;
 CLightGreen  =$a;
 CLightCyan   =$b;
 CLightRed    =$c;
 CLightMagenta=$d;
 CYellow      =$e;
 CWhite       =$f;

{ Für die Mischung von Farben für die Palettenregister: }
 EPRed  =$04; { HellRot    }
 EPGreen=$02; { HellGrün   }
 EPBlue =$01; { HellBlau   }
 ESRed  =$20; { DunkelRot  }
 ESGreen=$10; { DunkelGrün }
 ESBlue =$08; { DunkelBlau }
{ zum Mischen addieren oder OR-verknüpfen }

{ Für die Sicherung des Status der VGA }
 VGAregs      =$01;{ =Register sichern }
 VGAvars      =$02;{ =VideoBIOSVariablen sichern }
 VGAcolors    =$04;{ =Farbregister sichern }
 VGAsvgastatus=$08;{ =Super-VGA-Status (evtl nicht unterstützt) }
{ zum Mischen addieren oder OR-verknüpfen }

Type
{ Get/SetAllPal für 16 Palettenwerte und den Overscanwert }
 PalTable=array[0..$10]of byte;

 ROMStatusRec=record
  { Hardwareabhängige Eigenschaften }
  videomodes_00_07,
  videomodes_08_0f,
  videomodes_10_17:byte; { verfügbare Videomodi bei gesetzten Bits }
  reserviert1:longint;
  TextModeScanLines:byte;{ Mögliche Rasterzeilen bei gesetztem Bit:
			   Bit 0:200 1:350 2:400 }
  NrOfCharacterSetBlocks:byte; { Anzahl Textmoduszeichensatzblöcke }
  UsableCharacterSetBlocks:BYTE; { Anzahl gleichzeitig benutzbarer
				   Textmoduszeichensatzblöcke }
  Statusbits:word;	 { Bit  0: Alle Modi auf allen Monitoren verfügbar
				1: Graustufen verfügbar
				2: Benutzerdefinierte Zeichensätze
				3: Benutzerdefinierte Palettentabelle
				4: CGA-Cursoremulation
				5: EGA-Palettenregister
				6: VGA-Farbregister
				7: Mehrere Farbseiten
				8: Lichtgriffelinterface
				9: Speichern/Laden des Videostatus
				10:Umschalten 16 Hintergrundfarben/Blinken
				11:Display Combination Code }
  reseviert2:word;
  SavePointerFunctions:byte; { über SaveTablePointer verfügbare Funktionen:
			   Bit	0: 2 Zeichensätze installierbar
				1: Palette Save Area unterstützt
				2: Uset-Zeichensatz Textmodi
				3: User-Zeichensatz Grafikmodi
				4: User-Palettentabelle
				5: Display Combination Code erweiterung }
 end;

 posrec=record
  x,y:byte;
 end;

 Statusrec=record
  { Statustabelle, von BIOS-Funktion übergeben }
  ROMTable   :^RomStatusRec; { Tabelle mit Modusunabhängige Informationen }
  VideoMode  :byte; { Aktueller Videomodus }
  NrOfColumns:word; { Bildschirm-Textspalten }
  PageSize   :word; { Größe einer Bildseite in Bytes }
  PageOffset :word; { Offset der aktiven Bildseite }
  CursorPos  :array[0..7]of posrec; { Cursorpositionen Seite 0-7 }
  CursorStart:byte; { 1. Rasterzeile des Cursors }
  CursorEnd  :byte; { letzte Rasterzeile des Cursors }
  ActivePage :byte; { Aktive Bildschirmseite }
  BaseIOPort :word; { Basisport für Registerzugriffe }
  ModeCtrlReg:byte;{C} { Inhalt v. ModeControlRegister }
  ColorSelReg:byte;{C} {Inhalt ColorSelectRegister }
  NrOfRows   :byte; { Bildschirm-Textzeilen }
  CharSize   :word; { Höhe eines Zeichens in Rasterzeilen }
  DispCombA  :byte; { DisplayCombinationCode, aktiver Adapter }
  DispCombB  :byte; { DisplayCombinationCode, zweiter Adapter }
  NrOfColors :word; { Anzahl der darstellbaren Farben }
  NrOfPages  :byte; { Anzahl der Bildseiten }
  VRes	     :byte; { Vertikale Auflösung:0=200;1=350;2=400;3=480;>3=??? }
  CharBlockA :byte; { Zeichensatz-Block A }
  CharBlockB :byte; { Zeichensatz-Block B }
  StatusBits :byte; { Bit 0 = alle Videomodi stehen zur Verfügung
		      Bit 1 = Farbregister werden in Graustufen umgewandelt
		      Bit 2 = Monocrom-Monitor angeschlossen
		      Bit 3 = Paletten/Farbregister bleiben bei Moduswechsel
			      unverändert
		      Bit 4 = CGA-Cursoremulation aktiv
		      Bit 5 = blinkende Zeichen aktiviert }
  res1	     :word; { Reserviert }
  res2	     :byte; { Reserviert }
  Memory     :byte; { Installierter Speicher div 64k -1 }
  StatusBits2:byte; { Bit 0 = 512 Zeichen verfügbar
		      Bit 1 = Dynamic Save Area aktiv
		      Bit 2 = User-Zeichensatz installiert
		      Bit 3 = User-Grafik-Zeichensatz installiert
		      Bit 4 = User-Farbtabelle installiert
		      Bit 5 = Display Combination Code Erweiterung }
  res3	     :array[0..12] of byte; { Reserviert }
 end;



 UserPaletteProfileTable=record{ Länge:21+Anzahl Videomodi }
  { Tabelle mit benutzerdefinierten Paletteneinträgen }
  UnderlineFlag:byte; {  0: unterstreichen in Monocrom-Modi
			 1: immer unterstreichen
		       $ff: nie unterstreichen }
  reserved1:byte;
  reserved2:word;
  NrOfPaletteRegisters:word; { Anzahl der Palettenregister }
  FirstPaletteRegister:word; { erstes Palettenregister }
  PaletteRegisters:pointer;  { Tabelle mit Registerwerten }
  NrOfColorRegisters:word;   { Anzahl der Farbregister }
  FirstColorRegister:word;   { erstes Farbregister }
  Colors:pointer;	     { Tabele mit Farbwerten, r,g,b }
  videomodes:array [0..$ff] of byte;  { Videomodi, in denen die veränderten
			       Werte gelten sollen, $ff=Ende }
 end;

 DisplayCombinationCodeTable=record
  { Tabelle gültige DisplayCombinationCodes }
  NrOfEntrys:byte;		{ Anzahl Einträge }
  VersionNumber:byte;		{ Tabellen-Versionsnummer }
  MaxDisplayCombinationCode:byte;{ Maximaler DisplayCombinationCode }
  reserved:byte;
  CodeTable:array[0..0] of word;{ Tabelle mit DisplayCombinationCodes }
 end;

 FontDescriptor1=record
  { für Textmoduszeichen über AlphaModeAuxilaryPointer }
  CharacterSize:byte;	{ Zeichenhöhe = Bytes/Zeichen }
  CharacterBlock:byte;	{ EGA:0..3,VGA:0..7 }
  NumberOfChars:word;	{ Anzahl geänderte Zeichen }
  FirstChar:word;	{ Erstes geändertes Zeichen }
  CharacterSet:pointer;	{ Zeigt auf Zeichensatz }
  ScreenLines:byte;	{ Bildschirmzeilen, $ff=aus Zeichenhöhe berechnet }
  VideoModes:array [0..0] of byte; {Videomodi, in denen der Zeichensatz gilt.
			 $ff kennzeichnet das Ende der Liste }
 end;

 FontDescriptor2=record
  ScreenLines:byte;	{ Bildschirm-Textzeilen }
  CharacterSize:word;	{ Zeichenhöhe = Bytes/Zeichen }
  CharacterSet:pointer;	{ Zeigt auf Zeichensatz }
  VideoModes:array [0..0] of byte; {Videomodi, in denen der Zeichensatz gilt.
			 $ff kennzeichnet das Ende der Liste }
 end;

 FontDescriptor3=record
  { für Textmoduszeichen über SecondAlphaModeAuxilaryPointer }
  CharacterSize:byte;	{ Zeichenhöhe = Bytes/Zeichen }
  CharacterBlock:byte;	{ EGA:0..3,VGA:0..7 }
  reserved:byte;
  CharacterSet:pointer;	{ Zeigt auf Zeichensatz }
  VideoModes:array [0..0] of byte; {Videomodi, in denen der Zeichensatz gilt.
			 $ff kennzeichnet das Ende der Liste }
 end;

 SecondarySaveTable=record
  { Grafikkarteninformationen 2 }
  NrOfPointers:word;
   { Anzahl der Pointer in der Tabelle, Länge=4*NrOfPointers+2 }
  DisplayCombinationCodeTablePtr:^DisplayCombinationCodeTable;
   { Liste aller legalen DisplayCombinationCodes }
  SecondaryAlphaModeAuxilaryPtr:^FontDescriptor3;
   { Descriptor für alternativen Textmodus-Zeichensatz 2
     Ist dieser Zeiger NIL, so wird er ignoriert }
  UserPaletteProfileTablePtr:^UserPaletteProfileTable;
   { Descriptor für benutzerdefinierte Paletten/Farbregistereinträge
     Ist dieser Zeiger NIL, so wird er ignoriert }
 end;

 DynamicSaveArea=array[0..255] of byte;
  { in den ersten 16 Bytes stehen die Palettenregister, im
    17. Byte das Overscan-Register }

 SaveTable=record
  { Grafikkarteninformationen 1 }
  ParameterTablePtr:Pointer;
   { Registerwerte für Moduswechsel, NICHT VERÄNDERN! }
  DynamicSaveAreaPtr:^DynamicSaveArea;
   { Tabelle Standardpalettenregisterwerte, wird bei Moduswechsel gefüllt.
     Ist dieser Zeiger NIL, so wird er ignoriert }
  AlphaModeAuxilaryPtr:^FontDescriptor1;
   { Descriptor für alternativen Textmodus-Zeichensatz
     Ist dieser Zeiger NIL, so wird er ignoriert }
  GraphicModeAuxilaryPtr:^FontDescriptor2;
   { Descriptor für alternativen Grafikmodus-Zeichensatz
     Ist dieser Zeiger NIL, so wird er ignoriert }
  SecondarySaveTablePtr:^SecondarySaveTable;
   { erweiterte VGA-Tabelle, nur VGA}
  reserved1,
  reserved2:pointer;
 end;
 { Die SaveTable und ihre Untertabellen können im ROM liegen und müssen dann
   zum Verändern ins RAM kopiert werden oder durch eigene ersetzt werden }
 t_secondcharset=array[128..255,0..7] of byte;

{$ifndef unix}
VAR { Der BIOS-Variablenbereich: }
 VideoMode	:Byte ABSOLUTE 0:$449;		{ aktueller Videomodus }
 NrOfColumns	:Word ABSOLUTE 0:$44A;		{ darstellbare Textspalten }
 PageSize	:Word ABSOLUTE 0:$44C;		{ Bildseitengröße }
 PageStart	:Word ABSOLUTE 0:$44E;		{ Offsetadresse Bildseite }
 CursorPos	:ARRAY[0..7] OF posrec ABSOLUTE 0:$450; {Cursorposition }
 CursorStart	:Byte ABSOLUTE 0:$460;		{ Erste Cursorrasterzeile }
 CursorEnd	:Byte ABSOLUTE 0:$461;		{ Letzte Cursorrasterzeile }
 ActivePage	:Byte ABSOLUTE 0:$462;		{ Aktive Bildseite }
 CRTCPort	:Word ABSOLUTE 0:$463;		{ CRTC-Portadresse }
 NrOfRows	:Byte ABSOLUTE 0:$484;		{ Textzeilen - 1 }
 CharSize	:Word ABSOLUTE 0:$485;		{ aktuelle Zeichenhöhe - 1 }
 StatusBits	:Byte ABSOLUTE 0:$487;		{ Diverse Statusinfos }
 ConfigBits	:Byte ABSOLUTE 0:$488;		{ DIP-Schalterstellung }
 SaveTablePtr	:^SaveTable ABSOLUTE 0:$4A8;	{ Save Table Pointer }
 CharSet2nd8x8	:^t_secondcharset absolute 0:$108;
 GraphicCharSet :pointer absolute 0:$10c;
{$else}
var
    VideoMode: byte value 3;    (* aktueller Videomodus *)
    NrOfRows: Byte value 24;     (* Textzeilen - 1 *)
    NrOfColumns: byte value 79;  (* darstellbare Textspalten *)
    CursorPos:array [0..7] OF posrec value
    ((0,0),(0,0),(0,0),(0,0),
     (0,0),(0,0),(0,0),(0,0)); {Cursorposition }
//    CharSize: Word value 15;     (* aktuelle Zeichenhöhe - 1 *)
    CharSize: Word value 7;     (* aktuelle Zeichenhöhe - 1 *)
    GCharset: pointer value NIL;
	CursorStart	:Byte value 11;		{ Erste Cursorrasterzeile }
	CursorEnd	:Byte value 12;		{ Letzte Cursorrasterzeile }
    StatusBits :byte value $11;
const
	Pagesize=4000;
{$endif}

{=== Standardfunktionen ===}

{$ifndef unix}
procedure SetVideoMode(Mode:Word);
{ Setzt den Videomodus. Bit 7=1:Bildspeicher nicht löschen }
{$endif}

procedure SetCursorSize(Oben,Unten:Byte);
{ Einstellen der Cursorgröße
  Wenn die Cursoremulation nicht abgeschaltet wurde,
  werden die Werte so interpretiert, als wären sie
  für eine 8*8-Zeichenbox und automatisch angepaßt.
  SetCursorSize(0,7) stellt dann also ein Block-Cursor ein }

procedure SetCursorXY(x,y:byte;page:Word);
{ Setzt den Cursor der Seite page auf die Position x,y }

procedure SetVideoPage(Page:Word);
{CEV}
{ Zeigt die Bildseite page an }

procedure ScrollUpDown(x1,y1,x2,y2,rows:byte;NewColor:word;up:boolean);
{ Scrollt den Bereich x1,y1:x2,y2 rows Zeilen nach oben o.
  unten und füllt die neuen Zeilen mit Blanks in der Farbe
  NewColor. Ist rows=0, so wird dieser Bereich ganz ausge-
  füllt. Ist up=TRUE, so wird nach oben gescrollt, sonst
  nach unten.						   }

function ReadCA(page:word):word;
{ Liefert im Lo-Byte das Zeichen an der Cursorposition der Seite page.
  Im Textmodus gibt das Hi-Byte die entsprechende Farbe an.	       }

{$ifndef unix}
procedure WriteCA(c:char;attr:byte;Page:byte;Count:Word);
procedure WriteC(c:char;page:word;count:word);
{ Schreibt count mal das Zeichen c (in der Farbe attr) an
  der Cursorposition der Seite page, ohne den Cursor zu
  bewegen						  }
{$endif}

Procedure SetCGAPalette(color:byte);
{Modus 4&5}
{ Setzt die Farbpalette:
  Palette: 0     1
  Farbe:1 Grün  Türkis
	2 Rot   Magenta
	3 Braun Weiß     }

Procedure SetCGAColor(color:byte);
{Textmodi :setzt die Ramenfarbe}
{Modus 4&5:setzt die Hintergrundfarbe}
{Modus 6  :setzt die Vordergrundfarbe}

Procedure SetPixel(x,y,color,page:word);
{ setzt den Punkt x,y auf der Seite page auf die Farbe color }

function GetPixel(x,y:word;page:byte):byte;
{ liefert die Farbe des Punkts x,y auf der Seite page }

procedure Print(c:char;attr:byte);
{ Schreibt das Zeichen c in der Farbe attr an die aktuelle
  Cursorposition der aktiven Bildschirmseite und setzt den
  Cursor weiter. #7,#8,#10 und #13(BEL,BS,LF,CR) werden
  ausgeführt. attr wirkt nur im Grafikmodus		   }

procedure WriteSA(x,y,page,color:byte;anz:word;
		   movecursor,attributed:boolean;var s);
{nur AT}
{ Schreibt ein Zeichenstring auf den Bildschirm.
  attributed:false:s=Zeichen,Zeichen...
	     True:s=Zeichen,Attribut,Zeichen,Attribut...
  Beispiel:
  s:='Hallo'#7;
  WriteSA(3,5,0,$1e,byte(s[0]),true,false,s[1]); }

{=== EGAVGA Palettenfunktionen ===}

procedure SetPalReg(nr,wert:byte);
{ Setzen eines Palettenregisters

  0-$f:Palettenregister
   $10:Attribut Mode Control Register
   $11:Overscan Register
   $12:Color Plane Enable
   $13:Horizontal Pel Panning Register
   $14:Color Select Register (nur VGA)

  Die Farben setzen sich aus den obrigen Konstanten
  zusammen. Das Overscan Register bestimmt die Farbe
  des Bildschirmrandes. Näheres über die anderen
  Register erfahren Sie aus Fachliteratur	     }

procedure SetOverscanReg(wert:byte);
{ Setzt das Overscan-Register auf den Farbwert wert.
  Achtung: einige EGA-Karten vertragen in den
	   hochauflösenden Modi keinen Wert außer 0 }

procedure SetAllPal(var Pal:PalTable);
{ setzt die Palette auf die in Pal gespeicherten Werte
  (17 Byte:0..16:Palettenwerte;17:Overscanwert	       }

procedure SetFlashing(on:boolean);
{ Stellt das Blinken in den Textmodi an o. aus
  True : 8 Hintergrundfarben, Blinken an
  False:16 Hintergrundfarben, Blinken aus	}

Function GetPalReg(nr:byte):byte;
{V}
{ Liest Palettenregister nr aus. siehe SetPalReg }

Function GetOverscanReg:byte;
{V}
{ Liest das Overscan Register aus }

procedure GetAllPal(var Palette:PalTable);
{V}
{ Liest alle Palettenregister aus. Siehe SetAllPal. }

procedure SetPageMode(mode:byte);
{V}
function GetPageMode:byte;
{V}
{ Setzt/liest den Farbseitenmodus.
  0:4*64 Farbseiten 1:16*16 Farbseiten }

procedure SetColorPage(page:byte);
{V}
function GetColorPage:byte;
{V}
{ Setzt/liest die aktuelle Farbseite }

{=== VGA Farbregisterfunktionen ===}

procedure SetColorReg(nr:word;r,g,b:byte);
{ Standard:nr:0..255 r,g,b:0..63 }
{ Setzt den Rot, Grün und Blauwert des Farbregister
  nr auf r, g u. b. (63=volle Intensität.)	    }

procedure ReadColorReg(nr:word;var color);
{ Liest die 3 Farbwerte in color ein. Format:r,g,b }

{$ifndef unix}
procedure SetColorBlock(firstreg,anz:word;var Colortable);
{ setzt anz Farbregister ab dem Register firstreg
  auf die in Colortable gespeicherten Werte.
  Format: r1,g1,b1,r2,g2,b2...			 }
{$endif}

procedure ReadColorBlock(firstreg,anz:word;var Colortable);
{ liest anz Farbregister ab dem Register firstreg
  in Colortable ein.
  Format: r1,g1,b1,r2,g2,b2...			 }

procedure GrayScale(FirstReg,anz:word);
{ Wandelt anz Register ab FirstReg in Grauwerte um }

{=== Zeichensatzfunktionen === }
{Die Zeichensätze müssen so gespeichert sein, daß
 die Zeichen unmittelbar aufeinander folgen.
 Beispiel:array[1..anz,1..size]of byte		  }

{--Textmodus---}
{EGA:Block<4;VGA:Block<8
 Size<=32
 anz u. size werden ab 1 gezählt.}

procedure SetUserFont(firstchar,anz:word;size,block:byte;
		      KeepCharacterSize:boolean;var CharacterSet);
{ Installiert ein User-Zeichensatz, der mit dem
  firstchar-tem Zeichen beginnt, anz Zeichen
  enthält und size Rasterzeilen hoch ist, im
  Block block. Ist KeepCharacterSize=true, so
  wird die Zeichenhöhe des alten Zeichensatzes
  nicht auf die der neuen Zeichen gesetzt.	}

procedure SetRomFont(Block,nr:byte;KeepCharacterSize:boolean);
{ Installiert einen ROM-Zeichensatz in
  Block Block. nr gibt den Zeichensatz
  an: 0:8*14 1:8*8 2:8*16(nur VGA)		}

procedure SetCharacterBlock(a,b:byte);
{ Setzt die Zeichensatzblöcke, die auf dem
  Bildschirm verwendet werden. Für die Zeichen
  in den Farben $?0..$?7 wird Block a verwendet,
  für die anderen Block b.			 }

{---Grafikmodus---}
{rows wird ab 1 Gezählt.}

procedure SetUserGraphFont(size:word;rows:byte;var CharacterSet);
{ Installiert einen User-Grafik-Zeichensatz.
  Size gibt die Zeichenhöhe an, rows die Anzahl
  der darstellbaren Textzeilen. }

procedure SetROMGraphFont(nr,rows:byte);
{ Installiert einen ROM-Grafik-Zeichensatz.
  Siehe SetRomFont und SetUserGraphFont     }

{=== VGA:Status sichern/wiederherstellen ===}

function GetBufferSize(ToSave:word):longint;
{ Ermittelt die zum Speichern des Statuses
  notwendige Puffergröße		   }

procedure SaveStatus(ToSave:Word;var buffer);
{ Speichert den Status der Grafikkarte }

procedure RestoreStatus(ToSave:Word;var buffer);
{ Stellt einen gespeicherten Status wieder her }

{=== Sonstige Funktionen ===}

function IsEGAVGA:boolean;
{ True:EGA oder VGA-Karte installiert }

function IsVGA:boolean;
{ True:VGA ist installiert }

procedure SetTextRes(code:byte);
{V}
{ Stellt die Textmodusauflösung ein:
  0=200,8*8 1=350,8*14 2=400,8*16    }

procedure ResetPalColorsOnReset(b:boolean);
{ False unterdrückt das Zurücksetzen der Paletten-
  u. Farbregister bei folgenden Moduswechseln	   }

procedure VGACPUAccess(x:boolean);
{ Erlaubt/Unterbindet CPU-Zugriffe auf die Karte:
  TRUE:Zugriff erlaubt; False:Zugriffe unterdrücken }

procedure GrayscaleOnReset(b:boolean);
{ TRUE:bei folgenden Moduswechseln werden die
  Farbwerte in Graustufen umgewandelt	      }

procedure CGACursorEmulation(on:boolean);
{ TRUE:Cursorgröße wird bei SetCursorSize von
  8 Rasterzeilen Höhe auf die aktuelle Zeichenhöhe
  umgerechnet.
  FALSE:Cursorgröße wird bei SetCursorSize übernommen }

procedure VideoRefresh(on:boolean);
{ Schaltet die Bilddarstellung an/ab.
  Bei abgeschalteter Darstellung kann
  schneller gezeichnet werden.	      }

procedure ReadStatusInfo(var buffer);
{ Liest den Grafikkartenstatus ein buffer
  ist ein Record vom Typ Statusrec.	  }

implementation
{$ifndef unix}
{$l vbios.obj}

procedure SetVideoMode(Mode:Word);external;
procedure SetCursorSize(Oben,Unten:Byte);external;
procedure SetCursorXY(x,y:byte;page:Word);external;
procedure SetVideoPage(Page:Word);external;
procedure ScrollUpDown(x1,y1,x2,y2,rows:byte;NewColor:word;up:boolean);external;
function ReadCA(page:word):word;external;
procedure WriteCA(c:char;attr:byte;Page:byte;Count:Word);external;
procedure WriteC(c:char;page:word;count:word);external;
Procedure SetCGAPalette(color:byte);external;
Procedure SetCGAColor(color:byte);external;
Procedure SetPixel(x,y,color,page:word);external;
function GetPixel(x,y:word;page:byte):byte;external;
procedure Print(c:char;attr:byte);external;
procedure WriteSA(x,y,page,color:byte;anz:word;
		  movecursor,attributed:boolean;var s);external;
procedure SetPalReg(nr,wert:byte);external;
procedure SetOverscanReg(wert:byte);external;
procedure SetAllPal(var Pal:PalTable);external;
procedure SetFlashing(on:boolean);external;
Function GetPalReg(nr:byte):byte;external;
Function GetOverscanReg:byte;external;
procedure GetAllPal(var Palette:PalTable);external;
procedure SetPageMode(mode:byte);external;
function GetPageMode:byte;external;
procedure SetColorPage(page:byte);external;
function GetColorPage:byte;external;
procedure SetColorReg(nr:word;r,g,b:byte);external;
procedure ReadColorReg(nr:word;var color);external;
procedure ReadColorBlock(firstreg,anz:word;var Colortable);external;
procedure GrayScale(FirstReg,anz:word);external;
procedure SetUserFont(firstchar,anz:word;size,block:byte;
		      KeepCharacterSize:boolean;var CharacterSet);external;
procedure SetRomFont(Block,nr:byte;KeepCharacterSize:boolean);external;
procedure SetCharacterBlock(a,b:byte);external;
procedure SetUserGraphFont(size:word;rows:byte;var CharacterSet);external;
procedure SetROMGraphFont(nr,rows:byte);external;
function GetBufferSize(ToSave:word):longint;external;
procedure SaveStatus(ToSave:Word;var buffer);external;
procedure RestoreStatus(ToSave:Word;var buffer);external;
function IsEGAVGA:boolean;external;
function IsVGA:boolean;external;
procedure SetTextRes(code:byte);external;
procedure ResetPalColorsOnReset(b:boolean);external;
procedure VGACPUAccess(x:boolean);external;
procedure GrayscaleOnReset(b:boolean);external;
procedure CGACursorEmulation(on:boolean);external;
procedure VideoRefresh(on:boolean);external;
procedure ReadStatusInfo(var buffer);external;
{$else}
procedure nimp;
begin
	writeln('not implemented');
	halt;
end;

procedure SetCursorXY(x,y:byte;page:Word);
begin
	cursorpos[page].x:=x;
	cursorpos[page].y:=y;
end;

procedure SetVideoMode(Mode:Word);begin nimp; end;
procedure SetCursorSize(Oben,Unten:Byte);
begin
	if (StatusBits and $10<>0)and(videomode<7) then begin
		if oben>3 then oben:=CharSize-3+oben;
		if unten>3 then unten:=CharSize-3+unten;
	end;
	CursorStart:=oben;	
	CursorEnd:=unten;
end;

procedure SetVideoPage(Page:Word);begin nimp; end;
procedure ScrollUpDown(x1,y1,x2,y2,rows:byte;NewColor:word;up:boolean);begin nimp; end;
function ReadCA(page:word):word;begin nimp; end;
procedure WriteCA(c:char;attr:byte;Page:byte;Count:Word);begin nimp; end;
procedure WriteC(c:char;page:word;count:word);begin nimp; end;
Procedure SetCGAPalette(color:byte);begin nimp; end;
Procedure SetCGAColor(color:byte);begin nimp; end;
Procedure SetPixel(x,y,color,page:word);begin nimp; end;
function GetPixel(x,y:word;page:byte):byte;begin nimp; end;
procedure Print(c:char;attr:byte);begin nimp; end;
procedure WriteSA(x,y,page,color:byte;anz:word;
		  movecursor,attributed:boolean;var s);begin nimp; end;
procedure SetPalReg(nr,wert:byte);begin nimp; end;
procedure SetOverscanReg(wert:byte);begin nimp; end;
procedure SetAllPal(var Pal:PalTable);begin nimp; end;
procedure SetFlashing(on:boolean);begin nimp; end;
Function GetPalReg(nr:byte):byte;begin nimp; end;
Function GetOverscanReg:byte;begin nimp; end;
procedure GetAllPal(var Palette:PalTable);begin nimp; end;
procedure SetPageMode(mode:byte);begin nimp; end;
function GetPageMode:byte;begin nimp; end;
procedure SetColorPage(page:byte);begin nimp; end;
function GetColorPage:byte;begin nimp; end;
procedure SetColorReg(nr:word;r,g,b:byte);begin nimp; end;
procedure ReadColorReg(nr:word;var color);begin nimp; end;
procedure SetColorBlock(firstreg,anz:word;var Colortable);begin nimp; end;
procedure ReadColorBlock(firstreg,anz:word;var Colortable);begin nimp; end;
procedure GrayScale(FirstReg,anz:word);begin nimp; end;
procedure SetUserFont(firstchar,anz:word;size,block:byte;
		      KeepCharacterSize:boolean;var CharacterSet);begin nimp; end;
procedure SetRomFont(Block,nr:byte;KeepCharacterSize:boolean);begin nimp; end;
procedure SetCharacterBlock(a,b:byte);begin nimp; end;
procedure SetUserGraphFont(size:word;rows:byte;var CharacterSet);begin nimp; end;
procedure SetROMGraphFont(nr,rows:byte);begin nimp; end;
function GetBufferSize(ToSave:word):longint;begin nimp; end;
procedure SaveStatus(ToSave:Word;var buffer);begin nimp; end;
procedure RestoreStatus(ToSave:Word;var buffer);begin nimp; end;
function IsEGAVGA:boolean;begin IsEGAVGA:=true; end;
function IsVGA:boolean;begin IsVGA:=true; end;
procedure SetTextRes(code:byte);begin nimp; end;
procedure ResetPalColorsOnReset(b:boolean);begin nimp; end;
procedure VGACPUAccess(x:boolean);begin nimp; end;
procedure GrayscaleOnReset(b:boolean);begin nimp; end;
procedure CGACursorEmulation(on:boolean);begin nimp; end;
procedure VideoRefresh(on:boolean);begin nimp; end;
procedure ReadStatusInfo(var buffer);begin nimp; end;
{$endif}
begin

end.