ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng)/ProfitPress-MegaCDROM2.B6I/PROG/PASCAL/OPROSM.ZIP/PROCFUNC.ASC

Text File | 1990-01-04 | 274.7 KB | 4,871 lines

Extracted from the Object Professional manual, 1/4/90.
Contents Copyright (c) 1989, by TurboPower Software. All rights reserved.

Procedure and Function Reference
==============================================================================
This section provides a complete list of all documented procedures, functions, and
methods in the entire Object Professional library. The entry for each routine is
of the following form:

(v) c-ppp     procedure ProcedureName(parameters);
                {-Brief description}
The first column shows the volume (v), chapter (c), and page (ppp) where the routine
is documented in the manual. The second column shows the name of the routine and the
parameters it takes, followed by a brief description of the routine. In a very few
cases, you will see an entry like this

(v) c-ppp     procedure ProcedureName(...);
                {-Brief description}
where the parameters are shown as '...'. This is done (to save space) in a few cases
where a routine has a lengthy parameter list that is identical to that of the
previous routine.

The individual entries are grouped according to unit and object name. For example,
the entries for OPCRT are arranged into two groups, one for regular procedures and
functions, and one for the methods for the ColorSet object. A dividing line precedes
each section, and just above the line is the name of the unit and, if the routines in
the group are methods, the name of the object they belong to.

The arrangement of the entries within each group is not alphabetical; rather, it is
based on the order in which the routines are declared in the source code for the
unit/object. This order was chosen because it usually results in a series of smaller
groups of related routines, making it easier to find a routine when you have a
general idea of what you're looking for (a unit and a category, such as cursor
manipulation), but you don't know if such a routine exists, or you know that it does
but can't remember the name. The header at the top of the page shows the name of the
unit in which the entries at the top of the page appear. The main purpose of the
header is to make it easier to find the entries for a particular unit.


OpCrt   Procedures and Functions
==============================================================================

(1) 3-27      function MakeHiddenAttr(A : Byte) : Byte;
                {-Make foreground and background colors the same}
(1) 3-23      function GetCrtMode : Byte;
                {-Get the current video mode. Also reinitializes internal
                  variables. May reset: CurrentMode, ScreenWidth, ScreenHeight,
                  CurrentPage, and VideoSegment.}
(1) 3-24      procedure GotoXYAbs(X, Y : Byte);
                {-Move cursor to column X, row Y. No error checking done.}
(1) 3-42      function WhereXY : Word;
                {-Return absolute row and column coordinates of cursor. High byte
                  has current row (Y), low byte has current column (X).}
(1) 3-43      function WhereYAbs : Byte;
                {-Return absolute row coordinate of cursor}
(1) 3-42      function WhereXAbs : Byte;
                {-Return absolute column coordinate of cursor}
(1) 3-43      procedure WhereXYdirect(var X, Y : Byte);
                {-Read the current position of the cursor directly from the CRT
                  controller}
(1) 3-39      procedure SetVisiblePage(PageNum : Byte);
                {-Set current video page}
(1) 3-36      procedure SetActivePage(PageNo : Byte);
                {-Selects the video page that will be written to with subsequent
                  operations on the screen. Does not affect Write/Ln or Read/Ln.}
(1) 3-24      function GetPageSegment(PageNo : Byte) : Word;
                {-Get the video segment corresponding to the specified video page}
(1) 3-24      function GetPagePointer(PageNo : Byte) : Pointer;
                {-Get a pointer to the start of the specified video page}
(1) 3-14      procedure ClearPage(PageNo : Byte);
                {-Clear the specified video page with TextChar and TextAttr}
(1) 3-34      procedure ScrollWindowUp(XLo, YLo, XHi, YHi, Lines : Byte);
                {-Scrolls the designated window up the specified number of lines.}
(1) 3-34      procedure ScrollWindowDown(XLo, YLo, XHi, YHi, Lines : Byte);
                {-Scrolls the designated window down the specified number of
                  lines.}
(1) 3-15      function CursorTypeSL : Word;
                {-Returns a word. High byte has starting scan line, low byte has
                  ending.}
(1) 3-15      function CursorStartLine : Byte;
                {-Returns the starting scan line of the cursor}
(1) 3-15      function CursorEndLine : Byte;
                {-Returns the ending scan line of the cursor.}
