en:docs:tpro

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision		Previous revision
en:docs:tpro [2025/02/08 04:48] – prokusheven:docs:tpro [2025/02/08 13:36] (current) – prokushev
Line 19: Line 19:
 ===== WhereYAbs ===== ===== WhereYAbs =====
  
-<code>function WhereYAbs: Byte;</code>+<code pascal>function WhereYAbs: Byte;</code>
  
 Return absolute row coordinate of cursor Return absolute row coordinate of cursor
  
-function WhereXY: Word; +===== WhereXY =====
-  {-Return absolute coordinates of cursor}+
  
-function ScreenX: Byte; +<code pascal>function WhereXY: Word;</code>
-  {-Return absolute column coordinate of cursor}+
  
-function ScreenY: Byte; +Return absolute coordinates of cursor
-  {-Return absolute row coordinate of cursor}+
  
-procedure FastWrite(St : string; Row, Col, Attr : Byte); +===== ScreenX =====
-  {-Write St at Row,Col in Attr (video attribute) without snow}+
  
-procedure SetFrameChars(Vertical, Horizontal, LowerRight, UpperRight, +<code pascal>function ScreenX: Byte;</code>
-                        LowerLeft, UpperLeft : Char); +
-  {-Sets the frame characters to be used on subsequent FrameWindow calls.}+
  
-procedure WhereXYdirect(var X, Y : Byte); +Return absolute column coordinate of cursor
-  {-Read the current position of the cursor directly from the CRT controller}+
  
-function GetCrtMode : Byte; +===== ScreenY =====
- {-Get the current video mode. Also reinitializes internal variables. May +
-   reset: CurrentMode, ScreenWidth, ScreenHeight, CurrentPage, and +
-   VideoSegment.}+
  
-procedure GotoXYAbs(X, Y : Byte); +<code pascal>function ScreenY: Byte;</code>
-  {-Move cursor to column X, row Y. No error checking done.}+
  
-procedure SetVisiblePage(PageNum : Byte); +Return absolute row coordinate of cursor 
-  {-Set current video page}+ 
 +===== FastWrite ===== 
 + 
 +<code pascal>procedure FastWrite(St : string; Row, Col, Attr : Byte);</code> 
 + 
 +Write St at Row,Col in Attr (video attribute) without snow 
 + 
 +===== SetFrameChars ===== 
 + 
 +<code pascal>procedure SetFrameChars(Vertical, Horizontal, LowerRight, UpperRight, LowerLeft, UpperLeft : Char);</code> 
 + 
 +Sets the frame characters to be used on subsequent FrameWindow calls. 
 + 
 +===== WhereXYdirect ===== 
 + 
 +<code pascal>procedure WhereXYdirect(var X, Y : Byte);</code> 
 + 
 +Read the current position of the cursor directly from the CRT controller 
 + 
 +===== GetCrtMode ===== 
 + 
 +<code pascal>function GetCrtMode : Byte;</code> 
 + 
 +Get the current video mode. Also reinitializes internal variables. May reset: CurrentMode, ScreenWidth, ScreenHeight, CurrentPage, and VideoSegment. 
 + 
 +===== GotoXYAbs ===== 
 + 
 +<code pascal>procedure GotoXYAbs(X, Y : Byte);</code> 
 + 
 +Move cursor to column X, row Y. No error checking done. 
 + 
 +===== SetVisiblePage ===== 
 + 
 +<code pascal>procedure SetVisiblePage(PageNum : Byte);</code> 
 + 
 +Set current video page 
 + 
 +===== ScrollWindowUp ===== 
 + 
 +<code pascal>procedure ScrollWindowUp(XLo, YLo, XHi, YHi, Lines : Byte);</code> 
 + 
 +Scrolls the designated window up the specified number of lines. 
 + 
 +===== ScrollWindowDown ===== 
 + 
 +<code pascal>procedure ScrollWindowDown(XLo, YLo, XHi, YHi, Lines : Byte);</code> 
 + 
 +Scrolls the designated window down the specified number of lines. 
 + 
 +===== CursorTypeSL ===== 
 + 
 +<code pascal>function CursorTypeSL : Word;</code> 
 + 
 +Returns a word. High byte has starting scan line, low byte has ending. 
 + 
 +===== CursorStartLine ===== 
 +  
 +<code pascal>function CursorStartLine : Byte;</code> 
 + 
 +Returns the starting scan line of the cursor 
 + 
 +===== CursorEndLine ===== 
 + 
 +<code pascal>function CursorEndLine : Byte;</code> 
 + 
 +Returns the ending scan line of the cursor. 
 + 
 +===== SetCursorSize ===== 
 + 
 +<code pascal>procedure SetCursorSize(Startline, EndLine : Byte);</code> 
 + 
 +Sets the cursor's starting and ending scan lines. 
 + 
 +===== NormalCursor ===== 
 + 
 +<code pascal>procedure NormalCursor;</code> 
 + 
 +Set normal scan lines for cursor based on current video mode 
 + 
 +===== FatCursor ===== 
 + 
 +<code pascal>procedure FatCursor;</code> 
 + 
 +Set larger scan lines for cursor based on current video mode 
 + 
 +===== BlockCursor ===== 
 + 
 +<code pascal>procedure BlockCursor;</code> 
 + 
 +Set scan lines for a block cursor 
 + 
 +===== HiddenCursor ===== 
 + 
 +<code pascal>procedure HiddenCursor;</code> 
 + 
 +Hide the cursor 
 + 
 +===== ReadCharAtCursor ===== 
 + 
 +<code pascal>function ReadCharAtCursor: Char;</code> 
 + 
 +Returns character at the current cursor location on the selected page. 
 + 
 +===== ReadAttrAtCursor ===== 
 + 
 +<code pascal>function ReadAttrAtCursor: Byte;</code> 
 + 
 +Returns attribute at the current cursor location on the selected page. 
 + 
 +===== GetCursorState ===== 
 + 
 +<code pascal>procedure GetCursorState(var XY, ScanLines: Word);</code> 
 + 
 +Return the current position and size of the cursor 
 + 
 +===== RestoreCursorState ===== 
 + 
 +<code pascal>procedure RestoreCursorState(XY, ScanLines: Word);</code> 
 + 
 +Reset the cursor to a position and size saved with GetCursorState 
 + 
 +===== FastWriteWindow ===== 
 + 
 +<code pascal>procedure FastWriteWindow(St: string; Row, Col, Attr: Byte);</code> 
 + 
 +Write a string using window-relative coordinates 
 + 
 +===== FastText ===== 
 + 
 +<code pascal>procedure FastText(St: string; Row, Col: Byte);</code> 
 + 
 +Write St at Row,Col without changing the underlying video attribute. 
 + 
 +===== FastTextWindow ===== 
 + 
 +<code pascal>procedure FastTextWindow(St: string; Row, Col: Byte);</code> 
 + 
 +Write St at window Row,Col without changing the underlying video attribute. 
 + 
 +===== FastVert ===== 
 + 
 +<code pascal>procedure FastVert(St: string; Row, Col, Attr: Byte);</code> 
 + 
 +Write St vertically at Row,Col in Attr (video attribute) 
 + 
 +===== FastVertWindow ===== 
 + 
 +<code pascal>procedure FastVertWindow(St: string; Row, Col, Attr: Byte);</code> 
 + 
 +Write a string vertically using window-relative coordinates 
 + 
 +===== FastFill ===== 
 + 
 +<code pascal>procedure FastFill(Number: Word; Ch: Char; Row, Col, Attr: Byte);</code> 
 + 
 +Fill Number chs at Row,Col in Attr (video attribute) without snow 
 + 
 +===== FastFillWindow ===== 
 + 
 +<code pascal>procedure FastFillWindow(Number: Word; Ch: Char; Row, Col, Attr: Byte);</code> 
 + 
 +Fill Number chs at window Row,Col in Attr (video attribute) without snow 
 + 
 +===== FastCenter ===== 
 + 
 +<code pascal>procedure FastCenter(St: string; Row, Attr: Byte);</code> 
 + 
 +Write St centered on window Row in Attr (video attribute) without snow 
 + 
 +===== FastFlush ===== 
 + 
 +<code pascal>procedure FastFlush(St: string; Row, Attr: Byte);</code> 
 + 
 +Write St flush right on window Row in Attr (video attribute) without snow 
 + 
 +===== FastRead ===== 
 + 
 +<code pascal>procedure FastRead(Number, Row, Col: Byte; var St: string);</code> 
 + 
 +Read Number characters from the screen into St starting at Row,Col 
 + 
 +===== FastReadWindow ===== 
 + 
 +<code pascal>procedure FastReadWindow(Number, Row, Col: Byte; var St: string);</code> 
 + 
 +Read Number characters from the screen into St starting at window Row,Col 
 + 
 +===== ReadAttribute ===== 
 +<code pascal>procedure ReadAttribute(Number, Row, Col: Byte; var St: string);</code> 
 + 
 +Read Number attributes from the screen into St starting at Row,Col 
 + 
 +===== ReadAttributeWindow ===== 
 + 
 +<code pascal>procedure ReadAttributeWindow(Number, Row, Col: Byte; var St: string);</code> 
 + 
 +Read Number attributes from the screen into St starting at window Row,Col 
 + 
 +===== WriteAttribute ===== 
 + 
 +<code pascal>procedure WriteAttribute(St: String; Row, Col: Byte);</code> 
 + 
 +Write string of attributes St at Row,Col without changing characters 
 + 
 +===== WriteAttributeWindow ===== 
 + 
 +<code pascal>procedure WriteAttributeWindow(St: String; Row, Col: Byte);</code> 
 + 
 +Write string of attributes St at window Row,Col without changing characters 
 + 
 +===== ChangeAttribute ===== 
 + 
 +<code pascal>procedure ChangeAttribute(Number: Word; Row, Col, Attr: Byte);</code> 
 + 
 +Change Number video attributes to Attr starting at Row,Col 
 + 
 +===== ChangeAttributeWindow ===== 
 + 
 +<code pascal>procedure ChangeAttributeWindow(Number: Word; Row, Col, Attr: Byte);</code> 
 + 
 +Change Number video attributes to Attr starting at window Row,Col 
 + 
 +===== MoveScreen ===== 
 + 
 +<code pascal>procedure MoveScreen(var Source, Dest; Length : Word);</code> 
 + 
 +Move Length words from Source to Dest without snow 
 + 
 +===== FlexWrite ===== 
 + 
 +<code pascal>procedure FlexWrite(St : string; Row, Col : Byte; var FAttrs : FlexAttrs);</code> 
 + 
 +Write St at Row,Col with flexible color handling 
 + 
 +===== FlexWriteWindow ===== 
 + 
 +<code pascal>procedure FlexWriteWindow(St :string; Row, Col: Byte; var FAttrs: FlexAttrs);</code> 
 + 
 +Write a string flexibly using window-relative coordinates. 
 + 
 +===== SaveWindow ===== 
 + 
 +<code pascal>function SaveWindow(XLow, YLow, XHigh, YHigh : Byte; Allocate : Boolean; var Covers : Pointer) : Boolean;</code> 
 + 
 +Allocate buffer space if requested and save window contents 
 + 
 +===== RestoreWindow ===== 
 + 
 +<code pascal>procedure RestoreWindow(XLow, YLow, XHigh, YHigh : Byte; Deallocate : Boolean; var Covers : Pointer);</code> 
 + 
 +Restore screen contents and deallocate buffer space if requested 
 + 
 +===== StoreWindowCoordinates ===== 
 + 
 +<code pascal>procedure StoreWindowCoordinates(var WC : WindowCoordinates);</code> 
 + 
 +Store the window coordinates for the active window 
 + 
 +===== RestoreWindowCoordinates ===== 
 + 
 +<code pascal>procedure RestoreWindowCoordinates(WC : WindowCoordinates);</code> 
 + 
 +Restore previously saved window coordinates 
 + 
 +===== PackWindow ===== 
 + 
 +<code pascal>function PackWindow(XLow, YLow, XHigh, YHigh : Byte) : PackedWindowPtr;</code> 
 + 
 +Return a pointer to a packed window, or nil if not enough memory 
 + 
 +===== DispPackedWindow ===== 
 + 
 +<code pascal>procedure DispPackedWindow(PWP : PackedWindowPtr);</code> 
 + 
 +Display the packed window pointed to by PWP 
 + 
 +===== DispPackedWindowAt ===== 
 + 
 +<code pascal>procedure DispPackedWindowAt(PWP : PackedWindowPtr; Row, Col : Byte);</code> 
 + 
 +Display the packed window pointed to by PWP at Row,Col. If necessary, the coordinates are adjusted to allow it to fit on the screen. 
 + 
 +===== MapPackedWindowColors ===== 
 + 
 +<code pascal>procedure MapPackedWindowColors(PWP : PackedWindowPtr);</code> 
 + 
 +Map the colors in a packed window for improved appearance on mono/B&W displays 
 + 
 +===== DisposePackedWindow ===== 
 + 
 +<code pascal>procedure DisposePackedWindow(var PWP : PackedWindowPtr);</code> 
 + 
 +Dispose of a packed window, setting PWP to nil on exit 
 + 
 +===== WritePackedWindow ===== 
 + 
 +<code pascal>procedure WritePackedWindow(PWP : PackedWindowPtr; FName : string);</code> 
 + 
 +Store the packed window pointed to by PWP in FName 
 + 
 +===== ReadPackedWindow ===== 
 + 
 +<code pascal>function ReadPackedWindow(FName : string) : PackedWindowPtr;</code> 
 + 
 +Read the packed window stored in FName into memory 
 + 
 +===== CreateLibrary ===== 
 + 
 +<code pascal>function CreateLibrary(var F : file; Name : string; Entries : Byte) : DirectoryPtr;</code> 
 + 
 +Create a library with the specified # of directory entries 
 + 
 +===== OpenLibrary ===== 
 + 
 +<code pascal>function OpenLibrary(var F : file; Name : string) : DirectoryPtr;</code> 
 + 
 +Open the specified library and return a pointer to its directory 
 + 
 +===== CloseLibrary ===== 
 + 
 +<code pascal>procedure CloseLibrary(var F : file; var DP : DirectoryPtr);</code> 
 + 
 +Close library F and deallocate its directory 
 + 
 +===== PackLibrary ===== 
 + 
 +<code pascal>procedure PackLibrary(LName : string);</code> 
 + 
 +Pack a library to remove deleted entries. 
 + 
 +===== AddWindowToLibrary ===== 
 + 
 +<code pascal>procedure AddWindowToLibrary(PWP : PackedWindowPtr; var F : file; DP : DirectoryPtr; WinName : LibName);</code> 
 + 
 +Add a packed window to the specified library 
 + 
 +===== ReadWindowFromLibrary ===== 
 + 
 +<code pascal>function ReadWindowFromLibrary(var F : file; DP : DirectoryPtr; WinName : LibName) : PackedWindowPtr;</code> 
 + 
 +Read a packed window from a library 
 + 
 +===== DeleteWindowFromLibrary ===== 
 + 
 +<code pascal>procedure DeleteWindowFromLibrary(var F : file; DP : DirectoryPtr; WinName : LibName);</code> 
 + 
 +Delete a packed window from the specified library 
 + 
 +===== MapColor ===== 
 + 
 +<code pascal>function MapColor(c : Byte) : Byte;</code> 
 + 
 +Map a video attribute for visibility on mono/bw displays 
 + 
 +===== SetBlink ===== 
 + 
 +<code pascal>procedure SetBlink(Status : Boolean);</code> 
 + 
 +Enable text mode attribute blinking if On is True 
 + 
 +===== SetCrtBorder ===== 
 + 
 +<code pascal>procedure SetCrtBorder(Attr : Byte);</code> 
 + 
 +Set border to background color if card type and mode allow 
 + 
 +===== Font8x8Selected ===== 
 + 
 +<code pascal>function Font8x8Selected : Boolean;</code> 
 + 
 +Return True if EGA or VGA is active and in 8x8 font 
 + 
 +===== SelectFont8x8 ===== 
 + 
 +<code pascal>procedure SelectFont8x8(Status : Boolean);</code> 
 + 
 +Toggle 8x8 font on or off 
 + 
 +===== HercPresent ===== 
 + 
 +<code oascal>function HercPresent : Boolean;</code> 
 + 
 +Return true if a Hercules graphics card is present 
 + 
 +===== SwitchInColorCard ===== 
 + 
 +<code pascal>procedure SwitchInColorCard(ColorOn : Boolean);</code> 
 + 
 +Activate or deactivate colors on a Hercules InColor card 
 + 
 +===== HercGraphicsMode ===== 
 + 
 +<code pascal>function HercGraphicsMode : Boolean;</code> 
 + 
 +Return True if a Hercules card is in graphics mode 
 + 
 +===== HercModeTestWorks ===== 
 + 
 +<code pascal>function HercModeTestWorks : Boolean;</code> 
 + 
 +Return True if HercGraphicsMode will work 
 + 
 +===== SetHercMode =====
  