(1) 3-37      procedure SetCursorSize(Startline, EndLine : Byte);
                {-Sets the cursor's starting and ending scan lines.}
(1) 3-29      procedure NormalCursor;
                {-Set normal scan lines for cursor based on current video mode}
(1) 3-20      procedure FatCursor;
                {-Set larger scan lines for cursor based on current video mode}
(1) 3-12      procedure BlockCursor;
                {-Set scan lines for a block cursor}
(1) 3-26      procedure HiddenCursor;
                {-Hide the cursor}
(1) 3-38      procedure SetCursorType(CT : CursorType);
                {-Sets the cursor shape to the specified type}
(1) 3-13      function ClassifyCursorType : CursorType;
                {-Classify cursor type based on scan lines}
(1) 3-31      function ReadCharAtCursor : Char;
                {-Returns character at the current cursor location on the selected
                  page.}
(1) 3-30      function ReadAttrAtCursor : Byte;
                {-Returns attribute at the current cursor location on the selected
                  page.}
(1) 3-23      procedure GetCursorState(var XY, ScanLines : Word);
                {-Return the current position and size of the cursor}
(1) 3-32      procedure RestoreCursorState(XY, ScanLines : Word);
                {-Reset the cursor to a position and size saved with
                  GetCursorState}
(1) 3-19      procedure FastWrite(St : string; Row, Col : Word; Attr : Byte);
                {-Write St at Row,Col in Attr (video attribute) without snow}
(1) 3-18      procedure FastText(St : string; Row, Col : Word);
                {-Write St at Row,Col without changing the underlying video
                  attribute.}
(1) 3-18      procedure FastVert(St : string; Row, Col : Word; Attr : Byte);
                {-Write St vertically at Row,Col in Attr (video attribute)}
(1) 3-17      procedure FastFill(Number : Word; Ch : Char; Row, Col : Word;
                                 Attr : Byte);
                {-Fill Number chs at Row,Col in Attr (video attribute) without
                  snow}
(1) 3-16      procedure FastCenter(St : string; Row, Attr : Byte);
                {-Write St centered on window Row in Attr (video attribute)
                  without snow}
(1) 3-17      procedure FastFlush(St : string; Row, Attr : Byte);
                {-Write St flush right on window Row in Attr (video attribute)
                  without snow}
(1) 3-17      procedure FastRead(Number : Byte; Row, Col : Word; var St : string);
                {-Read Number characters from the screen into St starting at
                  Row, Col}
(1) 3-30      procedure ReadAttribute(Number : Byte; Row, Col : Word;
                                      var St : string);
                {-Read Number attributes from the screen into St starting at
                  Row, Col}
(1) 3-44      procedure WriteAttribute(St : String; Row, Col : Word);
                {-Write string of attributes St at Row,Col without changing
                  characters}
(1) 3-12      procedure ChangeAttribute(Number : Word; Row, Col : Word;
                                        Attr : Byte);
                {-Change Number video attributes to Attr starting at Row,Col}
(1) 3-29      procedure MoveScreen(var Source, Dest; Length : Word);
                {-Move Length words from Source to Dest without snow}
(1) 3-19      procedure FastWriteAttr(St : String; Row, Col : Word;
                                      AttrSt : String);
                {-Write St at Row,Col using attributes in AttrSt}
(1) 3-21      procedure FlexWrite(St : string; Row, Col : Word;
                                  var FAttrs : FlexAttrs);
                {-Write St at Row,Col with flexible color handling}
(1) 3-21      function FlexLen(S : string) : Byte;
                {-Return actual (visible) length of a flex string}
(1) 3-20      procedure FastWriteCtrl(St : String; Row, Col : Word;
                                      Attr, Ctrl : Byte);
                {-Write St at Row,Col in Attr (video attribute) without snow.
                  Control characters displayed in Ctrl as upper-case letters}
(1) 3-33      function SaveWindow(XLow, YLow, XHigh, YHigh : Byte;
                                  Allocate : Boolean;
                                  var Covers : Pointer) : Boolean;
                {-Allocate buffer space if requested and save window contents}
(1) 3-32      procedure RestoreWindow(XLow, YLow, XHigh, YHigh : Byte;
                                      Deallocate : Boolean; var Covers : Pointer);
                {-Restore screen contents and deallocate buffer space if
                  requested}
(1) 3-14      procedure ClearWindow(XLow, YLow, XHigh, YHigh : Word; Ch : Char;
                                    A : Byte);
                {-Clear a window using the specified character and attribute}
(1) 3-22      procedure FrameWindow(LeftCol, TopRow, RightCol, BotRow : Word;
                                    FAttr, HAttr : Byte; Header : string);
                {-Draws a frame around a window}
(1) 3-39      procedure StoreWindowCoordinates(var WC : WindowCoordinates);
                {-Store the window coordinates for the active window}
(1) 3-33      procedure RestoreWindowCoordinates(WC : WindowCoordinates);
                {-Restore previously saved window coordinates}
(1) 3-28      function MapColor(C : Byte) : Byte;
                {-Map a video attribute for visibility on mono/bw displays}
(1) 3-41      function UseColor : Boolean;
                {-Returns True if color video attributes should be used}
(1) 3-14      function ColorMono(Color, Mono : Byte) : Byte;
                {-Choose between a color and a monochrome video attribute}
(1) 3-28      function MapMono(Color, Mono : Byte) : Byte;
                {-Return a mapped color video attribute if Mono = $FF}
(1) 3-36      procedure SetBlink(On : Boolean);
                {-Enable text mode attribute blinking if On is True}
(1) 3-37      procedure SetCrtBorder(Attr : Byte);
                {-Set border to background color if card type and mode allow}
(1) 3-22      function Font8x8Selected : Boolean;
                {-Return True if EGA or VGA is active and in 8x8 font}
(1) 3-35      procedure SelectFont8x8(On : Boolean);
                {-Toggle 8x8 font on or off}
(1) 3-26      function HercPresent : Boolean;
                {-Return true if a Hercules graphics card is present}
(1) 3-41      procedure SwitchInColorCard(ColorOn : Boolean);
                {-Activate or deactivate colors on a Hercules InColor card}
(1) 3-25      function HercGraphicsMode : Boolean;
                {-Return True if a Hercules card is in graphics mode}
(1) 3-25      function HercModeTestWorks : Boolean;
                {-Return True if HercGraphicsMode will work}
(1) 3-38      procedure SetHercMode(GraphMode : Boolean; GraphPage : Byte);
                {-Set Hercules card to graphics mode or text mode, and activate
                  specified graphics page (if switching to graphics mode).}
(1) 3-31      function ReadKeyWord : Word;
                {-Waits for keypress, then returns scan and character codes
                  together}
(1) 3-13      function CheckKbd(var KeyCode : Word) : Boolean;
                {-Returns True (and the key codes) if a keystroke is waiting}
(1) 3-27      function KbdFlags : Byte;
                {-Returns keyboard status flags as a bit-coded byte}
(1) 3-16      function EnhancedKbdInstalled : Boolean;
                {-Returns True if an enhanced keyboard is installed}
(1) 3-40      procedure StuffKey(W : Word);
                {-Stuff one key into the keyboard buffer}
(1) 3-40      procedure StuffString(S : string);
                {-Stuff the contents of S into the keyboard buffer}
(1) 3-32      procedure ReInitCrt;
                {-Reinitialize CRT unit's internal variables}

OpCrt   ColorSet
==============================================================================

(1) 3-48      procedure SetTextAttr(Color, Mono : Byte);
                {-Set attributes for ordinary text}
(1) 3-48      procedure SetCtrlAttr(Color, Mono : Byte);
                {-Set attributes for control characters}
(1) 3-48      procedure SetFrameAttr(Color, Mono : Byte);
                {-Set attributes for window frames}
(1) 3-48      procedure SetHeaderAttr(Color, Mono : Byte);
                {-Set attributes for window headers}
(1) 3-48      procedure SetShadowAttr(Color, Mono : Byte);
                {-Set attributes for window shadows}
(1) 3-48      procedure SetHighlightAttr(Color, Mono : Byte);
                {-Set attributes used to highlight found text}
(1) 3-48      procedure SetPromptAttr(Color, Mono : Byte);
                {-Set attributes for entry field prompts}
(1) 3-48      procedure SetSelectedPromptAttr(Color, Mono : Byte);
                {-Set attributes for selected entry field prompts}
(1) 3-48      procedure SetProtectedPromptAttr(Color, Mono : Byte);
                {-Set attributes for protected entry field prompts}
(1) 3-48      procedure SetFieldAttr(Color, Mono : Byte);
                {-Set attributes for unselected entry fields}
(1) 3-48      procedure SetSelectedFieldAttr(Color, Mono : Byte);
                {-Set attributes for selected entry field fields}
(1) 3-48      procedure SetProtectedFieldAttr(Color, Mono : Byte);
                {-Set attributes for protected entry fields}
(1) 3-48      procedure SetScrollBarAttr(Color, Mono : Byte);
                {-Set attributes for scroll bars}
(1) 3-48      procedure SetSliderAttr(Color, Mono : Byte);
                {-Set attributes for sliders in scroll bars}
(1) 3-48      procedure SetHotSpotAttr(Color, Mono : Byte);
                {-Sets attributes for mouse hot spots}
(1) 3-48      procedure SetBlockAttr(Color, Mono : Byte);
                {-Set attributes for marked blocks}
(1) 3-48      procedure SetMarkerAttr(Color, Mono : Byte);
                {-Set attributes for text markers}
(1) 3-48      procedure SetDelimAttr(Color, Mono : Byte);
                {-Set attributes for unselected entry field delimiters}
(1) 3-48      procedure SetSelectedDelimAttr(Color, Mono : Byte);
                {-Set attributes for selected entry field delimiters}
(1) 3-48      procedure SetProtectedDelimAttr(Color, Mono : Byte);
                {-Set attributes for protected entry field delimiters}
(1) 3-48      procedure SetSelectedItemAttr(Color, Mono : Byte);
                {-Set attributes for selected pick and menu items}
(1) 3-48      procedure SetProtectedItemAttr(Color, Mono : Byte);
                {-Set attributes for protected pick and menu items}
(1) 3-48      procedure SetHighlightItemAttr(Color, Mono : Byte);
                {-Set attributes for highlighted selection characters for menu
                 items}
(1) 3-48      procedure SetFlexAHelpAttr(Color, Mono : Byte);
                {-Set attributes for help text surrounded by ^A}
(1) 3-48      procedure SetFlexBHelpAttr(Color, Mono : Byte);
                {-Set attributes for help text surrounded by ^B}
(1) 3-48      procedure SetFlexCHelpAttr(Color, Mono : Byte);
                {-Set attributes for help text surrounded by ^C}
(1) 3-48      procedure SetUnselXrefAttr(Color, Mono : Byte);
                {-Set attributes for unselected cross-references in help text}
(1) 3-48      procedure SetSelXrefAttr(Color, Mono : Byte);
                {-Set attributes for selected cross-references in help text}
(1) 3-48      procedure SetMouseAttr(Color, Mono : Byte);
                {-Set attributes for mouse cursor}

OpMouse Procedures and Functions
==============================================================================

(1) 3-71      function MousePressed : Boolean;
                {-Return True if a mouse button is currently being pressed}
(1) 3-71      function MouseKeyWord : Word;
                {-Return a pseudo-scan code based on which mouse button is being
                  pressed}
(1) 3-68      function KeyOrButtonPressed : Boolean;
                {-Return True if a key or mouse button has been pressed}
(1) 3-76      function ReadKeyOrButton : Word;
                {-Return next key or mouse button}
(1) 3-64      procedure EnableEventHandling;
                {-Enable the event handler needed for MousePressed and
                  MouseKeyWord}
(1) 3-63      procedure DisableEventHandling;
                {-Disable the event handler installed by EnableEventHandling}
(1) 3-68      procedure InitializeMouse;
                {-Reinitializes mouse and sets MouseInstalled}
(1) 3-80      procedure ShowMouse;
                {-Show the mouse cursor}
(1) 3-67      procedure HideMouse;
                {-Hide the mouse cursor}
(1) 3-73      procedure MouseWhereXY(var MouseX, MouseY : Byte;
                                     var Status : ButtonStatus);
                {-Return mouse position and button status}
(1) 3-72      function MouseWhereX : Byte;
                {-Return current X coordinate for mouse}
(1) 3-74      function MouseWhereY : Byte;
                {-Return current Y coordinate for mouse}
(1) 3-74      procedure MouseWhereXYabs(var MouseX, MouseY : Byte;
                                        var Status : ButtonStatus);
                {-Return mouse position (absolute) and button status}
(1) 3-73      function MouseWhereXabs : Byte;
                {-Return current X coordinate (absolute) for mouse}
(1) 3-75      function MouseWhereYabs : Byte;
                {-Return current Y coordinate (absolute) for mouse}
(1) 3-70      procedure MouseGotoXY(MouseX, MouseY : Byte);
                {-Set mouse position}
(1) 3-69      function MouseButtonPressed(Button : ButtonStatus; var Count : Word;
                                          var LastX, LastY : Byte) : Boolean;
                {-Returns True if the Button to check has been pressed. If so,
                  Count has the number of times it has been pressed, and
                  LastX/LastY have its position the last time it was pressed.}
(1) 3-69      function MouseButtonReleased(Button : ButtonStatus; var Count : Word;
                                           var LastX, LastY : Byte) : Boolean;
                {-Returns True if the Button to check has been released. If so,
                  Count has the number of times it has been released, and
                  LastX/LastY have its position the last time it was released.}
(1) 3-75      procedure MouseWindow(XLow, YLow, XHigh, YHigh : Byte);
                {-Sets window coordinates to be observed by the mouse}
(1) 3-65      procedure FullMouseWindow;
                {-Sets mouse window coordinates to full screen}
(1) 3-81      procedure StoreMouseCoordinates(var WC : WindowCoordinates);
                {-Store the mouse window coordinates in WC}
(1) 3-77      procedure RestoreMouseCoordinates(WC : WindowCoordinates);
                {-Restore previously saved mouse window coordinates}
(1) 3-70      function MouseInWindow(XLo, YLo, XHi, YHi : Byte) : Boolean;
                {-Return True if mouse is within the specified window}
(1) 3-81      procedure SoftMouseCursor(ScreenMask, CursorMask : Word);
                {-Set mouse to use a software cursor}
(1) 3-66      procedure HardMouseCursor(StartLine, EndLine : Word);
                {-Set mouse to use the hardware cursor. StartLine and EndLine
                  specify the shape of the cursor.}
(1) 3-76      procedure NormalMouseCursor;
                {-Set normal scan lines for mouse cursor based on current video
                  mode}
(1) 3-64      procedure FatMouseCursor;
                {-Set larger scan lines for mouse cursor based on current video
                  mode}
(1) 3-63      procedure BlockMouseCursor;
                {-Set scan lines for a block mouse cursor}
(1) 3-67      procedure HiddenMouseCursor;
                {-Hide the mouse cursor}
(1) 3-65      procedure GetMickeyCount(var Horizontal, Vertical : Integer);
                {-Returns the horizontal and vertical mickey count since the last
                  call to this function. Negative numbers indicate movement up or
                  to the left; positive numbers indicate movement down or to the
                  right.}
(1) 3-78      procedure SetMickeyToPixelRatio(Horizontal, Vertical : Integer);
                {-Sets the mickey-to-pixel ratio. Default setting is 8,16. A
                  setting of 16,32 slows down the mouse considerably. A setting of
                  4,8 makes the mouse fly.}
(1) 3-79      procedure SetMouseEventHandler(EventMask : MouseEventType;
                                             UserRoutine : Pointer);
                {-Sets the address of a routine to be called when the specified
                  mouse events occur}
(1) 3-66      function GetMousePage : Byte;
                {-Returns the video page where the mouse is being displayed}
(1) 3-79      procedure SetMousePage(Page : Byte);
                {-Sets the video page where the mouse will be displayed}
(1) 3-72      function MouseStateBufferSize : Word;
                {-Returns amount of memory needed to save the state of the mouse
                  driver}
(1) 3-78      procedure SaveMouseState(var MSP : MouseStatePtr;
                                       Allocate : Boolean);
                {-Save the state of the mouse driver, allocating the buffer if
                  requested.}
(1) 3-77      procedure RestoreMouseState(var MSP : MouseStatePtr;
                                          Deallocate : Boolean);
                {-Restore the state of the mouse driver and Deallocate the buffer
                  if requested}
(1) 3-67      procedure HideMousePrim(var MouseState : Boolean);
                {-Save state of mouse cursor in MouseState and hide it}
(1) 3-80      procedure ShowMousePrim(MouseState : Boolean);
                {-Hide or unhide the mouse cursor}

OpCmd   CommandProcessor
==============================================================================

(1) 3-105     constructor Init(KeysPtr : CmdTablePtr; MaxIndex : Word);
                {-Initialize a command processor with only one command table}
(1) 3-105     constructor InitCustom(PrimaryKeys : CmdTablePtr;
                                     PrimaryMaxIndex : Word;
                                     SecondaryKeys : CmdTablePtr;
                                     SecondaryMaxIndex : Word; Options : Word);
                {-Initialize a command processor with custom options}
(1) 3-100     destructor Done; virtual;
                {-Dispose of any memory that was allocated by the command
                  processor}
(1) 3-102     function GetCommand(var Key : Word) : Word;
                {-Get next command or character}
(1) 3-95      procedure AddCommand(Cmd : Word; NumKeys : Byte; Key1, Key2 : Word);
                {-Add a new primary command key assignment or change an existing
                  one}
(1) 3-96      procedure AddSecondaryCommand(Cmd : Word; NumKeys : Byte;
                                            Key1, Key2 : Word);
                {-Add a new secondary command key assignment or change an existing
                  one}
(1) 3-104     function GetLastError : Word;
                {-Returns last error code and clears it}
(1) 3-108     procedure SetGetKeyProc(GKP : GetKeyProc);
                {-Change the cpGetKey routine}
(1) 3-109     procedure SetKeyPressedProc(KPP : KeyPressedProc);
                {-Change the cpKeyPressed routine}
(1) 3-108     procedure SetHelpProc(GHP : GetHelpProc);
                {-Change the HelpProc field}
(1) 3-110     procedure SetUserHookProc(UHP : UserHookProc);
                {-Specify a routine to be called each time a keystroke is
                  evaluated}
(1) 3-99      procedure cpOptionsOn(OptionFlags : Word);
                {-Activate multiple options}
(1) 3-99      procedure cpOptionsOff(OptionFlags : Word);
                {-Deactivate multiple options}
(1) 3-99      function cpOptionsAreOn(OptionFlags : Word) : Boolean;
                {-Return true if all specified options are on}
(1) 3-98      function cpGetKey : Word; virtual;
                {-Called to get next keystroke}
(1) 3-98      function cpKeyPressed : Boolean; virtual;
                {-Called to determine if a key has been pressed}
(1) 3-98      procedure cpGetHelp(UnitCode : Byte; IdPtr : Pointer;
                                  HelpIndex : Word); virtual;
                {-Called when help is requested}
(1) 3-100     procedure cpUserHook(MT : MatchType; Key : Word); virtual;
                {-Called each time a keystroke is processed}
(1) 3-109     procedure SetKeyPtr(KeysPtr : CmdTablePtr; MaxIndex : Word);
                {-Change the primary command table}
(1) 3-103     function GetKeyPtr(var MaxIndex : Word) : CmdTablePtr;
                {-Return a pointer to the primary command table}
(1) 3-110     procedure SetSecondaryKeyPtr(KeysPtr : CmdTablePtr; MaxIndex : Word);
                {-Change the secondary command table}
(1) 3-104     function GetSecondaryKeyPtr(var MaxIndex : Word) : CmdTablePtr;
                {-Return a pointer to the secondary command table}
(1) 3-103     procedure GetKeyAssignment(Cmd : Word; var NumKeys : Byte;
                                         var Key1, Key2 : Word);
                {-Return one set of key(s) assigned to the specified command.
                  NumKeys = 0 if none found.}
(1) 3-101     function GetCmdAssignment(NumKeys : Byte; Key1, Key2 : Word;
                                        var Primary : Boolean) : Word;
                {-Return command associated with specified key combination, or
                  ccNone if none found. Primary is False only if match found in
                  secondary key set.}
(1) 3-96      function CheckForConflict(NumKeys : Byte;
                                        Key1, Key2 : Word) : MatchType;
                {-Check to see if the specified key combination conflicts with an
                  existing one}
(1) 3-107     procedure SetCommandList(CmdList : Pointer; NumCmds : Word);
                {-Specify a list of commands to be auto-executed}
(1) 3-97      function CommandStringPending : Boolean;
                {-Returns True if a text string is pending in the list of
                  auto-executed commands}
(1) 3-102     function GetCommandString : string;
                {-Returns a text string when CommandStringPending is True}
(1) 3-106     constructor Load(var S : IdStream);
                {-Load a command processor from a stream}
(1) 3-111     procedure Store(var S : IdStream);
                {-Store a command processor in a stream}
(1) 3-107     function MouseEnabled : Boolean;
                {-Return True if mouse support enabled}

OpCmd   CommandPacker
==============================================================================

(1) 3-116     constructor Init(PKeys : CmdTablePtr; MaxCmd, MaxIndex : Word;
                               UKeys : UnpackedCmdPtr; Columns : Byte;
                               CmdsAreWords : Boolean);
                {-Initialize pointers to packed/unpacked command tables}
(1) 3-116     function PackKeys : Boolean;
                {-Convert unpacked array into a packed list of keys again. Returns
                  False if keys won't all fit.}
(1) 3-116     function SizeKeys : Word;
                {-Return number of bytes in packed version of UnpackedKeys}
(1) 3-115     function GetKeyRecPtr(Cmd : Word; Col : Byte) : KeyRecPtr;
                {-Returns a pointer to the KeyRec for the Col'th instance of Cmd}
(1) 3-115     function ConflictsFound : Boolean;
                {-Check unpacked commands for conflicts. Returns True if conflicts
                  found}

OpCmd   Procedures and Functions
==============================================================================

(1) 3-118     procedure SetBell(Pitch, Duration : Word);
                {-Set pitch and duration for bell}
(1) 3-118     procedure RingBell;
                {-Ring the bell}
(1) 3-118     procedure DefaultErrorProc(UnitCode : Byte; var ErrorCode : Word;
                                         ErrorMsg : string);
                {-Default error handler--just beeps}

OpFrame AbstractFrame
==============================================================================

(1) 4-42      procedure ClearErrors;
                {-Clear all pending errors}

OpFrame ScreenRect
==============================================================================

(1) 4-11      constructor Alloc(X1, Y1, X2, Y2 : Byte);
                {-Initialize coordinates and allocate a screen buffer}
(1) 4-15      constructor Init(X1, Y1, X2, Y2 : Byte; BufPtr : Pointer);
                {-Initialize coordinates and assign a preallocated buffer}
(1) 4-14      destructor Done; virtual;
                {-Deallocate buffer}
(1) 4-12      function BufSize : Word;
                {-Return required size of buffer in bytes}
(1) 4-12      procedure Clear(FChar : Char; FAttr : Byte);
                {-Clear with character and attribute}
(1) 4-13      procedure CopyFromScreen;
                {-Copy from screen to buffer}
(1) 4-14      procedure CopyToScreen;
                {-Copy buffer to screen}
(1) 4-13      procedure CopyPartToScreen(X1, Y1, X2, Y2 : Byte);
                {-Copy part of the buffer to the screen}
(1) 4-10      procedure Adjust(X1, Y1, X2, Y2 : Byte);
                {-Adjust buffer coordinates to X1, Y1, X2, Y2}
(1) 4-19      procedure Transfer(X1, Y1, X2, Y2 : Byte;
                                 FChar : Char; FAttr : Byte);
                {-Transfer buffer to new buffer at coordinates X1, Y1, X2, Y2}
(1) 4-17      function srResult : Word;
                {-Return most recent status code}
(1) 4-19      procedure StoreContents(On : Boolean);
                {-Specify whether Store writes contents of screen buffer}
(1) 4-15      function HaveContents : Boolean;
                {-Return True if contents were loaded by Load}
(1) 4-12      procedure Coordinates(var X1, Y1, X2, Y2 : Byte);
                {-Return coordinates of screen rectangle}
(1) 4-16      constructor Load(var S : IdStream);
                {-Load from stream}
(1) 4-18      procedure Store(var S : IdStream);
                {-Store to stream}

OpFrame Frame
==============================================================================

(1) 4-48      constructor Init(X1, Y1, X2, Y2 : Byte; FA : FrameArray;
                               var Colors : ColorSet);
                {-Initialize frame coordinates and all fields}
(1) 4-46      constructor fCopy(var F : Frame);
                {-Initialize a frame from another, making a unique copy of all
                  dynamic structures}
(1) 4-44      destructor Done; virtual;
                {-Destroy a frame}
(1) 4-50      procedure SetFrameType(FA : FrameArray);
                {-Change the frame type}
(1) 4-50      procedure SetFrameAttr(Color, Mono : Byte); virtual;
                {-Set attributes for frame characters}
(1) 4-51      procedure SetHeaderAttr(Color, Mono : Byte; ChangeAll : Boolean);
                {-Set attributes for header characters}
(1) 4-51      procedure SetShadowAttr(Color, Mono : Byte; ChangeAll : Boolean);
                {-Set attributes for shadow characters}
(1) 4-34      procedure AddHeader(S : string; Posn : HeaderPosType);
                {-Add a standard header}
(1) 4-34      procedure AddHeaderColor(S : string; Posn : HeaderPosType;
                                       AttrColor, AttrMono : Byte);
                {-Add a standard header with custom color}
(1) 4-31      procedure AddCustomHeader(S : string; Posn : FrameCornerType;
                                        DX, DY : Integer;
                                        AttrColor, AttrMono : Byte);
                {-Add a custom header}
(1) 4-39      procedure AddSpanHeader(FirstChar, SpanChar, LastChar : Char;
                                      Dpos : Integer; Posn : FrameEdgeType);
                {-Add a header spanning the frame}
(1) 4-39      procedure AddSpanHeaderColor(FirstChar, SpanChar, LastChar : Char;
                                           Dpos : Integer; Posn : FrameEdgeType;
                                           AttrColor, AttrMono : Byte);
                {-Add a header spanning the frame with custom color}
(1) 4-47      function GetLastHeaderIndex : Byte;
                {-Return index of last header added}
(1) 4-41      procedure ChangeHeaderString(Index : Byte; S : string;
                                           var Redraw : Boolean);
                {-Change existing header string and update position}
(1) 4-40      procedure ChangeHeaderAttr(Index : Byte; Color, Mono : Byte);
                {-Change existing header colors}
(1) 4-45      procedure DrawHeader(Index : Byte);
                {-Draw specified header}
(1) 4-44      procedure DisableHeader(Index : Byte; On : Boolean);
                {-Disable or enable specified header}
(1) 4-37      procedure AddShadow(Posn : ShadowPosType; DrawType : ShadowDrawType);
                {-Add a standard shadow}
(1) 4-38      procedure AddShadowColor(Posn : ShadowPosType;
                                       DrawType : ShadowDrawType;
                                       AttrColor, AttrMono : Byte);
                {-Add a standard shadow with custom color}
(1) 4-33      procedure AddCustomShadow(ShChar : Char; Edge : FrameEdgeType;
                                        DX, DY : Integer; W, H : Byte;
                                        AttrColor, AttrMono : Byte);
                {-Add a custom shadow rectangle}
(1) 4-37      procedure AddScrollBar(Posn : FrameEdgeType;
                                     MinUser, MaxUser : LongInt;
                                     var Colors : ColorSet);
                {-Add a standard scroll bar}
(1) 4-33      procedure AddCustomScrollBar(Posn : FrameEdgeType;
                                           MinUser, MaxUser : LongInt;
                                           DecOffset, IncOffset : Byte;
                                           SliChar, BarChar : Char;
                                           var Colors : ColorSet);
                {-Add a custom scroll bar}
(1) 4-36      procedure AddHotSpot(Posn : FrameCornerType; HotChar : Char;
                                   var Colors : ColorSet);
                {-Add a hot spot in a frame corner}
(1) 4-35      procedure AddHotBar(Posn : FrameEdgeType; Code : Byte);
                {-Add a hot region covering an entire frame edge}
(1) 4-36      procedure AddHotRegion(Posn : FrameCharType; Code : Byte;
                                     DX, DY : Integer; Width, Height : Byte);
                {-Add a fixed size hot region relative to the frame corner}
(1) 4-35      procedure AddHotHeader(hType : HeaderPosType; Code : Byte;
                                     Len : Byte);
                {-Add a hot region to coincide with a header}
(1) 4-48      function GetLastHotIndex : Byte;
                {-Return index of last hot region}
(1) 4-42      procedure ChangeHotHeader(Index : Byte; Len : Byte);
                {-Change the length (and position) of a hot header}
(1) 4-52      procedure SetSizeLimits(MinW, MinH, MaxW, MaxH : Byte);
                {-Set limits for sizing of frame}
(1) 4-50      procedure SetClipLimits(MinXL, MinYL, MaxXH, MaxYH : Byte);
                {-Set limits for drawing frame (shadows get clipped)}
(1) 4-52      procedure SetSliderValue(Posn : FrameEdgeType; UserVal : LongInt);
                {-Change the user value without drawing it}
(1) 4-43      function CurUserValue(Posn : FrameEdgeType) : LongInt;
                {-Return the current user value for specified scroll bar}
(1) 4-45      procedure Draw; virtual;
                {-Draw the frame, scrollbars, headers, and shadows}
(1) 4-53      procedure UpdateFrame; virtual;
                {-Draw the frame, scrollbars, and headers (no shadows)}
(1) 4-49      function IsFramed : Boolean;
                {-Return True if any of the FrameChars are not NoFrameChar}
(1) 4-43      procedure Coordinates(var X1, Y1, X2, Y2 : Byte);
                {-Return the coordinates of the frame}
(1) 4-54      procedure WithinFrameCoords(var X1, Y1, X2, Y2 : Byte);
                {-Return the coordinates of region within, not including, the
                  border}
(1) 4-40      procedure AdjustFrame(X1, Y1, X2, Y2 : Byte);
                {-Set new coordinates and adjust related structures}
(1) 4-46      procedure Error(Code : Word); virtual;
                {-Report that an error occurred}
(1) 4-47      function GetLastError : Word; virtual;
                {-Return and clear the last error code, 0 if none}
(1) 4-49      constructor Load(var S : IdStream);
                {-Load from stream}
(1) 4-53      procedure Store(var S : IdStream);
                {-Store to stream}

OpWindow  AbstractWindow
==============================================================================

(1) 4-107     function Width : Word;
                {-Return the active width of the window}
(1) 4-84      function Height : Word;
                {-Return the active height of the window}
(1) 4-69      procedure ClearErrors;
                {-Clear all pending errors}

OpWindow  RawWindow
==============================================================================

(1) 4-85      constructor Init(X1, Y1, X2, Y2 : Byte);
                {-Create a window with default options and colors}
(1) 4-85      constructor InitCustom(X1, Y1, X2, Y2 : Byte; var Colors : ColorSet;
                                     Options : LongInt);
                {-Create a window with custom options}
(1) 4-106     constructor wCopy(var W : RawWindow);
                {-Initialize a window from another one, making a unique copy of
                  all dynamic structures}
(1) 4-71      destructor Done; virtual;
                {-Destroy a window}
(1) 4-63      procedure AdjustFrameCoords(X1, Y1, X2, Y2 : Byte);
                {-Change frame coordinates of an inactive window.
                  Completely clears existing frame definition}
(1) 4-71      procedure DeltaAdjustFrame(dX1, dY1, dX2, dY2 : Integer);
                {-Change frame coordinates of an inactive window.
                  Reallocates wCovers buffer but changes nothing else}
(1) 4-97      procedure SetSizeLimits(MinW, MinH, MaxW, MaxH : Byte);
                {-Set limits for sizing of active window}
(1) 4-96      procedure SetPosLimits(MinX, MinY, MaxX, MaxY : Byte);
                {-Set limits for moving and drawing (generally limited by frame)}
(1) 4-96      procedure SetFrameLimits(MinW, MinH, MaxW, MaxH : Byte);
                {-Set limits for sizing of frame}
(1) 4-103     procedure UpdateScreenSize;
                {-Update window size, position, and limits for current screen
                  size}
(1) 4-77      procedure EnableExplosions(StageDelay : Word);
                {-Enable exploding windows with StageDelay milliseconds per stage}
(1) 4-75      procedure EnableAlternateOpen(OpenProc, CloseProc : RawWindowProc;
                                            StageDelay : Word);
                {-Enable alternate draw and erase routines}
(1) 4-77      procedure EnableNormalOpen;
                {-Disable exploding windows or alternate draw routines}
(1) 4-109     procedure wOptionsOn(OptionCodes : LongInt);
                {-Turn options on}
(1) 4-108     procedure wOptionsOff(OptionCodes : LongInt);
                {-Turn options off}
(1) 4-107     function wOptionsAreOn(OptionCodes : LongInt) : Boolean;
                {-Return true if all specified options are on}
(1) 4-97      procedure SetTextAttr(Color, Mono : Byte); virtual;
                {-Set attributes for normal window text}
(1) 4-95      procedure SetBackChar(BackChar : Char); virtual;
                {-Set background character}
(1) 4-106     procedure wGotoXY(X, Y : Integer); virtual;
                {-Move cursor to window-relative coordinates}
(1) 4-110     procedure wWhereXY(var X, Y : Integer); virtual;
                {-Return window-relative coordinates of cursor}
(1) 4-110     procedure wWhereXYAbs(var X, Y : Byte);
                {-Return absolute coordinates of cursor}
(1) 4-95      procedure SetCursor(CT : CursorType);
                {-Set cursor shape}
(1) 4-83      function GetCursor : CursorType;
                {-Return current cursor shape}
(1) 4-67      procedure ChangeHeader(Index : Byte; S : string);
                {-Change header string, and if window is current, update screen}
(1) 4-86      function InWindow(AX, AY : Byte) : Boolean;
                {-Return true if specified absolute position is within active
                  window}
(1) 4-70      function CursorInWindow : Boolean;
                {-Return true if cursor is currently within active window}
(1) 4-80      procedure EvaluatePos(X, Y : Byte);
                {-Evaluate specified absolute position relative to window,
                  hotspots, and scrollbars. Access returned values using
                  PosResults}
(1) 4-79      procedure EvaluateMousePos;
                {-Evaluate current mouse position as with EvaluatePos}
(1) 4-91      function PosResults(var FramePos : FramePosType;
                                  var HotCode : Byte) : LongInt;
                {-Return values from most recent call to EvaluatePos or
                  EvaluateMousePos}
(1) 4-79      procedure Error(Code : Word); virtual;
                {-Report that an error occurred}
(1) 4-84      function GetLastError : Word; virtual;
                {-Return and clear the last error code, 0 if none}
(1) 4-86      function IsActive : Boolean; virtual;
                {-Return True if window is on-screen}
(1) 4-86      function IsCurrent : Boolean; virtual;
                {-Return True if window is the current one}
(1) 4-87      function IsZoomed : Boolean; virtual;
                {-Return True if window is currently zoomed}
(1) 4-89      function MainFramePtr : AbstractFramePtr; virtual;
                {-Return a pointer to frame used when window is current}
(1) 4-65      function AltFramePtr : AbstractFramePtr; virtual;
                {-Return a pointer to frame used when window is active but not
                  current}
(1) 4-62      function ActiveFramePtr : AbstractFramePtr; virtual;
                {-Return a pointer to frame the window is currently displaying,
                  nil if none}
(1) 4-70      procedure Coordinates(var X1, Y1, X2, Y2 : Byte);
                {-Return the active coordinates of the window}
(1) 4-81      procedure Extent(var X1, Y1, X2, Y2 : Byte;
                               IncludeShadows : Boolean);
                {-Return the complete extent of the window, counting shadows if
                  requested}
(1) 4-72      procedure Draw; virtual;
                {-Draw or update a window}
(1) 4-102     procedure UpdateContents; virtual;
                {-Update the contents of the currently displayed window}
(1) 4-78      procedure Erase; virtual;
                {-Erase a window}
(1) 4-93      procedure SaveContents; virtual;
                {-Save current window contents in the contents buffer}
(1) 4-74      procedure DrawSlider(Posn : FrameEdgeType; UserVal : LongInt);
                {-Draw or update the slider}
(1) 4-78      procedure EraseSlider(Posn : FrameEdgeType);
                {-Erase the slider}
(1) 4-100     function TweakSlider(Posn : FrameEdgeType; MousePosn : Byte;
                                   UserVal : LongInt; Step : LongInt) : LongInt;
                {-Adjust user value until slider exactly matches mouse position}
(1) 4-68      procedure ChangeScrollBar(Posn : FrameEdgeType;
                                        MinUser, MaxUser : LongInt);
                {-Change user range of existing scroll bar}
(1) 4-66      procedure ChangeAllScrollBars(MinHoriz, MaxHoriz : LongInt;
                                            MinVert, MaxVert : LongInt); virtual;
                {-Change user ranges of existing scroll bars. Erases sliders}
(1) 4-73      procedure DrawAllSliders(HorizVal, VertVal : LongInt); virtual;
                {-Draw or update all sliders}
(1) 4-68      procedure Clear; virtual;
                {-Clear active window area with wTextXXXX and wBackChar}
(1) 4-69      procedure ClearContents;
                {-Clear region within frame with wTextXXXX and wBackChar}
(1) 4-90      procedure MoveWindow(DX, DY : Integer); virtual;
                {-Move a window}
(1) 4-92      procedure ResizeWindow(DX, DY : Integer); virtual;
                {-Resize a window}
(1) 4-64      procedure AdjustWindow(X1, Y1, X2, Y2 : Word); virtual;
                {-Set new coordinates and adjust all related structures}
(1) 4-111     procedure Zoom; virtual;
                {-Increase window size to maximum limits temporarily}
(1) 4-101     procedure Unzoom; virtual;
                {-Return zoomed window to pre-zoomed size}
(1) 4-94      procedure ScrollHoriz(Cols : Integer); virtual;
                {-Scroll contents horizontally}
(1) 4-94      procedure ScrollVert(Rows : Integer); virtual;
                {-Scroll contents vertically}
(1) 4-89      procedure MarkCurrent; virtual;
                {-Called when window is made current}
(1) 4-89      procedure MarkNotCurrent; virtual;
                {-Called when window is deselected}
(1) 4-104     procedure wFastWrite(St : string; Row, Col, Attr : Byte);
                {-Write a string}
(1) 4-104     procedure wFastText(St : string; Row, Col : Byte);
                {-Write St at Row,Col without changing the underlying video
                  attribute}
(1) 4-104     procedure wFastVert(St : string; Row, Col, Attr : Byte);
                {-Write a string vertically}
(1) 4-104     procedure wFastFill(Number : Word; Ch : Char; Row, Col, Attr : Byte);
                {-Fill Number chars at Row,Col in Attr}
(1) 4-104     procedure wChangeAttribute(Number : Word; Row, Col, Attr : Byte);
                {-Change Number video attributes to Attr starting at Row,Col}
(1) 4-104     procedure wFastCenter(St : string; Row, Attr : Byte);
                {-Write St centered on Row in Attr}
(1) 4-104     procedure wFastFlush(St : string; Row, Attr : Byte);
                {-Write St flush right on Row in Attr}
(1) 4-104     procedure wFastRead(Number, Row, Col : Byte; var St : string);
                {-Read Number characters from the screen into St starting at
                  Row, Col}
(1) 4-104     procedure wReadAttribute(Number, Row, Col : Byte; var St : string);
                {-Read Number attributes from the screen into St starting at
                  Row, Col}
(1) 4-104     procedure wWriteAttribute(St : String; Row, Col : Byte);
                {-Write string of attributes St at Row,Col without changing
                  characters}
(1) 4-104     procedure wFlexWrite(St : string; Row, Col : Byte;
                                   var FAttrs : FlexAttrs);
                {-Write a string flexibly using window-relative coordinates}
(1) 4-104     procedure wFastWriteCtrl(St : String; Row, Col, Attr, Ctrl : Byte);
                {-Write St at Row,Col in Attr (video attribute) without snow.
                  Control characters displayed in Ctrl as upper-case letters}
(1) 4-82      procedure fFastWrite(St : string; Row, Col, Attr : Byte);
                {-Write a string}
(1) 4-82      procedure fFastText(St : string; Row, Col : Byte);
                {-Write St at Row,Col without changing the underlying video
                  attribute}
(1) 4-82      procedure fFastVert(St : string; Row, Col, Attr : Byte);
                {-Write a string vertically}
(1) 4-82      procedure fFastFill(Number : Word; Ch : Char; Row, Col, Attr : Byte);
                {-Fill Number chars at Row,Col in Attr}
(1) 4-82      procedure fChangeAttribute(Number : Word; Row, Col, Attr : Byte);
                {-Change Number video attributes to Attr starting at Row,Col}
(1) 4-82      procedure fFastCenter(St : string; Row, Attr : Byte);
                {-Write St centered on Row in Attr}
(1) 4-82      procedure fFastFlush(St : string; Row, Attr : Byte);
                {-Write St flush right on Row in Attr}
(1) 4-82      procedure fFastRead(Number, Row, Col : Byte; var St : string);
                {-Read Number characters from the screen into St starting at
                  Row, Col}
(1) 4-82      procedure fReadAttribute(Number, Row, Col : Byte; var St : string);
                {-Read Number attributes from the screen into St starting at
                  Row, Col}
(1) 4-82      procedure fWriteAttribute(St : String; Row, Col : Byte);
                {-Write string of attributes St at Row,Col without changing
                  characters}
(1) 4-82      procedure fFlexWrite(St : string; Row, Col : Byte;
                                   var FAttrs : FlexAttrs);
                {-Write a string flexibly using window-relative coordinates}
(1) 4-82      procedure fFastWriteCtrl(St : String; Row, Col, Attr, Ctrl : Byte);
                {-Write St at Row,Col in Attr (video attribute) without snow.
                  Control characters displayed in Ctrl as upper-case letters}
(1) 4-88      constructor Load(var S : IdStream);
                {-Load from stream}
(1) 4-98      procedure Store(var S : IdStream);
                {-Store to stream}

OpWindow  StackWindow
==============================================================================

(1) 4-122     constructor Init(X1, Y1, X2, Y2 : Byte);
                {-Create a stacked window with default options and colors}
(1) 4-122     constructor InitCustom(X1, Y1, X2, Y2 : Byte;
                                     var Colors : ColorSet; Options : LongInt);
                {-Create a window with custom options}
(1) 4-129     constructor wCopy(var S : StackWindow);
                {-Initialize a window from another one, making a unique copy of
                  all dynamic structures}
(1) 4-126     procedure SetStackProc(SP : StackWindowProc);
                {-Set window stack proc}
(1) 4-129     function WindowNumber : Word;
                {-Return window number. 0 if inactive, else 1 or greater}
(1) 4-119     procedure AssignNumber; virtual;
                {-Called to assign window number}
(1) 4-120     procedure Draw; virtual;
                {-Draw or update a window and push it on stack}
(1) 4-121     procedure Erase; virtual;
                {-Erase a window and pop from stack}
(1) 4-125     procedure Select; virtual;
                {-Make a window the current one by pulling to the top of stack}
(1) 4-120     procedure DrawHidden(var Under : StackWindow);
                {-Draw a window, inserting it in the stack underneath window Under}
(1) 4-121     procedure EraseHidden;
                {-Erase a window even if it's hidden on the window stack}
(1) 4-125     function OnStack : Boolean;
                {-Return True if window is displayed on the window stack}
(1) 4-118     procedure ActivateWrite;
                {-Activate fastwriting to a hidden window}
(1) 4-119     procedure DeactivateWrite;
                {-Deactivate fastwriting and display changes}
(1) 4-123     constructor Load(var S : IdStream);
                {-Load from stream}
(1) 4-127     procedure Store(var S : IdStream);
                {-Store to stream}

OpWindow  CommandWindow
==============================================================================

(1) 4-148     constructor Init(X1, Y1, X2, Y2 : Byte; var CP : CommandProcessor;
                               UnitCode : Byte);
                {-Create a command window with default options and colors}
(1) 4-148     constructor InitCustom(X1, Y1, X2, Y2 : Byte; var Colors : ColorSet;
                                     Options : LongInt; var CP : CommandProcessor;
                                     UnitCode : Byte);
                {-Create a command window with custom options}
(1) 4-152     procedure Process; virtual;
                {-Process commands}
(1) 4-154     procedure ProcessAutoPilot(var CmdList; NumCmds : Word);
                {-Process commands, starting with those in CmdList}
(1) 4-147     procedure GetNextCommand; virtual;
                {-Called by Process to get next command from user}
(1) 4-155     procedure RequestHelp(HelpIndex : Word); virtual;
                {-Called by Process to request context-sensitive help}
(1) 4-155     procedure SetCommandProcessor(var CP : CommandProcessor);
                {-Set command processor to use}
(1) 4-143     function GetCommandProcessor : CommandProcessorPtr;
                {-Return pointer to window's command processor}
(1) 4-145     function GetLastCommand : Word;
                {-Return last command entered by user}
(1) 4-158     procedure SetLastCommand(Cmd : Word);
                {-Change last command}
(1) 4-146     function GetLastKey : Word;
                {-Return last keystroke entered by user}
(1) 4-158     procedure SetHelpIndex(Index : Word);
                {-Set help topic number for this window}
(1) 4-144     function GetHelpIndex : Word;
                {-Return the help topic number for this window}
(1) 4-156     procedure SetErrorProc(EP : ErrorProc);
                {-Set error handler}
(1) 4-147     procedure GotError(ErrorCode : Word; ErrorMsg : string);
                {-To be called when an error occurs}
(1) 4-145     function GetLastError : Word; virtual;
                {-Return last I/O error code}
(1) 4-151     function PeekLastError : Word;
                {-Return last I/O error code without resetting internal variable}
(1) 4-143     function ClassifyError(ErrorCode : Word) : Byte;
                {-Return the class of the specified error code}
(1) 4-157     procedure SetExitCommands(ExitSetPtr : ByteSetPtr);
                {-Specify set of special exit commands}
(1) 4-144     function GetExitCommandPtr : ByteSetPtr;
                {-Return pointer to set of special exit commands}
(1) 4-149     constructor Load(var S : IdStream);
                {-Load from stream}
(1) 4-159     procedure Store(var S : IdStream);
                {-Store to stream}

OpWindow VirtScreen
==============================================================================

(1) 4-176     constructor Alloc(Height, Width : Word);
                {-Create a virtual screen of the specified dimensions}
(1) 4-180     constructor Init(Height, Width : Word; BufSeg : Word);
                {-Initialize a virtual screen with a preallocated buffer}
(1) 4-179     destructor Done; virtual;
                {-Deallocate a virtual screen}
(1) 4-175     procedure Activate;
                {-Activate fast write and read routines on virtual screen}
(1) 4-179     procedure Deactivate;
                {-Deactivate fast access to virtual screen}
(1) 4-176     procedure Clear(Attr : Byte; Fill : Char);
                {-Clear virtual screen}
(1) 4-185     procedure WriteTo(S : string; Row, Col : Word; Attr : Byte);
                {-Write a string to virtual screen}
(1) 4-182     procedure ReadFrom(Number : Byte; Row, Col : Word; var S : string);
                {-Read number characters from the virtual screen starting at
                  Row, Col}
(1) 4-182     procedure ScrollHoriz(Cols : Integer; Attr : Byte; Fill : Char);
                {-Scroll contents horizontally}
(1) 4-183     procedure ScrollVert(Rows : Integer; Attr : Byte; Fill : Char);
                {-Scroll contents vertically}
(1) 4-177     procedure CopyFromWindow(Row, Col : Word);
                {-Copy current window to position <Row,Col> on virtual screen}
(1) 4-178     procedure CopyToWindow(Row, Col : Word);
                {-Copy from position <Row,Col> on virtual screen to current window}
(1) 4-177     procedure CopyFromScreen(Row, Col : Word);
                {-Copy physical screen to position <Row,Col> on virtual screen}
(1) 4-178     procedure CopyToScreen(Row, Col : Word);
                {-Copy from position <Row,Col> on virtual screen to physical
                  screen}
(1) 4-185     function vRows : Word;
                {-Return number of rows in virtual screen}
(1) 4-184     function vCols : Word;
                {-Return number of columns in virtual screen}
(1) 4-181     constructor Load(var S : IdStream);
                {-Load from stream}
(1) 4-184     procedure Store(var S : IdStream);
                {-Store to stream}

OpWindow  WindowStack
==============================================================================

(1) 4-133     constructor Init(Max : Word);
                {-Allocate stack and initialize}
(1) 4-132     destructor Done; virtual;
                {-Clean up and dispose}
(1) 4-137     function UnstackTop : WindowPtr;
                {-Erase and unstack window at top of stack}
(1) 4-137     function TopWindow : WindowPtr;
                {-Return a pointer to the window at top of stack}
(1) 4-133     function EvaluateStackPos(X, Y : Byte) : WindowPtr;
                {-Evaluate position and return pointer to indicated window, if any}
(1) 4-132     function EvaluateStackMousePos : WindowPtr;
                {-Evaluate mouse position using EvaluatePos}
(1) 4-134     constructor Load(var S : IdStream);
                {-Load from stream}
(1) 4-135     procedure Store(var S : IdStream);
                {-Store to stream. Stores all currently stacked windows}

OpWindow  LoadableColorSet
==============================================================================

(1) 4-162     constructor Init(var Colors : ColorSet);
                {-Initialize this color set from another one}
(1) 4-162     constructor Load(var S : IdStream);
                {-Load a color set from a stream}
(1) 4-163     procedure Store(var S : IdStream);
                {-Store a color set in a stream}

OpWindow  PackedWindow
==============================================================================

(1) 4-167     constructor Init(XL, YL, XH, YH : Byte);
                {-Create a packed window}
(1) 4-168     constructor InitFromMemory(P : Pointer);
                {-Initialize a packed window from one stored to disk with Write
                  and bound into the EXE file with BINOBJ}
(1) 4-167     destructor Done; virtual;
                {-Deallocate the packed screen}
(1) 4-170     constructor Read(FName : string);
                {-Read the packed window stored in FName into memory}
(1) 4-172     function Write(FName : string) : Word;
                {-Store the packed window in FName}
(1) 4-169     constructor Load(var S : IdStream);
                {-Load a packed window from a stream}
(1) 4-171     procedure Store(var S : IdStream);
                {-Store a packed window in a stream}
(1) 4-166     procedure Display;
                {-Display the packed window}
(1) 4-166     procedure DisplayAt(Row, Col : Word);
                {-Display the packed window at Row,Col. If necessary, the
                  coordinates are adjusted to allow it to fit on the screen.}
(1) 4-170     procedure MapColors;
                {-Map the colors of the packed window for improved appearance on
                  mono/B&W displays}

OpPick  PickList
==============================================================================

(1) 4-218     constructor Init(X1, Y1, X2, Y2 : Byte; ItemWidth : Byte;
                               NumItems : Word; StringProc : pkStringProc;
                               Orientation : pkGenlProc;
                               CommandHandler : pkGenlProc);
                {-Initialize a pick window}
(1) 4-220     constructor InitCustom(X1, Y1, X2, Y2 : Byte; var Colors : ColorSet;
                                     Options : LongInt; ItemWidth : Byte;
                                     NumItems : Word; StringProc : pkStringProc;
                                     Orientation : pkGenlProc;
                                     CommandHandler : pkGenlProc);
                {-Initialize a pick window with custom window options}
(1) 4-219     constructor InitAbstract(X1, Y1, X2, Y2 : Byte;
                                       var Colors : ColorSet; Options : LongInt;
                                       ItemWidth : Byte; NumItems : Word;
                                       Orientation : pkGenlProc;
                                       CommandHandler : pkGenlProc);
                 {-Constructor to be called by derived types that override
                   the ItemString method}
(1) 4-221     constructor InitDeluxe(X1, Y1, X2, Y2 : Byte; var Colors : ColorSet;
                                     Options : LongInt; ItemWidth : Byte;
                                     NumItems : Word; StringProc : pkStringProc;
                                     Orientation : pkGenlProc;
                                     CommandHandler : pkGenlProc;
                                     PickOptions : Word);
                {-Initialize a pick window with custom window and pick options}
(1) 4-219     constructor InitAbstractDeluxe(X1, Y1, X2, Y2 : Byte;
                                             var Colors : ColorSet;
                                             Options : LongInt; ItemWidth : Byte;
                                             NumItems : Word;
                                             Orientation : pkGenlProc;
                                             CommandHandler : pkGenlProc;
                                             PickOptions : Word);
                 {-Constructor to be called by derived types that override the
                   ItemString method, with custom pick options}
(1) 4-214     destructor Done; virtual;
                {-Dispose of PickList}
(1) 4-208     procedure AddMoreHeader(PromptStr : String80;
                                      Posn : HeaderPosType;
                                      UpStr, DnStr, SepStr : String10;
                                      UpPos, DnPos, SepPos : Byte);
                {-Add a specialized more header to indicate more pick items}
(1) 4-209     procedure AddSearchHeader(MaxLen : Byte; Posn : HeaderPosType);
                {-Add a specialized search string header}
(1) 4-240     procedure UpdateContents; virtual;
                {-Redraw the complete pick window}
(1) 4-230     procedure Process; virtual;
                {-Process pick commands leading to a choice}
(1) 4-224     procedure ItemString(Item : Word; Mode : pkMode;
                                   var IType : pkItemType;
                                   var IString : String); virtual;
                {-Supplies each item string when the list is displayed or searched}
(1) 4-213     procedure CompleteItemString(Item : Word; Mode : pkMode;
                                           var IType : pkItemType;
                                           var IString : String); virtual;
                {-Supplies, marks, and pads item string}
(1) 4-230     procedure PreMove; virtual;
                {-Called just prior to getting each keyboard command}
(1) 4-224     function ItemSearch : Boolean; virtual;
                {-Called to search list each time an alphanumeric character is
                  entered}
(1) 4-232     procedure SetInitialChoice(Choice : Word);
                {-Set initial choice without scrolling if possible}
(1) 4-231     procedure SetChoice(Choice, FirstChoice : Word);
                {-Set initial choice with scrolling control}
(1) 4-232     procedure SetDefaultChoice(Choice : Word);
                {-Set the default choice number returned by GetDefaultChoice}
(1) 4-214     function GetDefaultChoice : Word;
                {-Return default choice number}
(1) 4-216     function GetLastChoice : Word;
                {-Return last selected item number}
(1) 4-215     function GetItemString(Item : Word) : string;
                {-Return specified item string in search format}
(1) 4-216     function GetLastChoiceString : string;
                {-Return last choice in search format}
(1) 4-240     procedure WhereSelect(var X, Y : Byte);
                {-Return window-relative coordinates of selected item}
(1) 4-240     procedure WhereSelectAbs(var X, Y : Byte);
                {-Return absolute coordinates of selected item}
(1) 4-217     function GetOrientation : Byte;
                {-Return the orientation code}
(1) 4-215     function GetItemCols : Byte;
                {-Return number of visible item columns}
(1) 4-216     function GetNumItems : Word;
                {-Return number of pick items}
(1) 4-229     procedure pkOptionsOn(OptionFlags : Word);
                {-Activate multiple options}
(1) 4-229     procedure pkOptionsOff(OptionFlags : Word);
                {-Deactivate multiple options}
(1) 4-229     function pkOptionsAreOn(OptionFlags : Word) : Boolean;
                {-Return True if all specified options are on}
(1) 4-236     procedure SetRowLimits(MinRows, MaxRows : Word);
                {-Set values for min and max rows}
(1) 4-233     procedure SetPadSize(LeftPad, RightPad : Byte);
                {-Set number of characters for padding of pick items}
(1) 4-233     procedure SetMoveProc(MP : pkGenlProc);
                {-Set user move procedure}
(1) 4-236     procedure SetSearchMode(SF : pkSearchFunc);
                {-Set a different search mode}
(1) 4-236     procedure SetSearchStart(SStart : Byte);
                {-Set start offset for string searching}
(1) 4-211     procedure ChangeNumItems(NumItems : Word);
                {-Change the number of items to display}
(1) 4-210     procedure ChangeItemWidth(ItemWidth : Byte);
                {-Change the item width}
(1) 4-212     procedure ChangeStringProc(StringProc : pkStringProc);
                {-Change the string function}
(1) 4-211     procedure ChangeOrientation(Orientation : pkGenlProc);
                {-Change the orientation}
(1) 4-210     procedure ChangeCommandHandler(CommandHandler : pkGenlProc);
                {-Change between single and multiple choice}
(1) 4-228     procedure OptimizeSize;
                {-Resize window to surround items}
(1) 4-234     procedure SetPickAttr(ItemType : pkItemType; Selected : Boolean;
                                    Color, Mono : Byte);
                {-Set one group of colors -- disables flexwriting}
(1) 4-235     procedure SetPickFlex(ItemType : pkItemType; Selected : Boolean;
                                    var Color, Mono : FlexAttrs);
                {-Set one group of colors for flexwriting}
(1) 4-237     procedure SetSelectMarker(Left, Right : String);
                {-Define strings to mark selected items}
(1) 4-209     procedure AllocateSelectSet(MaxItems : Word);
                {-Allocate the select set for the maximum items}
(1) 4-212     procedure ClearSelected;
                {-Clear selected items}
(1) 4-226     procedure MarkAllSelected;
                {-Mark all items selected}
(1) 4-231     procedure SelectItem(Item : Word); virtual;
                {-Select an item}
(1) 4-213     procedure DeselectItem(Item : Word); virtual;
                {-Deselect an item}
(1) 4-224     function ItemIsSelected(Item : Word) : Boolean;
                {-Return True if item is selected}
(1) 4-217     function GetSelectedCount : Word;
                {-Return number of items selected}
(1) 4-223     procedure InitSequence(var Item : Word);
                {-Prepare to get first selected item}
(1) 4-218     function HaveSelected(Item : Word) : Boolean;
                {-Return True if there is a selected item}
(1) 4-226     procedure NextSelected(var Item : Word);
                {-Position Item at the next selected item}
(1) 4-223     function IsProtected(Item : Word) : Boolean;
                {-Return True if item is protected from selection}
(1) 4-227     function NumSelectableItems : Word;
                {-Return number of items that are not protected}
(1) 4-225     constructor Load(var S : IdStream);
                {-Load a pick list from a stream}
(1) 4-238     procedure Store(var S : IdStream);
                {-Store a pick list in a stream}

OpPick  Procedures and Functions
==============================================================================

(1) 4-199     function PickNoSearch(P : PickListPtr) : Boolean;
                {-No searching mode}
(1) 4-199     function PickStringSearch(P : PickListPtr) : Boolean;
                {-String searching mode}
(1) 4-199     function PickAltStringSearch(P : PickListPtr) : Boolean;
                {-Alternate string searching mode}
(1) 4-199     function PickCharSearch(P : PickListPtr) : Boolean;
                {-Character searching mode}
(1) 4-199     function PickCharExit(P : PickListPtr) : Boolean;
                {-Character searching with exit on match}
(1) 4-199     function PickAnyCharExit(P : PickListPtr) : Boolean;
                {-Exit on any alpha character. No highlight repositioning}
(1) 4-194     procedure PickVertical(P : PickListPtr);
                {-Initialize pick for items arranged vertically}
(1) 4-194     procedure PickHorizontal(P : PickListPtr);
                {-Initialize pick for items arranged horizontally}
(1) 4-194     procedure PickSnaking(P : PickListPtr);
                {-Initialize pick for items arranged vertically, snaking}
(1) 4-188     procedure SingleChoice(P : PickListPtr);
                {-Initialize for a single choice picklist}
(1) 4-188     procedure MultipleChoice(P : PickListPtr);
                {-Initialize for a multiple choice picklist}
(1) 4-233     procedure NoMoveAction(P : PickListPtr);
                {-User hook routine called just before getting each pick command}

OpDir   DirList
==============================================================================

(1) 4-265     constructor Init(X1, Y1, X2, Y2 : Byte; HeapToUse : Word;
                               PickOrientation : pkGenlProc;
                               CommandInit : diInitCommandProc);
                {-Initialize a directory list}
(1) 4-266     constructor InitCustom(X1, Y1, X2, Y2 : Byte; var Colors : ColorSet;
                                     Options : LongInt; HeapToUse : Word;
                                     PickOrientation : pkGenlProc;
                                     CommandInit : diInitCommandProc);
                {-Initialize a directory list with custom window options}
(1) 4-256     destructor Done; virtual;
                {-Dispose of directory list}
(1) 4-251     procedure AddMaskHeader(FullPath : Boolean; PadSize : Byte;
                                      MaxLen : Byte; Posn : HeaderPosType);
                {-Add a header to display the search mask}
(1) 4-274     procedure SetMask(Mask : String; FileAttr : Byte);
                {-Set search mask and attribute and reset list}
(1) 4-271     procedure ResetList;
                {-Force reread of directory when it may have changed}
(1) 4-268     procedure PreloadDirList;
                {-Read directory in advance, in order to optimize size before
                  drawing}
(1) 4-268     procedure Process; virtual;
                {-Process pick commands leading to a file choice}
(1) 4-281     procedure UpdateContents; virtual;
                {-Redraw the contents of the directory window}
(1) 4-278     procedure SortList; virtual;
                {-Sort the list of directory entries}
(1) 4-269     function Reject(var X : DirRec) : Boolean; virtual;
                {-Return True to exclude a particular entry from pick}
(1) 4-257     procedure Format(var X : DirRec; var pkCat : Byte;
                               var S : String); virtual;
                {-Return a formatted string and category for a directory entry}
(1) 4-258     function GetFileName(Mask : String; FileAttr : Byte;
                                   var Name : PathStr) : Word;
                {-Set a new mask, pick a name and return. Returns status}
(1) 4-253     procedure ChangeDirectory(Mask : String; ChangeCode : Byte);
                {-Change to specified directory, or let user browse around to do
                  so}
(1) 4-260     function GetMatchingFileCount : Word;
                {-Return number of files matched in last directory}
(1) 4-260     function GetMatchingSize(ClusterSize : Word) : LongInt;
                {-Return number of bytes in all matched files}
(1) 4-264     function GetSelectedFile : FileStr;
                {-Return 12-character name of selected file}
(1) 4-264     function GetSelectedPath : PathStr;
                {-Return full pathname of selected file}
(1) 4-263     function GetSelectedDir : DirStr;
                {-Return directory of selected file}
(1) 4-263     procedure GetSelectedDirRec(var D : DirRec);
                {-Return full DirRec for selected file}
(1) 4-272     function SelectedFileInCurDir : Boolean;
                {-Return true if selected file is in current directory}
(1) 4-270     procedure RemoveSelectedFile;
                {-Remove current file from pick list}
(1) 4-255     procedure diOptionsOn(OptionFlags : Word);
                {-Activate multiple options}
(1) 4-255     procedure diOptionsOff(OptionFlags : Word);
                {-Deactivate multiple options}
(1) 4-254     function diOptionsAreOn(OptionFlags : Word) : Boolean;
                {-Return True if all specified options are on}
(1) 4-256     function FileCapacity : Word;
                {-Return the maximum number of files list can hold}
(1) 4-278     procedure SetNameFormat;
                {-Initialize for compact nnnnnnnn.xxx format}
(1) 4-278     procedure SetNameSizeFormat(DirStr : String);
                {-Initialize for nnnnnnn.xxx sssssssss format}
(1) 4-278     procedure SetNameSizeKFormat(DirStr : String);
                {-Initialize for nnnnnnn.xxx ssssssk format}
(1) 4-278     procedure SetNameTimeFormat(DatePicture, TimePicture : String);
                {-Initialize for name date time format}
(1) 4-278     procedure SetNameSizeTimeFormat(DirStr,
                                              DatePicture, TimePicture : String);
                {-Initialize for name size date time format}
(1) 4-278     procedure SetNameSizeKTimeFormat(DirStr,
                                               DatePicture, TimePicture : String);
                {-Initialize for name size date time format}
(1) 4-278     procedure SetAllFormat(DirStr, DatePicture, TimePicture : String);
                {-Initialize for name size date time attr format}
(1) 4-278     procedure SetUserFormat(MaxFmatLen : Byte; FF : diFormatProc);
                {-Set up for a user-defined format function}
(1) 4-273     procedure SetFileAttr(Color, Mono : Byte);
                {-Set video attributes for files}
(1) 4-273     procedure SetDirAttr(Color, Mono : Byte);
                {-Set video attributes for directories}
(1) 4-276     procedure SetSelectFileAttr(Color, Mono : Byte);
                {-Set video attributes for selected file}
(1) 4-276     procedure SetSelectDirAttr(Color, Mono : Byte);
                {-Set video attributes for selected directory}
(1) 4-277     procedure SetSortOrder(SP : diSortProc);
                {-Set alternate routine for sorting}
(1) 4-275     procedure SetRejectFunc(RF : diRejectFunc);
                {-Set alternate reject function for file selection}
(1) 4-252     procedure AddRejectString(S : String);
                {-Add a string to the set to reject}
(1) 4-254     procedure ClearRejectStrings;
                {-Clear the set of strings to reject}
(1) 4-262     function GetMultiFile(N : Word) : FileStr;
                {-Return 12-character name of specified file}
(1) 4-262     function GetMultiPath(N : Word) : PathStr;
                {-Return full pathname of specified file}
(1) 4-261     procedure GetMultiDirRec(N : Word; var D : DirRec);
                {-Return full DirRec for specified file}
(1) 4-265     function GetSelectedSize(ClusterSize : Word) : LongInt;
                {-Return total size of all selected files}
(1) 4-269     procedure RemoveMultiFile(N : Word);
                {-Remove specified file from list}
(1) 4-270     procedure RemoveSelectedFiles;
                {-Remove all selected files from list}
(1) 4-261     function GetMultiDirPtr(N : Word) : DirRecPtr;
                {-Return pointer to DirRec for specified file}
(1) 4-257     procedure FormatMultiFile(N : Word);
                {-Rebuild the format string for specified file}
(1) 4-272     procedure SelectItem(N : Word); virtual;
                {-Select an item. Overrides PickList.SelectItem to avoid
                  selecting directories}
(1) 4-267     constructor Load(var S : IdStream);
                {-Load a list from a stream}
(1) 4-279     procedure Store(var S : IdStream);
                {-Store a list in a stream}

OpDir   PathList
==============================================================================

(1) 4-287     constructor Init(X1, Y1, X2, Y2 : Byte; HeapToUse : Word;
                               PickOrientation : pkGenlProc;
                               CommandInit : paInitCommandProc);
                {-Initialize a path list}
(1) 4-288     constructor InitCustom(X1, Y1, X2, Y2 : Byte; var Colors : ColorSet;
                                     Options : LongInt; HeapToUse : Word;
                                     PickOrientation : pkGenlProc;
                                     CommandInit : paInitCommandProc);
                {-Initialize a path list with custom window options}
(1) 4-285     destructor Done; virtual;
                {-Dispose of path list}
(1) 4-293     procedure SetDrive(Drive : Char);
                {-Specify drive for path list}
(1) 4-292     procedure ResetList;
                {-Force reread of directories when they may have changed}
(1) 4-296     procedure UpdateContents; virtual;
                {-Redraw the complete pick window}
(1) 4-291     procedure Process; virtual;
                {-Display list if any, get one selection}
(1) 4-291     procedure PreloadPathList;
                {-Read paths in advance, in order to optimize size before drawing}
(1) 4-286     function GetPathName(Drive : Char) : PathStr;
                {-Set drive, pick a path, and return it. Returns empty string if
                  error.}
(1) 4-287     function GetSelectedPath : PathStr;
                {-Return selected pathname}
(1) 4-290     procedure paOptionsOn(OptionFlags : Word);
                {-Activate multiple options}
(1) 4-290     procedure paOptionsOff(OptionFlags : Word);
                {-Deactivate multiple options}
(1) 4-290     function paOptionsAreOn(OptionFlags : Word) : Boolean;
                {-Return True if all specified options are on}
(1) 4-292     procedure SetClusterSize(Size : Word);
                {-Set cluster size for adjusting files to DOS boundaries}
(1) 4-293     procedure SetDrawingChars(P : PathDrawArray);
                {-Set the characters used for line graphics}
(1) 4-294     procedure SetLineDrawMode;
                {-Display hierarchy with line draw characters (default)}
(1) 4-294     procedure SetFullPathMode;
                {-Display hierarchy with full path names}
(1) 4-295     procedure SetPathAttr(Color, Mono : Byte);
                {-Set video attributes for paths}
(1) 4-295     procedure SetSelectPathAttr(Color, Mono : Byte);
                {-Set video attributes for selected path}
(1) 4-285     function GetMultiPath(N : Word) : PathStr;
                {-Return pathname of specified path}
(1) 4-289     constructor Load(var S : IdStream);
                {-Load a list from a stream}
(1) 4-296     procedure Store(var S : IdStream);
                {-Store a list in a stream}

OpDir   Procedures and Functions
==============================================================================

(1) 4-242     procedure SingleFile(DirPtr : DirListPtr;
                                   var StringProc : pkStringProc;
                                   var CommandInitProc : pkGenlProc);
                {-Initialize for picking single files}
(1) 4-242     procedure MultipleFile(DirPtr : DirListPtr;
                                     var StringProc : pkStringProc;
                                     var CommandInitProc : pkGenlProc);
                {-Initialize for picking multiple files}
(1) 4-246     procedure SortNone(DirPtr : DirListPtr);
                {-No sort}
(1) 4-246     procedure SortName(DirPtr : DirListPtr);
                {-Sort alphabetically by name, then by extension}
(1) 4-246     procedure SortDirName(DirPtr : DirListPtr);
                {-Sort directories first, then alphabetically by name and
                  extension}
(1) 4-246     procedure SortSize(DirPtr : DirListPtr);
                {-Sort by size, then by name and extension}
(1) 4-246     procedure SortTime(DirPtr : DirListPtr);
                {-Sort by date, then by name/extension}
(1) 4-247     procedure NameFormat(var D : DirRec; var pkCat : Byte;
                                   var S : String; DirPtr : DirListPtr);
                {-Simple default format for directory lists}
(1) 4-247     procedure NameSizeKFormat(var D : DirRec; var pkCat : Byte;
                                        var S : String; DirPtr : DirListPtr);
                {-Show name and size in Kilobytes}
(1) 4-247     procedure NameSizeFormat(var D : DirRec; var pkCat : Byte;
                                       var S : String; DirPtr : DirListPtr);
                {-Show name and size in bytes}
(1) 4-247     procedure NameTimeFormat(var D : DirRec; var pkCat : Byte;
                                       var S : String; DirPtr : DirListPtr);
                {-Show name and date/time}
(1) 4-247     procedure NameSizeKTimeFormat(var D : DirRec; var pkCat : Byte;
                                            var S : String; DirPtr : DirListPtr);
                {-Show name, size(K), time}
(1) 4-247     procedure NameSizeTimeFormat(var D : DirRec; var pkCat : Byte;
                                           var S : String; DirPtr : DirListPtr);
                {-Show name, size, time}
(1) 4-247     procedure AllFormat(var D : DirRec; var pkCat : Byte;
                                  var S : String; DirPtr : DirListPtr);
                {-Show name, size, time, attr}
(1) 4-245     function RejectNone(var D : DirRec; DirPtr : DirListPtr) : Boolean;
                {-Don't reject any files}
(1) 4-245     function RejectExtensions(var D : DirRec;
                                        DirPtr : DirListPtr) : Boolean;
                {-Reject files with extensions in RejectSet}
(1) 4-245     function RejectFiles(var D : DirRec; DirPtr : DirListPtr) : Boolean;
                {-Reject all but subdirectories}
(1) 4-283     procedure SinglePath(PathPtr : PathListPtr;
                                   var StringProc : pkStringProc;
                                   var CommandInitProc : pkGenlProc);
                {-Initialize for picking single paths}
(1) 4-283     procedure MultiplePath(PathPtr : PathListPtr;
                                     var StringProc : pkStringProc;
                                     var CommandInitProc : pkGenlProc);
                {-Initialize for picking multiple paths}

OpMenu  MenuItemNode
==============================================================================

(1) 4-318     procedure Protect;
                {-Protect item}
(1) 4-319     procedure Unprotect;
                {-Unprotect item}
(1) 4-315     function ChangeName(Name : String) : Boolean;
                {-Change the name of item}
(1) 4-315     procedure ChangeKey(Key : LongInt);
                {-Change the item key}
(1) 4-314     function ChangeHelp(Help : String) : Boolean;
                {-Change the help string}
(1) 4-315     procedure ChangeSelectPos(SelectPos : Byte);
                {-Change the select character offset}
(1) 4-314     procedure ChangeDisplayPos(DisplayPos : Byte);
                {-Change the display offset}
(1) 4-316     procedure ChangeSubPtr(SPtr : SubMenuPtr);
                {-Change submenu pointer of item}
(1) 4-316     procedure DisplayInfo(var DisplayPos, SelectPos : Byte;
                                    var S : String);
                {-Return string and display offsets for item}
(1) 4-317     function HelpString : String;
                {-Return help string for item}
(1) 4-318     function ItemKey : LongInt;
                {-Return menu key for item}
(1) 4-319     function SubPtr : SubMenuPtr;
                {-Return submenu pointer for item}
(1) 4-317     function IsProtected : Boolean;
                {-Return True if item is protected}
(1) 4-318     function SelectChar : Char;
                {-Return alpha selection char (uppercase)}
(1) 4-317     function GetDisplayPos : Byte;
                {-Return just the display offset}

OpMenu  Menu
==============================================================================

(1) 4-338     constructor Init(X1, Y1, X2, Y2 : Byte; Orient : mnOrientation);
                {-Create a menu with default options and colors}
(1) 4-339     constructor InitCustom(X1, Y1, X2, Y2 : Byte; var Colors : ColorSet;
                                     Options : LongInt; Orient : mnOrientation);
                {-Create a menu with custom window options}
(1) 4-344     procedure mnOptionsOn(OptionFlags : Word);
                {-Activate multiple options}
(1) 4-344     procedure mnOptionsOff(OptionFlags : Word);
                {-Deactivate multiple options}
(1) 4-344     function mnOptionsAreOn(OptionFlags : Word) : Boolean;
                {-Return True if all specified options are on}
(1) 4-325     procedure AddItem(Name : String; DisplayPos, SelectPos : Byte;
                                Key : LongInt);
                {-Add item to current item list, allocating string space on heap}
(1) 4-325     procedure AddItemPtr(var Name : String; DisplayPos, SelectPos : Byte;
                                   Key : LongInt);
                {-Add item to current item list, not allocating string space on
                  heap}
(1) 4-325     procedure AddItemHelp(Name : String; DisplayPos, SelectPos : Byte;
                                    Key : LongInt; Help : String);
                {-Add item to current item list, allocating string space on heap}
(1) 4-325     procedure AddItemHelpPtr(var Name : String;
                                       DisplayPos, SelectPos : Byte;
                                       Key : LongInt; var Help : String);
                {-Add item to current item list, not allocating string space on
                  heap}
(1) 4-328     procedure AddSeparator(FirstChar, SpanChar, LastChar : Char;
                                     DisplayPos : Byte);
                {-Add a separator bar at offset DisplayPos within the window}
(1) 4-328     procedure AddSeparatorColor(FirstChar, SpanChar, LastChar : Char;
                                          DisplayPos : Byte;
                                          AttrColor, AttrMono : Byte);
                {-Add a separator bar at offset DisplayPos within the window with
                  specified colors}
(1) 4-329     procedure AddSubMenu(X1, Y1, X2, Y2 : Byte; Orient : mnOrientation);
                {-Add an unframed submenu with options and colors cloned from main
                  menu}
(1) 4-324     procedure AddFramedSubMenu(X1, Y1, X2, Y2 : Byte;
                                         Orient : mnOrientation; FA : FrameArray);
                {-Add a framed submenu with options and colors cloned from main
                  menu}
(1) 4-330     procedure AddSubMenuCustom(X1, Y1, X2, Y2 : Byte;
                                         var Colors : ColorSet; Options : LongInt;
                                         Orient : mnOrientation; FA : FrameArray);
                {-Add a submenu with custom window options}
(1) 4-341     procedure ItemsDone;
                {-Terminate the current item list. Set first item as default.}
(1) 4-342     procedure ItemsDoneCustom(OptimizeSize : Boolean;
                                        DefaultKey : LongInt);
                {-Terminate the current item list and customize size and default
                  key}
(1) 4-353     procedure SetNormAttr(Color, Mono : Byte);
                {-Set attributes for normal item text}
(1) 4-353     procedure SetSelectAttr(Color, Mono : Byte);
                {-Set attributes for selected item text}
(1) 4-353     procedure SetHighAttr(Color, Mono : Byte);
                {-Set attributes for pick highlight text}
(1) 4-353     procedure SetProtectAttr(Color, Mono : Byte);
                {-Set attributes for protected item text}
(1) 4-353     procedure SetFrameAttr(Color, Mono : Byte);
                {-Set frame attributes of all windows in menu system}
(1) 4-353     procedure SetHeaderAttr(Color, Mono : Byte);
                {-Set header attributes of all windows in menu system}
(1) 4-353     procedure SetShadowAttr(Color, Mono : Byte);
                {-Set shadow attributes of all windows in menu system}
(1) 4-354     procedure SetLeftPad(LeftPad : Byte);
                {-Set the number of characters to left pad each item when
                  displayed}
(1) 4-354     procedure SetSelectMarker(Left, Right : String);
                {-Define strings to mark selected items}
(1) 4-320     procedure AddHeader(S : string; Posn : HeaderPosType);
                {-Add a standard header}
(1) 4-320     procedure AddHeaderColor(S : string; Posn : HeaderPosType;
                                       AttrColor, AttrMono : Byte);
                {-Add a standard header with custom color}
(1) 4-320     procedure AddCustomHeader(S : string; Posn : FrameCornerType;
                                        DX, DY : Integer;
                                        AttrColor, AttrMono : Byte);
                {-Add a custom header}
(1) 4-329     procedure AddShadow(Posn : ShadowPosType; DrawType : ShadowDrawType);
                {-Add a standard shadow}
(1) 4-320     procedure AddShadowColor(Posn : ShadowPosType;
                                       DrawType : ShadowDrawType;
                                       AttrColor, AttrMono : Byte);
                {-Add a standard shadow with custom color}
(1) 4-320     procedure EnableExplosions(StageDelay : Word);
                {-Enable exploding windows with StageDelay milliseconds per stage}
(1) 4-320     procedure EnableNormalOpen;
                {-Disable exploding windows or alternate draw routines}
(1) 4-350     procedure SetAllNormAttr(Color, Mono : Byte);
                {-Set normal attributes of all items in menu system}
(1) 4-350     procedure SetAllSelectAttr(Color, Mono : Byte);
                {-Set select attributes of all items in menu system}
(1) 4-350     procedure SetAllHighAttr(Color, Mono : Byte);
                {-Set highlight attributes of all items in menu system}
(1) 4-350     procedure SetAllProtectAttr(Color, Mono : Byte);
                {-Set protect attributes of all items in menu system}
(1) 4-350     procedure SetAllFrameAttr(Color, Mono : Byte);
                {-Set frame attributes of all windows in menu system}
(1) 4-350     procedure SetAllHeaderAttr(Color, Mono : Byte);
                {-Set header attributes of all windows in menu system}
(1) 4-350     procedure SetAllShadowAttr(Color, Mono : Byte);
                {-Set shadow attributes of all windows in menu system}
(1) 4-329     procedure AddShadows(MainMenu : Boolean; Posn : ShadowPosType;
                                   DrawType : ShadowDrawType);
                {-Add shadows to all submenus}
(1) 4-333     procedure EnableAllExplosions(StageDelay : Word);
                {-Enable exploding windows with StageDelay milliseconds per stage}
(1) 4-332     procedure EnableAllAlternateOpen(OpenProc, CloseProc : RawWindowProc;
                                               StageDelay : Word);
                {-Enable alternate draw and erase routines}
(1) 4-333     procedure EnableAllNormalOpen;
                {-Disable exploding windows or alternate draw routines}
(1) 4-351     procedure SetAllSelectMarker(Left, Right : String);
                {-Define strings to mark selected items in all submenus}
(1) 4-352     procedure SetHelpAttr(Color, Mono : Byte);
                {-Set the colors for the help line}
(1) 4-337     procedure GetHelpAttr(var Color, Mono : Byte);
                {-Get the colors stored for the help line}
(1) 4-358     procedure VisitAllItems(IProc : mnItemProc; var D);
                {-Call the specified procedure for all items in the menu system}
(1) 4-358     procedure VisitAllWindows(WProc : mnWindowProc; var D);
                {-Call the specified procedure for all submenus in the menu system}
(1) 4-351     procedure SetCurrentItemProc(IP : mnCurrentItemProc);
                {-Set procedure to be called whenever the active item is drawn}
(1) 4-352     procedure SetCustomStringProc(CP : mnCustomProc);
                {-Set item string customization procedure}
(1) 4-330     procedure CurrentItem(IPtr : MenuItemNodePtr); virtual;
                {-Called just after the currently selected item is drawn}
(1) 4-346     procedure Process; virtual;
                {-Process menu commands leading to a choice}
(1) 4-344     function MenuChoice : LongInt;
                {-Return the last menu choice}
(1) 4-336     procedure EraseCurrentSubMenu;
                {-Erase current submenu}
(1) 4-335     procedure EraseAllSubMenus(ShowSelect, ShowHighlight : Boolean);
                {-Erase all submenus, leave main menu showing in specified state}
(1) 4-336     procedure EraseClear;
                {-Erase menu and clear active submenus for next draw}
(1) 4-348     procedure SelectItem(Key : LongInt);
                {-Select specified item and update screen}
(1) 4-350     procedure SelectSubMenu(Key : LongInt);
                {-Select current item of submenu containing Key and update screen}
(1) 4-349     function SelectItemByPos(X, Y : Byte) : Boolean;
                {-Select visible item (if any) at absolute position and update
                  screen}
(1) 4-347     procedure Redraw;
                {-Erase and redraw menu system, presumably after changing an item}
(1) 4-346     procedure ProtectItem(Key : LongInt);
                {-Protect specified item. No screen update}
(1) 4-357     procedure UnprotectItem(Key : LongInt);
                {-Unprotect specified item. No screen update}
(1) 4-331     procedure DefaultItem(Key : LongInt);
                {-Make item Key the default of its submenu. No screen update}
(1) 4-331     procedure DefaultPath(Key : LongInt);
                {-Select path to specified item. No screen update}
(1) 4-323     function ActiveListPtr : MenuItemListPtr;
                {-Return pointer to active item list}
(1) 4-323     function ActiveWinPtr : RawWindowPtr;
                {-Return pointer to active raw window}
(1) 4-323     function ActiveSubPtr : SubMenuPtr;
                {-Return pointer to active submenu}
(1) 4-323     function ActiveItemPtr : MenuItemNodePtr;
                {-Return pointer to currently active item}
(1) 4-337     function FindItem(Key : LongInt) : MenuItemNodePtr;
                {-Return pointer to item node}
(1) 4-343     constructor Load(var S : IdStream);
                {-Load a list from a stream}
(1) 4-355     procedure Store(var S : IdStream);
                {-Store a list in a stream}
(1) 4-332     destructor Done; virtual;
                {-Destroy a menu}
(1) 4-334     procedure Erase; virtual;
                {-Erase menu system. Remembers previous submenus for next draw}
(1) 4-341     function IsCurrent : Boolean; virtual;
                {-Return True if menu system is the current window}
(1) 4-345     procedure MoveWindow(DX, DY : Integer); virtual;
                {-Move a menu}
(1) 4-357     procedure UpdateScreenSize;
                {-Update window size, position, and limits for current screen size}

OpMenu  Procedures and Functions
==============================================================================

(1) 4-352     procedure NoCustomization(var Name : String; Key : LongInt;
                                        Selected, Highlighted : Boolean;
                                        WPtr : RawWindowPtr);
                {-Default string customization routine that does nothing}
(1) 4-351     procedure NoCurrItemAction(CurrentItem : MenuItemNodePtr;
                                         MPtr : MenuPtr);
                {-Default active item move routine that does nothing}

OpHelp  AbstractHelpWindow
==============================================================================

(2) 4-390     constructor Init(X1, Y1, X2, Y2 : Byte;
                               HelpFile : PathStr;
                               PickOrientation : pkGenlProc);
                {-Initialize help window and open help file}
(2) 4-394     constructor InitMem(X1, Y1, X2, Y2 : Byte;
                                  HelpAddr : Pointer;
                                  PickOrientation : pkGenlProc);
                {-Initialize help window using help bound into code}
(2) 4-391     constructor InitCustom(X1, Y1, X2, Y2 : Byte;
                                     var Colors : ColorSet;
                                     Options : LongInt;
                                     HelpFile : PathStr;
                                     PickOrientation : pkGenlProc);
                {-Initialize help window and open help file}
(2) 4-392     constructor InitDeluxe(X1, Y1, X2, Y2 : Byte;
                                     var Colors : ColorSet;
                                     Options : LongInt;
                                     HelpFile : PathStr;
                                     PickOrientation : pkGenlProc;
                                     HelpOptions : Word);
                {-Initialize help window and open help file}
(2) 4-394     constructor InitMemCustom(X1, Y1, X2, Y2 : Byte;
                                        var Colors : ColorSet;
                                        Options : LongInt;
                                        HelpAddr : Pointer;
                                        PickOrientation : pkGenlProc);
                {-Initialize help window using help bound into code}
(2) 4-395     constructor InitMemDeluxe(X1, Y1, X2, Y2 : Byte;
                                        var Colors : ColorSet;
                                        Options : LongInt;
                                        HelpAddr : Pointer;
                                        PickOrientation : pkGenlProc;
                                        HelpOptions : Word);
                {-Initialize help window using help bound into code}
(2) 4-385     destructor Done; virtual;
                {-Close up and dispose of help window}
(2) 4-396     procedure ItemString(Item : Word; Mode : pkMode;
                                   var IType : pkItemType;
                                   var IString : String); virtual;
                {-Supplies each item string when the list is displayed or searched}
(2) 4-386     procedure Draw; virtual;
                {-Choose appropriate frame and draw help window or pick index}
(2) 4-405     procedure UpdateContents; virtual;
                {-Redraw the help window in pick or help mode}
(2) 4-398     procedure Process; virtual;
                {-Draw help index or current topic}
(2) 4-402     procedure SetTopic(Topic : Word);
                {-Specify which topic is displayed next. 0 for index}
(2) 4-388     function GetTopicChoice : Word;
                {-Return topic chosen by pick}
(2) 4-390     function InHelpMode : Boolean;
                {-Return True if window shows help, not pick list}
(2) 4-405     function TopicStackPtr : StaticQueuePtr;
                {-Return a pointer to the topic stack}
(2) 4-385     function CurrentTopic : Word;
                {-Return the topic number currently loaded into the help buffers}
(2) 4-389     procedure hwOptionsOn(OptionFlags : Word);
                {-Activate multiple options}
(2) 4-389     procedure hwOptionsOff(OptionFlags : Word);
                {-Deactivate multiple options}
(2) 4-389     function hwOptionsAreOn(OptionFlags : Word) : Boolean;
                {-Return True if all specified options are on}
(2) 4-401     procedure SetPickPadSize(PadSize : Byte);
                {-Set number of characters for padding of pick items}
(2) 4-400     procedure SetHelpPadSize(Pad : Byte);
                {-Set number of blank characters at edges of help window}
(2) 4-384     procedure AddTopicHeader(PadSize : Byte; MaxLen : Byte;
                                       Posn : HeaderPosType);
                {-Add a header to display the topic name}
(2) 4-384     procedure AddMoreHelpHeader(PromptStr : String80;
                                          Posn : HeaderPosType;
                                          UpStr, DnStr, SepStr : String10;
                                          UpPos, DnPos, SepPos : Byte);
                {-Add a specialized more header to indicate more help}
(2) 4-394     procedure InitHelpFrame;
                {-Make help frame look like wFrame}
(2) 4-401     procedure SetPrevTopicHotSpot(SpotNum : Byte; Posn : FrameCharType);
                {-Activate a hot spot for previous topic command}
(2) 4-400     procedure SetNestedFunc(NF : hwNestedFunc);
                {-Set function to call for nested xref commands}
(2) 4-388     function HighestTopic : Word;
                {-Return highest topic number in help system}
(2) 4-398     function PickTopics : Word;
                {-Return number of help index topics in help system}
(2) 4-387     function FindTopic(Name : String;
                                 MatchFunc : hwMatchFunc) : Word; virtual;
                {-Return Topic number of help with specified Name, 0 if not found}
(2) 4-399     function ScreenWordXY(XPos, YPos : Byte;
                                    ScanBack, ScanForward : Boolean) : String;
                {-Parse word from screen at absolute (XPos, YPos)}
(2) 4-385     function CurrentXrefTopic : Word; virtual;
                {-Return help topic of current cross reference, $FFFF if none}
(2) 4-397     constructor Load(var S : IdStream);
                {-Load a help system from a stream}
(2) 4-403     procedure Store(var S : IdStream);
                {-Store a help system in a stream}

OpHelp  ScrollingHelpWindow
==============================================================================

(2) 4-416     procedure SetMaxScroll(MaxFirstCol : Word);
                {-Set a new value for maximum horizontal scrolling}
(2) 4-416     procedure SetSendFunc(SF : shSendFunc);
                {-Set function to be called by ccBlkCopy command}
(2) 4-415     procedure SetBlockAttr(Color, Mono : Byte);
                {-Set the attribute for blocks}
(2) 4-415     procedure ResetBlock;
                {-Hide and clear the current block. No screen update}
(2) 4-415     procedure HideBlock;
                {-Hide the current block. No screen update}

OpHelp  Procedures and Functions
==============================================================================

(2) 4-418     function ScrollingHelpFile(HelpFile : PathStr) : Boolean;
                {-Return True if HelpFile is designed for a scrolling help window}
(2) 4-387     function DefaultTopicMatch(VaryingName, FixedName : String;
                                         HPtr : AbstractHelpWindowPtr) : Boolean;
                {-Default match function}
(2) 4-379     function NoNestedAction(HPtr : AbstractHelpWindowPtr) : Boolean;
                {-Defaulted nested xref function that does nothing}

OpMemo  Memo
==============================================================================

(2) 5-10      constructor Init(X1, Y1, X2, Y2 : Byte; BufferSize : Word;
                               BufPtr : Pointer);
                {-Create a memo window}
(2) 5-11      constructor InitCustom(X1, Y1, X2, Y2 : Byte; var Colors : ColorSet;
                                     Options : LongInt; BufferSize : Word;
                                     BufPtr : Pointer);
                {-Create a memo window with custom window options}
(2) 5-10      destructor Done; virtual;
                {-Deallocate text buffer if appropriate}
(2) 5-14      procedure Process; virtual;
                {-Process editing commands}
(2) 5-14      procedure ReinitBuffer;
                {-Reinitialize internal variables when contents of buffer have
                  changed}
(2) 5-13      procedure meOptionsOn(OptionFlags : LongInt);
                {-Turn options on}
(2) 5-13      procedure meOptionsOff(OptionFlags : LongInt);
                {-Turn options off}
(2) 5-13      function meOptionsAreOn(OptionFlags : LongInt) : Boolean;
                {-Return true if all specified options are on}
(2) 5-15      procedure SetCtrlAttr(Color, Mono : Byte);
                {-Set attributes for control characters}
(2) 5-17      procedure SetStatusProc(MSP : MemoStatusProc);
                {-Set status procedure}
(2) 5-15      procedure SetLineLimit(N : Integer);
                {-Set limit on number of lines}
(2) 5-17      procedure SetTabSize(TabSize : Byte);
                {-Set size for fixed tabs}
(2) 5-16      procedure SetRightMargin(RM : Byte);
                {-Set right margin}
(2) 5-16      procedure SetMaxLength(Len : Byte);
                {-Set maximum line length}
(2) 5-12      constructor Load(var S : IdStream);
                {-Load a memo from a stream}
(2) 5-18      procedure Store(var S : IdStream);
                {-Store a memo in a stream}

OpMemo  MemoFile
==============================================================================

(2) 5-22      constructor Init(X1, Y1, X2, Y2 : Byte; BufferSize : Word;
                               BufPtr : Pointer);
                {-Create a memo window for editing files}
(2) 5-23      constructor InitCustom(X1, Y1, X2, Y2 : Byte; var Colors : ColorSet;
                                     Options : LongInt; BufferSize : Word;
                                     BufPtr : Pointer);
                {-Create a memo window for editing files}
(2) 5-22      constructor InitAndAlloc(X1, Y1, X2, Y2 : Byte; BufferSize : Word);
                {-Create a memo window for editing files and allocate a buffer}
(2) 5-24      constructor InitCustomAndAlloc(X1, Y1, X2, Y2 : Byte;
                                             var Colors : ColorSet;
                                             Options : LongInt; BufferSize : Word);
                {-Create a memo window for editing files and allocate a buffer}
(2) 5-26      procedure ReadFile(FName : string; var FSize : LongInt);
                {-Read a file into the buffer, returning a status code}
(2) 5-26      procedure SaveFile;
                {-Save the text buffer in mfFileName}
(2) 5-25      constructor Load(var S : IdStream);
                {-Load a memofile from a stream}
(2) 5-27      procedure Store(var S : IdStream);
                {-Store a memofile in a stream}

OpMemo  Procedures and Functions
==============================================================================

(2) 5-29      procedure MemoStatus(MP : MemoPtr);
                {-Display status line}
(2) 5-29      procedure MemoError(UnitCode : Byte; var ErrorCode : Word;
                                  ErrorMsg : string);
                {-Display error message and wait for key press}

OpEditor TextEditor
==============================================================================

(2) 5-42      constructor Init(X1, Y1, X2, Y2 : Byte; BufferSize : Word);
                {-Create a window for editing files}
(2) 5-44      constructor InitCustom(X1, Y1, X2, Y2 : Byte; var Colors : ColorSet;
                                     Options : LongInt; BufferSize : Word);
                {-Create a custom window for editing files}
(2) 5-42      constructor InitBuf(X1, Y1, X2, Y2 : Byte; BufferSize : Word;
                                  BufPtr : Pointer);
                {-Create a window for editing files, buffer already allocated}
(2) 5-42      constructor InitBufCustom(X1, Y1, X2, Y2 : Byte;
                                        var Colors : ColorSet;
                                        Options : LongInt; BufferSize : Word;
                                        BufPtr : Pointer);
                {-Create a custom window for editing files, buffer already
                  allocated}
(2) 5-46      procedure Process; virtual;
                {-Process editing commands}
(2) 5-55      procedure teOptionsOn(OptionFlags : LongInt);
                {-Turn options on}
(2) 5-55      procedure teOptionsOff(OptionFlags : LongInt);
                {-Turn options off}
(2) 5-55      function teOptionsAreOn(OptionFlags : LongInt) : Boolean;
                {-Return true if all specified options are on}
(2) 5-48      procedure SetEditProc(EF : EditorEditFunc);
                {-Set edit function}
(2) 5-49      procedure SetGetFileProc(GFF : EditorGetFileFunc);
                {-Set get file function}
(2) 5-52      procedure SetYesNoProc(YNF : EditorYesNoFunc);
                {-Set yes-no function}
(2) 5-47      procedure SetBlockAttr(Color, Mono : Byte);
                {-Set attributes for marked blocks}
(2) 5-51      procedure SetMarkerAttr(Color, Mono : Byte);
                {-Set attributes for text markers}
(2) 5-51      procedure SetHighlightAttr(Color, Mono : Byte);
                {-Set attributes for highlighted (found) text}
(2) 5-47      procedure SetBlockIndent(Indent : Byte);
                {-Set block indentation level}
(2) 5-47      procedure SetDefaultExtension(DefExt : ExtStr);
                {-Default extension to use when prompting for filenames}
(2) 5-51      procedure SetPrinter(LptNum : Byte);
                {-Set printer (1-3)}
(2) 5-41      procedure GotoLineCol(LineNum : Integer; Col : Byte);
                {-Move cursor to LineNum, Col. Must not be called until editor
                  window has been displayed once.}
(2) 5-41      procedure GotoOffset(Offset : Word);
                {-Move cursor to specified offset in the text buffer. Must not be
                  called until editor window has been displayed once.}
(2) 5-45      procedure InsertTextAtCursor(var Data; Bytes : Word);
                {-Insert specified number of Bytes of Data into the text buffer at
                  the cursor}
(2) 5-45      procedure InsertStringAtCursor(S : String);
                {-Insert string S into the text buffer at the cursor}
(2) 5-46      constructor Load(var S : IdStream);
                {-Load a text editor from a stream}
(2) 5-54      procedure Store(var S : IdStream);
             {-Store a text editor in a stream}

OpBrowse  Browser
==============================================================================

(2) 5-67      constructor Init(X1, Y1, X2, Y2 : Byte; HeapToUse : LongInt);
                {-Initialize the browser}
(2) 5-67      constructor InitCustom(X1, Y1, X2, Y2 : Byte; var Colors : ColorSet;
                                     Options : LongInt; HeapToUse : LongInt);
                {-Initialize the browser with custom window options}
(2) 5-65      destructor Done; virtual;
                {-Deallocate page buffers}
(2) 5-69      procedure Process; virtual;
                {-Process browse commands}
(2) 5-68      procedure OpenFile(FName : String);
                {-Open file for browsing}
(2) 5-65      procedure CloseFile;
                {-Close the current browse file}
(2) 5-65      function CurrentFileName : String;
                {-Return the name of the current browse file}
(2) 5-64      procedure brOptionsOn(OptionFlags : Word);
                {-Activate multiple options}
(2) 5-64      procedure brOptionsOff(OptionFlags : Word);
                {-Deactivate multiple options}
(2) 5-64      function brOptionsAreOn(OptionFlags : Word) : Boolean;
                {-Return true if all specified options are on}
(2) 5-76      procedure ToggleModes;
                {-Toggle between hex and ASCII modes}
(2) 5-76      procedure ToggleHighBitStripping;
                {-Toggle stripping of high bits}
(2) 5-69      procedure SetDefaultExtension(DefExt : ExtStr);
                {-Default extension to use when prompting for filenames}
(2) 5-73      procedure SetPrinter(LptNum : Byte);
                {-Set printer (1-3)}
(2) 5-74      procedure SetStatusProc(SP : BrowseStatusProc);
                {-Set status procedure}
(2) 5-70      procedure SetEditProc(EF : BrowseEditFunc);
                {-Set edit function}
(2) 5-71      procedure SetGetFileProc(GF : BrowseGetFileFunc);
                {-Set edit function}
(2) 5-69      procedure SetBlockAttr(Color, Mono : Byte);
                {-Set attributes for marked blocks}
(2) 5-73      procedure SetMarkerAttr(Color, Mono : Byte);
                {-Set attributes for text markers}
(2) 5-73      procedure SetHighlightAttr(Color, Mono : Byte);
                {-Set attributes for found text}
(2) 5-68      constructor Load(var S : IdStream);
                {-Load a browser from a stream}
(2) 5-75      procedure Store(var S : IdStream);
                {-Store a browser in a stream}
(2) 5-66      procedure GotoLine(LineNum : Word);
                {-Scroll display to the specified line}
(2) 5-66      procedure GotoOffset(Offset : LongInt);
                {-Scroll display to the line nearest Offset}
(2) 5-76      procedure Transfer(StartPos, StopPos : LongInt;
                                 var Buffer; BufSize : Word);
                {-Copy browse characters from StartPos to StopPos into Buffer}

OpBrowse    Procedures and Functions
==============================================================================

(2) 5-78      procedure BrowseStatus(BP : BrowserPtr);
                {-Display status line}

OpAbsFld    Procedures and Functions
==============================================================================

(2) 6-13      procedure ChangeDecimalChar(DC : Char);
                {-Reset DecimalChar to DC}
(2) 6-13      function InternationalCurrency(FormChar : Char; MaxDigits : Byte;
                                             FloatIfPossible : Boolean;
                                             AddCommas : Boolean) : string;
                {-Return a picture mask for a currency string, based on DOS's
                  country info}

OpField SelectField
==============================================================================

(2) 6-18      procedure sfOptionsOn(OptionFlags : LongInt);
                {-Activate multiple options}
(2) 6-18      procedure sfOptionsOff(OptionFlags : LongInt);
                {-Deactivate multiple options}
(2) 6-18      function sfOptionsAreOn(OptionFlags : LongInt) : Boolean;
                {-Return true if all specified options are on}
(2) 6-18      procedure SetPromptAttr(Color, Mono : Byte);
                {-Set attributes for prompts}
(2) 6-18      procedure SetSelectedPromptAttr(Color, Mono : Byte);
                {-Set attributes for selected prompts}
(2) 6-18      procedure SetProtectedPromptAttr(Color, Mono : Byte);
                {-Set attributes for protected prompts}
(2) 6-18      procedure SetFieldAttr(Color, Mono : Byte);
                {-Set attributes for unselected fields}
(2) 6-18      procedure SetSelectedFieldAttr(Color, Mono : Byte);
                {-Set attributes for selected fields}
(2) 6-18      procedure SetProtectedFieldAttr(Color, Mono : Byte);
                {-Set attributes for protected fields}
(2) 6-18      procedure SetCtrlAttr(Color, Mono : Byte);
                {-Set attributes for control characters}

OpField EntryField
==============================================================================

(2) 6-26      procedure efOptionsOn(OptionFlags : LongInt);
                {-Activate multiple options}
(2) 6-26      procedure efOptionsOff(OptionFlags : LongInt);
                {-Deactivate multiple options}
(2) 6-26      function efOptionsAreOn(OptionFlags : LongInt) : Boolean;
                {-Return true if all specified options are on}
(2) 6-26      procedure sefOptionsOn(OptionFlags : LongInt);
                {-Activate multiple secondary options}
(2) 6-26      procedure sefOptionsOff(OptionFlags : LongInt);
                {-Deactivate multiple secondary options}
(2) 6-26      function sefOptionsAreOn(OptionFlags : LongInt) : Boolean;
                {-Return true if all specified secondary options are on}

OpField Procedures and Functions
==============================================================================

(2) 6-46      function ValidateNoBlanks(EFP : EntryFieldPtr; var ErrCode : Word;
                                        var ErrorSt : StringPtr) : Boolean;
              {-Validate that no usable subfields in a string contain spaces}
(2) 6-46      function ValidateNotPartial(EFP : EntryFieldPtr; var ErrCode : Word;
                                          var ErrorSt : StringPtr) : Boolean;
              {-Validate that no usable subfields in a string contain spaces
                unless all do}
(2) 6-47      function ValidateSubfields(SubfieldMask : string;
                                         EFP : EntryFieldPtr; var ErrCode : Word;
                                         var ErrorSt : StringPtr) : Boolean;
              {-Validate that subfields in a string meet the requirements of
                SubfieldMask. Note: This is NOT a regular validation routine.}

OpSelect  AbstractSelector
==============================================================================

(2) 6-72      constructor InitCustom(X1, Y1, X2, Y2 : Byte; var Colors : ColorSet;
                                     Options : LongInt; var CP : CommandProcessor;
                                     UnitCode : Byte);
                {-Initialize an abstract selector with custom window options}
(2) 6-70      destructor Done; virtual;
                {-Deallocate field list, screen buffers}
(2) 6-70      procedure DrawField(ID : Word);
                {-Draw the specified field}
(2) 6-73      procedure ResetScreen;
                {-Call when contents of field(s) changed without calling DrawField}
(2) 6-80      procedure SetWrapMode(WM : WrapMode);
                {-Set the wrap mode for the selector}
(2) 6-78      procedure SetScreenUpdateProc(SUP : ScreenUpdateProc);
                {-Set procedure to be called after a complete screen update}
(2) 6-77      procedure SetPromptAttr(Color, Mono : Byte);
                {-Set attributes for prompts}
(2) 6-79      procedure SetSelectedPromptAttr(Color, Mono : Byte);
                {-Set attributes for selected prompts}
(2) 6-78      procedure SetProtectedPromptAttr(Color, Mono : Byte);
                {-Set attributes for protected prompts}
(2) 6-75      procedure SetFieldAttr(Color, Mono : Byte);
                {-Set attributes for unselected fields}
(2) 6-79      procedure SetSelectedFieldAttr(Color, Mono : Byte);
                {-Set attributes for selected fields}
(2) 6-77      procedure SetProtectedFieldAttr(Color, Mono : Byte);
                {-Set attributes for protected fields}
(2) 6-75      procedure SetCtrlAttr(Color, Mono : Byte);
                {-Set attributes for control characters}
(2) 6-67      procedure ChangePromptAttr(ID : Word; Color, Mono : Byte);
                {-Change attributes for prompts}
(2) 6-69      procedure ChangeSelectedPromptAttr(ID : Word; Color, Mono : Byte);
                {-Change attributes for selected prompts}
(2) 6-68      procedure ChangeProtectedPromptAttr(ID : Word; Color, Mono : Byte);
                {-Change attributes for protected prompts}
(2) 6-66      procedure ChangeFieldAttr(ID : Word; Color, Mono : Byte);
                {-Change attributes for unselected fields}
(2) 6-69      procedure ChangeSelectedFieldAttr(ID : Word; Color, Mono : Byte);
                {-Change attributes for selected fields}
(2) 6-67      procedure ChangeProtectedFieldAttr(ID : Word; Color, Mono : Byte);
                {-Change attributes for protected fields}
(2) 6-65      procedure ChangeCtrlAttr(ID : Word; Color, Mono : Byte);
                {-Change attributes for control characters}
(2) 6-64      procedure AddTextField(St : string; Row, Col : Word);
                {-Add a text field}
(2) 6-64      procedure AddTextFieldCustom(St : string; Row, Col : Word;
                                           Color, Mono : Byte);
                {-Add a text field with specific colors}
(2) 6-65      procedure AddTextFieldDeluxe(St : string; Row, Col : Word;
                                           var ColorAttrs, MonoAttrs : FlexAttrs);
                {-Add a text field with special colors}
(2) 6-70      function FindField(ID : Word) : SelectFieldPtr;
                {-Return a pointer to the specified field}
(2) 6-71      function FindTextField(ID : Word) : TextFieldPtr;
                {-Return a pointer to the specified text field}
(2) 6-76      procedure SetNextField(ID : Word);
                {-Set value of asNext}
(2) 6-71      function GetCurrentID : Word;
                {-Get the ID for the current field}
(2) 6-72      function GetHelpIndex(ID : Word) : Word;
                {-Get the help index for the specified field}
(2) 6-74      procedure SetAllFieldLinks(var LinksMap);
                {-Set the forward and backward links for all fields}
(2) 6-76      procedure SetFieldLinks(ID, Next, Prev : Word);
                {-Specify the fields to jump to when <Tab> or <ShTab> pressed on a
                  given field}
(2) 6-68      procedure ChangeProtection(ID : Word; On : Boolean);
                {-Change the protection status of the specified field}
(2) 6-66      procedure ChangeHidden(ID : Word; On : Boolean);
                {-Change the hidden status of the specified field}
(2) 6-66      procedure ChangeInvisibility(ID : Word; On : Boolean);
                {-Change the invisibility status of the specified field}
(2) 6-73      procedure PositionCursorAt(SFP : SelectFieldPtr); virtual;
                {-Puts the cursor on the beginning of the specified field}
(2) 6-80      procedure VisitAllSelectFields(FProc : asFieldProc; var D);
                {-Call the specified procedure for all fields in the selector}
(2) 6-80      procedure VisitAllTextFields(FProc : asTextFieldProc; var D);
                {-Call the specified procedure for all text fields in the selector}

OpSelect  Selector
==============================================================================

(2) 6-91      constructor Init(X1, Y1, X2, Y2 : Byte);
                {-Initialize the selector}
(2) 6-91      constructor InitCustom(X1, Y1, X2, Y2 : Byte;
                                     var Colors : ColorSet;
                                     Options : LongInt);
                {-Initialize a selector with custom window options}
(2) 6-93      procedure Process; virtual;
                {-Process selection commands}
(2) 6-90      procedure AddField(PromptRow, PromptCol : Word; PromptWidth : Byte;
                                 FieldRow, FieldCol : Word; FieldWidth : Byte;
                                 HelpIndex : Word);
                {-Add a field with the specified coordinates and help index}
(2) 6-97      procedure slOptionsOn(OptionFlags : Byte);
                {-Activate multiple options}
(2) 6-97      procedure slOptionsOff(OptionFlags : Byte);
                {-Deactivate multiple options}
(2) 6-97      function slOptionsAreOn(OptionFlags : Byte) : Boolean;
                {-Return true if all specified options are on}
(2) 6-96      procedure slFieldOptionsOn(OptionFlags : LongInt);
                {-Activate multiple options}
(2) 6-96      procedure slFieldOptionsOff(OptionFlags : LongInt);
                {-Deactivate multiple options}
(2) 6-95      function slFieldOptionsAreOn(OptionFlags : LongInt) : Boolean;
                {-Return true if all specified options are on}
(2) 6-94      procedure SetGetFieldProc(GFP : GetFieldProc);
                {-Set routine to call to get strings to display}
(2) 6-93      procedure SetActionProc(AP : SelectProc);
                {-Set routine to call when field is selected}
(2) 6-95      procedure SetPreSelectProc(PSP : SelectProc);
                {-Set routine to call before moving to new field}
(2) 6-94      procedure SetPostSelectProc(PSP : SelectProc);
                {-Set routine to call before moving to next one}
(2) 6-92      constructor Load(var S : IdStream);
                {-Load a selector from a stream}
(2) 6-98      procedure Store(var S : IdStream);
                {-Store a selector in a stream}

OpSelect  ScrollingSelector
==============================================================================

(2) 6-104     constructor Init(X1, Y1, X2, Y2 : Byte);
                {-Initialize the selector}
(2) 6-104     constructor InitCustom(X1, Y1, X2, Y2 : Byte; var Colors : ColorSet;
                                     Options : LongInt);
                {-Initialize a selector with custom window options}
(2) 6-103     destructor Done; virtual;
                {-Deallocate field list, screen buffers}
(2) 6-103     procedure AllocateScreen;
                {-Call after last field added to allocate virtual screen}
(2) 6-108     procedure VScreenToScreen; virtual;
                {-Copy the virtual screen to the physical screen}
(2) 6-105     constructor Load(var S : IdStream);
                {-Load a selector from a stream}
(2) 6-106     procedure Store(var S : IdStream);
                {-Store a selector in a stream}

OpEntry EntryScreen
==============================================================================

(2) 6-153     constructor Init(X1, Y1, X2, Y2 : Byte);
                {-Initialize the entry screen}
(2) 6-153     constructor InitCustom(X1, Y1, X2, Y2 : Byte;
                                     var Colors : ColorSet;
                                     Options : LongInt);
                {-Initialize the entry screen with custom window options}
(2) 6-147     destructor Done; virtual;
                {-Dispose of the entry screen}
(2) 6-155     procedure Process; virtual;
                {-Process data entry commands}
(2) 6-116     procedure AddStringField(Prompt : string;  pRow, pCol : Word;
                                       Picture : string; fRow, fCol : Word;
                                       fWidth : Byte;    HelpIndex : Word;
                                       var EditSt : string);
                {-Add a field of type string}
(2) 6-118     procedure AddSimpleStringField(Prompt : string; pRow, pCol : Word;
                                             PicChar : Char;  fRow, fCol : Word;
                                             fWidth, MaxLen : Byte;
                                             HelpIndex : Word;
                                             var EditSt : string);
                {-Add a field of type string (simple)}
(2) 6-116     procedure AddArrayField(Prompt : string;  pRow, pCol : Word;
                                      Picture : string; fRow, fCol : Word;
                                      fWidth : Byte;    HelpIndex : Word;
                                      var EditVar);
                {-Add a field of type array (of char)}
(2) 6-119     procedure AddCharField(Prompt : string;  pRow, pCol : Word;
                                     Picture : string; fRow, fCol : Word;
                                     HelpIndex : Word; CharLo, CharHi : Char;
                                     var EditChar : Char);
                {-Add a field of type char}
(2) 6-120     procedure AddSimpleCharField(Prompt : string;    pRow, pCol : Word;
                                           PicChar : Char;     fRow, fCol : Word;
                                           HelpIndex : Word;
                                           CharLo, CharHi : Char;
                                           var EditChar : Char);
                {-Add a field of type char (simple)}
(2) 6-120     procedure AddBooleanField(Prompt : string;  pRow, pCol : Word;
                                        Picture : string; fRow, fCol : Word;
                                        HelpIndex : Word;
                                        var EditBool : Boolean);
                {-Add a field of type boolean}
(2) 6-120     procedure AddSimpleBooleanField(Prompt : string; pRow, pCol : Word;
                                              fRow, fCol : Word;
                                              HelpIndex : Word;
                                              var EditBool : Boolean);
                {-Add a field of type boolean (simple)}
(2) 6-120     procedure AddYesNoField(Prompt : string;  pRow, pCol : Word;
                                      Picture : string; fRow, fCol : Word;
                                      HelpIndex : Word; var EditYesNo : Boolean);
                {-Add a field of type yes/no}
(2) 6-120     procedure AddSimpleYesNoField(Prompt : string;   pRow, pCol : Word;
                                            fRow, fCol : Word; HelpIndex : Word;
                                            var EditYesNo : Boolean);
                {-Add a field of type yes/no (simple)}
(2) 6-116     procedure AddLongField(Prompt : string;  pRow, pCol : Word;
                                     Picture : string; fRow, fCol : Word;
                                     HelpIndex : Word; LongLo, LongHi : LongInt;
                                     var EditLong : LongInt);
                {-Add a field of type LongInt}
(2) 6-120     procedure AddNumericLongField(...);
                {-Add a field of type LongInt (numeric)}
(2) 6-118     procedure AddSimpleLongField(Prompt : string; pRow, pCol : Word;
                                           PicChar : Char;  fRow, fCol : Word;
                                           fWidth : Byte;   HelpIndex : Word;
                                           LongLo, LongHi : LongInt;
                                           var EditLong : LongInt);
                {-Add a field of type LongInt (simple)}
(2) 6-116     procedure AddWordField(Prompt : string;  pRow, pCol : Word;
                                     Picture : string; fRow, fCol : Word;
                                     HelpIndex : Word; WordLo, WordHi : Word;
                                     var EditWord : Word);
                {-Add a field of type word}
(2) 6-120     procedure AddNumericWordField(...);
                {-Add a field of type word (numeric)}
(2) 6-118     procedure AddSimpleWordField(Prompt : string;    pRow, pCol : Word;
                                           PicChar : Char; fRow, fCol : Word;
                                           fWidth : Byte;      HelpIndex : Word;
                                           WordLo, WordHi : Word;
                                           var EditWord : Word);
                {-Add a field of type word (simple)}
(2) 6-116     procedure AddIntField(Prompt : string;  pRow, pCol : Word;
                                    Picture : string; fRow, fCol : Word;
                                    HelpIndex : Word; IntLo, IntHi : Integer;
                                    var EditInt : Integer);
                {-Add a field of type integer}
(2) 6-121     procedure AddNumericIntField(...);
                {-Add a field of type integer (numeric)}
(2) 6-118     procedure AddSimpleIntField(Prompt : string;    pRow, pCol : Word;
                                          PicChar : Char;     fRow, fCol : Word;
                                          fWidth : Byte;      HelpIndex : Word;
                                          IntLo, IntHi : Integer;
                                          var EditInt : Integer);
                {-Add a field of type integer (simple)}
(2) 6-116     procedure AddByteField(Prompt : string;  pRow, pCol : Word;
                                     Picture : string; fRow, fCol : Word;
                                     HelpIndex : Word; ByteLo, ByteHi : Byte;
                                     var EditByte : Byte);
                {-Add a field of type byte}
(2) 6-121     procedure AddNumericByteField(...);
                {-Add a field of type byte (numeric)}
(2) 6-118     procedure AddSimpleByteField(Prompt : string;    pRow, pCol : Word;
                                           PicChar : Char;     fRow, fCol : Word;
                                           fWidth : Byte;      HelpIndex : Word;
                                           ByteLo, ByteHi : Byte;
                                           var EditByte : Byte);
                {-Add a field of type byte (simple)}
(2) 6-116     procedure AddShortField(Prompt : string;   pRow, pCol : Word;
                                      Picture : string;  fRow, fCol : Word;
                                      HelpIndex : Word;
                                      ShortLo, ShortHi : ShortInt;
                                      var EditShort : ShortInt);
                {-Add a field of type shortint}
(2) 6-121     procedure AddNumericShortField(...);
                {-Add a field of type shortint (numeric)}
(2) 6-118     procedure AddSimpleShortField(Prompt : string; pRow, pCol : Word;
                                            PicChar : Char;  fRow, fCol : Word;
                                            fWidth : Byte;   HelpIndex : Word;
                                            ShortLo, ShortHi : ShortInt;
                                            var EditShort : ShortInt);
                {-Add a field of type shortint (simple)}
(2) 6-116     procedure AddRealField(Prompt : string;   pRow, pCol : Word;
                                     Picture : string;  fRow, fCol : Word;
                                     HelpIndex : Word;  RealLo, RealHi : Real;
                                     Places : Byte;     var EditReal : Real);
                {-Add a field of type real}
(2) 6-121     procedure AddNumericRealField(...);
                {-Add a field of type real (numeric)}
(2) 6-118     procedure AddSimpleRealField(Prompt : string; pRow, pCol : Word;
                                           PicChar : Char;  fRow, fCol : Word;
                                           fWidth : Byte;   HelpIndex : Word;
                                           RealLo, RealHi : Real; Places : Byte;
                                           var EditReal : Real);
                {-Add a field of type real (simple)}
(2) 6-117     procedure AddDateField(Prompt : string;      pRow, pCol : Word;
                                     Picture : DateString; fRow, fCol : Word;
                                     HelpIndex : Word;     DateLo, DateHi : Date;
                                     var EditDate : Date);
                {-Add a field of type date}
(2) 6-117     procedure AddDateStField(Prompt : string;      pRow, pCol : Word;
                                       Picture : DateString; fRow, fCol : Word;
                                       HelpIndex : Word;
                                       var EditDate : DateString);
                {-Add a field of type date string}
(2) 6-117     procedure AddTimeField(Prompt : string;      pRow, pCol : Word;
                                     Picture : DateString; fRow, fCol : Word;
                                     HelpIndex : Word;     TimeLo, TimeHi : Time;
                                     var EditTime : Time);
                {-Add a field of type time}
(2) 6-117     procedure AddNestedField(Prompt : string;  pRow, pCol : Word;
                                       Picture : string; fRow, fCol : Word;
                                       fWidth : Byte;    HelpIndex : Word);
                {-Add a field that is associated with a nested form}
(2) 6-118     procedure AddNestedStringField(Prompt : string;  pRow, pCol : Word;
                                             Picture : string; fRow, fCol : Word;
                                             fWidth : Byte;    HelpIndex : Word;
                                             var EditSt : string);
                {-Add a string field that is associated with a nested form}
(2) 6-122     procedure AddChoiceField(Prompt : string;  pRow, pCol : Word;
                                       Picture : string; fRow, fCol : Word;
                                       HelpIndex : Word; DataSize : Byte;
                                       Increment : IncChoiceProc;
                                       var EditVar);
                {-Add a multiple choice field}
(2) 6-122     procedure AddMultiLineField(Prompt : string; pRow, pCol : Word;
                                          PicChar : Char;  fRow, fCol : Word;
                                          fWidth, fHeight : Byte;
                                          HelpIndex : Word; var EditVar);
                {-Add a multi-line field}
(2) 6-122     procedure AddPickStringField(Prompt : string; pRow, pCol : Word;
                                           fRow, fCol : Word; fWidth : Byte;
                                           HelpIndex : Word;
                                           var EditSt : string;
                                           var PL : PickList);
                {-Add a field of type string to be edited with a pick list}
(2) 6-122     procedure AddUserField(Prompt : string; pRow, pCol : Word;
                                     Picture : string; fRow, fCol : Word;
                                     fWidth : Byte; HelpIndex : Word;
                                     RangeLo : RangeType; RangeHi : RangeType;
                                     DataSize : Word;     DecimalPlaces : Byte;
                                     Validate: ValidationFunc;
                                     Convert : ConversionProc;
                                     FDraw   : DrawProc;
                                     Editor  : EditProc;
                                     var EditVar);
                {-Add a field of a user-defined type}
(2) 6-160     procedure SetPreEditProc(PEP : esUserProc);
                {-Specify routine to call just before field is edited}
(2) 6-159     procedure SetPostEditProc(PEP : esUserProc);
                {-Specify routine to call after each edit}
(2) 6-162     procedure SetValidateFunc(UVF : esUserValidationFunc);
                {-Specify routine to call before exiting}
(2) 6-148     procedure esOptionsOn(OptionFlags : Byte);
                {-Activate multiple options}
(2) 6-147     procedure esOptionsOff(OptionFlags : Byte);
                {-Deactivate multiple options}
(2) 6-147     function esOptionsAreOn(OptionFlags : Byte) : Boolean;
                {-Return true if all specified options are on}
(2) 6-147     procedure esFieldOptionsOn(OptionFlags : LongInt);
                {-Activate multiple field options}
(2) 6-146     procedure esFieldOptionsOff(OptionFlags : LongInt);
                {-Deactivate multiple field options}
(2) 6-146     function esFieldOptionsAreOn(OptionFlags : LongInt) : Boolean;
                {-Return true if all specified field options are on}
(2) 6-149     procedure esSecFieldOptionsOn(OptionFlags : LongInt);
                {-Activate multiple secondary field options}
(2) 6-149     procedure esSecFieldOptionsOff(OptionFlags : LongInt);
                {-Deactivate multiple secondary field options}
(2) 6-148     function esSecFieldOptionsAreOn(OptionFlags : LongInt) : Boolean;
                {-Return true if all specified secondary field options are on}
(2) 6-158     procedure SetForceMode(Force, Overtype : Boolean);
                {-Force insert or overtype mode, else use previous setting}
(2) 6-158     procedure SetPadChar(Ch : Char);
                {-Set character used to pad ends of strings}
(2) 6-159     procedure SetPasswordChar(Ch : Char);
                {-Set character used in password mode}
(2) 6-156     procedure SetBeepOnError(On : Boolean);
                {-Activate/deactivate beeping on error option for all fields}
(2) 6-157     procedure SetDelimiters(Left, Right : Char);
                {-Set field delimiters for the entry screen (null = none)}
(2) 6-157     procedure SetDelimAttr(Color, Mono : Byte);
                {-Set attributes for delimiters (unselected)}
(2) 6-161     procedure SetSelectedDelimAttr(Color, Mono : Byte);
                {-Set attributes for delimiters (selected)}
(2) 6-160     procedure SetProtectedDelimAttr(Color, Mono : Byte);
                {-Set attributes for delimiters (protected)}
(2) 6-154     constructor Load(var S : IdStream);
                {-Load an entry screen from a stream}
(2) 6-163     procedure Store(var S : IdStream);
                {-Store an entry screen in a stream}
(2) 6-161     procedure SetUserRecord(var UserRec; UserRecSize : Word);
                {-Set the address and size of the user record}
(2) 6-152     function GetUserRecord : Pointer;
                {-Return a pointer to the user record}
(2) 6-152     function GetUserRecordSize : Word;
                {-Return the size of the user record}
(2) 6-144     procedure ChangeRequired(ID : Word; On : Boolean);
                {-Modify the required status of a field after it has been added}
(2) 6-145     procedure ChangeValidation(ID : Word; VF : ValidationFunc);
                {-Change the validation routine for the specified field}
(2) 6-144     procedure ChangeConversion(ID : Word; CP : ConversionProc);
                {-Change the conversion routine for the specified field}
(2) 6-144     procedure ChangeRange(ID : Word; var RangeLo, RangeHi);
                {-Change the valid range for the specified field}
(2) 6-145     function CurrentFieldModified : Boolean;
                {-Return True if current field was modified. Call only from
                  within a post-edit routine.}
(2) 6-150     function EvaluateCommand(var Cmd : Word) : Word;
                {-Given a command, return the ID for the field the cursor will
                  move to next. Cmd may be modified on return. This routine is
                  intended to be called only from within a post-edit routine!}
(2) 6-151     procedure GetFieldCoordinates(var Row, Col, Wid : Byte);
                {-Returns the absolute screen coordinates for the current field.
                  This routine is intended to be called only from within a
                  pre-edit routine!}
(2) 6-151     function GetLastField : EntryFieldPtr;
                {-Return pointer to last field in entry screen}
(2) 6-156     function RevalidateAll(var EFP : EntryFieldPtr; var ErrCode : Word;
                                     var ErrMsg : StringPtr) : Boolean;
                {-Re-validate all unprotected fields in entry screen. If an error
                  is found, EFP will point to the field with the error, an error
                  code and error message will be returned, and RevalidateAll will
                  be False.}
(2) 6-165     procedure VisitAllEntryFields(FProc : esFieldProc; var D);
                {-Call the specified procedure for all fields in the entry
                  screen}

OpEntry ScrollingEntryScreen
==============================================================================

(2) 6-170     constructor Init(X1, Y1, X2, Y2 : Byte);
                {-Initialize the entry screen}
(2) 6-170     constructor InitCustom(X1, Y1, X2, Y2 : Byte;
                                     var Colors : ColorSet; Options : LongInt);
                {-Initialize the entry screen with custom window options}
(2) 6-169     destructor Done; virtual;
                {-Deallocate field list, screen buffers}
(2) 6-169     procedure AllocateScreen;
                {-Call after last field added to allocate virtual screen}
(2) 6-172     procedure VScreenToScreen; virtual;
                {-Copy the virtual screen to the physical screen}
(2) 6-171     constructor Load(var S : IdStream);
                {-Load a scrolling entry screen from a stream}
(2) 6-172     procedure Store(var S : IdStream);
                {-Store a scrolling entry screen in a stream}

OpEdit  LineEditor
==============================================================================

(2) 6-189     constructor Init(var Colors : ColorSet);
                {-Sets default values for attributes, etc.}
(2) 6-188     function GetLastCommand : Word;
                {-Return last command entered by user}
(2) 6-188     function GetLastKey : Word;
                {-Return last keystroke entered by user}
(2) 6-188     function GetLastError : Word;
                {-Get last error code}
(2) 6-190     procedure leEditOptionsOn(OptionFlags : LongInt);
                {-Activate multiple options}
(2) 6-189     function leEditOptionsAreOn(OptionFlags : LongInt) : Boolean;
                {-Return true if all specified options are on}
(2) 6-190     procedure leEditOptionsOff(OptionFlags : LongInt);
                {-Deactivate multiple options}
(2) 6-192     procedure leSecEditOptionsOn(OptionFlags : LongInt);
                {-Activate multiple options}
(2) 6-191     function leSecEditOptionsAreOn(OptionFlags : LongInt) : Boolean;
                {-Return true if all specified options are on}
(2) 6-191     procedure leSecEditOptionsOff(OptionFlags : LongInt);
                {-Deactivate multiple options}
(2) 6-195     procedure SetPadChar(Ch : Char);
                {-Set character used to pad strings being edited}
(2) 6-195     procedure SetPasswordChar(Ch : Char);
                {-Set character used to represent text in password mode}
(2) 6-195     procedure SetHelpIndex(Index : Word);
                {-Set the help index}
(2) 6-193     procedure SetCommandProcessor(var CP : CommandProcessor);
                {-Set command processor to use}
(2) 6-194     procedure SetErrorProc(EEP : ErrorProc);
                {-Set procedure to call on error}
(2) 6-192     constructor Load(var S : IdStream);
                {-Load a line editor from a stream}
(2) 6-196     procedure Store(var S : IdStream);
                {-Store a line editor in a stream}
(2) 6-178     procedure ReadString(Prompt : string; Row, Col, MaxLen, Width : Byte;
                                   var St : string);
                {-Edit a string}
(2) 6-178     procedure ReadSpecial(Prompt : string;
                                    Row, Col, MaxLen, Width : Byte;
                                    PictureChar : Char; var St : string);
                {-Edit a string}
(2) 6-179     procedure ReadChar(Prompt : string; Row, Col : Byte;
                                 ValidChars : CharSet; var Ch : Char);
                {-Display a prompt and wait for a key in ValidChars}
(2) 6-179     function YesOrNo(Prompt : string; Row, Col : Byte;
                               Default : Char) : Boolean;
                {-Return true for yes, false for no}
(2) 6-178     procedure ReadLongInt(Prompt : string; Row, Col, Width : Byte;
                                    LLo, LHi : LongInt; var L : LongInt);
                {-Edit a long integer}
(2) 6-178     procedure ReadInteger(Prompt : string; Row, Col, Width : Byte;
                                    NLo, NHi : Integer; var N : Integer);
                {-Edit an integer}
(2) 6-178     procedure ReadWord(Prompt : string; Row, Col, Width : Byte;
                                 WLo, WHi : Word; var W : Word);
                {-Edit a word}
(2) 6-178     procedure ReadByte(Prompt : string; Row, Col, Width : Byte;
                                 BLo, BHi : Byte; var B : Byte);
                {-Edit a byte}
(2) 6-178     procedure ReadShortInt(Prompt : string; Row, Col, Width : Byte;
                                     SLo, SHi : ShortInt; var SI : Shortint);
                {-Edit a ShortInt}
(2) 6-178     procedure ReadReal(Prompt : string; Row, Col, Width, Places : Byte;
                                 RLo, RHi : Real; var R : Real);
                {-Edit a real}
(2) 6-179     procedure EditString(Prompt : string; Row, Col : Byte;
                                   Picture : string;
                                   Width : Byte; var St : string);
                {-Edit a string}
(2) 6-179     procedure EditArray(Prompt : string; Row, Col : Byte;
                                  Picture : string; Width : Byte; var A);
                {-Edit an array of char}
(2) 6-181     procedure EditChar(Prompt : string; Row, Col : Byte;
                                 Picture : string; ChLo, ChHi : Char;
                                 var Ch : Char);
                {-Edit an array of char}
(2) 6-181     procedure EditBoolean(Prompt : string; Row, Col : Byte;
                                    Picture : string; var B : Boolean);
                {-Edit a boolean variable}
(2) 6-181     procedure EditYesNo(Prompt : string; Row, Col : Byte;
                                  Picture : string; var YN : Boolean);
                {-Edit a yes-no variable}
(2) 6-180     procedure EditLongInt(Prompt : string; Row, Col : Byte;
                                    Picture : string; LLo, LHi : LongInt;
                                    var L : LongInt);
                {-Edit a long integer}
(2) 6-181     procedure EditNumericLongInt(...);
                {-Edit a long integer (numeric)}
(2) 6-180     procedure EditInteger(Prompt : string; Row, Col : Byte;
                                    Picture : string; NLo, NHi : Integer;
                                    var N : Integer);
                {-Edit an integer}
(2) 6-182     procedure EditNumericInteger(...);
                {-Edit an integer (numeric)}
(2) 6-180     procedure EditWord(Prompt : string; Row, Col : Byte;
                                 Picture : string; WLo, WHi : Word;
                                 var W : Word);
                {-Edit a word}
(2) 6-182     procedure EditNumericWord(...);
                {-Edit a word (numeric)}
(2) 6-180     procedure EditByte(Prompt : string; Row, Col : Byte;
                                 Picture : string; BLo, BHi : Byte;
                                 var B : Byte);
                {-Edit a byte}
(2) 6-182     procedure EditNumericByte(...);
                {-Edit a byte (numeric)}
(2) 6-180     procedure EditShortInt(Prompt : string; Row, Col : Byte;
                                     Picture : string; SLo, SHi : ShortInt;
                                     var SI : Shortint);
                {-Edit a ShortInt}
(2) 6-182     procedure EditNumericShortInt(...);
                {-Edit a ShortInt (numeric)}
(2) 6-180     procedure EditReal(Prompt : string; Row, Col : Byte;
                                 Picture : string; Places : Byte;
                                 RLo, RHi : Real; var R : Real);
                {-Edit a real}
(2) 6-182     procedure EditNumericReal(...);
                {-Edit a real (numeric)}
(2) 6-181     procedure EditDate(Prompt : string; Row, Col : Byte;
                                 Picture : string; DLo, DHi : Date; var D : Date);
                {-Edit a date variable}
(2) 6-181     procedure EditDateSt(Prompt : string; Row, Col : Byte;
                                   Picture : DateString; var DS : DateString);
                {-Edit a date string}
(2) 6-181     procedure EditTime(Prompt : string; Row, Col : Byte;
                                 Picture : DateString;
                                 TLo, THi : Time; var T : Time);
                {-Edit a time variable}
(2) 6-182     procedure EditChoice(Prompt : string; Row, Col : Byte;
                                   Picture : string; DataSize : Byte;
                                   Increment : IncChoiceProc; var MC);
                {-Edit a multiple choice variable}
(2) 6-182     procedure EditMultiLine(Prompt : string; Row, Col : Byte;
                                      Width, Height : Byte; var StArray);
             {-Edit a multiline field}

OpSEdit SimpleLineEditor
==============================================================================

(2) 6-202     constructor Init(var Colors : ColorSet);
                {-Sets default values for attributes, etc.}
(2) 6-201     function GetLastCommand : Word;
                {-Return last command entered by user}
(2) 6-201     function GetLastKey : Word;
                {-Return last keystroke entered by user}
(2) 6-202     procedure ReadString(Prompt : string; Row, Col, MaxLen, Width : Byte;
                                   var S : string);
                {-Edit a string}
(2) 6-203     procedure seOptionsOn(OptionFlags : LongInt);
                {-Activate multiple options}
(2) 6-203     function seOptionsAreOn(OptionFlags : LongInt) : Boolean;
                {-Return true if all specified options are on}
(2) 6-203     procedure seOptionsOff(OptionFlags : LongInt);
                {-Deactivate multiple options}
(2) 6-205     procedure SetPromptAttr(Color, Mono : Byte);
                {-Set attributes for prompts}
(2) 6-204     procedure SetFieldAttr(Color, Mono : Byte);
                {-Set attributes for line being edited}
(2) 6-204     procedure SetCtrlAttr(Color, Mono : Byte);
                {-Set attributes for control characters}
(2) 6-205     procedure SetHelpIndex(Index : Word);
                {-Set the help index}
(2) 6-204     procedure SetCommandProcessor(var CP : CommandProcessor);
                {-Set command processor to use}

OpDate  Procedures and Functions
==============================================================================

(2) 6-227     function ValidDate(Day, Month, Year : Integer) : Boolean;
                {-Verify that day, month, year is a valid date}
(2) 6-217     function DMYtoDate(Day, Month, Year : Integer) : Date;
                {-Convert from day, month, year to a julian date}
(2) 6-215     procedure DateToDMY(Julian : Date; var Day, Month, Year : Integer);
                {-Convert from a julian date to day, month, year}
(2) 6-218     function IncDate(Julian : Date;
                               Days, Months, Years : Integer) : Date;
                {-Add (or subtract) the number of days, months, and years to a
                  date}
(2) 6-219     function IncDateTrunc(Julian : Date; Months, Years : Integer) : Date;
                {-Add (or subtract) the specified number of months and years to a
                  date}
(2) 6-212     procedure DateDiff(Date1, Date2 : Date;
                                 var Days, Months, Years : Integer);
                {-Return the difference in days,months,years between two valid
                  julian dates}
(2) 6-215     function DayOfWeek(Julian : Date) : DayType;
                {-Return the day of the week for the date}
(2) 6-216     function DayOfWeekDMY(Day, Month, Year : Integer) : DayType;
                {-Return the day of the week for the day, month, year}
(2) 6-213     function DateStringToDate(Picture, S : DateString) : Date;
                {-Convert S, a string of the form indicated by Picture, to a
                  julian date. Picture and S must be of equal lengths}
(2) 6-214     function DateToDateString(Picture : DateString;
                                        Julian : Date) : DateString;
                {-Convert Julian to a string of the form indicated by Picture}
(2) 6-226     function Today : Date;
                {-Returns today's date as a julian}
(2) 6-215     function DateToSortString(Julian : Date) : string;
                {-Convert a date to a sortable string}
(2) 6-222     function SortStringToDate(S : string) : Date;
                {-Convert a sortable string form to a date}
(2) 6-221     function IsLeapYear(Year : Integer) : Boolean;
                {-Return True if Year is a leap year}
(2) 6-216     function DaysInMonth(Month, Year : Integer) : Integer;
                {-Return the number of days in the specified month of a given year}
(2) 6-213     function DateStringToDMY(Picture, S : DateString;
                                       var D, M, Y : Integer) : Boolean;
                {-Extract day, month, and year from S, returning true if string is
                  valid}
(2) 6-217     function DMYtoDateString(Picture : DateString;
                                       Day, Month, Year : Integer) : DateString;
                {-Merge the month, day, and year into the picture}
(2) 6-227     function TodayString(Picture : DateString) : DateString;
                {-Returns today's date as a string of the specified form}
(2) 6-227     function ValidTime(Hours, Minutes, Seconds : Integer) : Boolean;
                {-Return true if Hours:Minutes:Seconds is a valid time}
(2) 6-225     procedure TimeToHMS(T : Time; var Hours, Minutes, Seconds : Byte);
                {-Convert a Time variable to Hours, Minutes, Seconds}
(2) 6-217     function HMStoTime(Hours, Minutes, Seconds : Byte) : Time;
                {-Convert Hours, Minutes, Seconds to a Time variable}
(2) 6-224     function TimeStringToHMS(Picture, St : DateString;
                                       var H, M, S : Integer) : Boolean;
                {-Extract Hours, Minutes, Seconds from St, returning True if
                  string is valid}
(2) 6-224     function TimeStringToTime(Picture, S : DateString) : Time;
                {-Convert S, a string of the form indicated by Picture, to Time}
(2) 6-226     function TimeToTimeString(Picture : DateString;
                                        T : Time) : DateString;
                {-Convert T to a string of the form indicated by Picture}
(2) 6-225     function TimeToAmPmString(Picture : DateString;
                                        T : Time) : DateString;
                {-Convert T to a string of the form indicated by Picture. Times are
                  always displayed in am/pm format.}
(2) 6-212     function CurrentTime : Time;
                {-Returns current time in seconds since midnight}
(2) 6-212     function CurrentTimeString(Picture : DateString) : DateString;
                {-Returns current time as a string of the specified form}
(2) 6-223     procedure TimeDiff(Time1, Time2 : Time;
                                 var Hours, Minutes, Seconds : Byte);
                {-Return the difference in hours,minutes,seconds between two times}
(2) 6-219     function IncTime(T : Time; Hours, Minutes, Seconds : Byte) : Time;
                {-Add the specified hours,minutes,seconds to T and return result}
(2) 6-216     function DecTime(T : Time; Hours, Minutes, Seconds : Byte) : Time;
                {-Subtract the specified hours,minutes,seconds from T and return
                  the result}
(2) 6-226     function TimeToSortString(T : Time) : string;
                {-Convert a time variable to a sortable string}
(2) 6-221     function RoundToNearestHour(T : Time; Truncate : Boolean) : Time;
                {-Round T to the nearest hour or Truncate minutes & seconds from T}
(2) 6-222     function RoundToNearestMinute(T : Time; Truncate : Boolean) : Time;
                {-Round T to the nearest minute, or Truncate seconds from T}
(2) 6-223     function SortStringToTime(S : string) : Time;
                {-Convert a sortable string to a time variable}
(2) 6-214     procedure DateTimeDiff(DT1, DT2 : DateTimeRec;
                                     var Days : Word; var Secs : LongInt);
                {-Return the difference in days and seconds between two points
                  in time}
(2) 6-218     procedure IncDateTime(var DT1, DT2 : DateTimeRec; Days : Integer;
                                    Secs : LongInt);
                {-Increment (or decrement) DT1 by the specified number of days
                  and seconds and put the result in DT2}
(2) 6-220     function InternationalDate(WholeYear,
                                         ZeroPad : Boolean) : DateString;
                {-Return a picture mask for a date string, based on DOS's
                  country info}
(2) 6-220     function InternationalTime(
                  WithSeconds, ZeroPad, ExtraSpace, WithEm : Boolean) : DateString;
                {-Return a picture mask for a time string based on DOS's
                  country info}

OpPrnLow  BasePrinter
==============================================================================

(2) 7-19      constructor Init(PrnName : PathStr; TypeOfPrinter : PrnType;
                               PrnFlags : Word);
                {-Initializes a printer object}
(2) 7-15      procedure PrnPutChar(Character : Char); Virtual;
                {-Puts a character to the output device}
(2) 7-14      procedure PrnPutBlock(var Block; BlockSize : Word); Virtual;
                {-Puts a block of characters to the output device}
2) 7-16      function PrnStatus : Word; Virtual;
                {-Return the status of the device}
(2) 7-15      procedure PrnReset; Virtual;
                {-Reset the output device}
(2) 7-13      procedure PrnFlush; Virtual;
                {-Flush the device}
(2) 7-16      function PrnXlatErrorCode(Call : PrnCallType;
                                        ErrorCode : Word) : Word; Virtual;
                {-Translate a raw error code into appropriate user error code}
(2) 7-10      function CharXlat(C : Char) : Char; Virtual;
                {-Translate the Character C according to built in translation
                  table}
(2) 7-10      destructor Done; Virtual;
                {-Flush, close, and deallocate memory used by a printer object}
(2) 7-18      function TypeOfPrn : PrnType;
                {-Returns the type of printer}
(2) 7-11      function NameOfPrn : String;
                {-Returns the printer name}
(2) 7-12      function PrnError  : Word;
                {-Returns the last error and resets pLastError to zero}
(2) 7-15      function PrnRawError : Word;
                {-Returns the raw error code returned by the last operation}
(2) 7-13      function PrnErrorOp : PrnCallType;
                {-Returns the type of the last operation}
(2) 7-14      function PrnLastPut : Word;
                {-Returns the number of characters successfully written by last
                  PrnPutBlock}
(2) 7-18      procedure XlatCharItem(CharIndex : Char; Character : Char);
                {-Change the character associated with the ascii code of CharIndex
                  to Character}
(2) 7-10      procedure ClearXlatCharTable;
                {-Clears the character translation table (the default state)}
(2) 7-12      procedure NewXlatCharTable(var Table : XlatCharTable);
                {-Sets entire XlatChar table}
(2) 7-11      constructor Load(var S : IdStream);
                {-Load a BasePrinter from a stream}
(2) 7-17      procedure Store(var S : IdStream);
                {-Store a BasePrinter in a stream}

OpPrnLow  DosPrinter
==============================================================================

(2) 7-19      constructor Init(PrnName : PathStr; TypeOfPrinter : PrnType;
                               PrnFlags : Word);
                {-Initializes a printer object}

OpPrnLow  BiosPrinter
==============================================================================

(2) 7-21      constructor Init(LPTNumber : LPTType);
                {-Initializes a BIOS printer object}
(2) 7-22      constructor InitCustom(LPTNumber : LPTType;
                                     PrinterTestNumber, SuccessMask : Byte);
                {-Initializes a BIOS printer object with custom status check}
(2) 7-20      function GetLptPort : LPTType;
                {-Returns the LPT port number for this printer}
(2) 7-22      procedure SetLptPort(LPTNo : LPTType);
                {-Sets the LPT port number for this printer}
(2) 7-23      procedure SetXlatErrorFunc(Xlat : XlatFunc);
                {-Sets the XlatError routine}
(2) 7-21      function GetXlatErrorFunc : Pointer;
                {-Returns the Xlat Error routine}
(2) 7-20      procedure GetTestAndMask(var PrinterTestNumber, Mask : Byte);
                {-Return the printer test number and success mask}
(2) 7-23      procedure SetTestAndMask(PrinterTestNumber, Mask : Byte);
                {-Set the printer test number and success mask}

OpPrnLow  Procedures and Functions
==============================================================================

(2) 7-26      procedure DefaultXlatCharTable(var Table : XlatCharTable);
                {-Initialize Table to default state}
(2) 7-24      procedure AssignPrnObject(var F : Text;
                                        var PrinterObj : BasePrinter);
                {-Assign Text variable with a printer object}
(2) 7-26      function GetPrnObject(var F : Text) : BasePrinterPtr;
                {-Return a pointer to the Prn Object associated with a Text file}
(2) 7-25      function CallPrnStatus(var F : Text) : Word;
                {-Call PrnStatus method for Text file associated with Prn Object}

OpPrint  Printer
==============================================================================

(2) 7-44      constructor Init(Name : String; DeviceType : PrnType;
                               OptionFlags : Word);
                {-Initialize a Printer}
(2) 7-45      constructor InitCustom(Device : BasePrinterPtr;
                                     LPI, CPI, Point, LPP : Dimension;
                                     OptionFlags : Word);
                {-Initialize a printer with full control over Printer Device,
                  PrinterModes}
(2) 7-40      destructor Done; Virtual;
                {-Destroy a printer}
(2) 7-50      procedure PrintStr(S : String); Virtual;
                {-Print a String at the current position}
(2) 7-50      procedure PrintStrPos(S : String; Row, Col : Dimension;
                                    Relative : RelativeType); Virtual;
                {-Print a string at the specified position}
(2) 7-49      procedure Position(Row, Col : Dimension;
                                 Relative : RelativeType); Virtual;
                {-Position the printer to the desired place on the page}
(2) 7-41      procedure FormFeed;
                {-Advance to next page}
(2) 7-39      procedure AdvanceLine(NumLines : Byte);
                {-Advances NumLines number of lines}
(2) 7-39      procedure AdvanceSingleLine; Virtual;
                {-Advances to the top of the next line}
(2) 7-51      procedure ResetPage;
                {-Reset position information}
(2) 7-52      procedure SetLPP(LPP : Dimension);
                {-Sets lines per page}
(2) 7-54      procedure SetYRatio(Ratio : Dimension);
                {-Sets the Y printer ratio}
(2) 7-53      procedure SetXRatio(Ratio : Dimension);
                {-Sets the X printer ratio}
(2) 7-42      function GetLPP : Dimension;
                {-Returns lines per page}
(2) 7-43      function GetYRatio : Dimension;
                {-Returns the Y printer ratio}
(2) 7-43      function GetXRatio : Dimension;
                {-Returns the X printer ratio}
(2) 7-43      function GetRegisteredType : Word;
                {-Returns the hardware type registered to this Printer}
(2) 7-41      function GetBasePrinter : BasePrinterPtr;
                {-Returns the BasePrinterPtr}
(2) 7-41      function GetCurrentFont : Byte;
                {-Returns the current font's Mode ID or zero if no current font}
(2) 7-53      procedure SetPrintErrorFunc(PEF : PrintErrorFunc);
                {-Set the print error function}
(2) 7-53      procedure SetPositionPrim(PosFunc : PrinterPosFunc);
                {-Set printer position primitive}
(2) 7-38      procedure AddPrintMode(Name, OnEscSeq, OffEscSeq : String;
                                     Width, Height : Dimension;
                                     ID : Byte; OptionFlags : Word);
                {-Add a Print Mode to the linked list of modes}
(2) 7-51      procedure SetDefaultFont(Attr : Byte);
                {-Sets the default font for this printer}
(2) 7-42      function GetDefaultFont : Byte;
                {-Returns the Attr of the default font}
(2) 7-40      procedure EnableDefaultFont;
                {-Enables the default font}
(2) 7-56      procedure TurnOnByID(ID : Byte);
                {-Turn a print mode on by ID}
(2) 7-55      procedure TurnOffByID(ID : Byte);
                {-Turn a print mode off by ID}
(2) 7-56      procedure TurnOnByName(Name : String);
                {-Turn a print mode on by Name}
(2) 7-56      procedure TurnOffByName(Name : String);
                {-Turn a print mode off by Name}
(2) 7-49      function PrinterReady : Boolean;
                {-Returns true if printer ready}
(2) 7-48      procedure pOptionsOn(OptionFlags : Word);
                {-Turn on multiple Printer options}
(2) 7-48      procedure pOptionsOff(OptionFlags : Word);
                {-Turn off multiple printer options}
(2) 7-48      function pOptionsAreOn(OptionFlags : Word) : Boolean;
                {-Return True if all of the specified OptionFlags are on}
(2) 7-47      function pGetLastError : Word;
                {-Return the last error code and reset to zero}
(2) 7-45      function InLandscape : Boolean;
                {-Returns true if in Landscape mode}
(2) 7-55      procedure TurnOffAllActiveModes;
                {-Turn off all the currently active print modes}
(2) 7-39      procedure DisposeAllModes;
                {-Disposes of all print modes associated with this printer}
(2) 7-47      constructor Load(var S : IdStream);
                {-Load a Printer from a stream}
(2) 7-54      procedure Store(var S : IdStream);
                {-Store a Printer in a stream}
(2) 7-46      procedure LinkToPrinter(Device : BasePrinterPtr);
                {-Links the object with the specified Device}
(2) 7-46      procedure LinkToModes(var Modes : SingleList);
                {-Links the object to the specified Print Mode List}

OpDevice  Procedures and Functions
==============================================================================

(2) 7-63      procedure Deregister(P : PrinterPtr);
                {-Deregisters a Printer of any previous registration}
(2) 7-65      procedure LJRegister(P : PrinterPtr);
                {-Register this printer as an HP Laserjet compatible}
(2) 7-65      procedure LJFontGRegister(P : PrinterPtr);
                {-Registers cartridge font G for LJ}
(2) 7-64      function LJDeci2Row(Decipoints : Dimension;
                                  P : PrinterPtr) : Dimension;
                {-Convert decipoint to Row number}
(2) 7-64      function LJDeci2Col(Decipoints : Dimension;
                                  P : PrinterPtr) : Dimension;
                {-Convert decipoint to Col number}
(2) 7-64      function LJRow2Deci(Row : Dimension; P : PrinterPtr) : Dimension;
                {-Convert a Row number to a Decipoint}
(2) 7-63      function LJCol2Deci(Col : Dimension; P : PrinterPtr) : Dimension;
                {-Convert a Row number to a Decipoint}
(2) 7-65      procedure DiabloRegister(P : PrinterPtr);
                {-Register this printer as a Diablo compatible}
(2) 7-65      procedure EpsonMXRegister(P : PrinterPtr);
                {-Registers P as an Epson MX compatible printer}
(2) 7-65      procedure EpsonLQRegister(P : PrinterPtr);
                {-Registers P as an Epson LQ printer}
(2) 7-65      procedure ProPrinterIIRegister(P : PrinterPtr);
                {-Registers P as an IBM Proprinter II printer}
(2) 7-65      procedure GenericEpsonRegister(P : PrinterPtr);
                {-Registers P as a Generic Epson compatible printer}
(2) 7-65      procedure HPDeskJetRegister(P : PrinterPtr);
                {-Registers P as an HP Deskjet compatible}
(2) 7-65      procedure KXP1093Register(P : PrinterPtr);
                {-Registers P as a Panasonic KX-P1093 printer}
(2) 7-65      procedure ToshibaP321Register(P : PrinterPtr);
                {-Registers P as Toshiba P321SL or P341SL}
(2) 7-65      procedure StarMicronicsRegister(P : PrinterPtr);
                {-Registers P as a Star Micronics printer}
(2) 7-65      procedure Nec3510Register(P : PrinterPtr);
                {-Registers P as a Nec 3510/3530 printer}
(2) 7-65      procedure Nec8800Register(P : PrinterPtr);
                {-Registers P as a Nec 7710/7730/8830/8810 printer}
(2) 7-65      procedure ProwriterRegister(P : PrinterPtr);
                {-Registers P as a C. Itoh 8510 Prowriter printer}
(2) 7-65      procedure FacitRegister(P : PrinterPtr);
                {-Registers P as a Facit 4512 printer}
(2) 7-65      procedure DataProductsRegister(P : PrinterPtr);
                {-Registers P as a DataProducts DP printer}
(2) 7-65      procedure LJDeviceStream(SPtr : IdStreamPtr);
                {-Registers the LJ specific procedure and function pointers}

OpForm  PrintField
==============================================================================

(2) 7-89      procedure pfOptionsOn(OptionFlags : LongInt);
                {-Activate multiple options}
(2) 7-89      procedure pfOptionsOff(OptionFlags : LongInt);
                {-Deactivate multiple options}
(2) 7-89      function pfOptionsAreOn(OptionFlags : LongInt) : Boolean;
                {-Determine if multiple options are on}
(2) 7-88      function Convert : Boolean; Virtual;
                {-Convert from native type to printable string}
(2) 7-90      procedure Print(PrinterP : PrinterPtr); Virtual;
                {-Print the print field}
(2) 7-91      procedure SetConversion(ConvertFunc : PrintConversionFunc);
                {-Sets the conversion routine}
(2) 7-88      function GetFieldAttr : Byte;
                {-Return the print attribute for this Field}
(2) 7-88      procedure GetFieldPos(var Row, Col : Dimension);
                {-Return the row and col for this field}
(2) 7-91      procedure SetFieldPos(Row, Col : Dimension);
                {-Sets the row and col for this field}

OpForm  PrintedForm
==============================================================================

(2) 7-99      constructor Init(FormID : Byte; PrinterP : PrinterPtr);
                {-Initialize a PrintedForm}
(2) 7-100     constructor InitCustom(FormID : Byte; TopMargin, BottomMargin,
                                     LeftMargin, RightMargin : Dimension;
                                     PrinterP : PrinterPtr);
                {-Initialize a PrintedForm with custom options}
(2) 7-92      destructor Done; Virtual;
                {-Dispose of a PrintedForm}
(2) 7-102     procedure Process; Virtual;
                {-Print the Form}
(2) 7-97      function fPrinterPtr : PrinterPtr;
                {-Returns the PrinterPtr for this form}
(2) 7-94      function fGetLastError : Word;
                {-Returns the last error and resets to zero}
(2) 7-101     procedure NewBlock(BaseRow, BaseCol : Dimension;
                                 BlockFunc : UserBlockFunc);
                {-Starts a new block}
(2) 7-107     procedure SetUserRecord(var UserRec; UserRecSize : Word);
                {-Set the address and size of the user record for current block}
(2) 7-99      function GetUserRecord : Pointer;
                {-Return a pointer to the user record for current block}
(2) 7-99      function GetUserRecordSize : Word;
                {-Return the size of the user record for current block}
(2) 7-93      procedure DupCurrentBlock(NewRow, NewCol : Dimension);
                {-Duplicates the current block at the new block coordinates}
(2) 7-93      procedure DupCurrentPage;
                {-Duplicates the current page}
(2) 7-104     procedure PromptOptionsOn(OptionFlags : LongInt);
                {-Turn options for the prompts on}
(2) 7-95      procedure FieldOptionsOn(OptionFlags : LongInt);
                {-Turn options for the fields on}
(2) 7-103     procedure PromptOptionsOff(OptionFlags : LongInt);
                {-Turn options for the prompt off}
(2) 7-95      procedure FieldOptionsOff(OptionFlags : LongInt);
                {-Turn options for the fields off}
(2) 7-103     function PromptOptionsAreOn(OptionFlags : LongInt) : Boolean;
                {-Determine whether options for the prompts are on}
(2) 7-95      function FieldOptionsAreOn(OptionFlags : LongInt) : Boolean;
                {-Determine whether options for the fields are on}
(2) 7-72      procedure AddTextField(pFieldID : Word; Prompt : String;
                                     pRow, pCol : Dimension;
                                     pAttr, pWidth : Byte);
                {-Adds a text field (no user variable)}
(2) 7-73      procedure AddStringField(pFieldID : Word; Prompt : String;
                                       pRow, pCol : Dimension;
                                       pAttr, pWidth : Byte;
                                       fFieldID : Word; Picture : String;
                                       fRow, fCol : Dimension;
                                       fAttr, fWidth : Byte;
                                       var PrintSt : String);
                {-Adds a string field}
(2) 7-73      procedure AddCharField(pFieldID : Word; Prompt : String;
                                     pRow, pCol : Dimension;
                                     pAttr, pWidth : Byte;
                                     fFieldID : Word; Picture : String;
                                     fRow, fCol : Dimension;
                                     fAttr, fWidth : Byte;
                                     var PrintChar : Char);
                {-Adds prompt and character field}
(2) 7-72      procedure AddBooleanField(pFieldID : Word; Prompt : String;
                                        pRow, pCol : Dimension;
                                        pAttr, pWidth : Byte;
                                        fFieldID : Word; Picture : String;
                                        fRow, fCol : Dimension;
                                        fAttr, fWidth : Byte;
                                        var PrintBool : Boolean);
                {-Adds a Boolean field}
(2) 7-73      procedure AddYesNoField(pFieldID : Word; Prompt : String;
                                      pRow, pCol : Dimension;
                                      pAttr, pWidth : Byte;
                                      fFieldID : Word; Picture : String;
                                      fRow, fCol : Dimension;
                                      fAttr, fWidth : Byte;
                                      var PrintYesNo : Boolean);
                {-Adds a Yes/No field}
(2) 7-73      procedure AddLongField(pFieldID : Word; Prompt : String;
                                     pRow, pCol : Dimension;
                                     pAttr, pWidth : Byte;
                                     fFieldID : Word; Picture : String;
                                     fRow, fCol : Dimension;
                                     fAttr, fWidth : Byte;
                                     var PrintLong : LongInt);
                {-Adds a LongInt field}
(2) 7-73      procedure AddWordField(pFieldID : Word; Prompt : String;
                                     pRow, pCol : Dimension;
                                     pAttr, pWidth : Byte;
                                     fFieldID : Word; Picture : String;
                                     fRow, fCol : Dimension;
                                     fAttr, fWidth : Byte;
                                     var PrintWord : Word);
                {-Adds a Word field}
(2) 7-73      procedure AddIntField(pFieldID : Word; Prompt : String;
                                    pRow, pCol : Dimension;
                                    pAttr, pWidth : Byte;
                                    fFieldID : Word; Picture : String;
                                    fRow, fCol : Dimension;
                                    fAttr, fWidth : Byte;
                                    var PrintInt : Integer);
                {-Adds an Integer field}
(2) 7-73      procedure AddByteField(pFieldID : Word; Prompt : String;
                                     pRow, pCol : Dimension;
                                     pAttr, pWidth : Byte;
                                     fFieldID : Word; Picture : String;
                                     fRow, fCol : Dimension;
                                     fAttr, fWidth : Byte;
                                     var PrintByte : Byte);
                {-Adds a Byte field}
(2) 7-73      procedure AddShortField(pFieldID : Word; Prompt : String;
                                      pRow, pCol : Dimension;
                                      pAttr, pWidth : Byte;
                                      fFieldID : Word; Picture : String;
                                      fRow, fCol : Dimension;
                                      fAttr, fWidth : Byte;
                                      var PrintShort : ShortInt);
                {-Adds a ShortInt field}
(2) 7-73      procedure AddRealField(pFieldID : Word; Prompt : String;
                                     pRow, pCol : Dimension;
                                     pAttr, pWidth : Byte;
                                     fFieldID : Word; Picture : String;
                                     fRow, fCol : Dimension;
                                     fAttr : Byte; fDPlaces : Byte;
                                     fWidth : Byte; var PrintReal : Real);
                {-Adds a Real field}
(2) 7-74      procedure AddDateField(pFieldID : Word; Prompt : String;
                                     pRow, pCol : Dimension;
                                     pAttr, pWidth : Byte;
                                     fFieldID : Word; Picture : String;
                                     fRow, fCol : Dimension;
                                     fAttr, fWidth : Byte;
                                     var PrintDate : Date);
                {-Adds a Date field}
(2) 7-74      procedure AddTimeField(pFieldID : Word; Prompt : String;
                                     pRow, pCol : Dimension;
                                     pAttr, pWidth : Byte;
                                     fFieldID : Word; Picture : String;
                                     fRow, fCol : Dimension;
                                     fAttr, fWidth : Byte;
                                     var PrintTime : Time);
                {-Adds a Time field}
(2) 7-75      procedure AddDirective(FieldID : Word; Row, Col : Dimension;
                                     On : Boolean; Attr : Byte);
                {-Adds a print directive}
(2) 7-75      procedure AddLine(FieldID : Word; Row, Col : Dimension;
                                Len, LineThickness : Dimension;
                                Horizontal : Boolean; LineChar : Char;
                                Attr : Byte);
                {-Adds a line field}
(2) 7-75      procedure AddBox(FieldID : Word; Row, Col : Dimension;
                               Width, Height : Dimension;
                               HLineThickness, VLineThickness : Dimension;
                               BoxChars : BoxCharSet; Attr : Byte);
                {-Adds a box field}
(2) 7-75      procedure AddShaded(FieldID : Word; Row, Col : Dimension;
                                  Width, Height : Dimension; Intensity : Byte);
                {-Adds a shaded box field}
(2) 7-102     procedure NewPage;
                {-Start a new page}
(2) 7-106     procedure SetHeader(HeaderStr : String; Row, Col : Dimension;
                                  HAttr : Byte);
                {-Set up a header for the current page}
(2) 7-106     procedure SetHeaderFunc(Picture : String;
                                      HeadFunc : PrintConversionFunc);
                {-Set the HeadFunc function pointer for the current page}
(2) 7-98      function GetHeader : String;
                {-Returns the header string for the current page}
(2) 7-105     procedure SetFooter(FooterStr : String; Row, Col : Dimension;
                                  FAttr : Byte);
                {-Set up a Footer for the current page}
(2) 7-105     procedure SetFooterFunc(Picture : String;
                                      FootFunc : PrintConversionFunc);
                {-Set the HeadFunc function pointer for the current page}
(2) 7-97      function GetFooter : String;
                {-Returns the Footer string for the current page}
(2) 7-104     procedure SetErrorHandler(ErrorFunc : PrintErrorFunc);
                {-Sets the user error handler}
(2) 7-96      function FindField(FieldID : Word; var Page : PrintPagePtr;
                                 var Block : PrintBlockPtr) : PrintFieldPtr;
                {-Finds the first field with the specified FieldID}
(2) 7-96      function FindNextField(Field  : PrintFieldPtr;
                                     var Page : PrintPagePtr;
                                     var Block : PrintBlockPtr) : PrintFieldPtr;
                {-Finds the next field with the same FieldID as Field}
(2) 7-92      procedure ChangeConversion(FieldID : Word;
                                         ConvertFunc : PrintConversionFunc);
                {-Changes field's conversion routine}
(2) 7-107     procedure SetUserData(P : Pointer);
                {-Sets the user data field}
(2) 7-98      function GetUserData : Pointer;
                {-Returns the user data field}
(2) 7-106     procedure SetPrePageFunc(ppFunc : UserPageFunc);
                {-Sets the function that gets called before the current page is
                  printed}
(2) 7-107     procedure SetPrePostFormFunc(ppFunc : UserFormFunc);
                {-Sets the function that gets called before and after printing
                  the form}
(2) 7-100     constructor Load(var S : IdStream);
                {-Load a PrintedForm from a stream}
(2) 7-108     procedure Store(var S : IdStream);
                {-Store a PrintedForm in a stream}

OpForm  Report
==============================================================================

(2) 7-110     constructor Init;
                {-Create a report}
(2) 7-109     destructor Done; Virtual;
                {-Destroy a report}
(2) 7-112     function rGetLastError : Word;
                {-Get last error code and clear error code}
(2) 7-111     procedure Process; Virtual;
                {-Print the print field}
(2) 7-109     procedure AddForm(fPtr : PrintedFormPtr);
                {-Add a PrintedForm to Report by pointer}
(2) 7-110     function FindForm(FormID : Byte) : PrintedFormPtr;
                {-Return a pointer to the PrintedForm with the specified ID}
(2) 7-111     constructor Load(var S : IdStream);
                {-Load a Report from a stream}
(2) 7-112     procedure Store(var S : IdStream);
                {-Store a Report in a stream}

OpRoot  Root
==============================================================================

(3) 8-99      constructor Init;
                {-Initialize the object}
(3) 8-99      destructor Done; virtual;
                {-Destroy the object}

OpRoot  IdStream
==============================================================================

(3) 8-108     function ReadString : String;
                {-Read next variable length string from stream}
(3) 8-107     procedure ReadRange(var BufStart, BufBeyond);
                {-Read Ofs(BufBeyond)-Ofs(BufStart) bytes into BufStart}
(3) 8-118     procedure WriteString(S : String);
                {-Write a variable length string to stream}
(3) 8-118     procedure WriteRange(var BufStart, BufBeyond);
                {-Write Ofs(BufBeyond)-Ofs(BufStart) bytes to stream}
(3) 8-102     function GetSize : Longint;
                {-Determine size of stream}
(3) 8-116     procedure Seek(Pos : Longint);
                {-Set the current stream position to Pos,
                  relative to the beginning of stream}
(3) 8-101     function GetPos : Longint; virtual;
                {-Return the current stream position}
(3) 8-103     function GetStatus : Word;
                {-Return status of stream}
(3) 8-103     function PeekStatus : Word;
                {-Return status and leave internal variable unchanged}
(3) 8-115     procedure RegisterType(Code, Version : Word;
                                     TypePtr, StorePtr, LoadPtr : Pointer);
                {-Registers one object type of specified version for IdStream I/O.
                  May set Status to non-zero}
(3) 8-111     procedure RegisterOldVersion(Code, Version : Word;
                                           TypePtr, LoadPtr : Pointer);
                {-Registers an alternate loader for an old version of an object
                  type}
(3) 8-116     function TypeRegistered(TypePtr : Pointer) : Boolean;
                {-Return True if specified type is registered for store and load}
(3) 8-117     function TypeVerRegistered(TypePtr : Pointer;
                                         Version : Word) : Boolean;
                {-Return True if specified type and version is registered for load}
(3) 8-100     function CodeVerRegistered(Code, Version : Word) : Boolean;
                {-Return True if specified code and version number are registered}
(3) 8-110     procedure RegisterHier(RProc : StreamRegisterProc);
                {-Call a supplied routine to register a hierarchy of object types}
(3) 8-105     procedure PutPtr(RPtr : RootPtr);
                {-Calls polymorphic Store method to write object at RPtr^}
(3) 8-102     function GetPtr : RootPtr;
                {-Calls polymorphic Load constructor to allocate and read object}
(3) 8-104     procedure Put(var R : Root);
                {-Calls polymorphic Store method to write object R}
(3) 8-101     procedure Get(var R : Root);
                {-Calls polymorphic Load constructor to read static object R}
(3) 8-112     procedure RegisterPointer(Code : Word; Ptr : Pointer);
                {-Registers one pointer for IdStream I/O}
(3) 8-104     function PointerRegistered(Ptr : Pointer) : Boolean;
                {-Return True if specified pointer is registered with stream}
(3) 8-117     procedure WritePointer(Ptr : Pointer);
                {-Writes identifier for pointer to stream}
(3) 8-119     procedure WriteUserPointer(Ptr : Pointer; DefaultCode : Word);
                {-Writes Ptr code if registered, else DefaultCode}
(3) 8-106     function ReadPointer : Pointer;
                {-Reads pointer from stream}
(3) 8-109     function ReadUserPointer(DefaultPtr : Pointer) : Pointer;
                {-Reads pointer and assigns default instead of nil}
(3) 8-100     procedure Error(Code : Word); virtual;
                {-Report an error}

OpRoot  DosIdStream
==============================================================================

(3) 8-120     constructor Init(FileName : String; Mode : Word);
                {-Open DOS file in specified mode and initialize stream}
(3) 8-120     destructor Done; virtual;
                {-Close file and dispose stream}
(3) 8-121     procedure Read(var Buf; Count : Word); virtual;
                {-Read bytes from DOS file}
(3) 8-121     procedure Write(var Buf; Count : Word); virtual;
                {-Write bytes to DOS file}
(3) 8-121     procedure Truncate; virtual;
                {-Truncate file at current position}

OpRoot  BufIdStream
==============================================================================

(3) 8-124     constructor Init(FileName : String; Mode, Size : Word);
                {-Open DOS file in mode, and allocate buffer of Size bytes}
(3) 8-123     destructor Done; virtual;
                {-Flush and close file, deallocate buffer, dispose stream}
(3) 8-123     procedure Flush; virtual;
                {-Flush buffer}
(3) 8-124     procedure Read(var Buf; Count : Word); virtual;
                {-Read, using buffer}
(3) 8-124     procedure Write(var Buf; Count : Word); virtual;
                {-Write, using buffer}

OpRoot  MemIdStream
==============================================================================

(3) 8-125     constructor Init(BasePtr : Pointer; Size : Word);
                {-Initialize stream to point to a location in memory}
(3) 8-126     procedure Read(var Buf; Count : Word); virtual;
                {-Read bytes from memory stream}
(3) 8-126     procedure Write(var Buf; Count : Word); virtual;
                {-Write bytes to memory stream}
(3) 8-126     procedure Truncate; virtual;
                {-Truncate at current position. Does nothing but reduce Size.}

OpRoot  DirEntry
==============================================================================

(3) 8-135     constructor Init;
                {-Initialize an empty directory entry}
(3) 8-135     procedure Rename(Name : DirEntryName);
                {-Change the name of the directory entry}
(3) 8-136     procedure Update(Start, Len : LongInt; Code, Ver : Word); virtual;
                {-Update the start and length data}
(3) 8-135     procedure SetUserPointer(P : Pointer);
                {-Set the user pointer to P}
(3) 8-132     procedure deOptionsOn(Options : Word);
                {-Set the specified flag(s)}
(3) 8-132     procedure deOptionsOff(Options : Word);
                {-Clear the specified flag(s)}
(3) 8-132     function deOptionsAreOn(Options : Word) : Boolean;
                {-Returns True if the specified flag(s) are on}
(3) 8-133     function GetEntryName : DirEntryName;
                {-Return the name of the entry}
(3) 8-134     function GetEntryStart : LongInt;
                {-Return the starting point for the entry}
(3) 8-133     function GetEntryLength : LongInt;
                {-Return the length of the entry}
(3) 8-134     function GetUserPointer : Pointer;
                {-Return the user pointer}

OpRoot  Library
==============================================================================

(3) 8-143     constructor Init(FileName : PathStr; Mode, BufferSize : Word;
                               Sig : LibrarySig);
                {-Open an existing library}
(3) 8-137     constructor Create(FileName : PathStr; BufferSize : Word;
                                 Sig : LibrarySig; Entries : Word);
                {-Create a new library}
(3) 8-139     destructor Done; virtual;
                {-Flush and close library file, and dispose of directory and
                  stream}
(3) 8-146     procedure PutEntry(Name : DirEntryName; var R : Root);
                {-Calls polymorphic Store method to write object R}
(3) 8-142     procedure GetEntry(Name : DirEntryName; var R : Root);
                {-Calls polymorphic Load constructor to read static object R}
(3) 8-142     function GetEntryPtr(Name : DirEntryName) : RootPtr;
                {-Calls polymorphic Load constructor to allocate and read object}
(3) 8-138     procedure DeleteEntry(Name : DirEntryName); virtual;
                {-Mark the entry of the specified name as deleted}
(3) 8-147     procedure UndeleteEntry(Name : DirEntryName); virtual;
                {-Remove deletion mark from the specified entry}
(3) 8-144     procedure KillEntry(Name : DirEntryName);
                {-Permanently delete the entry of the specified name}
(3) 8-147     procedure RenameEntry(OldName, NewName : DirEntryName); virtual;
                {-Rename the specified entry}
(3) 8-141     procedure GetCodeAndVersion(Name : DirEntryName;
                                          var Code, Ver : Word);
                {-Return the code and version for the specified entry}
(3) 8-145     procedure Pack;
                {-Pack the library}
(3) 8-146     function PackedFileSize : LongInt;
                {-Returns size of library after packing}
(3) 8-139     function FileNeedsPacking : Boolean;
                {-Returns True if library needs packing}
(3) 8-141     function FindEntryByIndex(N : Word) : DirEntryPtr;
                {-Return a pointer to the N'th entry in the directory}
(3) 8-140     function FindDirectoryEntry(Name : DirEntryName) : DirEntryPtr;
                {-Return a pointer to a directory entry; nil if not found or
                  deleted}
(3) 8-140     function FindAnyDirectoryEntry(Name : DirEntryName) : DirEntryPtr;
                {-Return a pointer to a directory entry; nil if not found}
(3) 8-144     function MaxEntries : Word;
                {-Return the maximum number of entries in the library's directory}
(3) 8-138     function CurrentEntries : Word;
                {-Return the number of used entries in the library's directory,
                  not including deleted entries}
(3) 8-138     function DeletedEntries : Word;
                {-Return the number of deleted entries in the library's directory}
(3) 8-137     function AvailableEntries : Word;
                {-Return number of entries available in library's directory}

OpRoot  MemLibrary
==============================================================================

(3) 8-149     constructor Init(BasePtr : Pointer; Size : Word);
                {-Open an existing library in memory}
(3) 8-148     procedure GetEntry(Name : DirEntryName; var R : Root);
                {-Calls polymorphic Load constructor to read static object R}
(3) 8-148     function GetEntryPtr(Name : DirEntryName) : RootPtr;
                {-Calls polymorphic Load constructor to allocate and read object}

OpRoot  PointerStack
==============================================================================

(3) 8-10      constructor Init(Max : Word);
                {-Allocate a stack of pointers that can manage up to Max items}
(3) 8-9       destructor Done; virtual;
                {-Deallocate the stack}
(3) 8-16      function Size : Word;
                {-Return the size of the stack}
(3) 8-15      procedure Push(P : RootPtr);
                {-Push P onto the stack}
(3) 8-14      function Pop : RootPtr;
                {-Pop the topmost RootPtr off the stack}
(3) 8-16      function SP : Word;
                {-Return the current top of stack index}
(3) 8-13      function Peek(Index : Word) : RootPtr;
                {-Return stack element at position Index}
(3) 8-13      function PeekTop : RootPtr;
                {-Return pointer currently at the top of stack}
(3) 8-14      procedure Poke(P : RootPtr; Index : Word);
                {-Directly set a stack element}
(3) 8-9       procedure Clear;
                {-Remove all elements from the stack}
(3) 8-10      function GetStatus : Word;
                {-Return latest status code and reset internal status to zero}
(3) 8-16      function Resize(Max : Word) : Boolean;
                {-Expand or shrink stack to hold Max pointers}
(3) 8-11      constructor Load(var S : IdStream);
                {-Load a stack from a stream}
(3) 8-17      procedure Store(var S : IdStream);
                {-Store a stack in a stream}

OpRoot  StaticQueue
==============================================================================

(3) 8-23      constructor Init(NumElements, ElementSize : Word;
                               RejectIfFull : Boolean);
                {-Allocate space for static queue}
(3) 8-21      destructor Done; virtual;
                {-Deallocate space for the queue}
(3) 8-27      procedure PushTail(var Element);
                {-Add an element to the tail of the queue}
(3) 8-26      procedure PopTail(var Element);
                {-Remove an element from the tail of the queue}
(3) 8-25      procedure PeekTail(var Element);
                {-Look at the element at the tail of the queue}
(3) 8-26      procedure PopHead(var Element);
                {-Remove an element from the front of the queue}
(3) 8-25      procedure PeekHead(var Element);
                {-Look at the element at the front of the queue}
(3) 8-21      procedure Clear;
                {-Flush all elements from the queue}
(3) 8-21      function Elements : Word;
                {-Return the number of elements currently in the queue}
(3) 8-22      function GetStatus : Word;
                {-Return latest status code and reset internal status to zero}
(3) 8-22      procedure Error(Code : Word); virtual;
                {-Report error}
(3) 8-24      constructor Load(var S : IdStream);
                {-Load a static queue from a stream}
(3) 8-28      procedure Store(var S : IdStream);
                {-Store a static queue to a stream}

OpRoot  SingleListNode
==============================================================================

(3) 8-33      constructor Init;
                {-Initialize a singly linked list node}

OpRoot  SingleList
==============================================================================

(3) 8-35      constructor Init;
                {-Initialize an empty list of items}
(3) 8-34      destructor Done; virtual;
                {-Destroy list}
(3) 8-39      function Size : Word;
                {-Return the size of the current list}
(3) 8-34      procedure Append(P : SingleNodePtr);
                {-Add element to end of list}
(3) 8-35      procedure Insert(P : SingleNodePtr);
                {-Insert element at start of list}
(3) 8-38      procedure Place(P, L : SingleNodePtr);
                {-Place element P into list _after_ existing element L}
(3) 8-39      procedure PlaceBefore(P, L : SingleNodePtr);
                {-Place element P into list _before_ existing element L}
(3) 8-34      procedure Delete(P : SingleNodePtr);
                {-Delete existing element in list, dispose of its contents}
(3) 8-39      procedure Remove(P : SingleNodePtr);
                {-Remove existing element from list without disposing of it}
(3) 8-35      function Head : SingleNodePtr;
                {-Return pointer to head of list}
(3) 8-42      function Tail : SingleNodePtr;
                {-Return pointer to tail of list}
(3) 8-38      function Next(P : SingleNodePtr) : SingleNodePtr;
                {-Returns a pointer to the next node}
(3) 8-36      constructor Load(var S : IdStream);
                {-Load a list from a stream}
(3) 8-40      procedure Store(var S : IdStream);
                {-Store a list in a stream}

OpRoot  DoubleListNode
==============================================================================

(3) 8-43      constructor Init;
                {-Initialize a doubly linked list node}

OpRoot  DoubleList
==============================================================================

(3) 8-45      constructor Init;
                {-Initialize an empty list of items}
(3) 8-44      destructor Done; virtual;
                {-Destroy list}
(3) 8-48      function Size : Word;
                {-Return the size of the current list}
(3) 8-44      procedure Append(P : DoubleNodePtr);
                {-Add element to end of list}
(3) 8-45      procedure Insert(P : DoubleNodePtr);
                {-Insert element at start of list}
(3) 8-46      procedure Place(P, L : DoubleNodePtr);
                {-Place element P into list _after_ existing element L}
(3) 8-47      procedure PlaceBefore(P, L : DoubleNodePtr);
                {-Place element P into list _before_ existing element L}
(3) 8-44      procedure Delete(P : DoubleNodePtr);
                {-Delete existing element in list, disposing of its contents}
(3) 8-47      procedure Remove(P : DoubleNodePtr);
                {-Remove existing element from list without disposing of it}
(3) 8-45      function Head : DoubleNodePtr;
                {-Return pointer to head of list}
(3) 8-48      function Tail : DoubleNodePtr;
                {-Return pointer to tail of list}
(3) 8-46      function Next(P : DoubleNodePtr) : DoubleNodePtr; virtual;
                {-Returns a pointer to the next node}
(3) 8-47      function Prev(P : DoubleNodePtr) : DoubleNodePtr; virtual;
                {-Returns a pointer to the previous node}
(3) 8-46      constructor Load(var S : IdStream);
                {-Load a list from a stream}
(3) 8-48      procedure Store(var S : IdStream);
                {-Store a list in a stream}

OpRoot  CircularList
==============================================================================

(3) 8-49      function Next(P : DoubleNodePtr) : DoubleNodePtr; virtual;
                {-Returns a pointer to the next node (wraps at end)}
(3) 8-49      function Prev(P : DoubleNodePtr) : DoubleNodePtr; virtual;
                {-Returns a pointer to the previous node (wraps at begin)}
(3) 8-49      procedure Store(var S : IdStream);
                {-Store a list in a stream}

OpRoot  BitSet
==============================================================================

(3) 8-55      constructor Init(Max : LongInt);
                {-Allocate space for elements}
(3) 8-54      destructor Done; virtual;
                {-Deallocate data area}
(3) 8-53      procedure ClearAll; virtual;
                {-Clear all bits}
(3) 8-60      procedure SetAll; virtual;
                {-Set all bits}
(3) 8-58      function MaxBits : LongInt;
                {-Return capacity of bitset}
(3) 8-61      procedure SetBit(Element : LongInt); virtual;
                {-Set bit}
(3) 8-53      procedure ClearBit(Element : LongInt); virtual;
                {-Clear bit}
(3) 8-63      procedure ToggleBit(Element : LongInt);
                {-Toggle bit}
(3) 8-54      procedure ControlBit(Element : LongInt; State : Boolean);
                {-Set or clear bit depending on State}
(3) 8-63      function TestSetBit(Element : LongInt) : Boolean;
                {-Return current state of bit and set it}
(3) 8-63      function TestClearBit(Element : LongInt) : Boolean;
                {-Return current state of bit and clear it}
(3) 8-52      function BitIsSet(Element : LongInt) : Boolean; virtual;
                {-Return True if bit is set}
(3) 8-59      function NextSet(Element : LongInt) : LongInt; virtual;
                {-Return index of next set element, NoMoreBits if none}
(3) 8-58      function NextClear(Element : LongInt) : LongInt; virtual;
                {-Return index of next clear element, NoMoreBits if none}
(3) 8-60      function PrevSet(Element : LongInt) : LongInt; virtual;
                {-Return index of previous set element, NoMoreBits if none}
(3) 8-59      function PrevClear(Element : LongInt) : LongInt; virtual;
                {-Return index of previous clear element, NoMoreBits if none}
(3) 8-52      function BitsSet : LongInt; virtual;
                {-Return number of bits set}
(3) 8-55      function FirstSet : LongInt;
                {-Return index of first set bit, NoMoreBits if none}
(3) 8-56      function LastSet : LongInt;
                {-Return index of last set bit, NoMoreBits if none}
(3) 8-54      function FirstClear : LongInt;
                {-Return index of first clear bit, NoMoreBits if none}
(3) 8-56      function LastClear : LongInt;
                {-Return index of last clear bit, NoMoreBits if none}
(3) 8-57      constructor Load(var S : IdStream);
                {-Load a bitset from a stream}
(3) 8-62      procedure Store(var S : IdStream);
                {-Store a bitset to a stream}

OpRoot  LargeBitSet
==============================================================================

(3) 8-65      constructor Init(Max : LongInt);
                {-Allocate space for elements}
(3) 8-66      function Resize(Max : LongInt) : Boolean;
                {-Expand or shrink large bitset to hold Max bits}
(3) 8-64      function GetStatus : Word;
                {-Return latest status code and reset internal status to zero}
(3) 8-64      procedure Error(Code : Word); virtual;
                {-Report an error}
(3) 8-65      constructor Load(var S : IdStream);
                {-Load a bitset from a stream}
(3) 8-66      procedure Store(var S : IdStream);
                {-Store a bitset to a stream}

OpRoot  StringDict
==============================================================================

(3) 8-75      constructor Init;
                {-Allocate hash pool for a string dictionary}
(3) 8-73      destructor Done; virtual;
                {-Deallocate pool}
(3) 8-71      procedure Add(S : String; Value : LongInt);
                {-Add string and associated value to dictionary}
(3) 8-77      function Member(S : String; var Value : LongInt) : Boolean;
                {-Return true and associated value if S is element of dictionary}
(3) 8-79      procedure Update(S : String; Value : LongInt);
                {-Change the data value associated with a string}
(3) 8-77      procedure Remove(S : String);
                {-Remove string from dictionary}
(3) 8-73      procedure Clear;
                {-Remove all strings from dictionary}
(3) 8-74      function GetStatus : Word;
                {-Return status code and reset internal result to zero}
(3) 8-76      constructor Load(var S : IdStream);
                {-Load a string dictionary from a stream}
(3) 8-78      procedure Store(var S : IdStream);
                {-Store a string dictionary to a stream}
(3) 8-75      function Hash(var S : String) : Word; virtual;
                {-Return a hash code for the specified string}
(3) 8-73      function Equal(var S, T : String) : Boolean; virtual;
                {-Return True if the two strings are considered equal}
(3) 8-74      procedure Error(Code : Word); virtual;
                {-Report an error}

OpRoot  StringSet
==============================================================================

(3) 8-80      procedure Add(S : String);
                {-Add string to set}
(3) 8-81      function Member(S : String) : Boolean;
                {-Return true if S is element of set}
(3) 8-80      constructor Load(var S : IdStream);
                {-Load a list from a stream}
(3) 8-81      procedure Store(var S : IdStream);
                {-Store a list in a stream}

OpRoot  StringArray
==============================================================================

(3) 8-84      constructor Init(StrMax, Amount : Word);
                {-Allocate space for StrMax strings in Amount space}
(3) 8-86      constructor ReadText(FileName : PathStr);
                {-Initialize a packed array from a text file}
(3) 8-82      destructor Done; virtual;
                {-Deallocate packed array}
(3) 8-89      procedure WriteText(FileName : PathStr);
                {-Write a packed array to a text file}
(3) 8-85      constructor Load(var S : IdStream);
                {-Load a binary packed array from a stream}
(3) 8-88      procedure Store(var S : IdStream);
                {-Write a packed array to a stream}
(3) 8-83      function GetString(Which : Word) : String; virtual;
                {-Return string from packed array}
(3) 8-83      function GetStringPtr(Which : Word) : StringPtr;
                {-Return pointer to string from packed array}
(3) 8-87      function Shrink : Boolean;
                {-Remove excess packed array space}
(3) 8-82      function AddString(St : String) : Word;
                {-Add a new string, returning its index, or 0 if error}
(3) 8-85      function NumStrings : Word;
                {-Return number of strings in the packed array}
(3) 8-87      function Size : Word;
                {-Return the number of bytes used by strings}

OpLarray  AbstractArray
==============================================================================

(3) 8-165     constructor Init(Rows, Cols : Word; ElementSize : Word;
                               ArrayOptions : Byte);
                {-Make a new array}
(3) 8-168     constructor LoadA(ArrayOptions : Byte);
                {-Load an array from disk}
(3) 8-162     destructor Done; Virtual;
                {-Dispose of an array}
(3) 8-163     function ErrorA : Word;
                {-Return last error code (0 indicates no error)}
(3) 8-173     procedure SetA(Row, Col : Word; var Value); Virtual;
                {-Set an array element}
(3) 8-171     procedure RetA(Row, Col : Word; var Value); Virtual;
                {-Return an array element}
(3) 8-172     procedure SafeSetA(Row, Col : Word; var Value); Virtual;
                {-Set an array element and safely deal with out of range
                  coordinates}
(3) 8-172     procedure SafeRetA(Row, Col : Word; var Value); Virtual;
                {-Return an array element and safely deal with out of range
                  coordinates}
(3) 8-161     procedure ClearA(var Value; Initialize : InitType); Virtual;
                {-Clear the array}
(3) 8-175     procedure StoreA(FileName : String); Virtual;
                {-Store large array in a file}
(3) 8-164     procedure FlushA; Virtual;
                {-Flush changes to disk}
(3) 8-170     function RangeError(Row, Col : Word) : Boolean; Virtual;
                {-Returns true if passed Row or Col are out of range}
(3) 8-175     function TypeOfArray : ArrayType;
                {-Returns the type of array}
(3) 8-174     procedure SetErrorProc(EP : ErrorProc);
                {-Setup a user errorproc}
(3) 8-164     procedure GetErrorProc(var EP : ErrorProc);
                {-Get current errorproc}
(3) 8-161     procedure ArrayDimensions(var Rows,Cols : Word);
                {-Return array dimensions}
(3) 8-169     procedure lOptionsOn(OptionCodes : Word);
                {-Set array options on}
(3) 8-169     procedure lOptionsOff(OptionCodes : Word);
                {-Set array options off}
(3) 8-169     function lOptionsAreOn(OptionCodes : Word) : Boolean;
                {-Check options}

OpLarray  RamArray
==============================================================================

(3) 8-165     constructor Init(Rows, Cols : Word; ElementSize : Word;
                               ArrayOptions : Byte);
                {-Make a new array}
(3) 8-168     constructor LoadA(FileName : String; ArrayOptions : Byte);
                {-Load an array from disk}

OpLarray  RamRCArray
==============================================================================

(3) 8-165     constructor Init(Rows, Cols : Word; ElementSize : Word;
                               ArrayOptions : Byte);
                {-Make a new array}
(3) 8-168     constructor LoadA(FileName : String; ArrayOptions : Byte);
                {-Load an array from disk}

OpLarray  EmsArray
==============================================================================

(3) 8-165     constructor Init(Rows, Cols : Word; ElementSize : Word;
                               ArrayOptions : Byte);
                {-Make a new array}
(3) 8-168     constructor LoadA(FileName : String; ArrayOptions : Byte);
                {-Load an array from disk}

OpLarray  EmsRCArray
==============================================================================

(3) 8-165     constructor Init(Rows, Cols : Word; ElementSize : Word;
                               ArrayOptions : Byte);
                {-Make a new array}
(3) 8-168     constructor LoadA(FileName : String; ArrayOptions : Byte);
                {-Load an array from disk}

OpLarray  VirtualArray
==============================================================================

(3) 8-165     constructor Init(Rows, Cols : Word; ElementSize : Word;
                               FileName : String; HeapToUse : LongInt;
                               ArrayOptions : Byte);
                {-Make a new array}
(3) 8-168     constructor LoadA(FileName : String; ArrayOptions : Byte);
                {-Load an array from disk}

OpLarray  PrimitiveArray
==============================================================================

(3) 8-165     constructor Init(RowsInPage : Word; ColsInPage : Word;
                               PagesDown : Word;  PagesAcross : Word;
                               ElementSize : Word; FileName : string;
                               HeapToUse : LongInt; ArrayOptions : Byte);
                {-Make a new array}

OpLarray  VirtualRCArray
==============================================================================

(3) 8-165     constructor Init(Rows, Cols : Word; ElementSize : Word;
                               FileName : String; HeapToUse : LongInt;
                               ArrayOptions : Byte);
                {-Make a new array}
(3) 8-168     constructor LoadA(FileName : String; ArrayOptions : Byte);
                {-Load an array from disk}

OpLarray  OpArray
==============================================================================

(3) 8-165     constructor Init(Rows, Cols : Word; ElementSize : Word;
                               FileName : String; HeapToUse : LongInt;
                               ArrayOptions : Byte; var Priority : AutoPriority);
                {-Make a new array}
(3) 8-168     constructor LoadA(FileName : String; ArrayOptions : Byte;
                                var Priority : AutoPriority);
                {-Load an array}

OpLarray  Procedures and Functions
==============================================================================

(3) 8-176     procedure DisplayLErrorProc(UnitCode : Byte; var ErrorCode : Word;
                                          ErrorMsg : String);
                {-An error procedure that displays a standard message for errors
                  generated by this unit.  Does not halt on errors}

OpString  Procedures and Functions
==============================================================================

(3) 9-16      function HexB(B : Byte) : string;
                {-Return hex string for byte}
(3) 9-17      function HexW(W : Word) : string;
                {-Return hex string for word}
(3) 9-17      function HexL(L : LongInt) : string;
                {-Return hex string for longint}
(3) 9-17      function HexPtr(P : Pointer) : string;
                {-Return hex string for pointer}
(3) 9-3       function BinaryB(B : Byte) : string;
                {-Return binary string for byte}
(3) 9-4       function BinaryW(W : Word) : string;
                {-Return binary string for word}
(3) 9-3       function BinaryL(L : LongInt) : string;
                {-Return binary string for longint}
(3) 9-22      function OctalB(B : Byte) : string;
                {-Return octal string for byte}
(3) 9-23      function OctalW(W : Word) : string;
                {-Return octal string for word}
(3) 9-22      function OctalL(L : LongInt) : string;
                {-Return octal string for longint}
(3) 9-27      function Str2Int(S : string; var I : Integer) : Boolean;
                {-Convert a string to an integer, returning true if successful}
(3) 9-27      function Str2Word(S : string; var I : Word) : Boolean;
                {-Convert a string to a word, returning true if successful}
(3) 9-27      function Str2Long(S : string; var I : LongInt) : Boolean;
                {-Convert a string to an longint, returning true if successful}
(3) 9-27      function Str2Real(S : string; var R : Float) : Boolean;
                {-Convert a string to a real, returning true if successful}
(3) 9-21      function Long2Str(L : LongInt) : string;
                {-Convert a longint/word/integer/byte/shortint to a string}
(3) 9-24      function Real2Str(R : Float; Width : Byte;
                                Places : ShortInt) : string;
                {-Convert a real to a string}
(3) 9-14      function Form(Mask : string; R : Float) : string;
                {-Returns a formatted string with digits from R merged into the
                  Mask}
(3) 9-21      function LongIntForm(Mask : string; L : LongInt) : string;
                {-Returns a formatted string with digits from L merged into the
                  Mask}
(3) 9-32      function UpCaseMac(Ch : Char) : Char;
                {-Uppercase character macro, no international character support}
(3) 9-20      function LoCaseMac(Ch : Char) : Char;
                {-Lowercase character macro, no international character support}
(3) 9-32      function Upcase(Ch : Char) : Char;
                {-Return uppercase of char, with international character support}
(3) 9-30      function StUpcase(S : string) : string;
                {-Convert lower case letters in string to uppercase, with intl
                  chars}
(3) 9-20      function LoCase(Ch : Char) : Char;
                {-Return lowercase of char, with international character support}
(3) 9-26      function StLocase(S : string) : string;
                {-Convert upper case letters in string to lowercase, with intl
                  chars}
(3) 9-7       function CharStr(Ch : Char; Len : Byte) : string;
                {-Return a string of length len filled with ch}
(3) 9-23      function PadCh(S : string; Ch : Char; Len : Byte) : string;
                {-Return a string right-padded to length len with ch}
(3) 9-23      function Pad(S : string; Len : Byte) : string;
                {-Return a string right-padded to length len with blanks}
(3) 9-20      function LeftPadCh(S : string; Ch : Char; Len : Byte) : string;
                {-Return a string left-padded to length len with ch}
(3) 9-19      function LeftPad(S : string; Len : Byte) : string;
                {-Return a string left-padded to length len with blanks}
(3) 9-30      function TrimLead(S : string) : string;
                {-Return a string with leading white space removed}
(3) 9-31      function TrimTrail(S : string) : string;
                {-Return a string with trailing white space removed}
(3) 9-30      function Trim(S : string) : string;
                {-Return a string with leading and trailing white space removed}
(3) 9-31      function TrimSpaces(S : string) : string;
                {-Return a string with leading and trailing spaces removed}
(3) 9-7       function CenterCh(S : string; Ch : Char; Width : Byte) : string;
                {-Return a string centered in a string of Ch with specified width}
(3) 9-6       function Center(S : string; Width : Byte) : string;
                {-Return a string centered in a blank string of specified width}
(3) 9-12      function Entab(S : string; TabSize : Byte) : string;
                {-Convert blanks in a string to tabs on spacing TabSize}
(3) 9-11      function Detab(S : string; TabSize : Byte) : string;
                {-Expand tabs in a string to blanks on spacing TabSize}
(3) 9-33      function WordCount(S : string; WordDelims : CharSet) : Byte;
                {-Given a set of word delimiters, return number of words in S}
(3) 9-33      function WordPosition(N : Byte; S : string;
                                    WordDelims : CharSet) : Byte;
                {-Given a set of word delimiters, return start position of N'th
                  word in S}
(3) 9-13      function ExtractWord(N : Byte; S : string;
                                   WordDelims : CharSet) : string;
                {-Given a set of word delimiters, return the N'th word in S}
(3) 9-34      procedure WordWrap(InSt : string; var OutSt, Overlap : string;
                                 Margin : Byte; PadToMargin : Boolean);
                {-Wrap InSt at Margin, storing the result in OutSt and the
                  remainder in Overlap}
(3) 9-9       function CompString(S1, S2 : string) : CompareType;
                {-Return less, equal, greater if s1<s2, s1=s2, or s1>s2}
(3) 9-10      function CompUCString(S1, S2 : string) : CompareType;
                {-Compare two strings in a case insensitive manner}
(3) 9-10      function CompStruct(var S1, S2; Size : Word) : CompareType;
                {-Compare two fixed size structures}
(3) 9-25      function Search(var Buffer; BufLength : Word;
                              var Match; MatLength : Word) : Word;
                {-Search through Buffer for Match. BufLength is length of range to
                  search. MatLength is length of string to match. Returns number
                  of bytes searched to find Match, $FFFF if not found.}
(3) 9-25      function SearchUC(var Buffer; BufLength : Word;
                                var Match; MatLength : Word) : Word;
                {-Search through Buffer for Match, CASE-INSENSITIVE.
                  Otherwise same as Search.}
(3) 9-4       procedure BMMakeTable(MatchString : string; var BT : BTable);
                {-Build Boyer-Moore link table}
(3) 9-5       function BMSearch(var Buffer; BufLength : Word;
                              BT : BTable; MatchString : string) : Word;
                {-Search Buffer for MatchString. BufLength is length of range to
                  search. Returns number of bytes searched to find MatchString,
                  $FFFF if not found}
(3) 9-6       function BMSearchUC(var Buffer; BufLength : Word;
                                  BT : BTable; MatchString : string) : Word;
                {-Search Buffer for MatchString, CASE-INSENSITIVE. Assumes
                  MatchString is already in uppercase. Otherwise same as BMSearch}
(3) 9-26      function Soundex(S : string) : string;
                {-Return 4 character soundex of input string}
(3) 9-22      function MakeLetterSet(S : string) : LongInt;
                {-Return a bit-mapped long storing the individual letters contained
                  in S}
(3) 9-8       function CompareLetterSets(Set1, Set2 : LongInt) : Word;
                {-Returns the sum of the values of the letters common to Set1
                  and Set2}
(3) 9-29      function StringToHeap(S : string) : StringPtr;
                {-Allocate space for s and return pointer}
(3) 9-29      function StringFromHeap(P : StringPtr) : string;
                {-Return string at p}
(3) 9-12      procedure DisposeString(P : StringPtr);
                {-Deallocate space for string at p}
(3) 9-11      function DefaultExtension(Name : string; Ext : ExtStr) : string;
                {-Return a file name with a default extension attached}
(3) 9-13      function ForceExtension(Name : string; Ext : ExtStr) : string;
                {-Force the specified extension onto the file name}
(3) 9-18      function JustFilename(PathName : string) : string;
                {-Return just the filename and extension of a pathname}
(3) 9-19      function JustName(PathName : string) : string;
                {-Return just the name (no extension, no path) of a pathname}
(3) 9-18      function JustExtension(Name : string) : ExtStr;
                {-Return just the extension of a pathname}
(3) 9-19      function JustPathname(PathName : string) : string;
                {-Return just the drive:directory portion of a pathname}
(3) 9-3       function AddBackSlash(DirName : string) : string;
                {-Add a default backslash to a directory name}
(3) 9-7       function CleanPathName(PathName : string) : string;
                {-Return a pathname cleaned up as DOS will do it}
(3) 9-16      function FullPathName(FName : string) : string;
                {-Given FName (known to exist), return a full pathname}

OpAsciiz  Procedures and Functions
==============================================================================

(3) 9-36      function Asc2Str(var A : Asciiz) : string;
                {-Convert Asciiz to Turbo string, truncating if longer than 255
                  chars}
(3) 9-48      procedure Str2Asc(S : string; var A : Asciiz);
                {-Convert a Turbo string into an Asciiz}
(3) 9-46      function LenAsc(A : Asciiz) : Word;
                {-Return the length of an Asciiz string}
(3) 9-43      procedure CopyAsc(var A : Asciiz; Start, Len : Word; var O : Asciiz);
                {-Return a substring of a. Note start=0 for first char in a}
(3) 9-44      procedure DeleteAsc(var A : Asciiz; Start, Len : Word);
                {-Delete len characters of a, starting at position start}
(3) 9-42      procedure ConcatAsc(var A, B, C : Asciiz);
                {-Concatenate two Asciiz strings, returning a third}
(3) 9-43      procedure ConcatStr(var A : Asciiz; S : string; var C : Asciiz);
                {-Concatenate a string to an asciiz, returning a new asciiz}
(3) 9-45      procedure InsertAsc(var Obj, A : Asciiz; Start : Word);
                {-Insert asciiz obj at position start of a}
(3) 9-45      procedure InsertStr(Obj : string; var A : Asciiz; Start : Word);
                {-Insert string obj at position start of a}
(3) 9-47      function PosStr(Obj : string; var A : Asciiz) : Word;
                {-Return the position of the string obj in a, returning NotFound if
                  not found}
(3) 9-46      function PosAsc(var Obja, A : Asciiz) : Word;
                {-Return the position of obja in a, returning NotFound if not
                  found}
(3) 9-40      function AscToHeap(var A : Asciiz) : AsciizPtr;
                {-Put Asciiz on heap, returning a pointer, nil if insufficient
                  memory}
(3) 9-37      procedure AscFromHeap(P : AsciizPtr; var A : Asciiz);
                {-Return an Asciiz from the heap, empty if pointer is nil}
(3) 9-44      procedure DisposeAsc(P : AsciizPtr);
                {-Dispose of heap space pointed to by P}
(3) 9-47      function ReadLnAsc(var F : Text; var A : Asciiz) : Boolean;
                {-Read an Asciiz from text file, returning true if successful}
(3) 9-48      function WriteAsc(var F : Text; var A : Asciiz) : Boolean;
                {-Write an Asciiz to text file, returning true if successful}
(3) 9-41      procedure AscUpcase(var A, B : Asciiz);
                {-Uppercase the Asciiz in a, returning b}
(3) 9-38      procedure AscLocase(var A, B : Asciiz);
                {-Lowercase the Asciiz in a, returning b}
(3) 9-37      procedure AscCharStr(Ch : Char; Len : Word; var A : Asciiz);
                {-Return an Asciiz of length len filled with ch}
(3) 9-39      procedure AscPadCh(var A : Asciiz; Ch : Char; Len : Word;
                                 var B : Asciiz);
                {-Right-pad the Asciiz in a to length len with ch, returning b}
(3) 9-39      procedure AscPad(var A : Asciiz; Len : Word; var B : Asciiz);
                {-Right-pad the Asciiz in a to length len with blanks, returning b}
(3) 9-38      procedure AscLeftPadCh(var A : Asciiz; Ch : Char; Len : Word;
                                     var B : Asciiz);
                {-Left-pad the Asciiz in a to length len with ch, returning b}
(3) 9-38      procedure AscLeftPad(var A : Asciiz; Len : Word; var B : Asciiz);
                {-Left-pad the Asciiz in a to length len with blanks, returning b}
(3) 9-41      procedure AscTrimLead(var A, B : Asciiz);
                {-Return an Asciiz with leading white space removed}
(3) 9-41      procedure AscTrimTrail(var A, B : Asciiz);
                {-Return an Asciiz with trailing white space removed}
(3) 9-40      procedure AscTrim(var A, B : Asciiz);
                {-Return an Asciiz with leading and trailing white space removed}
(3) 9-36      procedure AscCenterCh(var A : Asciiz; Ch : Char; Width : Word;
                                    var B : Asciiz);
                {-Return an Asciiz centered in an Asciiz of Ch with specified
                  width}
(3) 9-36      procedure AscCenter(var A : Asciiz; Width : Word; var B : Asciiz);
                {-Return an Asciiz centered in an Asciiz of blanks with specified
                  width}
(3) 9-42      function CompAsc(var a1, a2 : Asciiz) : AscCompareType;
                {-Return less, equal, greater if a1<a2, a1=a2, or a1>a2}
(3) 9-42      function CompUCAsc(var a1, a2 : Asciiz) : AscCompareType;
                {-Compare two Asciizs in a case insensitive manner}

OpStrDev  Procedures and Functions
==============================================================================

(3) 9-50      procedure ReadStr(var S : string);
                {-'Read' a string into S from our string buffer}
(3) 9-50      function ReturnStr : string;
                {-Return the contents of our string buffer}

OpDos   Procedures and Functions
==============================================================================

(3) 10-7      function DosVersion : Word;
                {-Returns the DOS version number. High byte has major version
                  number, low byte has minor version number. Eg.,
                  DOS 3.1 => $0301.}
(3) 10-20     function NumberOfDrives : Byte;
                {-Returns the number of logical drives}
(3) 10-23     procedure SelectDrive(Drive : Char);
                {-Selects the specified drive as default if possible}
(3) 10-7      function DefaultDrive : Char;
                {-Returns the default drive as an uppercase letter}
(3) 10-30     function ValidDrive(Drive : Char) : Boolean;
                {-Return True if the specified drive is valid}
(3) 10-14     function GetDiskInfo(Drive : Byte;
                                   var ClustersAvailable, TotalClusters,
                                   BytesPerSector,
                                   SectorsPerCluster : Word) : Boolean;
                {-Return technical info about the specified drive}
(3) 10-13     function GetDiskClass(Drive : Char;
                                    var SubstDriveChar : Char) : DiskClass;
                {-Return the disk class for the drive with the specified letter}
(3) 10-22     function ReadDiskSectors(Drive : Word; FirstSect : Longint;
                                       NumSects : Word; var Buf) : Boolean;
                {-Read absolute disk sectors.}
(3) 10-31     function WriteDiskSectors(Drive : Word; FirstSect : Longint;
                                        NumSects : Word; var Buf) : Boolean;
                {-Write absolute disk sectors.}
(3) 10-16     function GetFileMode(FName : string; var Attr : Word) : Byte;
                {-Returns a file's attribute in Attr and the DOS error code as the
                  function result.}
(3) 10-13     function FlushDosBuffers(var F) : Boolean;
                {-Flush DOS's buffers for the specified file}
(3) 10-12     function FileHandlesLeft : Byte;
                {-Return the number of available file handles}
(3) 10-12     function FileHandlesOpen(CountDevices : Boolean) : Byte;
                {-Return the number of open files owned by a program}
(3) 10-24     procedure SetDta(DTAptr : Pointer);
                {-Set the DOS DTA to point to DTAptr}
(3) 10-14     procedure GetDta(var DTAptr : Pointer);
                {-Return the DOS DTA pointer}
(3) 10-21     function ParsePath(var InputPath, SearchPath,
                                 LeadInPath : string) : Boolean;
                {-Takes a user entered path, trims blanks, and returns a valid
                  global search path and a valid lead-in path.}
(3) 10-21     function PrintInstalled : Boolean;
                {-Returns True if PRINT.COM is installed}
(3) 10-28     function SubmitPrintFile(FileName : string) : Byte;
                {-This procedure submits a file to the PC DOS 3.0 or greater
                  concurrent print utility.}
(3) 10-5      procedure CancelPrintFile(FileMask : string);
                {-Cancels the files matched by the file mask passed in FileMask.}
(3) 10-5      procedure CancelAllPrintFiles;
                {-Cancels all files in the print queue}
(3) 10-17     function GetPrintStatus(var QPtr : Pointer) : Byte;
                {-Halts printing, returns current error status, puts pointer to the
                  filename queue in the QPtr variable. Filenames in the queue are
                  64-byte ASCIIZ strings. The end of the queue is marked by a name
                  starting with a null.}
(3) 10-8      procedure EndPrintStatus;
                {-Releases the spooler from the GetPrintStatus procedure.}
(3) 10-15     function GetEnvironmentString(SearchString : string) : string;
                {-Return a string from the environment}
(3) 10-24     function SetBlock(var Paragraphs : Word) : Boolean;
                {-Change size of DOS memory block allocated to this program}
(3) 10-9      procedure NoExecDosProc(ActionCode : ActionCodeType; Param : Word);
                {-Do-nothing ExecDosProc}
(3) 10-9      function ExecDos(Command : string; UseSecond : Boolean;
                               EDP : ExecDosProc) : Integer;
                {-Execute any DOS command}
(3) 10-29     function TextSeek(var F : Text; Target : LongInt) : Boolean;
                {-Do a Seek for a text file opened for input. Returns False in case
                   of I/O error}
(3) 10-28     function TextFileSize(var F : Text) : LongInt;
                {-Return the size of text file F. Returns -1 in case of I/O error.}
(3) 10-29     function TextPos(var F : Text) : LongInt;
                {-Return the current position of the logical file pointer (that is,
                  for the position of the physical file pointer, adjusted to
                  account buffering). Returns -1 in case of I/O error.}
(3) 10-29     function TextFlush(var F : Text) : Boolean;
                {-Flush the buffer(s) for a text file. Returns False in case of
                  I/O error.}
(3) 10-20     function OpenStdDev(var F : Text; StdHandle : Word) : Boolean;
                {-Assign the text file to a standard DOS device: 0, 1, 2, or 4}
(3) 10-18     function HandleIsConsole(Handle : Word) : Boolean;
                {-Return true if handle is the console device}
(3) 10-26     procedure SetRawMode(var F : Text; On : Boolean);
                {-Set "raw" mode on or off for the specified text file (must be a
                  device)}
(3) 10-11     function ExistFile(FName : string) : Boolean;
                {-Return true if file is found}
(3) 10-11     function ExistOnPath(FName : string;
                                   var FullName : string) : Boolean;
                {-Return true if fname is found in a) current directory,
                  b) program's directory (DOS 3.X only), or c) any DOS path
                  directory and return full path name to file}
(3) 10-18     function IsDirectory(FName : String) : Boolean;
                {-Return true if FName is a directory}
(3) 10-23     function SameFile(FilePath1,FilePath2 : String;
                                var ErrorCode : Word) : Boolean;
                {-Return true if FilePath1 and FilePath2 refer to the same
                  physical file. Error codes: 0 - Success (no error),
                  1 - Invalid FilePath}
(3) 10-6      function CopyFile(SrcPath, DestPath : String;
                                Buffer : Pointer;
                                BufferSize : Word) : Word;
                {-Copy the file specified by SrcPath into DestPath}
(3) 10-30     function TimeMs : LongInt;
                {-Return time of day in milliseconds since midnight}
(3) 10-19     procedure MasterEnv(var Env : EnvRec);
                {-Return master environment record}
(3) 10-6      procedure CurrentEnv(var Env : EnvRec);
                {-Return current environment record}
(3) 10-20     procedure ParentEnv(var Env : EnvRec);
                {-Return environment record of program's parent}
(3) 10-19     procedure NewEnv(var Env : EnvRec; Size : Word);
                {-Allocate a new environment on the heap}
(3) 10-7      procedure DisposeEnv(var Env : EnvRec);
                {-Deallocate an environment previously allocated on heap}
(3) 10-24     procedure SetCurrentEnv(Env : EnvRec);
                {-Specify a different environment for the current program}
(3) 10-5      procedure CopyEnv(Src, Dest : EnvRec);
                {-Copy contents of Src environment to Dest environment}
(3) 10-8      function EnvFree(Env : EnvRec) : Word;
                {-Return bytes free in environment}
(3) 10-15     function GetEnvStr(Env : EnvRec; Search : string) : string;
                {-Return a string from the environment}
(3) 10-25     function SetEnvStr(Env : EnvRec; Search, Value : string) : Boolean;
                {-Set environment string, returning true if successful}
(3) 10-8      procedure DumpEnv(Env : EnvRec);
                {-Dump the environment to the screen}
(3) 10-17     function GetProgramStr(Env : EnvRec) : string;
                {-Return the name of the program that owns Env, '' if DOS < 3.0
                  or unknown}
(3) 10-26     function SetProgramStr(Env : EnvRec; Path : string) : Boolean;
                {-Add a program name to the end of an environment if sufficient
                  space}
(3) 10-27     function ShellWithPrompt(Prompt : string;
                                       EDP : ExecDosProc) : Integer;
                {-Shell to DOS with a new prompt}

OpExec  Procedures and Functions
==============================================================================

(3) 10-41     procedure SetSwapMsgOn(On : Boolean);
                {-Turns Swap message on or off}
(3) 10-39     procedure ExecWithSwap(Path, CmdLine : String);
                {-DOS shell with swapping to EMS or disk}
(3) 10-40     function PrepareExecWithSwap(LastToSave : Pointer;
                                           SwapFileName : PathStr) : Boolean;
                {-Set up for a shell with swapping, returning true if successful}
(3) 10-41     procedure RemoveExecWithSwap;
                {-Deallocate EMS space or erase swap file, whichever was allocated}
(3) 10-36     function ExecDosSwap(Command : string; UseSecond : Boolean;
                                   EDP : Pointer; SwapFName : PathStr) : Integer;
                {-Execute any DOS command}

OpEnhKbd  Procedures and Functions
==============================================================================

(3) 10-45     procedure RestoreKbdVectors;
                {-Restores original vectors for INT's $09 and $16}
(3) 10-45     procedure InitKbdVectors;
                {-Save and setup interrupt vectors. This routine should be called
                  only if RestoreKbdVectors has been called first!!}

OpInt   Procedures and Functions
==============================================================================

(3) 11-8      procedure InterruptsOn;
                {-Turn interrupts on}
(3) 11-8      procedure InterruptsOff;
                {-Turn interrupts off}
(3) 11-10     procedure SendEOI;
                {-Send an End Of Interrupt command to the Programmable Interrupt
                  Controller}
(3) 11-9      procedure IntReturn(var IntRegs : IntRegisters);
                {-Return from interrupt. Needed only if stack has been changed.}
(3) 11-6      procedure ChainInt(var Regs : IntRegisters; JumpAddr : Pointer);
                {-Restores stack, registers from Regs and 'jumps' to JumpAddr}
(3) 11-11     procedure SwapStackAndCallNear(Routine : Word; SP : Pointer;
                                             var Regs : IntRegisters);
                {-Switches to stack designated by SP and calls Routine with Regs
                  as a parameter. The Routine must be a NEAR call from the current
                  ISR.}
(3) 11-11     procedure SwapStackAndCall(Routine, SP : Pointer;
                                         var Regs : IntRegisters);
                {-Switches to stack designated by SP and calls Routine with Regs
                  as a parameter. The Routine must be a FAR call from the current
                  ISR.}
(3) 11-7      procedure EmulateInt(var Regs : IntRegisters; IntAddr : Pointer);
                {-Emulates an interrupt by filling the CPU registers with the
                  values in Regs, clearing interrupts, pushing the flags, and
                  calling far to IntAddr.}
(3) 11-8      function InitVector(IntNumber, Handle : Byte;
                                  UserRoutine : Pointer) : Boolean;
                {-Sets up an interrupt service routine}
(3) 11-10     procedure RestoreVector(Handle : Byte);
                {-Restores an interrupt vector to its original value}
(3) 11-9      procedure RestoreAllVectors;
                {-Restores all captured interrupt vectors.}
(3) 11-6      function AllocateStack(var P : Pointer;
                                     SizeInBytes : Word) : Boolean;
                {-Allocates a stack of size SizeInBytes}
(3) 11-7      procedure DeallocateStack(P : Pointer);
                {-Frees an allocated stack}

OpTsr   Procedures and Functions
==============================================================================

(3) 11-30     function ParagraphsToKeep : Word;
                {-Returns # of paragraphs currently used for code, data, stack,
                  and heap.}
(3) 11-29     function MaxParagraphsToKeep : Word;
                {-Maximum number of paragraphs to keep when going resident}
(3) 11-33     procedure StayRes(ParasToKeep : Word; ExitCode : Byte);
                {-Terminate and stay resident, freeing up all our memory except
                  ParasToKeep. Returns only if unable to go resident.}
(3) 11-31     procedure PopupsOn;
                {-Turns popups on}
(3) 11-31     procedure PopupsOff;
                {-Turns popups off}
(3) 11-25     function DefinePopProc(var Handle : Byte; Routine : PopupProc;
                                     StackPtr : Pointer) : Boolean;
                {-Defines a routine that can be triggered by calling SetPopTicker.
                  Returns false if no more Popup handles are available.}
(3) 11-26     procedure DeletePopProc(Handle : Byte);
                {-Deletes a popup routine defined with DefinePopProc.  Its handle
                  may then be used for other popups.}
(3) 11-25     function DefinePop(HotKey : Word; Routine : PopupProc;
                                 StackPtr : Pointer; DosWait : Boolean) : Boolean;
                {-Defines a popup routine associated with a particular hotkey.
                  Returns False if no more Popup handles are available.}
(3) 11-26     procedure DeletePop(HotKey : Word);
                {-Deletes the popup routine associated with HotKey.  Its handle
                  may then be used for other popups.}
(3) 11-24     function ChangeHotKey(OldHotKey, NewHotKey : Word) : Boolean;
                {-Change a popup's hotkey from OldHotKey to NewHotKey}
(3) 11-24     function AddHotKey(PrimaryHotKey, SecondaryHotKey : Word) : Boolean;
                {-Add a second hot key for the popup with the specified primary
                  hot key}
(3) 11-32     procedure SetPopTicker(Handle : Byte; TimeOut : Word);
                {-Sets the pop ticker for the indicated procedure, clears
                  interrupts, then returns.  No range checking is performed.}
(3) 11-31     procedure RemovePops;
                {-Removes all popup routines from the system and releases all
                  associated interrupt vectors}
(3) 11-28     procedure InitPops;
                {-Must be called before any other popup specific routines}
(3) 11-27     function DisableTSR : Boolean;
                {-Disable TSR by restoring interrupt vectors and releasing memory.
                  This does *not* halt the program. Returns False if it's not
                  safe.}
(3) 11-32     function SafeToDisable : Boolean;
                {-Returns True if it is safe to disable the TSR}
(3) 11-28     procedure InstallModule(var ModuleName : string;
                                      CmdEntryRoutine : Pointer);
                {-Installs this program as a resident module that can be located
                  and accessed by other programs.}
(3) 11-33     procedure UninstallModule;
                {-Uninstalls the module from the linked list of modules}
(3) 11-30     function ModulePtrByName(var ModuleName : string) : IfcPtr;
                {-Returns a pointer to the IfcRecord for the module named
                  ModuleName or Nil}
(3) 11-29     function ModuleInstalled(var ModuleName : string) : Boolean;
                {-Returns true if ModuleName is installed.}
(3) 11-27     function DosBusyFlag : Byte;
                {-Returns current value of DOS busy flag}
(3) 11-27     function DosCriticalFlag : Byte;
                {-Returns current value of DOS critical flag}
(3) 11-28     function GetPSP : Word;
                {-Returns current PSP}
(3) 11-32     procedure SetPSP(PSP : Word);
                {-Sets current PSP}

OpSwap  Procedures and Functions
==============================================================================

(3) 11-57     procedure SetPopTicker(TimeOut : Word);
                {-Sets the pop ticker for the CmdEntry procedure, clears
                  interrupts, then returns.}

OpSwap1 Procedures and Functions
==============================================================================

(3) 11-48     function AllocateStack(var P : Pointer;
                                     SizeInBytes : Word) : Boolean;
                {-Allocates a stack of size SizeInBytes}
(3) 11-48     procedure DeallocateStack(P : Pointer);
                {-Frees an allocated stack}
(3) 11-49     procedure PopupsOn;
                {-Turns popups on}
(3) 11-49     procedure PopupsOff;
                {-Turns popups off}
(3) 11-48     function ChangeHotKey(OldHotKey, NewHotKey : Word) : Boolean;
                {-Change a popup's hotkey from OldHotKey to NewHotKey}
(3) 11-48     function AddHotKey(PrimaryHotKey, SecondaryHotKey : Word) : Boolean;
                {-Add a second hot key for the popup with the specified primary
                  hot key}
(3) 11-50     function DefinePop(HotKey : Word; Routine : PopupProc;
                                 StackPtr : Pointer) : Boolean;
                {-Defines a popup routine associated with a particular hotkey.
                  Returns False if no more Popup handles are available.}
(3) 11-49     procedure RestoreAllVectors;
                {-Restores all captured interrupt vectors}
(3) 11-55     function WillSwapUseEms(ParasToKeep : Word) : Boolean;
                {-Returns True if OpSwap will use EMS memory for swapping}
(3) 11-49     function ParagraphsToKeep : Word;
                {-Returns # of paragraphs currently used for code, data, stack,
                  and heap}
(3) 11-52     function MaxParagraphsToKeep : Word;
                {-Maximum number of paragraphs to keep when going resident}
(3) 11-55     procedure StayResSwap(ParasToKeep : Word; ExitCode : Byte;
                                    SwapFileName1, SwapFileName2 : String;
                                    UseSwapping : Boolean);
                {-Terminate and stay resident. If UseSwapping is False, then the
                  TSR does not use the swapping techniques and behaves like a
                  normal TSR written with OpTSR (or TpTSR)}
(3) 11-48     function DisableTSR : Boolean;
                {-Disable TSR by restoring interrupt vectors and releasing memory.
                  This does *not* halt the program. Returns false if it's not
                  safe.}
(3) 11-49     function SafeToDisable : Boolean;
                {-Returns True if it is safe to disable the TSR}
(3) 11-51     procedure DisablePopup;
                {-An external interface procedure that attempts to disable the
                  popup and reports the results in the UserData field of the
                  IfcRecord. UserData is set to 1 on success.}
(3) 11-52     procedure InstallModule(var ModName : string;
                                      CmdEntryPtr : PopupProc);
                {-Installs this program as a resident module that can be located
                  and accessed by other programs.}
(3) 11-49     procedure UninstallModule;
                {-Uninstalls the module from the linked list of modules.}
(3) 11-53     procedure SetSwapMsgAttr(Attr : Byte);
                {-Sets the attribute used by Swap manager for swap message}
(3) 11-53     procedure SetSwapMsgOn(On : Boolean);
                {-Turns Swap message on or off}
(3) 11-53     procedure SetSwapMsgRow(Row : Byte);
                {-Sets the row where swapping messages are to appear}
(3) 11-54     procedure SetUserExitProc(UserExitProc : PopupProc);
                {-Sets a pointer to a far procedure that is to be called before
                  disabling the TSR}
(3) 11-48     function ModulePtrByName(var ModuleName : string) : IfcPtr;
                {-Returns a pointer to the IfcRecord for the module named
                  ModuleName or Nil.}
(3) 11-48     function ModuleInstalled(var ModuleName : string) : Boolean;
                {-Returns true if ModuleName is installed.}
(3) 11-48     procedure EmulateInt(var Regs : IntRegisters; IntAddr : Pointer);
                {-Emulates an interrupt by filling the CPU registers with the
                  values in Regs, clearing interrupts, pushing the flags, and
                  calling far to IntAddr.}
(3) 11-48     function DosBusyFlag : Byte;
                {-Returns current value of DOS busy flag}
(3) 11-48     procedure InterruptsOn;
                {-Turn interrupts on}
(3) 11-48     procedure InterruptsOff;
                {-Turn interrupts off}

Op8087  Procedures and Functions
==============================================================================

(3) 11-63     procedure Save8087(var SaveBuf : SaveBuffer8087);
                {-Saves the 80x87 registers in the save buffer.}
(3) 11-63     procedure Restore8087(var SaveBuf : SaveBuffer8087);
                {-Restores the 80x87 registers from the save buffer.}
(3) 11-62     function Installed8087 : Boolean;
                {-Returns true if an 80x87 coprocessor is installed.}
(3) 11-61     procedure Exceptions8087(On : Boolean);
                {-Turn exception interrupts on or off}
(3) 11-61     function Error8087 : Word;
                {-Return (and clear) the error status of the 80x87}
(3) 11-62     procedure Reinit8087;
                {-Reinitialize the 8087 chip}
(3) 11-62     procedure ReinitEmulator;
                {-Reinitialize the emulator}
(3) 11-63     function UseEmulator : Boolean;
                {-Return True if ReinitEmulator should be used rather than
                  Reinit8087}

OpEms   Procedures and Functions
==============================================================================

(3) 12-6      function EmsInstalled : Boolean;
                {-Returns true if the EMM is installed.}
(3) 12-5      function EmmSigFound : Boolean;
                {-Returns True if EMM signature found}
(3) 12-9      function EmsStatusOK : Boolean;
                {-Returns true if the EMM reports its status as being OK.}
(3) 12-8      function EmsPagesAvail : Word;
                {-Returns the number of available pages from the expanded memory
                  manager, or EmsErrorCode in case of error.}
(3) 12-9      function EmsTotalPages : Word;
                {-Returns total number of pages of EMS memory, including allocated
                  pages, or EmsErrorCode in case of error.}
(3) 12-7      function EmsPageFramePtr : Pointer;
                {-Returns the page frame base address as a pointer to the page
                  frame.}
(3) 12-4      function AllocateEmsPages(NumPages : Word) : Word;
                {-Allocates the indicated number of pages and returns a handle.
                  Returns EmsErrorCode in case of error.}
(3) 12-10     function MapEmsPage(Handle, LogicalPage : Word;
                                  PhysicalPage : Byte) : Boolean;
                {-Maps the specified LogicalPage associated with Handle into
                  PhysicalPage (0-3). Returns true if successful.}
(3) 12-5      function DeallocateEmsHandle(Handle : Word) : Boolean;
                {-Deallocates the indicated handle and the memory associated with
                  it.}
(3) 12-10     function EmsVersion : Byte;
                {-Returns a BCD version number of the EMM handle. To check for
                  version 3.2 or greater for example, use: 'if EmsVersion >= $32
                  then'. Returns 0 in case of error.}
(3) 12-11     function SaveEmsContext(Handle : Word) : Boolean;
                {-Saves the EMM context for resident programs. The handle passed
                  must have been allocated with a call to AllocateEmsPages.
                  Returns true if successful.}
(3) 12-11     function RestoreEmsContext(Handle : Word) : Boolean;
                {-Restores the mapping context of the EMM driver for the handle
                  specified. The handle should the same one used in a prior call
                  to SaveEmsContext. Returns true if successful.}
(3) 12-6      function EmsActiveHandles : Word;
                {-Returns the number of active EMS handles, EmsErrorCode in case
                  of error}
(3) 12-8      function EmsPagesOwned(Handle : Word) : Word;
                {-Returns the number of pages owned by Handle, or EmsErrorCode in
                  case of error.}

OpExtMem  Procedures and Functions
==============================================================================

(3) 12-16     function PtrToHuge(P : Pointer) : HugePtr;
                {-Converts a pointer to a huge pointer. The pointer must be in the
                  range $0:$0 to $FFFF:$000F.}
(3) 12-15     procedure MoveExtMem(Src, Dest : HugePtr; WCount : Word);
                {-Move WCount words of extended memory from Src to Dest.}
(3) 12-13     function ExtMemTotal : LongInt;
                {-Returns total number of bytes of extended memory in the system.}
(3) 12-13     function ExtMemAvail : Word;
                {-Returns the number of KB of extended memory that is actually
                  free.}
(3) 12-14     function GetExtMem(N : Word) : HugePtr;
                {-Allocate N Kb of extended memory.  Returns Nil if insufficient
                  memory.}
(3) 12-14     function FreeExtMem(P : HugePtr) : Boolean;
                {-Deallocates extended memory which has been allocated with
                  GetExtMem.}
(3) 12-15     procedure MarkExtMem(var P : HugePtr);
                {-Store the location of the next extended memory block in P}
(3) 12-16     procedure ReleaseExtMem(P : HugePtr);
                {-Release all extended memory above P. P *must* have been set by
                  MarkExtMem. It cannot be a huge pointer returned by GetExtMem.}

OpMacro Procedures and Functions
==============================================================================

(3) 13-7      function DefineMacro(Key : Word; var Macro) : Boolean;
                {-Define a new macro or delete an existing one.}
(3) 13-9      function MacroAddress(Key : Word) : Pointer;
                {-Returns a pointer to the macro for a key, or nil if key is not
                  defined.}
(3) 13-9      function MacroCount : Word;
                {-Returns the number of macros that have been defined}
(3) 13-5      function AllocateMacro(Key : Word; var Macro;
                                     var Name : string) : Byte;
                {-Allocates a macro on the heap, and returns one of the following
                  values: 0 : Macro allocated; 1 : Macro table full; 2 : Out of
                  heap space; 3 : Macro was blank }
(3) 13-6      function DeallocateMacro(Key : Word) : Boolean;
                {-If the macro exists, this routine erases it and deallocates its
                  memory. Returns False if the macro was not found.}
(3) 13-5      function AssignMacroName(Key : Word; var Name : string) : Boolean;
                {-Assign a Name to a macro, deleting the existing name assigned to
                  the macro, if any. Returns false if insufficient memory exists
                  or macro not found.}
(3) 13-11     function ReadMacroFile(FName : string; Merge : Boolean) : Byte;
                {-Read a macro file. Returns 0 if successful, $FF if not a valid
                  macro file, $FE if we ran out of memory, else IOresult. If Merge
                  is false, any existing macros are deleted before the file is
                  read.}
(3) 13-14     function WriteMacroFile(FName : string) : Byte;
                {-Write a macro file. Returns 0 if successful, else IOresult.}
(3) 13-6      procedure ClearMacros;
                {-Clears out the current macros.}
(3) 13-10     procedure MacrosOn;
                {-Turns macro processing on}
(3) 13-10     procedure MacrosOff;
                {-Turns macro processing off}
(3) 13-10     procedure MacroRecordingOn;
                {-Turns macro recording on}
(3) 13-9      procedure MacroRecordingOff;
                {-Turns macro recording off}
(3) 13-13     procedure StartMacro(Macro : Pointer);
                {-Starts execution of the specified macro. If a macro is already in
                  progress it will immediately be replaced by the macro passed.}
(3) 13-13     procedure StartMacroByKey(Key : Word);
                {-Starts execution of the macro attached to key, if any. If a macro
                  is already in progress it will immediately be replaced by the
                  macro passed.}
(3) 13-11     procedure RemoveMacros;
                {-Restores all vectors associated with macros.}
(3) 13-12     procedure SetEndOfMacroProc(P : Pointer);
                {-Set pointer to procedure to call when end of macro reached}
(3) 13-7      function FindMacroIndex(Key : Word) : Word;
                {-Find the array index for the macro assigned to Key. Returns 0 if
                  not found.}
(3) 13-8      function InitMacros : Boolean;
                {-Initializes macros. After this routine is called, no macros will
                  be defined and both macro processing and macro recording will be
                  turned off. Returns false if INT $16 cannot be taken over.}
(3) 13-6      function CharToMacro(MacroChar : Char) : Word;
                {-Converts a character to a keyboard code/char representation.
                  This table holds all scan code values for ASCII characters from
                  0 to 63. All alpha characters can be mapped to this table by
                  subtracting a number divisible by 32 that would put that alpha
                  in the range of 0..63.}
(3) 13-13     procedure StringToMacro(S : string; MRP : MacroRecPtr;
                                      MaxKeys : Word);
                {-Initialize MRP^ from a string}
(3) 13-14     procedure StringToScrapMacro(S : string);
                {-Initialize ScrapMacro from a string}
(3) 13-8      procedure KeyToString(Key : Word; var S : string;
                                    var Special : Boolean);
                {-Returns a string (S) representing a Key. Special is set to False
                  if a simple character is being returned.}

OpMacEd Procedures and Functions
==============================================================================

(3) 13-16     function EditKeys(Key : Word; var Macro : MacroRec;
                                MinCol, MinRow, MaxCol, MaxRow,
                                Dim, Bright : Byte;
                                var Modified : Boolean) : MacroRecPtr;
                {-Edit the Macro associated with Key.}

OpReplay  Procedures and Functions
==============================================================================

(3) 13-21     procedure StartMacro(Macro : MacroRecPtr);
                {-Starts execution of the specified macro}
(3) 13-19     function CharToMacro(MacroChar : Char) : Word;
                {-Converts a character to a keyboard code/char representation}
(3) 13-22     procedure StringToScrapMacro(S : string);
                {-Initialize ScrapMacro from a string}
(3) 13-22     procedure StringToMacro(S : string; MRP : MacroRecPtr;
                                      MaxKeys : Word);
                {-Initialize MRP^ from a string}
(3) 13-20     procedure Int16;
                {-The macro engine used to replay keystrokes. It is the user's
                  responsibility to install and uninstall this interrupt handler.}
(3) 13-21     procedure SetEndOfMacroProc(P : Pointer);
                {-Set pointer to procedure to call when end of macro reached}
(3) 13-19     procedure InitScrapMacroPtr;
                {-Initialize ScrapMacroPtr}

OpBCD   Procedures and Functions
==============================================================================

(3) 14-11     procedure RealToBCD(R : Real; var B : BCD);
                {-Convert a real to a BCD}
(3) 14-9      procedure LongintToBCD(L : LongInt; var B : BCD);
                {-Convert a Longint to a BCD}
(3) 14-5      function BCDtoReal(B : BCD) : Real;
                {-Convert a BCD to a real}
(3) 14-13     function StrBCD(B : BCD; Width, Places : Byte) : string;
                {-Return a BCD as a string}
(3) 14-13     function StrExpBCD(B : BCD; Width : Byte) : string;
                {-Return B as a string in exponential format}
(3) 14-15     procedure ValBCD(S : string; var B : BCD; var Code : Word);
                {-Convert a string to a BCD}
(3) 14-4      procedure AbsBCD(B1 : BCD; var B2 : BCD);
                {-Returns absolute value of B1 in B2}
(3) 14-7      procedure FracBCD(B1 : BCD; var B2 : BCD);
                {-Returns the fractional part of B1 in B2}
(3) 14-8      procedure IntBCD(B1 : BCD; var B2 : BCD);
                {-Returns the integer part of B1 in B2}
(3) 14-11     function RoundBCD(B1 : BCD) : LongInt;
                {-Returns the value of B1 rounded to the nearest long integer}
(3) 14-14     function TruncBCD(B1 : BCD) : LongInt;
                {-Returns the greatest long integer less than or equal to B1}
(3) 14-7      function Form(Mask : string; B : BCD) : string;
                {-Returns a formatted string with digits from B merged into the
                  Mask}
(3) 14-4      procedure AddBCD(B1, B2 : BCD; var B3 : BCD);
                {-Add B1 to B2 and put result in B3}
(3) 14-14     procedure SubBCD(B1, B2 : BCD; var B3 : BCD);
                {-Subtract B2 from B1 and put result in B3}
(3) 14-10     procedure MultBCD(B1, B2 : BCD; var B3 : BCD);
                {-Multiply B1 by B2 and put result in B3}
(3) 14-5      procedure DivBCD(B1, B2 : BCD; var B3 : BCD);
                {-Divide B1 by B2 and put result in B3}
(3) 14-6      function EqualBCD(B1, B2 : BCD) : Boolean;
                {-Returns true if B1 = B2}
(3) 14-10     function NotEqualBCD(B1, B2 : BCD) : Boolean;
                {-Returns true if B1 <> B2}
(3) 14-7      function GreaterBCD(B1, B2 : BCD) : Boolean;
                {-Returns true if B1 > B2}
(3) 14-8      function GreaterEqualBCD(B1, B2 : BCD) : Boolean;
                {-Returns true if B1 >= B2}
(3) 14-8      function LessBCD(B1, B2 : BCD) : Boolean;
                {-Returns true if B1 < B2}
(3) 14-9      function LessEqualBCD(B1, B2 : BCD) : Boolean;
                {-Returns true if B1 <= B2}
(3) 14-4      procedure ArcTanBCD(B1 : BCD; var B2 : BCD);
                {-Returns arc tangent of B1 in B2}
(3) 14-5      procedure CosBCD(B1 : BCD; var B2 : BCD);
                {-Returns cosine of B1 in B2}
(3) 14-6      procedure ExpBCD(B1 : BCD; var B2 : BCD);
                {-Returns the exponential of B1 in B2}
(3) 14-9      procedure LnBCD(B1 : BCD; var B2 : BCD);
                {-Returns the natural log of B1 in B2}
(3) 14-12     procedure SinBCD(B1 : BCD; var B2 : BCD);
                {-Returns the sine of B1 in B2}
(3) 14-12     procedure SqrBCD(B1 : BCD; var B2 : BCD);
                {-Returns the square of B1 in B2}
(3) 14-12     procedure SqrtBCD(B1 : BCD; var B2 : BCD);
                {-Returns the square root of B1 in B2}

OpClone Cloner
==============================================================================

(3) 14-21     constructor Init(FName : string; DUT : DateUpdateType);
                {-Open file for cloning}
(3) 14-21     constructor InitCustom(FName : string; DUT : DateUpdateType;
                                     BufSize : Word);
                {-Open file for cloning}
(3) 14-22     constructor InitAndFind(FName : string; DUT : DateUpdateType;
                                      var IdSize : Word);
                {-Open file and find ID. Uses FindDefaultsEnd}
(3) 14-19     destructor Done; virtual;
                {-Close clone file, adjust time stamp, and deallocate buffer}
(3) 14-19     function FindDefaultsEnd(var ID; IdSize : Word;
                                       Skip : LongInt) : Boolean;
                {-Find the ID in the clone file, searching from the end backward}
(3) 14-19     function FindDefaultsStart(var ID; IdSize : Word;
                                         Skip : LongInt) : Boolean;
                {-Find the ID in the clone file, searching from the start forward}
(3) 14-20     function GetLastError : Word;
                {-Get the code for the last error}
(3) 14-21     function GetPos : LongInt;
                {-Get position where an ID string was found (offset returned is
                  the start of the ID string)}
(3) 14-23     procedure LoadDefaults(FileOfs : LongInt; var Defaults;
                                     Bytes : Word);
                {-Seek to position FileOfs and read defaults there}
(3) 14-24     procedure StoreDefaults(FileOfs : LongInt; var Defaults;
                                      Bytes : Word);
                {-Seek to position FileOfs and store defaults there}

OpErrHan  Procedures and Functions
==============================================================================

(3) 14-27     procedure ErrorRecovery(On : Boolean; UserRoutine : Pointer);
                {-Turn error recovery on and off, and attach to a user error
                  routine}

OpInline  Procedures and Functions
==============================================================================

(3) 14-43     function SetJump(var JumpDest : JumpRecord) : Word;
                {-Save current SP, BP, and a jump destination}
(3) 14-37     procedure LongJump(var JumpDest : JumpRecord; Result : Word);
                {-Restore SP, BP, and jump to JumpDest.JmpPt}
(3) 14-34     procedure FarCall(ProcAddr : Pointer);
                {-ProcAddr is the address of a routine to be called far. Can be
                  used to implement jump tables if procedures take no parameters.}
(3) 14-41     procedure NearCall(ProcOfs : Word);
                {-ProcOfs is the offset of a routine to be called near.}
(3) 14-36     procedure JumpToOldIsr(OldIsr : Pointer);
                {-Jump to previous ISR from an interrupt procedure.}
(3) 14-39     function MakeLongInt(H, L : Word) : LongInt;
                {-Constructs a LongInt from two Words}
(3) 14-38     function MakeInteger(H, L : Byte): Integer;
                {-Constructs an integer from two bytes}
(3) 14-39     function MakeWord(H, L : Byte) : Word;
                {-Constructs a word from two bytes}
(3) 14-30     function Array2Str(var A; Len : Byte) : string;
                {-Convert an array of char to a string}
(3) 14-31     procedure CallOldIsr(OldIsr : Pointer);
                {-Call previous ISR from an interrupt procedure. Destroys BX.}
(3) 14-42     procedure Reboot;
                {-Reboot the machine}
(3) 14-36     function HiWord(L : LongInt) : Word;
                {-Return high-order word of L}
(3) 14-38     function LoWord(L : LongInt) : Word;
                {-Return low-order word of L}
(3) 14-44     function SwapNibble(B : Byte) : Byte;
                {-Swap the high and low nibbles of B: SwapNibble($F0) returns $0F.}
(3) 14-44     function SwapWord(L : LongInt) : LongInt;
                {-Swap low- and high-order words of L}
(3) 14-41     function Normalized(P : Pointer) : Pointer;
                {-Return P as a normalized pointer}
(3) 14-43     procedure SetFlag(var Flags : Word; FlagMask : Word);
                {-Set the bit(s) specified by FlagMask in Flags}
(3) 14-31     procedure ClearFlag(var Flags : Word; FlagMask : Word);
                {-Clear the bit(s) specified by FlagMask in Flags}
(3) 14-35     function FlagIsSet(Flags, FlagMask : Word) : Boolean;
                {-Returns True if the bit specified by FlagMask is set in Flags}
(3) 14-42     procedure SetByteFlag(var Flags : Byte; FlagMask : Byte);
                {-Set the bit(s) specified by FlagMask in Flags}
(3) 14-31     procedure ClearByteFlag(var Flags : Byte; FlagMask : Byte);
                {-Clear the bit(s) specified by FlagMask in Flags}
(3) 14-30     function ByteFlagIsSet(Flags, FlagMask : Byte) : Boolean;
                {-Returns True if the bit specified by FlagMask is set in Flags}
(3) 14-44     procedure SetLongFlag(var Flags : LongInt; FlagMask : LongInt);
                {-Set the bit(s) specified by FlagMask in Flags}
(3) 14-32     procedure ClearLongFlag(var Flags : LongInt; FlagMask : LongInt);
                {-Clear the bit(s) specified by FlagMask in Flags}
(3) 14-37     function LongFlagIsSet(Flags, FlagMask : LongInt) : Boolean;
                {-Returns True if the bit specified by FlagMask is set in Flags}
(3) 14-32     procedure ExchangeBytes(var I, J : Byte);
                {-Exchange bytes I and J}
(3) 14-33     procedure ExchangeWords(var I, J : Word);
                {-Exchange words I and J}
(3) 14-32     procedure ExchangeLongInts(var I, J : LongInt);
                {-Exchange LongInts I and J}
(3) 14-33     procedure ExchangeStructs(var I, J; Size : Word);
                {-Exchange structures I and J. Useful in sorts}
(3) 14-40     function MinWord(A, B : Word) : Word;
                {-Returns the smaller of A and B}
(3) 14-40     function MaxWord(A, B : Word) : Word;
                {-Returns the greater of A and B}
(3) 14-40     function MinLong(A, B : LongInt) : LongInt;
                {-Returns the smaller of A and B}
(3) 14-39     function MaxLong(A, B : LongInt) : LongInt;
                {-Returns the greater of A and B}
(3) 14-35     procedure FillWord(var Dest; Count, Filler : Word);
                {-Fill memory starting at Dest with Count instances of Filler}
(3) 14-34     procedure FillStruct(var Dest; Count : Word; var Filler;
                                   FillerSize : Word);
                {-Fill memory starting at Dest with Count instances of Filler}
(3) 14-29     function AddWordToPtr(P : Pointer; W : Word) : Pointer;
                {-Add a Word to a pointer. No normalization or wrap checking
                  performed}
(3) 14-42     function PtrToLong(P : Pointer) : LongInt;
                {-Convert pointer, in range $0:$0 to $FFFF:$000F, to LongInt}
(3) 14-38     function LongToPtr(L : LongInt) : Pointer;
                {-Return LongInt L as a normalized pointer}
(3) 14-41     function PtrDiff(P1, P2 : Pointer) : LongInt;
                {-Return the number of bytes between P1^ and P2^}
(3) 14-29     function AddLongToPtr(P : Pointer; L : LongInt) : Pointer;
                {-Add a LongInt to a pointer, returning a normalized pointer}

OpSort  Procedures and Functions
==============================================================================

(3) 14-48     function PutElement(var X) : Boolean;
                {-Put a sort element into the sort array}
(3) 14-47     function GetElement(var X) : Boolean;
                {-Get next element from the sorted array}
(3) 14-49     function Sort(Elements    : Word; ElementSize : Word;
                            GetElements : GetPutProc; LessFunc : UserLessFunc;
                            PutElements : GetPutProc) : SortStatus;
                {-Sort a group of elements}