-procedure ScrollWindowUp(XLo, YLo, XHi, YHi, Lines : Byte); +<code pascal>procedure SetHercMode(GraphMode : Boolean; GraphPage : Byte);</code>
-  {-Scrolls the designated window up the specified number of lines.}+
  
-procedure ScrollWindowDown(XLo, YLo, XHi, YHi, Lines : Byte); +Set Hercules card to graphics mode or text mode, and activate specified graphics page (if switching to graphics mode).
-  {-Scrolls the designated window down the specified number of lines.}+
  
-function CursorTypeSL : Word; +===== ReadKeyWord =====
-  {-Returns a word. High byte has starting scan line, low byte has ending.}+
  
-function CursorStartLine : Byte; +<code pascal>function ReadKeyWord : Word;</code>
-  {-Returns the starting scan line of the cursor}+
  
-function CursorEndLine : Byte; +Waits for keypress, then returns scan and character codes together
-  {-Returns the ending scan line of the cursor.}+
  
-procedure SetCursorSize(Startline, EndLine : Byte); +===== CheckKbd =====
-  {-Sets the cursor's starting and ending scan lines.}+
  
-procedure NormalCursor; +<code pascal>function CheckKbd(var KeyCode : Word) : Boolean;</code>
-  {-Set normal scan lines for cursor based on current video mode}+
  
-procedure FatCursor; +Returns True (and the key codes) if a keystroke is waiting
-  {-Set larger scan lines for cursor based on current video mode}+
  
-procedure BlockCursor; +===== KbdFlags =====
-  {-Set scan lines for a block cursor}+
  
-procedure HiddenCursor; +<code pascal>function KbdFlags : Byte;</code>
-  {-Hide the cursor}+
  
-function ReadCharAtCursor : Char; +Returns keyboard status flags as a bit-coded byte
-  {-Returns character at the current cursor location on the selected page.}+
  
-function ReadAttrAtCursor : Byte; +===== StuffKey =====
-  {-Returns attribute at the current cursor location on the selected page.}+
  
-procedure GetCursorState(var XY, ScanLines : Word); +<code pascal>procedure StuffKey(W : Word);</code>
-  {-Return the current position and size of the cursor}+
  
-procedure RestoreCursorState(XY, ScanLines : Word); +Stuff one key into the keyboard buffer
-  {-Reset the cursor to a position and size saved with GetCursorState}+
  
-procedure FastWriteWindow(St : string; Row, Col, Attr : Byte); +===== StuffString =====
-  {-Write a string using window-relative coordinates}+
  
-procedure FastText(St : string; Row, Col : Byte); +<code pascal>procedure StuffString(S : string);</code>
-  {-Write St at Row,Col without changing the underlying video attribute.}+
  
-procedure FastTextWindow(St : string; Row, Col : Byte); +Stuff the contents of S into the keyboard buffer
-  {-Write St at window Row,Col without changing the underlying video attribute.}+
  
-procedure FastVert(St : string; Row, Col, Attr : Byte); +===== ReInitCrt =====
-  {-Write St vertically at Row,Col in Attr (video attribute)}+
  
-procedure FastVertWindow(St : string; Row, Col, Attr : Byte); +<code pascal>procedure ReInitCrt;</code>
-  {-Write a string vertically using window-relative coordinates}+
  
-procedure FastFill(Number : Word; Ch : Char; Row, Col, Attr : Byte); +Reinitialize CRT unit's internal variables. For TSR's or programs with DOS shells. May reset: CurrentMode, ScreenWidth, ScreenHeight, WindMin/WindMax, CurrentPage, CurrentDisplay, CheckSnow, and VideoSegment
-  {-Fill Number chs at Row,Col in Attr (video attribute) without snow}+
  
-procedure FastFillWindow(Number : Word; Ch : Char; Row, Col, Attr : Byte); +===== SetSafeCPSwitching =====
-  {-Fill Number chs at window Row,Col in Attr (video attribute) without snow}+
  
-procedure FastCenter(St : string; Row, Attr : Byte); +<code psacal>procedure SetSafeCPSwitching(F: Boolean);</code>
-  {-Write St centered on window Row in Attr (video attribute) without snow}+
  
-procedure FastFlush(St : string; Row, Attr : Byte); +===== SetUseACP =====
-  {-Write St flush right on window Row in Attr (video attribute) without snow}+
  
-procedure FastRead(Number, Row, Col : Byte; var St : string); +<code pascal>procedure SetUseACP(F: Boolean);</code>
-  {-Read Number characters from the screen into St starting at Row,Col}+
  
-procedure FastReadWindow(Number, Row, Col : Byte; var St : string); 
-  {-Read Number characters from the screen into St starting at window Row,Col} 
  
-procedure ReadAttribute(Number, Row, Col : Byte; var St : string); +===== AssignConToCrt =====
-  {-Read Number attributes from the screen into St starting at Row,Col}+
  
-procedure ReadAttributeWindow(Number, Row, Col : Byte; var St : string); +<code pascal>procedure AssignConToCrt;</code>
-  {-Read Number attributes from the screen into St starting at window Row,Col}+
  
-procedure WriteAttribute(St : String; Row, Col : Byte); +===== ClrScr =====
-  {-Write string of attributes St at Row,Col without changing characters}+
  
-procedure WriteAttributeWindow(St : String; Row, Col : Byte); +<code psacal>procedure ClrScr;</code>
-  {-Write string of attributes St at window Row,Col without changing characters}+
  
-procedure ChangeAttribute(Number : Word; Row, Col, Attr : Byte); +Clears the screen and returns the cursor to the upper-left corner
-  {-Change Number video attributes to Attr starting at Row,Col}+
  
-procedure ChangeAttributeWindow(Number : Word; Row, Col, Attr : Byte); +===== TextBackground =====
-  {-Change Number video attributes to Attr starting at window Row,Col}+
  
-procedure MoveScreen(var Source, Dest; Length : Word); +<code pascal>procedure TextBackground(Color: Byte);</code>
-  {-Move Length words from Source to Dest without snow}+
  
-procedure FlexWrite(St : string; Row, Col : Byte; var FAttrs : FlexAttrs); +Selects the background color
-  {-Write St at Row,Col with flexible color handling}+
  
-procedure FlexWriteWindow(St : string; Row, Col : Byte; var FAttrs : FlexAttrs); +===== TextColor =====
-  {-Write a string flexibly using window-relative coordinates.}+
  
-function SaveWindow(XLow, YLow, XHigh, YHigh : Byte; Allocate : Boolean; +<code pascal>procedure TextColor(Color: Byte);</code>
-                    var Covers : Pointer) : Boolean; +
-  {-Allocate buffer space if requested and save window contents}+
  
-procedure RestoreWindow(XLow, YLow, XHigh, YHigh : Byte; +Selects the foreground character color
-                        Deallocate : Boolean; var Covers : Pointer); +
-  {-Restore screen contents and deallocate buffer space if requested}+
  
-procedure StoreWindowCoordinates(var WC : WindowCoordinates); +===== Window =====
-  {-Store the window coordinates for the active window}+
  
-procedure RestoreWindowCoordinates(WC : WindowCoordinates); +<code pascal>procedure Window(X1,Y1,X2,Y2: Byte);</code>
-  {-Restore previously saved window coordinates}+
  
-function PackWindow(XLow, YLow, XHigh, YHigh : Byte) : PackedWindowPtr; +Defines a text window on the screen
-  {-Return a pointer to a packed window, or nil if not enough memory}+
  
-procedure DispPackedWindow(PWP : PackedWindowPtr); +===== GotoXY =====
-  {-Display the packed window pointed to by PWP}+
  
-procedure DispPackedWindowAt(PWP : PackedWindowPtr; Row, Col : Byte); +<code pascal>procedure GotoXY(X,Y: Byte);</code>
-  {-Display the packed window pointed to by PWP at Row,Col. If necessary, +
-   the coordinates are adjusted to allow it to fit on the screen.}+
  
-procedure MapPackedWindowColors(PWP : PackedWindowPtr); +Moves the cursor to the given coordinates within the screen
-  {-Map the colors in a packed window for improved appearance on mono/B&W +
-   displays}+
  
-procedure DisposePackedWindow(var PWP : PackedWindowPtr); +===== WhereX =====
-  {-Dispose of a packed window, setting PWP to nil on exit}+
  
-procedure WritePackedWindow(PWP : PackedWindowPtr; FName : string); +<code pascal>function WhereX: Byte;</code>
-  {-Store the packed window pointed to by PWP in FName}+
  
-function ReadPackedWindow(FName : string) : PackedWindowPtr; +Returns the X coordinate of the current cursor location
-  {-Read the packed window stored in FName into memory}+
  
-function CreateLibrary(var F : file; Name : string; +===== WhereY =====
-                       Entries : Byte) : DirectoryPtr; +
-  {-Create a library with the specified # of directory entries}+
  
-function OpenLibrary(var F : file; Name : string) : DirectoryPtr; +<code pascal>function WhereY: Byte;</code>
-  {-Open the specified library and return a pointer to its directory}+
  
-procedure CloseLibrary(var F : file; var DP : DirectoryPtr); +Returns the Y coordinate of the current cursor location
-  {-Close library F and deallocate its directory}+
  
-procedure PackLibrary(LName : string); +===== ClrEol =====
-  {-Pack a library to remove deleted entries.}+
  
-procedure AddWindowToLibrary(PWP : PackedWindowPtr; var F : file; +<code pascal>procedure ClrEol;</code>
-                             DP : DirectoryPtr; WinName : LibName); +
-  {-Add a packed window to the specified library}+
  
-function ReadWindowFromLibrary(var F : file; DP : DirectoryPtr; +Clears all characters from the cursor position to the end of the line without moving the cursor.
-                               WinName : LibName) : PackedWindowPtr; +
-  {-Read a packed window from a library}+
  
-procedure DeleteWindowFromLibrary(var F : file; DP : DirectoryPtr; +===== KeyPressed =====
-                                  WinName : LibName); +
-  {-Delete a packed window from the specified library}+
  
-function MapColor(c : Byte) : Byte; +<code pascal>function KeyPressed: Boolean;</code>
-  {-Map a video attribute for visibility on mono/bw displays}+
  
-procedure SetBlink(Status : Boolean); +Determines if a key has been pressed on the keyboard and returns True if a key has been pressed
-  {-Enable text mode attribute blinking if On is True}+
  
-procedure SetCrtBorder(Attr : Byte); +===== ReadKey =====
-  {-Set border to background color if card type and mode allow}+
  
-function Font8x8Selected : Boolean; +<code pascal>function ReadKey: Char;</code>
-  {-Return True if EGA or VGA is active and in 8x8 font}+
  
-procedure SelectFont8x8(Status : Boolean); +Reads a character from the keyboard and returns a character or an extended scan code.
-  {-Toggle 8x8 font on or off}+
  
-function HercPresent : Boolean; +===== TextMode =====
-  {-Return true if a Hercules graphics card is present}+
  
-procedure SwitchInColorCard(ColorOn : Boolean); +<code pascal>procedure TextMode (Mode: word);</code>
-  {-Activate or deactivate colors on a Hercules InColor card}+
  
-function HercGraphicsMode : Boolean; +===== InsLine =====
-  {-Return True if a Hercules card is in graphics mode}+
  
-function HercModeTestWorks : Boolean; +<code pascal>procedure InsLine;</code>
-  {-Return True if HercGraphicsMode will work}+
  
-procedure SetHercMode(GraphMode : Boolean; GraphPage : Byte); +Inserts an empty line at the cursor position
-  {-Set Hercules card to graphics mode or text mode, and activate specified +
-   graphics page (if switching to graphics mode).}+
  
-function ReadKeyWord : Word; +===== DelLine =====
-  {-Waits for keypress, then returns scan and character codes together}+
  
-function CheckKbd(var KeyCode : Word) : Boolean; +<code pascal>procedure DelLine;</code>
-  {-Returns True (and the key codes) if a keystroke is waiting}+
  
-function KbdFlags : Byte; +Deletes the line containing the cursor
-  {-Returns keyboard status flags as a bit-coded byte}+
  
-procedure StuffKey(W : Word); +===== LowVideo =====
-  {-Stuff one key into the keyboard buffer}+
  
-procedure StuffString(S : string); +<code pascal>procedure LowVideo;</code>
-  {-Stuff the contents of S into the keyboard buffer}+
  
-procedure ReInitCrt; +Selects low intensity characters
-  {-Reinitialize CRT unit's internal variables. For TSR's or programs with +
-   DOS shells. May reset: CurrentMode, ScreenWidth, ScreenHeight, +
-   WindMin/WindMax, CurrentPage, CurrentDisplay, CheckSnow, and VideoSegment}+
  
-{$ifdef WIN32} +===== HighVideo =====
-procedure SetSafeCPSwitching(F: Boolean); +
-procedure SetUseACP(F: Boolean); +
-{$ENDIF}+
  
 +<code pascal>procedure HighVideo;</code>
  
-procedure AssignConToCrt;+Selects high-intensity characters
  
-procedure ClrScr; +===== NormVideo =====
-  {-Clears the screen and returns the cursor to the upper-left corner}+
  
-procedure TextBackground(Color: Byte); +<code pascal>procedure NormVideo;</code>
-  {-Selects the background color}+
  
-procedure TextColor(Color: Byte); +Selects normal intensity characters
-  {-Selects the foreground character color}+
  
-procedure Window(X1,Y1,X2,Y2: Byte); +===== Delay =====
-  {-Defines a text window on the screen}+
  
-procedure GotoXY(X,Y: Byte); +<code pascal>procedure Delay(MS: Word);</code>
-  {-Moves the cursor to the given coordinates within the screen}+
  
-function WhereX: Byte; +===== Sound =====
-  {-Returns the X coordinate of the current cursor location}+
  
-function WhereY: Byte; +<code pascal>procedure Sound(Hz: Word);</code>
-  {-Returns the Y coordinate of the current cursor location}+
  
-procedure ClrEol; +===== NoSound =====
-  {-Clears all characters from the cursor position to the end of the line } +
-  { without moving the cursor.                                            }+
  
-function KeyPressed: Boolean; +<code pascal>procedure NoSound;</code>
-  {-Determines if a key has been pressed on the keyboard and returns True } +
-  { if a key has been pressed                                             }+
  
-function ReadKey: Char; +===== AssignCrt =====
-  {-Reads a character from the keyboard and returns a character or an     } +
-  { extended scan code.                                                   }+
  
-procedure TextMode (Mode: word); +<code pascal>procedure AssignCrt(var F: Text);</code>
-procedure InsLine; +
-  {-Inserts an empty line at the cursor position}+
  
-procedure DelLine; +Associates a text file with CRT device.
-  {-Deletes the line containing the cursor}+
  
-procedure LowVideo; +===== PlaySound =====
-  {-Selects low intensity characters}+
  
-procedure HighVideo; +<code pascal>procedure PlaySound(Freq,Duration: Longint);</code>
-  {-Selects high-intensity characters}+
  
-procedure NormVideo; +Setups window coordinates 
-  {-Selects normal intensity characters}+
  
-procedure Delay(MS: Word); +===== GetLastMode =====
-procedure Sound(Hz: Word); +
-procedure NoSound; +
-procedure AssignCrt(var F: Text); +
-  {-Associates a text file with CRT device.}+
  
-procedure PlaySound(Freq,Duration: Longint); +<code pascal>procedure GetLastMode;</code>
-  {-Setups window coordinates }+
  
-procedure GetLastMode;