     Справочник по процедурам и функциям

     В данном  разделе приводится полный перечень всех документи-
рованных процедур, функций и методов во всей библиотеке. Описание
каждого элемента имеет следующий формат:

procedure ИмяПроцедуры(Параметры);
  {-Краткое описание}

     Здесь приводится имя подпрограммы, получаемые ею параметры и
краткое описание действия, которое выполняется данной подпрограм-
мой.

     Отдельные элементы  сгруппированы в  соответствии с  именами
модуля и  объекта. Например,  элементы модуля  OPCRT разделены на
две группы,  одна из  них содержит обычные процедуры и функции, а
другая содержит методы для объекта ColorSet. Разделительная линия
предшествует каждому  из разделов, и непосредственно над этой ли-
нией расположены  имя этого  модуля и, если подпрограммы в данной
группе являются  методами, имя  того объекта, к которому они при-
надлежат.

     Порядок расположения  элементов в  каждой группе не является
алфавитным; вместо этого используется тот порядок, в котором дан-
ные подпрограммы объявляются в исходном коде модуля/объекта. Дан-
ный порядок был выбран в силу того, что в результате него появля-
ется последовательность более мелких групп связанных подпрограмм,
что упрощает  поиск подпрограммы в ситуациях, когда у Вас имеется
общее представление  об искомой подпрограмме (модуль и категория,
например, манипуляции с курсором), но Вы не знаете, существует ли
необходимая подпрограмма, или Вы знаете о ее существовании, но не
можете вспомнить ее имени.



OpCrt   Процедуры и функции
────────────────────────────────────────────────────────────────

  function MakeHiddenAttr(A : Byte) : Byte;
    {-Сделать одинаковыми основной и фоновый цвета}

  function GetCrtMode : Byte;
   {-Получить значение текущего видеорежима. Также ре-
     инициализирует внутренние переменные. Может при-
     вести к сбросу значений переменных: CurrentMode,
     ScreenWidth, ScreenHeight, CurrentPage, and
     VideoSegment.}

  procedure GotoXYAbs(X, Y : Byte);
    {-Переместить курсор в столбец X, строку Y. Проверка на
      возникновение ошибки не производится.}

  function WhereXY : Word;
   {-Возвратить абсолютные значения координат строки и столбца
     курсора. Старший байт содержит текущее значение строки (Y),

                           - 2 -
     а младший байт содержит текущее значение столбца (X).}

  function WhereYAbs : Byte;
    {-Возвратить абсолютное значение координаты строки}

  function WhereXAbs : Byte;
    {-Возвратить абсолютное значение координаты столбца}

  procedure WhereXYdirect(var X, Y : Byte);
    {-Считать текущее значение позиции курсора непосредственно
      с контроллера ЭЛТ}

  procedure SetVisiblePage(PageNum : Byte);
    {-Задать текущую видеостраницу}

  procedure SetActivePage(PageNo : Byte);
   {-Выбрать видеостраницу, в которую будет производиться запись
     последующими операциями работы с экраном.
     Не оказывает влияния на работу процедур Write/Ln и Read/Ln.}

  function GetPageSegment(PageNo : Byte) : Word;
    {-Получить значение видеосегмента, который соответствует
      указанной видеостранице}

  function GetPagePointer(PageNo : Byte) : Pointer;
    {-Получить указатель на начало заданной видеостраницы}

  procedure ClearPage(PageNo : Byte);
    {-Стереть содержимое заданной видеостраницы, используя
      значения TextChar и TextAttr}

  procedure ScrollWindowUp(XLo, YLo, XHi, YHi, Lines : Byte);
    {-Осуществить прокрутку обозначенного окна вверх
      на заданное число строк.}

  procedure ScrollWindowDown(XLo, YLo, XHi, YHi, Lines : Byte);
    {-Осуществить прокрутку обозначенного окна вверх
      на заданное число строк.}

  function CursorTypeSL : Word;
    {-Возвращает слово. Старший байт содержит значение начальной
      линии сканирования, младший байт содержит значение конечной
      линии сканирования.}

  function CursorStartLine : Byte;
    {-Возвращает значение начальной линии сканирования курсора.}

  function CursorEndLine : Byte;
    {-Возвращает значение конечной линии сканирования курсора.}

  procedure SetCursorSize(Startline, EndLine : Byte);
    {-Задает значения начальной и конечной линий сканирования
      курсора.}


                           - 3 -
  procedure NormalCursor;
    {-Задать нормальное число линий сканирования для курсора на
      основании текущего видеорежима}

  procedure FatCursor;
    {-Задать увеличенное число линий сканирования для курсора на
      основании текущего видеорежима}

  procedure BlockCursor;
    {-Задать такое число линий сканирования, чтобы курсор отобра-
      жался бы в виде блока}

  procedure HiddenCursor;
    {-Убрать курсор с экрана}

  procedure SetCursorType(CT : CursorType);
    {-Устанавливает заданную форму курсора}

  function ClassifyCursorType : CursorType;
    {-Определить тип курсора на основании числа линий
      сканирования}

  function ReadCharAtCursor : Char;
    {-Возвращает символ, который находится на текущей позиции
      курсора в выбранной странице.}

  function ReadAttrAtCursor : Byte;
    {-Возвращает значение атрибута на текущей позиции курсора
      в выбранной странице.}

  procedure GetCursorState(var XY, ScanLines : Word);
    {-Возвращает текущие позицию курсора и его размер}

  procedure RestoreCursorState(XY, ScanLines : Word);
    {-Восстанавливает позицию курсора и его размер, которые были
      сохранены с помощью процедуры GetCursorState}

  procedure FastWrite(St : string; Row, Col : Word; Attr : Byte);
    {-Записать строку St, начиная со строки и столбца Row,Col и
      используя видеоатрибут Attr без возникновения снежных
      хлопьев}

  procedure FastText(St : string; Row, Col : Word);
    {-Записать строку St, начиная со строки и столбца Row,Col,
      не изменяя видеоатрибут символа.}

  procedure FastVert(St : string; Row, Col : Word; Attr : Byte);
    {-Записать строку St вертикально, начиная со строки и столб-
      ца Row,Col и используя видеоатрибут Attr}

  procedure FastFill(Number : Word; Ch : Char; Row, Col : Word;
                     Attr : Byte);
    {-Отобразить на экране Number символов ch, начиная со строки и
      столбца Row,Col и используя видеоатрибут Attr без возникно-

                           - 4 -
      вения снежных хлопьев}

  procedure FastCenter(St : string; Row, Attr : Byte);
    {-Записать строку St, отцентрировав ее в окне на строке Row,
      используя видеоатрибут Attr без возникновения снежных
      хлопьев}

  procedure FastFlush(St : string; Row, Attr : Byte);
    {-Записать строку St выровненной по правому краю окна в строке
      Row, используя видеоатрибут Attr без возникновения снежных
      хлопьев}

  procedure FastRead(Number : Byte; Row, Col : Word;
                     var St : string);
    {-Считать Number символов с экрана в строку St начиная со строки
      и столбца Row,Col}

  procedure ReadAttribute(Number : Byte; Row, Col : Word;
                          var St : string);
    {-Считать Number атрибутов с экрана в строку St начиная со
      строки и столбца  Row,Col}

  procedure WriteAttribute(St : String; Row, Col : Word);
    {-Отобразить строку атрибутов St начиная со строки и столбца
      Row,Col без изменения самих символов}

  procedure ChangeAttribute(Number : Word; Row, Col : Word;
                            Attr : Byte);
    {-Изменить Number видеоатрибутов на Attr начиная со строки и
      столбца Row,Col}

  procedure MoveScreen(var Source, Dest; Length : Word);
    {-Переместить Length слов из исходной области Source в
      результирующую область Dest без возникновения снежных
      хлопьев}

  procedure FastWriteAttr(St : String; Row, Col : Word;
                          AttrSt : String);
    {-Отобразить строку St начиная со строки и столбца Row,Col
      и используя атрибуты, заданные в строке AttrSt}

  procedure FlexWrite(St : string; Row, Col : Word;
                      var FAttrs : FlexAttrs);
    {-Отобразить строку St начиная со строки и столбца Row,Col
      с использованием гибких средств управления цветом}

  function FlexLen(S : string) : Byte;
    {-Возвратить действительную (видимую) длину строки, которая
      отображена с помощью гибких средств отображения}

  procedure FastWriteCtrl(St : String; Row, Col : Word;
                          Attr, Ctrl : Byte);
    {-Отобразить St начиная со строки и столбца Row,Col и используя
      видеоатрибут Attr без возникновения снежных хлопьев.

                           - 5 -
      Управляющие символы отображаются с помощью атрибута Ctrl
      в виде букв верхнего регистра}

  function SaveWindow(XLow, YLow, XHigh, YHigh : Byte;
                      Allocate : Boolean;
                      var Covers : Pointer) : Boolean;
    {-Выделить память для буфера, если этого требует значение
      переменной Allocate и сохранить в нем содержимое указанного
      окна}

  procedure RestoreWindow(XLow, YLow, XHigh, YHigh : Byte;
                          Deallocate : Boolean;
                          var Covers : Pointer);
    {-Восстановить содержимое экрана и вернуть память, занятую
      буфером, если этого требует значение переменной Deallocate}

  procedure ClearWindow(XLow, YLow, XHigh, YHigh : Word;
                        Ch : Char; A : Byte);
    {-Очистить окна, используя для этого указанный символ и
      видеоатрибут}

  procedure FrameWindow(LeftCol, TopRow, RightCol, BotRow : Word;
                        FAttr, HAttr : Byte;
                        Header : string);
    {-Отобразить рамку вокруг окна}

  procedure StoreWindowCoordinates(var WC : WindowCoordinates);
    {-Сохранить координаты активного окна}

  procedure RestoreWindowCoordinates(WC : WindowCoordinates);
    {-Восстановить ранее сохраненные координаты окна}

  function MapColor(C : Byte) : Byte;
    {-Произвести преобразование видеоатрибута, чтобы обеспечить
      видимость на монохромных или черно-белых мониторах}

  function UseColor : Boolean;
    {-Возвращает значение True, если должны использоваться цветные
      видеоатрибуты}

  function ColorMono(Color, Mono : Byte) : Byte;
    {-Осуществить выбор между цветным и монохромным видеоатрибутом}

  function MapMono(Color, Mono : Byte) : Byte;
    {-Возвратить преобразованный цветной видеоатрибут, если
      Mono = $FF}

  procedure SetBlink(On : Boolean);
    {-Разрешить мигание для атрибута текстового режима, если
      On равняется True}

  procedure SetCrtBorder(Attr : Byte);
    {-Установить цвет бордюра экрана равным фоновому цвету,
      если это позволяет тип платы и видеорежим}

                           - 6 -

  function Font8x8Selected : Boolean;
    {-Возвратить True если используется плата EGA или VGA, которая
      работает в режиме шрифта 8x8}

  procedure SelectFont8x8(On : Boolean);
    {-Включить или выключить шрифт 8x8}

  function HercPresent : Boolean;
    {-Возвратить true, если имеется графическая плата Hercules}

  procedure SwitchInColorCard(ColorOn : Boolean);
    {-Задать или отменить использование цветов на графической
      плате Hercules InColor}

  function HercGraphicsMode : Boolean;
    {-Возвратить True, если плата Hercules находится в графическом
      режиме}

  function HercModeTestWorks : Boolean;
    {-Возвратить True, если будет работать HercGraphicsMode}

  procedure SetHercMode(GraphMode : Boolean; GraphPage : Byte);
   {-Перевести плату Hercules в графический режим или в текстовый
     режим и активизировать заданную графическую страницу (если
     плата переключена в графический режим).}

  function ReadKeyWord : Word;
   {-Ожидает нажатия клавиши, затем возвращает код сканирования и
     код символа}

  function CheckKbd(var KeyCode : Word) : Boolean;
    {-Возвращает True (и коды клавиш), если клавиатура ожидает
      считывания}

  function KbdFlags : Byte;
    {-Возвращает флаги состояния клавиатуры в виде байта, где биты
      представляют собой флаги}

  function EnhancedKbdInstalled : Boolean;
    {-Возвращает True, если установлена расширенная клавиатура}

  procedure StuffKey(W : Word);
    {-Заносит код одной клавиши в клавиатурный буфер}

  procedure StuffString(S : string);
    {-Заносит содержимое строки S в клавиатурный буфер}

  procedure ReInitCrt;
    {-Реинициализировать внутренние переменные модуля CRT.}

OpCrt    Объект ColorSet (набор цветов)
────────────────────────────────────────────────────────────────


                           - 7 -
  procedure SetTextAttr(Color, Mono : Byte);
    {-Задать атрибуты для обычного текста}

  procedure SetCtrlAttr(Color, Mono : Byte);
    {-Задать атрибуты для управляющих символов}

  procedure SetFrameAttr(Color, Mono : Byte);
    {-Задать атрибуты для рамки окна}

  procedure SetHeaderAttr(Color, Mono : Byte);
    {-Задать атрибуты для заголовков окна}

  procedure SetShadowAttr(Color, Mono : Byte);
    {-Задать атрибуты для тени, которая отбрасывается окном}

  procedure SetHighlightAttr(Color, Mono : Byte);
    {-Задать атрибуты, используемые для выделения найденного
      текста}

  procedure SetPromptAttr(Color, Mono : Byte);
    {-Задать атрибуты для запросов полей ввода}

  procedure SetSelectedPromptAttr(Color, Mono : Byte);
    {-Задать атрибуты для запросов выделенных полей ввода}

  procedure SetProtectedPromptAttr(Color, Mono : Byte);
    {-Задать атрибуты для запросов защищенных полей ввода}

  procedure SetFieldAttr(Color, Mono : Byte);
    {-Задать атрибуты для невыбранных полей ввода}

  procedure SetSelectedFieldAttr(Color, Mono : Byte);
    {-Задать атрибуты для выбранных полей поля ввода}

  procedure SetProtectedFieldAttr(Color, Mono : Byte);
    {-Задать атрибуты для защищенных полей ввода}

  procedure SetScrollBarAttr(Color, Mono : Byte);
    {-Задать атрибуты для полос прокрутки}

  procedure SetSliderAttr(Color, Mono : Byte);
    {-Задать атрибуты для маркеров позиции в полосах прокрутки}

  procedure SetHotSpotAttr(Color, Mono : Byte);
    {-Задать атрибуты для областей активации мыши}

  procedure SetBlockAttr(Color, Mono : Byte);
    {-Задать атрибуты для маркированных блоков}

  procedure SetMarkerAttr(Color, Mono : Byte);
    {-Задать атрибуты для текстовых маркеров}

  procedure SetDelimAttr(Color, Mono : Byte);
    {-Задать атрибуты для невыбранных разделителей полей ввода}

                           - 8 -

  procedure SetSelectedDelimAttr(Color, Mono : Byte);
    {-Задать атрибуты для выбранных разделителей полей ввода}

  procedure SetProtectedDelimAttr(Color, Mono : Byte);
    {-Задать атрибуты для защищенных разделителей полей ввода}

  procedure SetSelectedItemAttr(Color, Mono : Byte);
    {-Задать атрибуты для выбранных элементов списков
      выбора и меню}

  procedure SetProtectedItemAttr(Color, Mono : Byte);
    {-Задать атрибуты для защищенных элементов списков
      выбора и меню}

  procedure SetHighlightItemAttr(Color, Mono : Byte);
    {-Задать атрибуты для маркированных символов
      выбора для элементов меню}

  procedure SetFlexAHelpAttr(Color, Mono : Byte);
    {-Задать атрибуты для текста подсказки, окруженного ^A}

  procedure SetFlexBHelpAttr(Color, Mono : Byte);
    {-Задать атрибуты для текста подсказки, окруженного ^B}

  procedure SetFlexCHelpAttr(Color, Mono : Byte);
    {-Задать атрибуты для текста подсказки, окруженного ^C}

  procedure SetUnselXrefAttr(Color, Mono : Byte);
    {-Задать атрибуты для невыбранных перекрестных ссылок
      в тексте подсказки}

  procedure SetSelXrefAttr(Color, Mono : Byte);
    {-Задать атрибуты для выбранных перекрестных ссылок
      в тексте подсказки}

  procedure SetMouseAttr(Color, Mono : Byte);
    {-Задать атрибуты для курсора мыши}

OpMouse   Процедуры и функции
────────────────────────────────────────────────────────────────

  function MousePressed : Boolean;
    {-Возвратить значение True, если в настоящий момент
      нажата кнопка мыши}

  function MouseKeyWord : Word;
    {-Возвратить псевдокод сканирования, основанный на том, какая
      кнопка мыши нажата}

  function KeyOrButtonPressed : Boolean;
    {-Возвратить значение True, если была нажата клавиша или
      кнопка мыши}


                           - 9 -
  function ReadKeyOrButton : Word;
    {-Возвратить код очередной нажатой клавиши или кнопки мыши}

  procedure EnableEventHandling;
    {-Задействовать подпрограмму обработки ошибок, необходимую для
      обработки подпрограмм MousePressed и MouseKeyWord}

  procedure DisableEventHandling;
    {-Отменить использование подпрограммы обработки ошибок, которая
      была задействована вызовом процедуры EnableEventHandling}

  procedure InitializeMouse;
    {-Осуществляет реинициализацию мыши и "взводит" переменную
      MouseInstalled}

  procedure ShowMouse;
    {-Отобразить на экране курсор мыши}

  procedure HideMouse;
    {-Удалить с экрана курсора мыши}

  procedure MouseWhereXY(var MouseX, MouseY : Byte;
                         var Status : ButtonStatus);
    {-Возвратить позицию мыши и состояние кнопок мыши}

  function MouseWhereX : Byte;
    {-Возвратить текущее значение координаты X мыши}

  function MouseWhereY : Byte;
    {-Возвратить текущее значение координаты Y мыши}

  procedure MouseWhereXYabs(var MouseX, MouseY : Byte;
                            var Status : ButtonStatus);
    {-Возвратить позицию мыши (абсолютную) и состояние
      кнопок мыши}

  function MouseWhereXabs : Byte;
    {-Возвратить текущее значение (абсолютное) координаты X мыши}

  function MouseWhereYabs : Byte;
    {-Возвратить текущее значение (абсолютное) координаты Y мыши}

  procedure MouseGotoXY(MouseX, MouseY : Byte);
    {-Установить позицию мыши}

  function MouseButtonPressed(Button : ButtonStatus;
                              var Count : Word;
                              var LastX, LastY : Byte) : Boolean;
    {-Возвращает True, если была нажата проверяемая кнопка. Если
      это так, то переменная Count содержит число раз, которое эта
      клавиша была нажата, а переменные LastX/LastY содержат
      значение позиции мыши на тот момент, когда она была нажата
      в последний раз}


                           - 10 -
  function MouseButtonReleased(Button : ButtonStatus;
                               var Count : Word;
                               var LastX, LastY : Byte) : Boolean;
    {-Возвращает значение True, если была отпущена проверяемая
      кнопка. Если это так, то переменная Count содержит число
      раз, которое она была отпущена, а переменные LastX/LastY
      содержат значение позиции мыши на тот момент, когда она
      была нажата в последний раз.}

  procedure MouseWindow(XLow, YLow, XHigh, YHigh : Byte);
    {-Устанавливает координаты окна, за которым будет "следить" мышь}

  procedure FullMouseWindow;
    {-Устанавливает координаты окна мыши, равные всему экрану}

  procedure StoreMouseCoordinates(var WC : WindowCoordinates);
    {-Сохранить координаты окна мыши в переменной WC}

  procedure RestoreMouseCoordinates(WC : WindowCoordinates);
    {-Восстановить ранее сохраненные координаты окна мыши}

  function MouseInWindow(XLo, YLo, XHi, YHi : Byte) : Boolean;
    {-Возвратить True, если мышь находится внутри заданного окна}

  procedure SoftMouseCursor(ScreenMask, CursorMask : Word);
    {-Мышь будет использовать программный курсор.}

  procedure HardMouseCursor(StartLine, EndLine : Word);
    {-Мышь будет использовать аппаратный курсор. Параметры
      StartLine и EndLine задают форму курсора.}

  procedure NormalMouseCursor;
    {-Задать нормальное число строк сканирования для курсора
      мыши на основании текущего видеорежима}

  procedure FatMouseCursor;
    {-Задать увеличенное число строк сканирования для курсора
      мыши на основании текущего видеорежима}

  procedure BlockMouseCursor;
    {-Задать такое число строк сканирования для курсора мыши,
      чтобы курсор приобрел форму блока (прямоугольника)}

  procedure HiddenMouseCursor;
    {-Убрать курсор мыши с экрана}

  procedure GetMickeyCount(var Horizontal, Vertical : Integer);
    {-Возвращает число "микки" (mickey) с момента последнего вызова
      данной функции. Отрицательные значения указывают на перемещение
      вверх или влево. Положительные значения указывают на
      перемещение вниз или вправо.}

  procedure SetMickeyToPixelRatio(Horizontal, Vertical : Integer);
    {-Задает отношение числа "микки" к числу пикселов. Стандартными

                           - 11 -
      значениями являются 8, 16. Значения 16, 32 существенно
      замедляют перемещение маркера мыши. Значения 4, 8 заставляют мышь
      почти что "летать".}

  procedure SetMouseEventHandler(EventMask : MouseEventType;
                                 UserRoutine : Pointer);
    {-Задает адрес подпрограммы, которая должна быть вызвана при
      возникновении заданного события в работе с мышью. OPMOUSE
      осуществляет сохранение регистров драйвера мыши и заносит
      в регистр DS значение, рассчитанное на работу подпрограммы
      UserRoutine. Информация о событии передается программе
      пользователя UserRoutine с помощью глобальных переменных
      MouseEvent, MouseStatus, MouseLastX и MouseLastY}

  function GetMousePage : Byte;
    {-Возвращает номер видеостраницы, на которой отображается
      курсор мыши}

  procedure SetMousePage(Page : Byte);
    {-Задает номер видеостраницы, на которой будет отображаться
      курсор мыши}

  function MouseStateBufferSize : Word;
    {-Возвращает объем памяти, необходимый для сохранения
      состояния драйвера мыши}

  procedure SaveMouseState(var MSP : MouseStatePtr;
                               Allocate : Boolean);
    {-Сохраняет состояние драйвера мыши, переменная Allocate
      указывает на необходимость выделения памяти под буфер.}

  procedure RestoreMouseState(var MSP : MouseStatePtr;
                                  Deallocate : Boolean);
    {-Восстанавливает состояние драйвера мыши, переменная
      Deallocate указывает на необходимость возвращения
      системе памяти, которую занимал буфер}

  procedure HideMousePrim(var MouseState : Boolean);
    {-Сохранить состояние курсора мыши в переменной
      MouseState и удалить курсор с экрана}

  procedure ShowMousePrim(MouseState : Boolean);
    {-Скрыть или восстановить курсор мыши}

OpCmd   Объект CommandProcessor (Процессор команд)
────────────────────────────────────────────────────────────────

  constructor Init(KeysPtr : CmdTablePtr; MaxIndex : Word);
    {-Инициализировать командный процессор с заданием
      только одной таблицы команд}

  constructor InitCustom(PrimaryKeys : CmdTablePtr;
                         PrimaryMaxIndex : Word;
                         SecondaryKeys : CmdTablePtr;

                           - 12 -
                         SecondaryMaxIndex : Word;
                         Options : Word);
    {-Инициализировать командный процессор со специальными
      параметрами}

  destructor Done; virtual;
    {-Вернуть системе всю память, которая была выделена для
      командного процессора.}

  function GetCommand(var Key : Word) : Word;
    {-Получить очередную команду или символ}

  procedure AddCommand(Cmd : Word; NumKeys : Byte;
                       Key1, Key2 : Word);
    {-Добавить назначение клавиш для новой команды первичной
      таблицы или изменить назначение клавиш для уже
      существующей в первичной таблице команды}

  procedure AddSecondaryCommand(Cmd : Word; NumKeys : Byte;
                                Key1, Key2 : Word);
    {-Добавить назначение клавиш для новой команды вторичной
      таблицы или изменить назначение клавиш для уже сущест-
      вующей во вторичной таблице команды}

  function GetLastError : Word;
    {-Возвращает код ошибки, соответствующий последней
      ошибке и стирает его}

  procedure SetGetKeyProc(GKP : GetKeyProc);
    {-Изменить подпрограмму cpGetKey}

  procedure SetKeyPressedProc(KPP : KeyPressedProc);
    {-Изменить подпрограмму cpKeyPressed}

  procedure SetHelpProc(GHP : GetHelpProc);
    {-Изменить процедуру HelpProc}

  procedure SetUserHookProc(UHP : UserHookProc);
    {-Задать подпрограмму, которая будет вызываться всякий раз,
      когда необходимо определить нажатую клавишу}

  procedure cpOptionsOn(OptionFlags : Word);
    {-Задать несколько параметров-флагов}

  procedure cpOptionsOff(OptionFlags : Word);
    {-Отменить несколько параметров-флагов}

  function cpOptionsAreOn(OptionFlags : Word) : Boolean;
    {-Возвратить значение true, если все указанные
      параметры-флаги установлены}

  function cpGetKey : Word; virtual;
    {-Вызывается для получения информации об
      очередной нажатой клавише}

                           - 13 -

  function cpKeyPressed : Boolean; virtual;
    {-Вызывается для определения факта нажатия клавиши}

  procedure cpGetHelp(UnitCode : Byte; IdPtr : Pointer;
                      HelpIndex : Word); virtual;
    {-Вызывается, если обнаружено обращение к системе подсказки}

  procedure cpUserHook(MT : MatchType; Key : Word); virtual;
    {-Вызывается каждый раз, когда осуществляется обработка
      нажатой клавиши}

  procedure SetKeyPtr(KeysPtr : CmdTablePtr; MaxIndex : Word);
    {-Заменить первичную таблицу команд.}

  function GetKeyPtr(var MaxIndex : Word) : CmdTablePtr;
    {-Возвратить указатель на первичную таблицу команд.}

  procedure SetSecondaryKeyPtr(KeysPtr : CmdTablePtr;
                               MaxIndex : Word);
    {-Заменить вторичную таблицу команд}

  function GetSecondaryKeyPtr(var MaxIndex : Word) : CmdTablePtr;
    {-Возвратить указатель на вторичную таблицу команд}

  procedure GetKeyAssignment(Cmd : Word; var NumKeys : Byte;
                             var Key1, Key2 : Word);
    {-Возвратить один набор кодов клавиш, который был назначен
      указанной команде. Если команда не найдена, то  NumKeys = 0}

  function GetCmdAssignment(NumKeys : Byte; Key1, Key2 : Word;
                            var Primary : Boolean) : Word;
    {-Возвратить команду, связанную с указанной комбинацией
      клавиш или значение ccNone, если комбинация клавиш не
      найдена. Переменная Primary имеет значение False (ложно)
      только в том случае, если подходящая комбинация клавиш
      была обнаружена во вторичной таблице.}

  function CheckForConflict(NumKeys : Byte;
                            Key1, Key2 : Word) : MatchType;
    {-Проверить, не вступает ли указанная комбинация клавиш в
      противоречие с уже существующей комбинацией}

  procedure SetCommandList(CmdList : Pointer; NumCmds : Word);
    {-Задать список команд, которые должны выполняться
      автоматически}

  function CommandStringPending : Boolean;
    {-Возвращает True, если текстовая строка находится в
      списке команд, предназначенных для автоматического
      выполнения}

  function GetCommandString : string;
    {-Возвращает текстовую строку, когда

                           - 14 -
      функция CommandStringPending возвращает значение True}

  constructor Load(var S : IdStream);
    {-Загрузить процессор команд из потока}

  procedure Store(var S : IdStream);
    {-Загрузить процессор команд в поток}

  function MouseEnabled : Boolean;
    {-Возвращает значение True, если разрешена работа
      с мышью}

OpCmd   Объект CommandPacker (Упаковщик команд)
────────────────────────────────────────────────────────────────

  constructor Init(PKeys : CmdTablePtr;
                   MaxCmd : Word;
                   MaxIndex : Word;
                   UKeys : UnpackedCmdPtr;
                   Columns : Byte;
                   CmdsAreWords : Boolean);
    {-Инициализировать указатели на упакованные / распакованные
      таблицы команд}

  function PackKeys : Boolean;
    {-Вновь преобразовать распакованный массив в упакованный список
      кодов клавиш. Возвращает значение False, если не все клавиши
      умещаются.}

  function SizeKeys : Word;
    {-Возвращает число байтов в упакованной версии UnpackedKeys}

  function GetKeyRecPtr(Cmd : Word; Col : Byte) : KeyRecPtr;
    {-Возвращает указатель на KeyRec для Col-ого по счету экземпляра
      команды Cmd}

  function ConflictsFound : Boolean;
    {-Проверить непротиворечивость распакованных команд. Возвращает
      True, если обнаружены противоречия}

OpCmd   Процедуры и функции
────────────────────────────────────────────────────────────────

  procedure SetBell(Pitch, Duration : Word);
    {-Задать частоту и продолжительность звукового сигнала}

  procedure RingBell;
    {-Подать звуковой сигнал}

  procedure DefaultErrorProc(UnitCode : Byte;
                             var ErrorCode : Word;
                             ErrorMsg : string);
    {-Стандартная процедура обработки ошибок--лишь выдает
      звуковой сигнал}

                           - 15 -

OpFrame       Объект AbstractFrame (Абстрактная рамка)
────────────────────────────────────────────────────────────────

  procedure ClearErrors;
    {-Удалить все ожидающие обработки ошибки}

OpFrame       Объект ScreenRect (Экранный прямоугольник)
────────────────────────────────────────────────────────────────

  constructor Alloc(X1, Y1, X2, Y2 : Byte);
    {-Инициализировать координаты и выделить память для
      буфера экрана}

  constructor Init(X1, Y1, X2, Y2 : Byte; BufPtr : Pointer);
    {-Инициализировать координаты и назначить ранее выделенный
      в памяти буфер}

  destructor Done; virtual;
    {-Вернуть системе память, выделенную для буфера}

  function BufSize : Word;
    {-Возвратить требуемый размер буфера в байтах}

  procedure Clear(FChar : Char; FAttr : Byte);
    {-Произвести очистку, используя для этого заданный
      символ и атрибут}

  procedure CopyFromScreen;
    {-Копировать с экрана в буфер}

  procedure CopyToScreen;
    {-Копировать содержимое буфера на экран}

  procedure CopyPartToScreen(X1, Y1, X2, Y2 : Byte);
    {-Копировать часть буфера на экран}

  procedure Adjust(X1, Y1, X2, Y2 : Byte);
    {-Изменить координаты буфера, задав их равными X1, Y1, X2, Y2}

  procedure Transfer(X1, Y1, X2, Y2 : Byte;
                    FChar : Char; FAttr : Byte);
    {-Переместить содержимое буфера в новый буфер, задаваемый
      координатами X1, Y1, X2, Y2}

  function srResult : Word;
    {-Возвратить самый последний код состояния}

  procedure StoreContents(On : Boolean);
    {-Указать, будет ли подпрограмма Store осуществлять запись
      содержимого буфера экрана}

  function HaveContents : Boolean;
    {-Возвратить True, если содержимое было загружено

                           - 16 -
      конструктором Load}

  procedure Coordinates(var X1, Y1, X2, Y2 : Byte);
    {-Возвратить координаты прямоугольной области на экране}

  constructor Load(var S : IdStream);
    {-Загрузить из потока}

  procedure Store(var S : IdStream);
    {-Занести в поток}

OpFrame       Объект Frame (Рамка)
────────────────────────────────────────────────────────────────

  constructor Init(X1, Y1, X2, Y2 : Byte;
                   FA : FrameArray;
                   var Colors : ColorSet);
    {-Инициализировать координаты рамки и все поля}

  constructor fCopy(var F : Frame);
    {-Инициализировать рамку на основании другой, создавая при
      этом уникальную копию всех динамических структур}

  destructor Done; virtual;
    {-Удалить рамку}

  procedure SetFrameType(FA : FrameArray);
    {-Изменить тип рамки}

  procedure SetFrameAttr(Color, Mono : Byte); virtual;
    {-Задать атрибуты для символов рамки}

  procedure SetHeaderAttr(Color, Mono : Byte; ChangeAll : Boolean);
    {-Задать атрибуты для символов заголовка}

  procedure SetShadowAttr(Color, Mono : Byte; ChangeAll : Boolean);
    {-Задать атрибуты для символов тени}

  procedure AddHeader(S : string; Posn : HeaderPosType);
    {-Добавить стандартный заголовок}

  procedure AddHeaderColor(S : string; Posn : HeaderPosType;
                           AttrColor, AttrMono : Byte);
    {-Добавить стандартный заголовок со произвольно заданными
      цветами}

  procedure AddCustomHeader(S : string; Posn : FrameCornerType;
                            DX, DY : Integer;
                            AttrColor, AttrMono : Byte);
    {-Добавить заголовок с произвольным расположением}

  procedure AddSpanHeader(FirstChar, SpanChar, LastChar : Char;
                          Dpos : Integer; Posn : FrameEdgeType);
    {-Добавить заголовок, который располагается от одного края

                           - 17 -
      рамки до другого}

  procedure AddSpanHeaderColor(FirstChar, SpanChar, LastChar : Char;
                               Dpos : Integer; Posn : FrameEdgeType;
                               AttrColor, AttrMono : Byte);
    {-Добавить заголовок, который располагается от одного края
      рамки до другого и имеет произвольные цветовые атрибуты}

  function GetLastHeaderIndex : Byte;
    {-Возвратить индекс последнего добавленного заголовка}

  procedure ChangeHeaderString(Index : Byte; S : string;
                               var Redraw : Boolean);
    {-Изменить строку существующего заголовка и обновить его}

  procedure ChangeHeaderAttr(Index : Byte; Color, Mono : Byte);
    {-Изменить цвета существующего заголовка}

  procedure DrawHeader(Index : Byte);
    {-Отобразить указанный заголовок}

  procedure DisableHeader(Index : Byte; On : Boolean);
    {-Разрешить или запретить отображение указанного заголовка}

  procedure AddShadow(Posn : ShadowPosType;
                      DrawType : ShadowDrawType);
    {-Добавить стандартное затенение}

  procedure AddShadowColor(Posn : ShadowPosType;
                           DrawType : ShadowDrawType;
                           AttrColor, AttrMono : Byte);
    {-Добавить стандартное затенение со произвольно заданными
      цветами}

  procedure AddCustomShadow(ShChar : Char; Edge : FrameEdgeType;
                            DX, DY : Integer; W, H : Byte;
                            AttrColor, AttrMono : Byte);
    {-Добавить произвольную прямоугольную область затенения}

  procedure AddScrollBar(Posn : FrameEdgeType;
                         MinUser, MaxUser : LongInt;
                         var Colors : ColorSet);
    {-Добавить стандартную полосу прокрутки}

  procedure AddCustomScrollBar(Posn : FrameEdgeType;
                               MinUser, MaxUser : LongInt;
                               DecOffset, IncOffset : Byte;
                               SliChar, BarChar : Char;
                               var Colors : ColorSet);
    {-Добавить полосу прокрутки с произвольными характеристиками}

  procedure AddHotSpot(Posn : FrameCornerType;
                       HotChar : Char;
                       var Colors : ColorSet);

                           - 18 -
    {-Добавить точку активации, расположенную в углу рамки}

  procedure AddHotBar(Posn : FrameEdgeType; Code : Byte);
    {-Добавить область активации, которая будет покрывать весь
      контур рамки}

  procedure AddHotRegion(Posn : FrameCharType;
                         Code : Byte;
                         DX, DY : Integer;
                         Width, Height : Byte);
    {-Добавить область активации фиксированного размера,
      которая "привязана" к углу рамки}

  procedure AddHotHeader(hType : HeaderPosType; Code : Byte;
                         Len : Byte);
    {-Добавить область активации, которая совпадает с заголовком}

  function GetLastHotIndex : Byte;
    {-Возвратить индекс области активации, добавленной последней}

  procedure ChangeHotHeader(Index : Byte; Len : Byte);
    {-Изменить длину заголовка, совпадающего с областью активации}

  procedure SetSizeLimits(MinW, MinH, MaxW, MaxH : Byte);
    {-Задать пределы для изменения размеров рамки}

  procedure SetClipLimits(MinXL, MinYL, MaxXH, MaxYH : Byte);
    {-Задать пределы для отображения рамки (при условии отсе-
      чения затененных областей)}

  procedure SetSliderValue(Posn : FrameEdgeType;
                           UserVal : LongInt);
    {-Изменить задаваемое пользователем значение маркера позиции
      без отображения этого маркера}

  function CurUserValue(Posn : FrameEdgeType) : LongInt;
    {-Возвратить текущее задаваемое пользователем значение маркера
      позиции для указанной полосы прокрутки}

  procedure Draw; virtual;
    {-Отобразить рамку, полосы прокрутки, заголовки и области
      затенения}

  procedure UpdateFrame; virtual;
    {-Отобразить рамку, полосы прокрутки и заголовки (но не области
      затенения)}

  function IsFramed : Boolean;
    {-Возвратить значение True, Если хотя бы один из символов
      переменной FrameChars не имеет значение NoFrameChar}

  procedure Coordinates(var X1, Y1, X2, Y2 : Byte);
    {-Возвратить значения координат рамки}


                           - 19 -
  procedure WithinFrameCoords(var X1, Y1, X2, Y2 : Byte);
    {-Возвратить значения координат области, которая находится
      внутри рамки, но не включая область границы рамки}

  procedure AdjustFrame(X1, Y1, X2, Y2 : Byte);
    {-Задать новые значения координат и скорректировать
      связанные с координатами структуры}

  procedure Error(Code : Word); virtual;
    {-Сообщить о возникновении ошибки}

  function GetLastError : Word; virtual;
    {-Возвратить и стереть последний код ошибки или значение 0,
      если ошибки не возникало}

  function PeekLastError : Word; virtual;
    {-Возвратить последний код ошибки или значение 0,
      если ошибки не возникало}

  constructor Load(var S : IdStream);
    {-Загрузить из потока}

  procedure Store(var S : IdStream);
    {-Поместить в поток}

OpWindow      Объект AbstractWindow (Абстрактное окно)
────────────────────────────────────────────────────────────────

  function Width : Word;
    {-Возвратить активную ширину окна}

  function Height : Word;
    {-Возвратить активную высоту окна}

  procedure ClearErrors;
    {-Удалить все сохраняющиеся ошибки}

OpWindow      Объект RawWindow (Окно-прототип)
────────────────────────────────────────────────────────────────

  constructor Init(X1, Y1, X2, Y2 : Byte);
    {-Создать окно со стандартными параметрами и
      цветами}

  constructor InitCustom(X1, Y1, X2, Y2 : Byte;
                         var Colors : ColorSet;
                         Options : LongInt);
    {-Создать окно с произвольными значениями параметров}

  constructor wCopy(var W : RawWindow);
    {-Инициализировать окно на базе другого окна, создавая при
      этом уникальную копию всех динамических структур}

  destructor Done; virtual;

                           - 20 -
    {-Удалить окно}

  procedure AdjustFrameCoords(X1, Y1, X2, Y2 : Byte);
    {-Изменить координаты рамки неактивного окна. Полностью
      стирает существующее описание рамки}

  procedure DeltaAdjustFrame(dX1, dY1, dX2, dY2 : Integer);
    {-Изменить координаты рамки неактивного окна.
      Производит перевыделение памяти, но не осуществляет
      никаких других изменений}

  procedure SetSizeLimits(MinW, MinH, MaxW, MaxH : Byte);
    {-Устанавливает пределы для изменения размеров
      активного окна}

  procedure SetPosLimits(MinX, MinY, MaxX, MaxY : Byte);
    {-Устанавливает пределы для перемещения и отображения
      (которые, как правило, ограничены рамкой)}

  procedure SetFrameLimits(MinW, MinH, MaxW, MaxH : Byte);
    {-Устанавливает пределы для изменения размера рамки}

  procedure UpdateScreenSize;
    {-Обновить размер окна, его позицию и пределы для
      текущего размера экрана}

  procedure EnableExplosions(StageDelay : Word);
    {-Разрешить раскрытие окон с параметром StageDelay
      (задержка на этапе) миллисекунд на каждый этап раскрытия}

  procedure EnableAlternateOpen(OpenProc,
                                CloseProc : RawWindowProc;
                                StageDelay : Word);
    {-Задать использование альтернативных подпрограмм отображения
      и стирания}

  procedure EnableNormalOpen;
    {-Заретить раскрытие окон или использование альтернативных
      подпрограмм отображения}

  procedure wOptionsOn(OptionCodes : LongInt);
    {-Задать несколько параметров-флагов}

  procedure wOptionsOff(OptionCodes : LongInt);
    {-Отменить несколько параметров-флагов}

  function wOptionsAreOn(OptionCodes : LongInt) : Boolean;
    {-Возвратить значение true, если все указанные параметры
      находятся в состоянии on (используется)}

  procedure SetTextAttr(Color, Mono : Byte); virtual;
    {-Задать атрибуты для отображения обычного текста в окне}

  procedure SetBackChar(BackChar : Char); virtual;

                           - 21 -
    {-Задать символ-заполнитель для фона}

  procedure wGotoXY(X, Y : Integer); virtual;
    {-Переместить курсор в координаты, которые задаются относи-
      тельно границ окна}

  procedure wWhereXY(var X, Y : Integer); virtual;
    {-Возвратить координаты курсора относительно окна}

  procedure wWhereXYAbs(var X, Y : Byte);
    {-Возвратить абсолютные координаты курсора}

  procedure SetCursor(CT : CursorType);
    {-Задать форму курсора}

  function GetCursor : CursorType;
    {-Возвратить информацию об используемой в настоящий момент
      форме курсора}

  procedure ChangeHeader(Index : Byte; S : string);
    {-Изменить строку заголовка и, если окно является текущим,
      обновить экранный кадр}

  function InWindow(AX, AY : Byte) : Boolean;
    {-Возвратить true, если указанная позиция, выраженная в
      абсолютных координатах, находится внутри активного
      окна}

  function CursorInWindow : Boolean;
    {-Возвратить true, если в настоящий момент курсор находится
      внутри активного окна}

  procedure EvaluatePos(X, Y : Byte);
    {-Определить заданную абсолютную позицию по отношению к окну,
      областям активации и полосам прокрутки. Доступ к возвраща-
      емым значениям осуществляется с помощью функции PosResults}

  procedure EvaluateMousePos;
    {-Определить текущую позицию мыши аналогично процедуре
      EvaluatePos}

  function PosResults(var FramePos : FramePosType;
                      var HotCode : Byte) : LongInt;
    {-Возвратить значения, полученные в результате самого
      последнего вызова процедур EvaluatePos или EvaluateMousePos}

  procedure Error(Code : Word); virtual;
    {-Сообщить о возникновении ошибки}

  function GetLastError : Word; virtual;
    {-Возвратить код последней ошибки и стереть его или
      возвратить значение 0, если ошибки не произошло}

  function PeekLastError : Word; virtual;

                           - 22 -
    {-Возвратить код последней ошибки без стирания значения
      внутренней переменной}

  function IsActive : Boolean; virtual;
    {-Возвратить значение True, если окно находится
      на экране}

  function IsCurrent : Boolean; virtual;
    {-Возвратить значение True, если окно является текущим}

  function IsZoomed : Boolean; virtual;
    {-Возвратить значение True, если в настоящий момент
      окно находится в распахнутом состоянии}

  function MainFramePtr : AbstractFramePtr; virtual;
    {-Возвратить указатель на рамку, которая используется, когда
      окно является текущим}

  function AltFramePtr : AbstractFramePtr; virtual;
    {-Возвратить указатель на рамку, которая используется, когда
      окно является активным, но не текущим}

  function ActiveFramePtr : AbstractFramePtr; virtual;
    {-Возвратить указатель на рамку, которую в настоящий момент
      отображает окно или значение nil, если рамка не определена}

  procedure Coordinates(var X1, Y1, X2, Y2 : Byte);
    {-Возвратить активные координаты окна}

  procedure Extent(var X1, Y1, X2, Y2 : Byte;
                   IncludeShadows : Boolean);
    {-Возвратить координаты, которые определяют всю площадь окна,
      учитывая, если это необходим, затененные области}

  procedure Draw; virtual;
    {-Отобразить или обновить окно}

  procedure UpdateContents; virtual;
    {-Обновить содержимое окна, которое отображается в настоящий
      момент}

  procedure Erase; virtual;
    {-Стереть окно}

  procedure SaveContents; virtual;
    {-Сохранить текущее содержимое окна в буфере содержимого}

  procedure DrawSlider(Posn : FrameEdgeType; UserVal : LongInt);
    {-Отобразить или обновить маркер позиции}

  procedure EraseSlider(Posn : FrameEdgeType);
    {-Стереть маркер позиции}

  function TweakSlider(Posn : FrameEdgeType; MousePosn : Byte;

                           - 23 -
                       UserVal : LongInt; Step : LongInt) : LongInt;
    {-Корректировать пользовательское значение до тех пор, пока
      маркер позиции не совпадет в точности с позицией мыши}

  procedure ChangeScrollBar(Posn : FrameEdgeType;
                            MinUser, MaxUser : LongInt);
    {-Изменить заданный пользователем диапазон существующей полосы
      прокрутки}

  procedure ChangeAllScrollBars(MinHoriz, MaxHoriz : LongInt;
                                MinVert,
                                MaxVert : LongInt); virtual;
    {-Изменить заданные пользователем диапазоны существующих полос
      прокрутки. Осуществляет стирание маркеров позиции}

  procedure DrawAllSliders(HorizVal, VertVal : LongInt); virtual;
    {-Отобразить или обновить все маркеры позиции}

  procedure Clear; virtual;
    {-Стереть область активного окна, используя для этого
      wTextXXXX и wBackChar}

  procedure ClearContents;
    {-Стереть область внутри рамки, используя для этого
      wTextXXXX и wBackChar}

  procedure MoveWindow(DX, DY : Integer); virtual;
    {-Переместить окно}

  procedure ResizeWindow(DX, DY : Integer); virtual;
    {-Изменить размеры окна}

  procedure AdjustWindow(X1, Y1, X2, Y2 : Word); virtual;
    {-Задать новые координаты и скорректировать все необходимые
      структуры окна}

  procedure Zoom; virtual;
    {-Временно увеличить размеры окна до максимальных пределов}

  procedure Unzoom; virtual;
    {-Возвратить распахнутое окно к его предшествующему состоянию}

  procedure ScrollHoriz(Cols : Integer); virtual;
    {-Осуществить горизонтальную прокрутку}

  procedure ScrollVert(Rows : Integer); virtual;
    {-Осуществить вертикальную прокрутку}

  procedure MarkCurrent; virtual;
    {-Вызывается, когда окно становится текущим}

  procedure MarkNotCurrent; virtual;
    {-Вызывается, когда окно перестает быть выбранным}


                           - 24 -
  procedure wFastWrite(St : string; Row, Col, Attr : Byte);
    {-Отобразить строку}

  procedure wFastText(St : string; Row, Col : Byte);
    {-Отобразить строку St в позиции строки и столбца Row,Col, не
      изменяя при этом видеоатрибута символов}

  procedure wFastVert(St : string; Row, Col, Attr : Byte);
    {-Отобразить строку в вертикальной ориентации}

  procedure wFastFill(Number : Word; Ch : Char; Row, Col,
                      Attr : Byte);
    {-Заполнить Number позиций символом ch, начиная с позиции строки
      и столбца Row,Col и используя для этого атрибут Attr}

  procedure wChangeAttribute(Number : Word; Row, Col, Attr : Byte);
    {-Изменить Number видеоатрибутов на Attr, начиная с позиции
      строки и столбца Row,Col}

  procedure wFastCenter(St : string; Row, Attr : Byte);
    {-Отобразить строку St центрированной на строке Row, используя
      для этого атрибут Attr}

  procedure wFastFlush(St : string; Row, Attr : Byte);
    {-Отобразить строку St выровненной по правому краю на строке
      Row, используя для этого атрибут Attr}

  procedure wFastRead(Number, Row, Col : Byte; var St : string);
    {-Считать Number символов с экрана в строку St, начиная с
      позиции строки и столбца Row,Col}

  procedure wReadAttribute(Number, Row, Col : Byte;
                           var St : string);
    {-Считать Number атрибутов с экрана в строку St, начиная
      с позиции строки и столбца Row,Col}

  procedure wWriteAttribute(St : String; Row, Col : Byte);
    {-Записать на экран строку St атрибутов с позиции строки и столбца
      Row,Col, не меняя при этом символов}

  procedure wFlexWrite(St : string; Row, Col : Byte;
                       var FAttrs : FlexAttrs);
    {-Отобразить строку, используя гибкие средства управления
      цветом; координаты задаются относительно окна}

  procedure wFastWriteCtrl(St : String; Row, Col, Attr, Ctrl : Byte);
    {-Отобразить строку St с позиции строки и столбца Row,Col,
      используя для этого видеоатрибут Attr без возникновения снеж-
      ных хлопьев. Управляющие символы отображаются с помощью
      атрибута Ctrl как буквы верхнего регистра}

  procedure fFastWrite(St : string; Row, Col, Attr : Byte);
    {-Отобразить строку}


                           - 25 -
  procedure fFastText(St : string; Row, Col : Byte);
    {-Отобразить строку St с позиции строки и столбца Row,Col без
      изменения видеоатрибута}

  procedure fFastVert(St : string; Row, Col, Attr : Byte);
    {-Отобразить строку в вертикальной ориентации}

  procedure fFastFill(Number : Word; Ch : Char; Row, Col,
                      Attr : Byte);
    {-Заполнить Number позиций символом ch, начиная с позиции
      строки и столбца Row,Col и используя для этого атрибут Attr}

  procedure fChangeAttribute(Number : Word; Row, Col, Attr : Byte);
    {-Изменить Number видеоатрибутов на Attr, начиная с позиции
      строки и столбца Row,Col}

  procedure fFastCenter(St : string; Row, Attr : Byte);
    {-Отобразить строку St центрированной на строке Row, используя
      для этого атрибут Attr}

  procedure fFastFlush(St : string; Row, Attr : Byte);
    {-Отобразить строку St выровненной по правому краю на строке Row,
     используя для этого атрибут Attr}

  procedure fFastRead(Number, Row, Col : Byte; var St : string);
    {-Считать Number символов с экрана в строку St, начиная с позиции
      строки и столбца Row,Col}

  procedure fReadAttribute(Number, Row, Col : Byte; var St : string);
    {-Считать Number атрибутов с экрана в строку St, начиная с позиции
      строки и столбца Row,Col}

  procedure fWriteAttribute(St : String; Row, Col : Byte);
    {-Записать на экран строку St атрибутов с позиции строки и столбца
      Row,Col, не меняя при этом символов}

  procedure fFlexWrite(St : string; Row, Col : Byte;
                       var FAttrs : FlexAttrs);
    {-Отобразить строку, используя гибкие средства управления
      цветом; координаты задаются относительно окна}

  procedure fFastWriteCtrl(St : String; Row, Col, Attr, Ctrl : Byte);
    {-Отобразить строку St с позиции строки и столбца Row,Col,
      используя для этого видеоатрибут Attr без возникновения снеж-
      ных хлопьев. Управляющие символы отображаются с помощью
      атрибута Ctrl как буквы верхнего регистра}

  constructor Load(var S : IdStream);
    {-Загрузить из потока}

  procedure Store(var S : IdStream);
    {-Занести в поток}

OpWindow      Объект StackWindow (Стековое окно)

                           - 26 -
────────────────────────────────────────────────────────────────

  constructor Init(X1, Y1, X2, Y2 : Byte);
    {-Создать стековое окно со стандартными параметрами и цветами}

  constructor InitCustom(X1, Y1, X2, Y2 : Byte;
                         var Colors : ColorSet; Options : LongInt);
    {-Создать окно с произвольными значениями параметров}

  constructor wCopy(var S : StackWindow);
    {-Инициализировать окно на базе другого окна, создавая при
      этом уникальную копию всех динамических структур}

  procedure SetStackProc(SP : StackWindowProc);
    {-Задать процедуру обработки стекового окна}

  function WindowNumber : Word;
    {-Возвратить номер окна. 0 если оно находится в неактивном
      состоянии, иначе 1 или большее число}

  procedure AssignNumber; virtual;
    {-Вызывается для присвоения номера окна}

  procedure Draw; virtual;
    {-Отобразить или обновить окно и занести его в стек}

  procedure Erase; virtual;
    {-Стереть окна и вытолкнуть его из стека}

  procedure Select; virtual;
    {-Сделать окно текущим, вталкивая его на вершину стека}

  procedure DrawHidden(var Under : StackWindow);
    {-Отобразить окно, вставляя его в стек под окно, которое
      задано параметром Under (под)}

  procedure EraseHidden;
    {-Стереть окно, даже если оно является скрытым в стеке окон}

  function OnStack : Boolean;
    {-Возвратить значение True (истинно), если окно отображается
      в стеке окон}

  procedure ActivateWrite;
    {-Задать использование процедур быстрой записи в скрытое окно}

  procedure DeactivateWrite;
    {-Отменить использование процедур быстрой записи и
      отобразить изменения}

  constructor Load(var S : IdStream);
    {-Загрузить из потока}

  procedure Store(var S : IdStream);

                           - 27 -
    {-Занести в поток}

OpWindow      Объект CommandWindow (Командное окно)
────────────────────────────────────────────────────────────────

  constructor Init(X1, Y1, X2, Y2 : Byte;
                   var CP : CommandProcessor;
                   UnitCode : Byte);
    {-Создать командное окно со стандартными значениями параметров
      и цветов}

  constructor InitCustom(X1, Y1, X2, Y2 : Byte;
                         var Colors : ColorSet;
                         Options : LongInt;
                         var CP : CommandProcessor;
                         UnitCode : Byte);
    {-Создать командное окно с произвольными значениями параметров}

  procedure Process; virtual;
    {-Обработать команды}

  procedure ProcessAutoPilot(var CmdList; NumCmds : Word);
    {-Обработать команды, начав с тех, которые находятся в
      CmdList (список команд)}

  procedure GetNextCommand; virtual;
    {-Вызывается процедурой Process (Обработать) для получения
      от пользователя очередной команды}

  procedure RequestHelp(HelpIndex : Word); virtual;
    {-Вызывается процедурой Process (Обработать) для
      получения контекстно-чувствительной подсказки}

  procedure SetCommandProcessor(var CP : CommandProcessor);
    {-Задать используемый командный процессор}

  function GetCommandProcessor : CommandProcessorPtr;
    {-Возвратить указатель на командный процессор окна}

  function GetLastCommand : Word;
    {-Возвратить последнюю команду, которая была введена пользователем}

  procedure SetLastCommand(Cmd : Word);
    {-Изменить последнюю команду}

  function GetLastKey : Word;
    {-Возвратить код последней клавиши, которая была нажата
      пользователем}

  procedure SetHelpIndex(Index : Word);
    {-Задать номер темы подсказки для данного окна}

  function GetHelpIndex : Word;
    {-Возвратить номер темы подсказки для данного окна}

                           - 28 -

  procedure SetErrorProc(EP : ErrorProc);
    {-Задать подпрограмму обработки ошибок}

  procedure GotError(ErrorCode : Word; ErrorMsg : string);
    {-Должна вызываться при возникновении ошибки}

  function GetLastError : Word; virtual;
    {-Возвратить последний код ошибки ввода/вывода}

  function PeekLastError : Word; virtual;
    {-Возвратить последний код ошибки ввода/вывода без
      сброса значения внутренней переменной}

  function ClassifyError(ErrorCode : Word) : Byte;
    {-Возвратить класс указанного кода ошибки}

  procedure SetExitCommands(ExitSetPtr : ByteSetPtr);
    {-Задать набор специальных команд выхода}

  function GetExitCommandPtr : ByteSetPtr;
    {-Возвратить указатель на набор специальных команд выхода}

  constructor Load(var S : IdStream);
    {-Загрузить из потока}

  procedure Store(var S : IdStream);
    {-Занести в поток}

OpWindow      Объект VirtScreen (Виртуальный экран)
────────────────────────────────────────────────────────────────

  constructor Alloc(Height, Width : Word);
    {-Создать виртуальный экран заданных размеров}

  constructor Init(Height, Width : Word; BufSeg : Word);
    {-Инициализировать виртуальный экран на основе
      ранее выделенного в памяти буфера}

  destructor Done; virtual;
    {-Возвратить системе память, которую занимал виртуальный экран}

  procedure Activate;
    {-Назначить процедуры быстрой записи и считывания
      на работу с виртуальным экраном}

  procedure Deactivate;
    {-Отменить работу процедур быстрой записи и считывания
      с виртуальным экраном}

  procedure Clear(Attr : Byte; Fill : Char);
    {-Очистить виртуальный экран}

  procedure WriteTo(S : string; Row, Col : Word; Attr : Byte);

                           - 29 -
    {-Записать строку на виртуальный экран}

  procedure ReadFrom(Number : Byte; Row, Col : Word; var S : string);
    {-Считать number символов с виртуального экрана, начиная
      со строки и столбца Row,Col}

  procedure ScrollHoriz(Cols : Integer; Attr : Byte; Fill : Char);
    {-Осуществить горизонтальную прокрутку содержимого окна}

  procedure ScrollVert(Rows : Integer; Attr : Byte; Fill : Char);
    {-Осуществить вертикальную прокрутку содержимого окна}

  procedure CopyFromWindow(Row, Col : Word);
    {-Копировать текущее окно на позицию  <Row,Col> (строка, столбец)
      на виртуальном экране}

  procedure CopyToWindow(Row, Col : Word);
    {-Копировать с позиции <Row,Col> (строка, столбец) на виртуальном
      экране в текущее окно}

  procedure CopyFromScreen(Row, Col : Word);
    {-Копировать физический экран в позицию <Row,Col> на
      виртуальном экране}

  procedure CopyToScreen(Row, Col : Word);
    {-Копировать с позиции <Row,Col> на виртуальном экране
      на физический экран}

  function vRows : Word;
    {-Возвратить число строк на виртуальном экране}

  function vCols : Word;
    {-Возвратить число столбцов на виртуальном экране}

  constructor Load(var S : IdStream);
    {-Загрузить из потока}

  procedure Store(var S : IdStream);
    {-Занести в поток}

OpWindow      Объект WindowStack (Стек окон)
────────────────────────────────────────────────────────────────

  constructor Init(Max : Word);
    {-Выделить память под стек и осуществить инициализацию}

  destructor Done; virtual;
    {-Удалить и вернуть память в систему}

  function UnstackTop : WindowPtr;
    {-Стереть и вытолкнуть из стека окно, которое находится
      на вершине стека}

  function TopWindow : WindowPtr;

                           - 30 -
    {-Возвратить указатель на окно, которое находится
      на вершине стека}

  function EvaluateStackPos(X, Y : Byte) : WindowPtr;
    {-Определить позицию и вернуть указатель на заданное окно,
      если таковое имеется}

  function EvaluateStackMousePos : WindowPtr;
    {-Определить позицию мыши с помощью подпрограммы EvaluatePos}

  constructor Load(var S : IdStream);
    {-Загрузить из потока}

  procedure Store(var S : IdStream);
    {-Занести в поток}

OpWindow      Объект LoadableColorSet (Загружаемый  набор цветов)
────────────────────────────────────────────────────────────────

  constructor Init(var Colors : ColorSet);
    {-Инициализировать данный набор цветов на базе другого}

  constructor Load(var S : IdStream);
    {-Загрузить набор цветов из потока}

  procedure Store(var S : IdStream);
    {-Занести набор цветов в поток}

OpWindow      Объект PackedWindow (Упакованное окно)
────────────────────────────────────────────────────────────────

  constructor Init(XL, YL, XH, YH : Byte);
    {-Создать упакованное окно}

  constructor InitFromMemory(P : Pointer);
    {-Инициализировать упакованное окно на основе того, которое
      записано на диск с помощью функции Write и прикомпоновано к
      выполняемому (EXE) файлу с помощью утилиты BINOBJ}

  destructor Done; virtual;
    {-Вернуть системе память, которую занимает упакованное окно}

  constructor Read(FName : string);
    {-Считать упакованное окно, которое хранится в FName,
      в память}

  function Write(FName : string) : Word;
    {-Поместить упакованное окно в FName}

  constructor Load(var S : IdStream);
    {-Загрузить упакованное окно из потока}

  procedure Store(var S : IdStream);
    {-Занести упакованное окно в поток}

                           - 31 -

  procedure Display;
    {-Отобразить упакованное окно}

  procedure DisplayAt(Row, Col : Word);
    {-Отобразить упакованное окно с позиции строки и столбца Row,Col.
      При необходимости координаты корректируются таким образом, чтобы
      окно могло бы уместиться на экране.}

  procedure MapColors;
    {-Преобразовать цвета, используемые для отображения упакованного
      окна, чтобы улучшить его восприятие на монохромных/ черно-белых
      мониторах}

OpPick        Объект PickList (Список выбора)
────────────────────────────────────────────────────────────────

  constructor Init(X1, Y1, X2, Y2 : Byte;
                   ItemWidth : Byte;
                   NumItems : Word;
                   StringProc : pkStringProc;
                   Orientation : pkGenlProc;
                   CommandHandler : pkGenlProc);
    {-Инициализировать окно выбора}

  constructor InitCustom(X1, Y1, X2, Y2 : Byte;
                         var Colors : ColorSet;
                         Options : LongInt;
                         ItemWidth : Byte;
                         NumItems : Word;
                         StringProc : pkStringProc;
                         Orientation : pkGenlProc;
                         CommandHandler : pkGenlProc);
    {-Инициализировать окно выбора с произвольными параметрами окна}

  constructor InitAbstract(X1, Y1, X2, Y2 : Byte;
                           var Colors : ColorSet;
                           Options : LongInt;
                           ItemWidth : Byte;
                           NumItems : Word;
                           Orientation : pkGenlProc;
                           CommandHandler : pkGenlProc);
     {-Конструктор, который должен вызываться порожденными типами,
       которые переопределяют метод ItemString}

  constructor InitDeluxe(X1, Y1, X2, Y2 : Byte;
                         var Colors : ColorSet;
                         Options : LongInt;
                         ItemWidth : Byte;
                         NumItems : Word;
                         StringProc : pkStringProc;
                         Orientation : pkGenlProc;
                         CommandHandler : pkGenlProc;
                         PickOptions : Word);

                           - 32 -
    {-Инициализировать окно выбора с произвольными параметрами окна
      и выбора}

  constructor InitAbstractDeluxe(X1, Y1, X2, Y2 : Byte;
                                 var Colors : ColorSet;
                                 Options : LongInt;
                                 ItemWidth : Byte;
                                 NumItems : Word;
                                 Orientation : pkGenlProc;
                                 CommandHandler : pkGenlProc;
                                 PickOptions : Word);
     {-Конструктор, который должен вызываться порожденными типами,
       которые переопределяют метод ItemString и задают произвольные
       параметры выбора}

  destructor Done; virtual;
    {-Возвратить системе память, которую занимал объект PickList}

  procedure AddMoreHeader(PromptStr : String80;
                          Posn : HeaderPosType;
                          UpStr, DnStr, SepStr : String10;
                          UpPos, DnPos, SepPos : Byte);
    {-Добавить специализированный заголовок, указывающий на наличие
      других элементов выбора за пределами окна}

  procedure AddSearchHeader(MaxLen : Byte; Posn : HeaderPosType);
    {-Добавить специализированный заголовок строки поиска}

  procedure UpdateContents; virtual;
    {-Регенерировать все окно выбора}

  procedure Process; virtual;
    {-Обработать команды выбора, которые ведут к некоторому
      выбору}

  procedure ItemString(Item : Word; Mode : pkMode;
                       var IType : pkItemType;
                       var IString : String); virtual;
    {-Формирует строку каждого элемента выбора, когда происходит
      отображение списка или поиск в нем}

  procedure CompleteItemString(Item : Word; Mode : pkMode;
                               var IType : pkItemType;
                               var IString : String); virtual;
    {-Формирует, маркирует и дополняет пробелами строку элемента}

  procedure PreMove; virtual;
    {-Вызывается непосредственно перед получением каждой команды
      с клавиатуры}

  function ItemSearch : Boolean; virtual;
    {-Вызывается для поиска в списке всякий раз, когда
      вводится алфавитно-цифровой символ}


                           - 33 -
  procedure SetInitialChoice(Choice : Word);
    {-Задать начальный элемент выбора без прокрутки (в случае
      возможности)}

  procedure SetChoice(Choice, FirstChoice : Word);
    {-Задать начальный выбор с управлением прокруткой}

  procedure SetDefaultChoice(Choice : Word);
    {-Задать номер используемого по умолчанию элемента выбора,
      который будет возвращен функцией GetDefaultChoice}

  function GetDefaultChoice : Word;
    {-Возвратить номер элемента выбора по умолчанию}

  function GetLastChoice : Word;
    {-Возвратить номер последнего выбранного элемента}

  function GetItemString(Item : Word) : string;
    {-Возвратить заданную строку элемента в поисковом формате}

  function GetLastChoiceString : string;
    {-Возвратить последний вариант выбора в поисковом формате}

  procedure WhereSelect(var X, Y : Byte);
    {-Возвратить координаты выбранного элемента по отношению к окну}

  procedure WhereSelectAbs(var X, Y : Byte);
    {-Возвратить абсолютные координаты выбранного элемента}

  function GetOrientation : Byte;
    {-Возвратить код ориентации}

  function GetItemCols : Byte;
    {-Возвратить число видимых столбцов элементов}

  function GetNumItems : Word;
    {-Возвратить число элементов выбора}

  procedure pkOptionsOn(OptionFlags : Word);
    {-Задать несколько параметров-флагов}

  procedure pkOptionsOff(OptionFlags : Word);
    {-Отменить несколько параметров-флагов}

  function pkOptionsAreOn(OptionFlags : Word) : Boolean;
    {-Возвратить значение True (истинно), если все указанные
      параметры заданы}

  procedure SetRowLimits(MinRows, MaxRows : Word);
    {-Задать значения для минимальной и максимальной строк}

  procedure SetPadSize(LeftPad, RightPad : Byte);
    {-Задать число символов пробела, которые окружают элементы выбора}


                           - 34 -
  procedure SetMoveProc(MP : pkGenlProc);
    {-Задать пользовательскую процедуру перемещения}

  procedure SetSearchMode(SF : pkSearchFunc);
    {-Задать другой режим поиска}

  procedure SetSearchStart(SStart : Byte);
    {-Задать начальное смещение для поиска строк}

  procedure ChangeNumItems(NumItems : Word);
    {-Изменить число отображаемых элементов}

  procedure ChangeItemWidth(ItemWidth : Byte);
    {-Изменить ширину элемента}

  procedure ChangeStringProc(StringProc : pkStringProc);
    {-Изменить функцию формирования строк}

  procedure ChangeOrientation(Orientation : pkGenlProc);
    {-Изменить ориентацию}

  procedure ChangeCommandHandler(CommandHandler : pkGenlProc);
    {-Переключиться между выбором одного элемента и выбором нескольких}

  procedure OptimizeSize;
    {-Изменить размер окна, чтобы уместить туда элементы}

  procedure SetPickAttr(ItemType : pkItemType; Selected : Boolean;
                        Color, Mono : Byte);
    {-Задать одну группу цветов -- отменяет гибкое использование цветов
      при записи на экран}

  procedure SetPickFlex(ItemType : pkItemType; Selected : Boolean;
                        var Color, Mono : FlexAttrs);
    {-Задать одну группу цветов для гибкого использования цвета}

  procedure SetSelectMarker(Left, Right : String);
    {-Описать строки для маркирования выделенных элементов}

  procedure AllocateSelectSet(MaxItems : Word);
    {-Отвести память под множество выбора для максимального числа
      элементов}

  procedure ClearSelected;
    {-Удалить выделенные элементы}

  procedure MarkAllSelected;
    {-Маркировать все элементы как выбранные}

  procedure SelectItem(Item : Word); virtual;
    {-Выбрать элемент}

  procedure DeselectItem(Item : Word); virtual;
    {-Исключить элемент из числа выбранных}

                           - 35 -

  function ItemIsSelected(Item : Word) : Boolean;
    {-Возвратить значения True (истинно), если элемент выбран}

  function GetSelectedCount : Word;
    {-Возвратить число выбранных элементов}

  procedure InitSequence(var Item : Word);
    {-Подготовиться к получению первого выбранного элемента}

  function HaveSelected(Item : Word) : Boolean;
    {-Возвратить значение True (истинно), если имеется выбранный
      элемент}

  procedure NextSelected(var Item : Word);
    {-Установить переменную Item равной следующему выбранному
      элементу}

  function IsProtected(Item : Word) : Boolean;
    {-Возвратить True (истинно), если элемент защищен и, следовательно,
      не может быть выбран}

  function NumSelectableItems : Word;
    {-Возвратить число незащищенных элементов}

  constructor Load(var S : IdStream);
    {-Загрузить список выбора из потока}

  procedure Store(var S : IdStream);
    {-Занести список выбора в поток}

OpPick        Процедуры и функции
────────────────────────────────────────────────────────────────

  function PickNoSearch(P : PickListPtr) : Boolean;
    {-Режим отсутствия поиска}

  function PickStringSearch(P : PickListPtr) : Boolean;
    {-Режим поиска строк}

  function PickAltStringSearch(P : PickListPtr) : Boolean;
    {-Альтернативный режим поиска строк}

  function PickCharSearch(P : PickListPtr) : Boolean;
    {-Режим поиска символов}

  function PickCharExit(P : PickListPtr) : Boolean;
    {-Поиск символов с выходом при совпадении}

  function PickAnyCharExit(P : PickListPtr) : Boolean;
    {-Выход при вводе любого алфавитного символа. Перемещения
      светового маркера не происходит}

  procedure PickVertical(P : PickListPtr);

                           - 36 -
    {-Инициализировать выбор для элементов, расположенных вертикально}

  procedure PickHorizontal(P : PickListPtr);
    {-Инициализировать выбор для элементов, расположенных горизонтально}

  procedure PickSnaking(P : PickListPtr);
    {-Инициализировать выбор для элементов, расположенных
      вертикально зигзагами}

  procedure SingleChoice(P : PickListPtr);
    {-Инициализировать список выбора в расчете на выбор только одного
      элемента}

  procedure MultipleChoice(P : PickListPtr);
    {-Инициализировать список выбора в расчете на выбор нескольких
      элементов}

  procedure NoMoveAction(P : PickListPtr);
    {-Пользовательская подпрограмма привязки, вызываемая непосред-
      ственно перед получением каждой команды выбора}

OpDir         Объект DirList (Список директории)
────────────────────────────────────────────────────────────────

  constructor Init(X1, Y1, X2, Y2 : Byte;
                   HeapToUse : Word;
                   PickOrientation : pkGenlProc;
                   CommandInit : diInitCommandProc);
    {-Инициализировать список директории}

  constructor InitCustom(X1, Y1, X2, Y2 : Byte;
                         var Colors : ColorSet;
                         Options : LongInt;
                         HeapToUse : Word;
                         PickOrientation : pkGenlProc;
                         CommandInit : diInitCommandProc);
    {-Инициализировать список директории с произвольными
      параметрами окна}

  destructor Done; virtual;
    {-Возвратить в систему память, которую занимает список директории}

  procedure AddMaskHeader(FullPath : Boolean;
                          PadSize : Byte;
                          MaxLen : Byte;
                          Posn : HeaderPosType);
    {-Добавить заголовок для отображения маски поиска}

  procedure SetMask(Mask : String; FileAttr : Byte);
    {-Задать маску поиска и атрибут и реинициализировать список}

  procedure ResetList;
    {-Осуществить повторное считывание директории в ситуации, когда
      ее содержимое могло измениться}

                           - 37 -

  procedure PreloadDirList;
    {-Произвести предварительное считывание директории в целях
      оптимизации размера перед отображением}

  procedure Process; virtual;
    {-Обработать команды выбора, ведущие к выбору файла}

  procedure UpdateContents; virtual;
    {-Регенерировать содержимое окна директории}

  procedure SortList; virtual;
    {-Сортировать список элементов директории}

  function Reject(var X : DirRec) : Boolean; virtual;
    {-Возвратить значение True (истинно), чтобы исключить конкрет-
      ный элемент из списка выбора}

  procedure Format(var X : DirRec; var pkCat : Byte;
                   var S : String); virtual;
    {-Возвратить форматированную строку и категорию для
      элемента директории}

  function GetFileName(Mask : String; FileAttr : Byte;
                       var Name : PathStr) : Word;
    {-Задать новую маску, выбрать имя и возвратить управление.
      Возвращает слово состояния}

  procedure ChangeDirectory(Mask : String; ChangeCode : Byte);
    {-Перейти в заданную директорию или позволить пользователю
      сделать это интерактивно}

  function GetMatchingFileCount : Word;
    {-Возвратить число удовлетворяющих критерию выбора файлов,
      которые находятся в последней директории}

  function GetMatchingSize(ClusterSize : Word) : LongInt;
    {-Возвратить число байтов во всех удовлетворяющих критерию
      выбора файлах}

  function GetSelectedFile : FileStr;
    {-Возвратить 12-символьное имя выбранного файла}

  function GetSelectedPath : PathStr;
    {-Возвратить полное маршрутное имя выбранного файла}

  function GetSelectedDir : DirStr;
    {-Возвратить имя директории выбранного файла}

  procedure GetSelectedDirRec(var D : DirRec);
    {-Возвратить полную запись директории DirRec для выбранного
      файла}

  function SelectedFileInCurDir : Boolean;

                           - 38 -
    {-Возвратить значение true (истинно), если выбранный файл
      находится в текущей директории}

  procedure RemoveSelectedFile;
    {-Удалить текущий файл из списка выбора}

  procedure diOptionsOn(OptionFlags : Word);
    {-Задать несколько параметров-флагов}

  procedure diOptionsOff(OptionFlags : Word);
    {-Отменить несколько параметров-флагов}

  function diOptionsAreOn(OptionFlags : Word) : Boolean;
    {-Возвратить значение True (истинно), если все указанные
      параметры-флаги установлены}

  function FileCapacity : Word;
    {-Возвратить максимальное число файлов, которое может
      содержаться в списке}

  procedure SetNameFormat;
    {-Инициализировать для компактного формата nnnnnnnn.xxx}

  procedure SetNameSizeFormat(DirStr : String);
    {-Инициализировать для формата nnnnnnn.xxx sssssssss}

  procedure SetNameSizeKFormat(DirStr : String);
    {-Инициализировать для формата nnnnnnn.xxx ssssssk}

  procedure SetNameTimeFormat(DatePicture, TimePicture : String);
    {-Инициализировать для формата name date time (имя дата время)}

  procedure SetNameSizeTimeFormat(DirStr,
                                  DatePicture, TimePicture : String);
    {-Инициализировать для формата name size date time
      (имя размер дата время)}

  procedure SetNameSizeKTimeFormat(DirStr,
                                   DatePicture, TimePicture : String);
    {-Инициализировать для формата name size date time format
      (имя размер дата время)}

  procedure SetAllFormat(DirStr, DatePicture, TimePicture : String);
    {-Инициализировать для формата name size date time attr
      (имя размер дата время атрибут)}

  procedure SetUserFormat(MaxFmatLen : Byte; FF : diFormatProc);
    {-Задать определяемую пользователем функцию формата}

  procedure SetFileAttr(Color, Mono : Byte);
    {-Задать видеоатрибуты для файлов}

  procedure SetDirAttr(Color, Mono : Byte);
    {-Задать видеоатрибуты для директорий}

                           - 39 -

  procedure SetSelectFileAttr(Color, Mono : Byte);
    {-Задать видеоатрибуты для выбранного файла}

  procedure SetSelectDirAttr(Color, Mono : Byte);
    {-Задать видеоатрибуты для выбранной директории}

  procedure SetSortOrder(SP : diSortProc);
    {-Задать альтернативную подпрограмму для сортировки}

  procedure SetRejectFunc(RF : diRejectFunc);
    {-Задать альтернативную функцию отбраковки для
      процесса селекции файлов}

  procedure AddRejectString(S : String);
    {-Добавить строку к множеству отбраковки}

  procedure ClearRejectStrings;
    {-Удалить множество строк, предназначенных для отбраковки}

  procedure SkipDrives(Drives : DriveSet);
    {-Задать дисководы, которые следует "опустить" при
      отображении литер дисководов}

  procedure SetDriveDelim(Left, Right : String);
    {-Задать строки-разделители, которые располагаются слева и
      справа от литер дисководов}

  function GetMultiFile(N : Word) : FileStr;
    {-Возвратить 12-символьное имя заданного файла}

  function GetMultiPath(N : Word) : PathStr;
    {-Возвратить полное маршрутное имя заданного файла}

  procedure GetMultiDirRec(N : Word; var D : DirRec);
    {-Возвратить полную запись директории DirRec заданного файла}

  function GetSelectedSize(ClusterSize : Word) : LongInt;
    {-Возвратить полный размер всех выделенных файлов}

  procedure RemoveMultiFile(N : Word);
    {-Удалить заданный файл из списка}

  procedure RemoveSelectedFiles;
    {-Удалить все выделенные файлы из списка}

  function GetMultiDirPtr(N : Word) : DirRecPtr;
    {-Возвратить указатель на запись директории DirRec
      заданного файла}

  procedure FormatMultiFile(N : Word);
    {-Реконструировать строку формата для заданного файла}

  procedure SelectItem(N : Word); virtual;

                           - 40 -
    {-Выбрать элемент. Переопределяет метод PickList.SelectItem,
      чтобы избежать выбора директорий}

  constructor Load(var S : IdStream);
    {-Загрузить список из потока}

  procedure Store(var S : IdStream);
    {-Занести список в поток}


                            - 41 -

OpDir         Объект PathList (Список маршрутных имен)
────────────────────────────────────────────────────────────────

  constructor Init(X1, Y1, X2, Y2 : Byte;
                   HeapToUse : Word;
                   PickOrientation : pkGenlProc;
                   CommandInit : paInitCommandProc);
    {-Инициализировать список маршрутных имен}

  constructor InitCustom(X1, Y1, X2, Y2 : Byte;
                         var Colors : ColorSet;
                         Options : LongInt;
                         HeapToUse : Word;
                         PickOrientation : pkGenlProc;
                         CommandInit : paInitCommandProc);
    {-Инициализировать список маршрутных имен с произвольными
      параметрами окна}

  destructor Done; virtual;
    {-Вернуть в систему память, выделенную для списка маршрутных имен}

  procedure SetDrive(Drive : Char);
    {-Задать дисковод для списка маршрутных имен}

  procedure ResetList;
    {-Осуществить повторное считывание директорий в ситуации, когда
      их содержимое могло измениться}

  procedure UpdateContents; virtual;
    {-Регенерировать полное окно выбора}

  procedure Process; virtual;
    {-Отобразить список, если таковой имеется, осуществить один выбор}

  procedure PreloadPathList;
    {-Произвести предварительное считывание маршрутных имен в целях
      оптимизации размера перед отображением}

  function GetPathName(Drive : Char) : PathStr;
    {-Задать дисковод, выбрать маршрутное имя и возвратить его.
      В случае ошибки возвращается пустая строка.}

  function GetSelectedPath : PathStr;
    {-Возвратить выбранное маршрутное имя}

  procedure paOptionsOn(OptionFlags : Word);
    {-Установить несколько параметров-флагов}

  procedure paOptionsOff(OptionFlags : Word);
    {-Отменить несколько параметров-флагов}

  function paOptionsAreOn(OptionFlags : Word) : Boolean;
    {-Возвратить значение true, если все указанные
      параметры-флаги установлены}

                            - 42 -

  procedure SetClusterSize(Size : Word);
    {-Задать размер кластера для выравнивания файлов
      по границам, установленным в DOS}

  procedure SetDrawingChars(P : PathDrawArray);
    {-Задать символы, которые используются для
      вычерчивания линий}

  procedure SetLineDrawMode;
    {-Отображать иерархию с помощью символов вычерчивания линий
      (используется по умолчанию)}

  procedure SetFullPathMode;
    {-Отображать иерархию с помощью полных маршрутных имен}

  procedure SetPathAttr(Color, Mono : Byte);
    {-Задать видеоатрибуты для маршрутных имен}

  procedure SetSelectPathAttr(Color, Mono : Byte);
    {-Задать видеоатрибуты для выбранных маршрутных имен}

  function GetMultiPath(N : Word) : PathStr;
    {-Возвратить маршрутное имя для выбранного маршрута}

  constructor Load(var S : IdStream);
    {-Загрузить список из потока}

  procedure Store(var S : IdStream);
    {-Занести список в поток}

OpDir         Процедуры и функции
────────────────────────────────────────────────────────────────

  procedure SingleFile(DirPtr : DirListPtr;
                       var StringProc : pkStringProc;
                       var CommandInitProc : pkGenlProc);
    {-Инициализировать для выбора одиночных файлов}

  procedure MultipleFile(DirPtr : DirListPtr;
                         var StringProc : pkStringProc;
                         var CommandInitProc : pkGenlProc);
    {-Инициализировать для выбора нескольких файлов}

  procedure SortNone(DirPtr : DirListPtr);
    {-Сортировка не производится}

  procedure SortName(DirPtr : DirListPtr);
    {-Сортировать в алфавитном порядке сначала по имени, затем по
      расширению имени}

  procedure SortDirName(DirPtr : DirListPtr);
    {-Сортировать сначала директории, затем в алфавитном порядке
      по имени и расширению имени}

                            - 43 -

  procedure SortSize(DirPtr : DirListPtr);
    {-Сортировать по размеру, затем по имени и расширению имени}

  procedure SortTime(DirPtr : DirListPtr);
    {-Сортировать по дате, затем по имени и расширению имени}

  procedure NameFormat(var D : DirRec; var pkCat : Byte;
                       var S : String; DirPtr : DirListPtr);
    {-Простой стандартный формат для списков директории}

  procedure NameSizeKFormat(var D : DirRec; var pkCat : Byte;
                            var S : String; DirPtr : DirListPtr);
    {-Отобразить имя и размер в Килобайтах}

  procedure NameSizeFormat(var D : DirRec; var pkCat : Byte;
                           var S : String; DirPtr : DirListPtr);
    {-Отобразить имя и размер в байтах}

  procedure NameTimeFormat(var D : DirRec; var pkCat : Byte;
                           var S : String; DirPtr : DirListPtr);
    {-Отобразить имя и дату/время}

  procedure NameSizeKTimeFormat(var D : DirRec; var pkCat : Byte;
                                var S : String; DirPtr : DirListPtr);
    {-Отобразить имя, размер (в Килобайтах), время}

  procedure NameSizeTimeFormat(var D : DirRec; var pkCat : Byte;
                               var S : String; DirPtr : DirListPtr);
    {-Отобразить имя, размер, время}

  procedure AllFormat(var D : DirRec; var pkCat : Byte;
                      var S : String; DirPtr : DirListPtr);
    {-Отобразить имя, размер, время, атрибут}

  function RejectNone(var D : DirRec; DirPtr : DirListPtr) : Boolean;
    {-Не отбраковывать никаких файлов}

  function RejectExtensions(var D : DirRec;
                            DirPtr : DirListPtr) : Boolean;
    {-Отбраковывать файлы с расширением, которое указано в множестве
      RejectSet}

  function RejectFiles(var D : DirRec; DirPtr : DirListPtr) : Boolean;
    {-Отбраковывать все кроме поддиректорий}

  procedure SinglePath(PathPtr : PathListPtr;
                       var StringProc : pkStringProc;
                       var CommandInitProc : pkGenlProc);
    {-Инициализировать для выбора одиночных маршрутных имен}

  procedure MultiplePath(PathPtr : PathListPtr;
                         var StringProc : pkStringProc;
                         var CommandInitProc : pkGenlProc);

                            - 44 -
    {-Инициализировать для выбора нескольких маршрутных имен}

OpMenu        Объект MenuItemNode (Узел элемента меню)
────────────────────────────────────────────────────────────────

  procedure Protect;
    {-Установить на элемент защиту от выбора}

  procedure Unprotect;
    {-Снять с элемента защиту от выбора}

  function ChangeName(Name : String) : Boolean;
    {-Изменить имя элемента}

  procedure ChangeKey(Key : LongInt);
    {-Изменить код (ключ) элемента}

  function ChangeHelp(Help : String) : Boolean;
    {-Изменить строку подсказки}

  procedure ChangeSelectPos(SelectPos : Byte);
    {-Изменить смещение буквы выбора}

  procedure ChangeDisplayPos(DisplayPos : Byte);
    {-Изменить смещение позиции отображения}

  procedure ChangeSubPtr(SPtr : SubMenuPtr);
    {-Изменить указатель на подменю элемента}

  procedure DisplayInfo(var DisplayPos, SelectPos : Byte;
                        var S : String);
    {-Возвратить строку и смещение позиции отображения элемента}

  function HelpString : String;
    {-Возвратить строку подсказки для элемента}

  function ItemKey : LongInt;
    {-Возвратить код в меню (ключ) элемента}

  function SubPtr : SubMenuPtr;
    {-Возвратить указатель на подменю для элемента}

  function IsProtected : Boolean;
    {-Возвратить значение True (истинно), если элемент защищен от
      выбора}

  function SelectChar : Char;
    {-Возвратить алфавитный символ выбора элемента (в верхнем
      регистре)}

  function GetDisplayPos : Byte;
    {-Возвратить только смещение позиции отображения}

OpMenu        Объект Menu (Меню)

                            - 45 -
────────────────────────────────────────────────────────────────

  constructor Init(X1, Y1, X2, Y2 : Byte;
                   Orient : mnOrientation);
    {-Создать меню со стандартными параметрами и цветами}

  constructor InitCustom(X1, Y1, X2, Y2 : Byte;
                         var Colors : ColorSet;
                         Options : LongInt;
                         Orient : mnOrientation);
    {-Создать меню с произвольными параметрами окна}

  procedure mnOptionsOn(OptionFlags : Word);
    {-Задать несколько параметров-флагов}

  procedure mnOptionsOff(OptionFlags : Word);
    {-Отменить несколько параметров-флагов}

  function mnOptionsAreOn(OptionFlags : Word) : Boolean;
    {-Возвратить значение true, если все указанные
      параметры-флаги установлены}

  procedure AddItem(Name : String; DisplayPos, SelectPos : Byte;
                    Key : LongInt);
    {-Добавить элемент к текущему списку элементов, выделяя память
      для строки в динамической области (куче)}

  procedure AddItemPtr(var Name : String; DisplayPos,
                       SelectPos : Byte;
                       Key : LongInt);
    {-Добавить элемент к текущему списку элементов без выделения
      памяти для строки в динамической области (куче)}

  procedure AddItemHelp(Name : String; DisplayPos, SelectPos : Byte;
                        Key : LongInt; Help : String);
    {-Добавить элемент (с подсказкой к текущему списку элементов,
      выделяя память для строки в динамической области (куче)}

  procedure AddItemHelpPtr(var Name : String; DisplayPos,
                           SelectPos : Byte;
                           Key : LongInt; var Help : String);
    {-Добавить элемент (с подсказкой) к текущему списку элементов
      без выделения памяти для строки в динамической области (куче)}

  procedure AddSeparator(FirstChar, SpanChar, LastChar : Char;
                         DisplayPos : Byte);
    {-Добавить строку-разделитель со смещением DisplayPos внутри окна}

  procedure AddSeparatorColor(FirstChar, SpanChar, LastChar : Char;
                              DisplayPos : Byte;
                              AttrColor, AttrMono : Byte);
    {-Добавить строку-разделитель со смещением DisplayPos внутри окна
      с заданными цветами}


                            - 46 -
  procedure AddSubMenu(X1, Y1, X2, Y2 : Byte; Orient : mnOrientation);
    {-Добавить подменю без рамки с параметрами и значениями цветов,
      унаследованными от основного меню}

  procedure AddFramedSubMenu(X1, Y1, X2, Y2 : Byte;
                             Orient : mnOrientation;
                             FA : FrameArray);
    {-Добавить подменю с рамкой с параметрами и значениями цветов,
      унаследованными от основного меню}

  procedure AddSubMenuCustom(X1, Y1, X2, Y2 : Byte;
                             var Colors : ColorSet;
                             Options : LongInt;
                             Orient : mnOrientation;
                             FA : FrameArray);
    {-Добавить подменю с произвольными параметрами окна}

  procedure ItemsDone;
    {-Завершить формирование текущего списка элементов. В качестве
      используемого по умолчанию задается первый элемент.}

  procedure ItemsDoneCustom(OptimizeSize : Boolean;
                            DefaultKey : LongInt);
    {-Завершить формирование текущего списка элементов и
      скорректировать размер списка и значение используемого
      по умолчанию ключа.}

  procedure SetNormAttr(Color, Mono : Byte);
    {-Задать атрибуты для обычного текста элемента}

  procedure SetSelectAttr(Color, Mono : Byte);
    {-Задать атрибуты для текста выбранного элемента}

  procedure SetHighAttr(Color, Mono : Byte);
    {-Задать атрибуты для текста светового маркера выбора}

  procedure SetProtectAttr(Color, Mono : Byte);
    {-Задать атрибуты для текста защищенного элемента}

  procedure SetFrameAttr(Color, Mono : Byte);
    {-Задать атрибуты рамки для всех окон в системе меню}

  procedure SetHeaderAttr(Color, Mono : Byte);
    {-Задать атрибуты заголовков для всех окон в
      системе меню}

  procedure SetShadowAttr(Color, Mono : Byte);
    {-Задать атрибуты затененной области для всех окон в системе меню}

  procedure SetLeftPad(LeftPad : Byte);
    {-Задать число символов для отступа слева при
      отображении каждого элемента}

  procedure SetSelectMarker(Left, Right : String);

                            - 47 -
    {-Задать строки для маркирования выделенных элементов}

  procedure AddHeader(S : string; Posn : HeaderPosType);
    {-Добавить стандартный заголовок}

  procedure AddHeaderColor(S : string; Posn : HeaderPosType;
                           AttrColor, AttrMono : Byte);
    {-Добавить стандартный заголовок с произвольными параметрами}

  procedure AddCustomHeader(S : string; Posn : FrameCornerType;
                            DX, DY : Integer;
                            AttrColor, AttrMono : Byte);
    {-Добавить специализированный заголовок}

  procedure AddShadow(Posn : ShadowPosType;
                      DrawType : ShadowDrawType);
    {-Добавить стандартную затененную область}

  procedure AddShadowColor(Posn : ShadowPosType;
                           DrawType : ShadowDrawType;
                           AttrColor, AttrMono : Byte);
    {-Добавить стандартную затененную область с произвольными
      цветами}

  procedure EnableExplosions(StageDelay : Word);
    {-Разрешить раскрытие окон с параметром StageDelay
      (задержка на этапе) миллисекунд на каждый этап раскрытия}

  procedure EnableNormalOpen;
    {-Заретить раскрытие окон или использование альтернативных
      подпрограмм отображения}

  procedure SetAllNormAttr(Color, Mono : Byte);
    {-Задать атрибуты нормального текста для всех элементов
      в системе меню}

  procedure SetAllSelectAttr(Color, Mono : Byte);
    {-Задать атрибуты выбранного текста для всех элементов
      в системе меню}

  procedure SetAllHighAttr(Color, Mono : Byte);
    {-Задать атрибуты светового маркера для всех элементов
      в системе меню}

  procedure SetAllProtectAttr(Color, Mono : Byte);
    {-Задать атрибуты защищенных элементов для всех элементов
      в системе меню}

  procedure SetAllFrameAttr(Color, Mono : Byte);
    {-Задать атрибуты рамок всех окон в системе меню}

  procedure SetAllHeaderAttr(Color, Mono : Byte);
    {-Задать атрибуты заголовков всех окон в системе меню}


                            - 48 -
  procedure SetAllShadowAttr(Color, Mono : Byte);
    {-Задать атрибуты затененных областей всех окон
      в системе меню}

  procedure AddShadows(MainMenu : Boolean; Posn : ShadowPosType;
                       DrawType : ShadowDrawType);
    {-Добавить затененные области ко всем подменю}

  procedure EnableAllExplosions(StageDelay : Word);
    {-Разрешить раскрытие окон с параметром StageDelay
      (задержка на этапе) миллисекунд на каждый этап раскрытия}

  procedure EnableAllAlternateOpen(OpenProc, CloseProc : RawWindowProc;
                                   StageDelay : Word);
    {-Задать использование альтернативных подпрограмм отображения
      и стирания}

  procedure EnableAllNormalOpen;
    {-Запретить раскрытие окон или использование альтернативных
      подпрограмм отображения}

  procedure SetAllSelectMarker(Left, Right : String);
    {-Описывает строки для маркирования выделенных элементов
      во всех подменю}

  procedure SetHelpAttr(Color, Mono : Byte);
    {-Задать цвета для строки подсказки}

  procedure GetHelpAttr(var Color, Mono : Byte);
    {-Получить цвета, назначенные строке подсказки}

  procedure VisitAllItems(IProc : mnItemProc; var D);
    {-Вызвать заданную процедуру для всех элементов в системе меню}

  procedure VisitAllWindows(WProc : mnWindowProc; var D);
    {-Вызвать заданную процедуру для всех подменю в системе меню}

  procedure VisitAllItemLists(LProc : mnListProc; var D);
    {-Вызвать заданную процедуру для всех списков элементов
      в системе меню}

  procedure SetCurrentItemProc(IP : mnCurrentItemProc);
    {-Задать процедуру, которая должна вызываться при отображении
      активного элемента}

  procedure SetCustomStringProc(CP : mnCustomProc);
    {-Задать процедуру коррекции строк}

  procedure CurrentItem(IPtr : MenuItemNodePtr); virtual;
    {-Вызывается непосредственно после того, как был
      отображен выбранный в настоящий момент элемент}

  procedure Process; virtual;
    {-Обработать команды меню, которые ведут к выбору действия}

                            - 49 -

  function MenuChoice : LongInt;
    {-Возвратить номер последнего выбранного элемента меню}

  procedure EraseCurrentSubMenu;
    {-Стереть текущее подменю}

  procedure EraseAllSubMenus(ShowSelect, ShowHighlight : Boolean);
    {-Стереть все подменю, оставив основное меню отображенным
      с заданным состоянием маркера выбора ShowHighlight}

  procedure EraseClear;
    {-Стереть меню и удалить активные подменю при последующем
      отображении}

  procedure SelectItem(Key : LongInt);
    {-Выбрать указанный элемент и регенерировать экран}

  procedure SelectSubMenu(Key : LongInt);
    {-Выбрать текущий элемент подменю, содержащего код
      Key и регенерировать экран}

  function SelectItemByPos(X, Y : Byte) : Boolean;
    {-Выбрать видимый элемент (если таковой существует) в абсолютной
      позиции и регенерировать экран}

  procedure Redraw;
    {-Стереть и регенерировать систему меню, вероятно после
      изменения элемента}

  procedure ProtectItem(Key : LongInt);
    {-Установить защиту от выбора на заданный элемент. Регенерация
      экрана не осуществляется}

  procedure UnprotectItem(Key : LongInt);
    {-Снять защиту с заданного элемента. Регенерация экрана не
      осуществляется}

  procedure DefaultItem(Key : LongInt);
    {-Сделать элемент Key стандартным (используемым по умолчанию)
      в своем подменю. Регенерация экрана не производится}

  procedure DefaultPath(Key : LongInt);
    {-Выбрать маршрут к заданному элементу. Регенерация экрана
      не осуществляется}

  function ActiveListPtr : MenuItemListPtr;
    {-Возвратить указатель на активный список элементов}

  function ActiveWinPtr : RawWindowPtr;
    {-Возвратить указатель на активное окно-прототип}

  function ActiveSubPtr : SubMenuPtr;
    {-Возвратить указатель на активное подменю}

                            - 50 -

  function ActiveItemPtr : MenuItemNodePtr;
    {-Возвратить указатель на активный в настоящий момент элемент}

  function FindItem(Key : LongInt) : MenuItemNodePtr;
    {-Возвратить указатель на узел элемента}

  constructor Load(var S : IdStream);
    {-Загрузить список из потока}

  procedure Store(var S : IdStream);
    {-Занести список в поток}

  destructor Done; virtual;
    {-Вернуть системе память, которая была выделена для меню}

  procedure UpdateContents; virtual;
    {-Регенерировать содержимое}

  procedure Erase; virtual;
    {-Стереть систему меню. Запоминает предыдущие подменю для
      последующего отображения}

  function IsCurrent : Boolean; virtual;
    {-Возвратить True (истинно), если система меню
      является текущим окном}

  procedure MoveWindow(DX, DY : Integer); virtual;
    {-Переместить меню}

  procedure UpdateScreenSize;
    {-Корректировать размер окна, позицию и пределы для текущего
      размера экрана}

OpMenu        Процедуры и функции
────────────────────────────────────────────────────────────────

  procedure NoCustomization(var Name : String; Key : LongInt;
                            Selected, Highlighted : Boolean;
                            WPtr : RawWindowPtr);
    {-Стандартная процедура коррекции строк, которая не выполняет
      никаких действий}

  procedure NoMoveAction(MPtr : MenuPtr);
    {-Стандартная процедура (предшествующая перемещению), которая
      не выполняет никаких действий}

  procedure NoCurrItemAction(CurrentItem : MenuItemNodePtr;
                             MPtr : MenuPtr);
    {-Стандартная процедура перемещения активного элемента, которая
      не выполняет никаких действий}

OpHelp        Объект AbstractHelpWindow (Абстрактное окно подсказки)
────────────────────────────────────────────────────────────────

                            - 51 -

  constructor Init(X1, Y1, X2, Y2 : Byte;
                   HelpFile : PathStr;
                   PickOrientation : pkGenlProc);
    {-Инициализировать окно подсказки и открыть файл подсказки}

  constructor InitMem(X1, Y1, X2, Y2 : Byte;
                      HelpAddr : Pointer;
                      PickOrientation : pkGenlProc);
    {-Инициализировать окно подсказки, используя текст подсказки,
      который прикомпонован к коду}

  constructor InitCustom(X1, Y1, X2, Y2 : Byte;
                         var Colors : ColorSet;
                         Options : LongInt;
                         HelpFile : PathStr;
                         PickOrientation : pkGenlProc);
    {-Инициализировать окно подсказки и открыть файл подсказки}

  constructor InitDeluxe(X1, Y1, X2, Y2 : Byte;
                         var Colors : ColorSet;
                         Options : LongInt;
                         HelpFile : PathStr;
                         PickOrientation : pkGenlProc;
                         HelpOptions : Word);
    {-Инициализировать окно подсказки и открыть файл подсказки}

  constructor InitMemCustom(X1, Y1, X2, Y2 : Byte;
                            var Colors : ColorSet;
                            Options : LongInt;
                            HelpAddr : Pointer;
                            PickOrientation : pkGenlProc);
    {-Инициализировать окно подсказки, используя текст подсказки,
      который прикомпонован к коду}

  constructor InitMemDeluxe(X1, Y1, X2, Y2 : Byte;
                            var Colors : ColorSet;
                            Options : LongInt;
                            HelpAddr : Pointer;
                            PickOrientation : pkGenlProc;
                            HelpOptions : Word);
    {-Инициализировать окно подсказки, используя текст подсказки,
      который прикомпонован к коду}

  destructor Done; virtual;
    {-Удалить систему подсказки и вернуть память системе}

  procedure ItemString(Item : Word; Mode : pkMode;
                       var IType : pkItemType;
                       var IString : String); virtual;
    {-Формирует строку каждого элемента, когда осуществляется
      отображение списка или поиск в нем}

  procedure Draw; virtual;

                            - 52 -
    {-Выбрать соответствующую рамку и отобразить окно подсказки
      или индекс выбора}

  procedure UpdateContents; virtual;
    {-Регенерировать окно подсказки в режиме выбора или в режиме
      подсказки}

  procedure Process; virtual;
    {-Отобразить индекс подсказки или текущую тему}

  procedure SetTopic(Topic : Word);
    {-Указать, какая тема будет отображаться. Значение 0 задает
      отображение индекса}

  function GetTopicChoice : Word;
    {-Возвратить номер темы, выбранной в списке выбора}

  function InHelpMode : Boolean;
    {-Возвратить значение True (истинно), если в окне отображается
      подсказка, а не список выбора}

  function TopicStackPtr : StaticQueuePtr;
    {-Возвратить указатель на стек тем}

  function CurrentTopic : Word;
    {-Возвратить номер темы, которая в настоящий момент загружена в
      буфер подсказки}

  procedure hwOptionsOn(OptionFlags : Word);
    {-Задать несколько параметров-флагов}

  procedure hwOptionsOff(OptionFlags : Word);
    {-Отменить несколько параметров-флагов}

  function hwOptionsAreOn(OptionFlags : Word) : Boolean;
    {-Возвратить значение True (истинно), если все указанные
      параметры заданы}

  procedure SetPickPadSize(PadSize : Byte);
    {-Задать число символов пробела, которые окружают элементы выбора}

  procedure SetHelpPadSize(Pad : Byte);
    {-Задать число символов пробела на краях окна подсказки}

  procedure AddTopicHeader(PadSize : Byte; MaxLen : Byte;
                           Posn : HeaderPosType);
    {-Добавить заголовок для отображения темы подсказки}

  procedure AddMoreHelpHeader(PromptStr : String80;
                              Posn : HeaderPosType;
                              UpStr, DnStr, SepStr : String10;
                              UpPos, DnPos, SepPos : Byte);
    {-Добавить специализированный заголовок, указывающий на наличие
      других элементов выбора за пределами окна}

                            - 53 -

  procedure InitHelpFrame;
    {-Задать рамку окна подсказки тождественной рамке wFrame}

  procedure SetPrevTopicHotSpot(SpotNum : Byte; Posn : FrameCharType);
    {-Задать область активации для команды выбора предыдущей темы}

  procedure SetNestedFunc(NF : hwNestedFunc);
    {-Задать функцию, которая вызывается при обращении к вложенным
      перекрестным ссылкам}

  function HighestTopic : Word;
    {-Возвратить номер самой старшей темы в системе подсказки}

  function PickTopics : Word;
    {-Возвратить число тем индекса (указателя) подсказки
      в системе подсказки}

  function FindNextTopic(PrevMatch : Word; Circular : Boolean;
                         var Name : String;
                         MatchFunc : hwMatchFunc) : Word; virtual;
    {-Возвратить номер темы с указанным именем Name, начиная после
      элемента PrevMatch, если параметр Circular (циклический)
      равен True (истинно), то поиск осуществляется "по кругу"}

  function FindTopic(Name : String;
                     MatchFunc : hwMatchFunc) : Word; virtual;
    {-Возвратить номер темы подсказки с заданным именем Name, 0,
      если тема не найдена}

  function ScreenWordXY(XPos, YPos : Byte;
                        ScanBack, ScanForward : Boolean) : String;
    {-Осуществить синтаксический анализ слова, расположенного на
      экране с абсолютными координатами (XPos, YPos)}

  function CurrentXrefTopic : Word; virtual;
    {-Возвратить тему подсказки текущей перекрестной ссылки,
      значение $FFFF, если перекрестная ссылка не найдена}

  constructor Load(var S : IdStream);
    {-Загрузить систему подсказки из потока}

  procedure Store(var S : IdStream);
    {-Занести систему подсказки в поток}

OpHelp        Объект ScrollingHelpWindow (Окно подсказки с
              прокруткой)
────────────────────────────────────────────────────────────────

  procedure SetMaxScroll(MaxFirstCol : Word);
    {-Задать новое значение для максимальной горизонтальной
      прокрутки}

  procedure SetSendFunc(SF : shSendFunc);

                            - 54 -
    {-Задать функцию, которая должна быть вызвана командной
      ccBlkCopy (копирование блока)}

  procedure SetBlockAttr(Color, Mono : Byte);
    {-Задать атрибут для блоков}

  procedure ResetBlock;
    {-Скрыть и удалить текущий блок. Регенерации экрана не
      производится}

  procedure HideBlock;
    {-Скрыть текущий блок. Регенерации экрана не производится}

OpHelp        Процедуры и функции
────────────────────────────────────────────────────────────────

  function ScrollingHelpFile(HelpFile : PathStr) : Boolean;
    {-Возвратить значение True (истинно), если файл подсказки
      HelpFile создан для работы с окном подсказки, в котором
      реализована прокрутка}

  function DefaultTopicMatch(VaryingName, FixedName : String;
                             HPtr : AbstractHelpWindowPtr) : Boolean;
    {-Стандартная функция поиска эквивалентных элементов}

  function NoNestedAction(HPtr : AbstractHelpWindowPtr) : Boolean;
    {-Стандартная функция обработки перекрестных ссылок,
      которая не выполняет никаких действий}

OpMemo        Объект Memo (Меморандум (комментарий))
────────────────────────────────────────────────────────────────

  constructor Init(X1, Y1, X2, Y2 : Byte;
                   BufferSize : Word;
                   BufPtr : Pointer);
    {-Создать окно мемо}

  constructor InitCustom(X1, Y1, X2, Y2 : Byte;
                         var Colors : ColorSet;
                         Options : LongInt;
                         BufferSize : Word;
                         BufPtr : Pointer);
    {-Создать окно мемо с произвольными параметрами окна}

  destructor Done; virtual;
    {-Возвратить в систему память, которую занимал текстовый
      буфер (если это необходимо)}

  procedure Process; virtual;
    {-Обработать команды редактирования}

  procedure ReinitBuffer;
    {-Реинициализировать внутренние переменные при изменении
      содержимого буфера}

                            - 55 -

  procedure meOptionsOn(OptionFlags : LongInt);
    {-Задать несколько параметров-флагов}

  procedure meOptionsOff(OptionFlags : LongInt);
    {-Отменить несколько параметров-флагов}

  function meOptionsAreOn(OptionFlags : LongInt) : Boolean;
    {-Возвратить значение True (истинно), если все указанные
      параметры заданы}

  procedure SetCtrlAttr(Color, Mono : Byte);
    {-Задать атрибуты для управляющих символов}

  procedure SetStatusProc(MSP : MemoStatusProc);
    {-Задать процедуру статуса (состояния)}

  procedure SetLineLimit(N : Integer);
    {-Задать предел на число строк}

  procedure SetTabSize(TabSize : Byte);
    {-Задать размер для фиксированных табуляций}

  procedure SetRightMargin(RM : Byte);
    {-Задать правое поле}

  procedure SetMaxLength(Len : Byte);
    {-Задать максимальную длину строки}

  constructor Load(var S : IdStream);
    {-Загрузить мемо из потока}

  procedure Store(var S : IdStream);
    {-Занести мемо в поток}

OpMemo        Объект MemoFile (Файл меморандума (комментария))
────────────────────────────────────────────────────────────────

  constructor Init(X1, Y1, X2, Y2 : Byte;
                   BufferSize : Word;
                   BufPtr : Pointer);
    {-Создать окно мемо для редактирования файлов}

  constructor InitCustom(X1, Y1, X2, Y2 : Byte;
                         var Colors : ColorSet;
                         Options : LongInt;
                         BufferSize : Word;
                         BufPtr : Pointer);
    {-Создать окно мемо для редактирования файлов}

  constructor InitAndAlloc(X1, Y1, X2, Y2 : Byte;
                           BufferSize : Word);
    {-Создать окно мемо для редактирования файлов и выделить буфер}


                            - 56 -
  constructor InitCustomAndAlloc(X1, Y1, X2, Y2 : Byte;
                                 var Colors : ColorSet;
                                 Options : LongInt;
                                 BufferSize : Word);
    {-Создать окно мемо для редактирования файлов и выделить буфер}

  procedure ReadFile(FName : string; var FSize : LongInt);
    {-Считать файл в буфер, возвращая код состояния}

  procedure SaveFile;
    {-Сохранить содержимое текстового буфера в файле mfFileName}

  constructor Load(var S : IdStream);
    {-Загрузить файл мемо из потока}

  procedure Store(var S : IdStream);
    {-Занести файл мемо в поток}

OpMemo        Процедуры и функции
────────────────────────────────────────────────────────────────

  procedure MemoStatus(MP : MemoPtr);
    {-Отобразить строку состояния}

  procedure MemoError(UnitCode : Byte;
                      var ErrorCode : Word; ErrorMsg : string);
    {-Отобразить сообщение об ошибке и ждать нажатия клавиши}

OpEditor      Объект TextEditor (редактор текста)
────────────────────────────────────────────────────────────────

  constructor Init(X1, Y1, X2, Y2 : Byte; BufferSize : Word);
    {-Создать окно для редактирования файлов}

  constructor InitCustom(X1, Y1, X2, Y2 : Byte;
                         var Colors : ColorSet;
                         Options : LongInt;
                         BufferSize : Word);
    {-Создать окно с произвольными параметрами для редактирования
      файлов}

  constructor InitBuf(X1, Y1, X2, Y2 : Byte;
                      BufferSize : Word;
                      BufPtr : Pointer);
    {-Создать окно для редактирования файлов, буфер уже выделен}

  constructor InitBufCustom(X1, Y1, X2, Y2 : Byte;
                            var Colors : ColorSet;
                            Options : LongInt;
                            BufferSize : Word;
                            BufPtr : Pointer);
    {-Создать окно с произвольными параметрами для редактирования
      файлов, буфер уже выделен}


                            - 57 -
  procedure Process; virtual;
    {-Обработать команды редактирования}

  procedure teOptionsOn(OptionFlags : LongInt);
    {-Задать несколько параметров-флагов}

  procedure teOptionsOff(OptionFlags : LongInt);
    {-Отменить несколько параметров-флагов}

  function teOptionsAreOn(OptionFlags : LongInt) : Boolean;
    {-Возвратить значение True (истинно), если все указанные
      параметры заданы}

  procedure SetEditProc(EF : EditorEditFunc);
    {-Задать функцию редактирования}

  procedure SetGetFileProc(GFF : EditorGetFileFunc);
    {-Задать функцию получения файла}

  procedure SetYesNoProc(YNF : EditorYesNoFunc);
    {-Задать функцию "Да-Нет"}

  procedure SetBlockAttr(Color, Mono : Byte);
    {-Задать атрибуты для выделенных блоков}

  procedure SetMarkerAttr(Color, Mono : Byte);
    {-Задать атрибуты для текстовых маркеров}

  procedure SetHighlightAttr(Color, Mono : Byte);
    {-Задать атрибуты для выделенного световым маркером (найденного)
      текста}

  procedure SetBlockIndent(Indent : Byte);
    {-Задать уровень структурного отступа блока}

  procedure SetDefaultExtension(DefExt : ExtStr);
    {-Стандартное расширение, которое должно использоваться для
      запроса имен файлов}

  procedure SetPrinter(LptNum : Byte);
    {-Задать принтер (1-3)}

  procedure GotoLineCol(LineNum : Integer; Col : Byte);
    {-Переместить курсор к строке и столбцу LineNum, Col. Не должна
      вызываться до тех пор, пока окно редактора не было отображено
      по меньшей мере один раз.}

  procedure GotoOffset(Offset : Word);
    {-Переместить курсор к заданному смещению в текстовом буфере.
      Не должна вызываться до тех пор, пока окно редактора не
      было отображено по меньшей мере один раз.}

  procedure InsertTextAtCursor(var Data; Bytes : Word);
    {-Вставить заданное число байтов данных в текстовый буфер в позиции

                            - 58 -
      курсора}

  procedure InsertStringAtCursor(S : String);
    {-Вставить строку S в текстовый буфер в позиции курсора}

  constructor Load(var S : IdStream);
    {-Загрузить текстовый редактор из потока}

  procedure Store(var S : IdStream);
    {-Занести текстовый редактор в поток}

OpBrowser     Объект Browser (модуль просмотра текста)
────────────────────────────────────────────────────────────────

  constructor Init(X1, Y1, X2, Y2 : Byte; HeapToUse : LongInt);
    {-Инициализировать модуль просмотра текста}

  constructor InitCustom(X1, Y1, X2, Y2 : Byte;
                         var Colors : ColorSet;
                         Options : LongInt;
                         HeapToUse : LongInt);
    {-Инициализировать модуль просмотра текста с произвольными
      параметрами окна}

  destructor Done; virtual;
    {-Вернуть системе память, которые занимали буферы страниц}

  procedure Process; virtual;
    {-Обработать команды просмотра текста}

  procedure OpenFile(FName : String);
    {-Открыть файл для просмотра текста}

  procedure CloseFile;
    {-Закрыть текущий просматриваемый файл}

  function CurrentFileName : String;
    {-Возвратить имя текущего просматриваемого файла}

  procedure brOptionsOn(OptionFlags : Word);
    {-Задать несколько параметров-флагов}

  procedure brOptionsOff(OptionFlags : Word);
    {-Отменить несколько параметров-флагов}

  function brOptionsAreOn(OptionFlags : Word) : Boolean;
    {-Возвратить значение True (истинно), если все указанные
      параметры заданы}

  procedure ToggleModes;
    {-Переключить между режимами просмотра шестнадцатеричных значений
      и просмотра в символах кодов ASCII}

  procedure ToggleHighBitStripping;

                            - 59 -
    {-Переключить отсечение старших разрядов}

  procedure SetDefaultExtension(DefExt : ExtStr);
    {-Стандартное расширение, которое используется для запросов
      имен файлов}

  procedure SetPrinter(LptNum : Byte);
    {-Задать принтер (1-3)}

  procedure SetStatusProc(SP : BrowseStatusProc);
    {-Задать процедуру статуса (состояния)}

  procedure SetEditProc(EF : BrowseEditFunc);
    {-Задать функцию редактирования}

  procedure SetGetFileProc(GF : BrowseGetFileFunc);
    {-Задать функцию редактирования}

  procedure SetBlockAttr(Color, Mono : Byte);
    {-Задать атрибуты для выделенных блоков}

  procedure SetMarkerAttr(Color, Mono : Byte);
    {-Задать атрибуты для текстовых маркеров}

  procedure SetHighlightAttr(Color, Mono : Byte);
    {-Задать атрибуты для найденного текста}

  constructor Load(var S : IdStream);
    {-Загрузить модуль просмотра текстов из потока}

  procedure Store(var S : IdStream);
    {-Занести модуль просмотра текстов в поток}

  procedure GotoLine(LineNum : Word);
    {-Осуществить прокрутку изображения до заданной строки}

  procedure GotoOffset(Offset : LongInt);
    {-Осуществить прокрутку изображения к строке, которая наиболее
      близко расположена к смещению Offset}

  procedure Transfer(StartPos, StopPos : LongInt;
                     var Buffer; BufSize : Word);
    {-Скопировать символы в окне просмотра текстов с позиции
      StartPos по позицию StopPos в буфер Buffer}

OpBrowser     Процедуры и функции
────────────────────────────────────────────────────────────────

  procedure BrowseStatus(BP : BrowserPtr);
    {-Отобразить строку состояния}

OpAbsFld      Процедуры и функции
────────────────────────────────────────────────────────────────


                            - 60 -
  procedure ChangeDecimalChar(DC : Char);
    {-Изменить использовавшийся ранее символ десятичной точки
      DecimalChar, задав его равным DC}

  function InternationalCurrency(FormChar : Char; MaxDigits : Byte;
                                 FloatIfPossible : Boolean;
                                 AddCommas : Boolean) : string;
    {-Возвратить маску форматирования для строки, содержащей валютные
      символы, на основании кода страны, полученного из DOS}

OpField       Объект SelectField (поле выбора)
────────────────────────────────────────────────────────────────

  procedure sfOptionsOn(OptionFlags : LongInt);
    {-Задать несколько параметров-флагов}

  procedure sfOptionsOff(OptionFlags : LongInt);
    {-Отменить несколько параметров-флагов}

  function sfOptionsAreOn(OptionFlags : LongInt) : Boolean;
    {-Возвратить значение True (истинно), если все указанные
      параметры заданы}

  procedure SetPromptAttr(Color, Mono : Byte);
    {-Задать атрибуты для запросов}

  procedure SetSelectedPromptAttr(Color, Mono : Byte);
    {-Задать атрибуты для выделенных запросов}

  procedure SetProtectedPromptAttr(Color, Mono : Byte);
    {-Задать атрибуты для защищенных запросов}

  procedure SetFieldAttr(Color, Mono : Byte);
    {-Задать атрибуты для невыбранных полей}

  procedure SetSelectedFieldAttr(Color, Mono : Byte);
    {-Задать атрибуты для выбранных полей}

  procedure SetProtectedFieldAttr(Color, Mono : Byte);
    {-Задать атрибуты для защищенных полей}

  procedure SetCtrlAttr(Color, Mono : Byte);
    {-Задать атрибуты для управляющих символов}

OpField       Объект EntryField (поле ввода)
────────────────────────────────────────────────────────────────

  procedure efOptionsOn(OptionFlags : LongInt);
    {-Задать несколько параметров-флагов}

  procedure efOptionsOff(OptionFlags : LongInt);
    {-Отменить несколько параметров-флагов}

  function efOptionsAreOn(OptionFlags : LongInt) : Boolean;

                            - 61 -
    {-Возвратить значение True (истинно), если все указанные
      параметры заданы}

  procedure sefOptionsOn(OptionFlags : LongInt);
    {-Задать несколько вторичных параметров-флагов}

  procedure sefOptionsOff(OptionFlags : LongInt);
    {-Отменить несколько вторичных параметров-флагов}

  function sefOptionsAreOn(OptionFlags : LongInt) : Boolean;
    {-Возвратить значение True (истинно), если все указанные
      вторичные параметры заданы}

OpField       Процедуры и функции
────────────────────────────────────────────────────────────────

  function ValidateNoBlanks(EFP : EntryFieldPtr;
                            var ErrCode : Word;
                            var ErrorSt : StringPtr) : Boolean;
    {-Удостовериться, что никакие используемые субполя в строке
      не содержат пробелов}

  function ValidateNotPartial(EFP : EntryFieldPtr;
                              var ErrCode : Word;
                              var ErrorSt : StringPtr) : Boolean;
    {-Удостовериться, что никакие используемые субполя в строке
      не содержат пробелов (за исключением ситуации, когда пробелы
      содержатся во всех полях}

  function ValidateSubfields(SubfieldMask : string;
                             EFP : EntryFieldPtr;
                             var ErrCode : Word;
                             var ErrorSt : StringPtr) : Boolean;
    {-Удостовериться, что все субполя в строке удовлетворяют условию,
      которое задано маской субполя SubfieldMask. Примечание: данная
      функция НЕ является стандартной подпрограммой проверки допусти-
      мости. Она должна вызываться только подпрограммами проверки
      достоверности более высокого уровня, которые содержат маску
      субполя SubfieldMask, задаваемую данной подпрограмме.}

OpSelect      Объект AbstractSelector (абстрактный селектор)
────────────────────────────────────────────────────────────────

  constructor InitCustom(X1, Y1, X2, Y2 : Byte;
                         var Colors : ColorSet;
                         Options : LongInt;
                         var CP : CommandProcessor;
                         UnitCode : Byte);
    {-Инициализировать абстрактный селектор с задание произвольных
      параметров окна}

  destructor Done; virtual;
    {-Вернуть системе память, которые занимал список полей и
      и экранные буферы}

                            - 62 -

  procedure DrawField(ID : Word);
    {-Отобразить указанное поле}

  procedure ResetScreen;
    {-Вызвать, когда содержимое поля (полей) изменилось без вызова
      процедуры DrawField}

  procedure SetWrapMode(WM : WrapMode);
    {-Задать режим переноса слов для селектора}

  procedure SetScreenUpdateProc(SUP : ScreenUpdateProc);
    {-Задать процедуру, которая должна быть вызвана после полного
      обновления экрана}

  procedure SetPromptAttr(Color, Mono : Byte);
    {-Задать атрибуты для запросов}

  procedure SetSelectedPromptAttr(Color, Mono : Byte);
    {-Задать атрибуты для выделенных запросов}

  procedure SetProtectedPromptAttr(Color, Mono : Byte);
    {-Задать атрибуты для защищенных запросов}

  procedure SetFieldAttr(Color, Mono : Byte);
    {-Задать атрибуты для невыбранных полей}

  procedure SetSelectedFieldAttr(Color, Mono : Byte);
    {-Задать атрибуты для выбранных полей}

  procedure SetProtectedFieldAttr(Color, Mono : Byte);
    {-Задать атрибуты для защищенных полей}

  procedure SetCtrlAttr(Color, Mono : Byte);
    {-Задать атрибуты для управляющих символов}

  procedure ChangePromptAttr(ID : Word; Color, Mono : Byte);
    {-Изменить атрибуты для запросов}

  procedure ChangeSelectedPromptAttr(ID : Word; Color, Mono : Byte);
    {-Изменить атрибуты для выделенных запросов}

  procedure ChangeProtectedPromptAttr(ID : Word; Color, Mono : Byte);
    {-Изменить атрибуты для защищенных запросов}

  procedure ChangeFieldAttr(ID : Word; Color, Mono : Byte);
    {-Изменить атрибуты для невыбранных полей}

  procedure ChangeSelectedFieldAttr(ID : Word; Color, Mono : Byte);
    {-Изменить атрибуты для выбранных полей}

  procedure ChangeProtectedFieldAttr(ID : Word; Color, Mono : Byte);
    {-Изменить атрибуты для защищенных полей}


                            - 63 -
  procedure ChangeCtrlAttr(ID : Word; Color, Mono : Byte);
    {-Изменить атрибуты для управляющих символов}

  procedure AddTextField(St : string; Row, Col : Word);
    {-Добавить текстовое поле}

  procedure AddTextFieldCustom(St : string; Row, Col : Word;
                               Color, Mono : Byte);
    {-Добавить текстовое поле с произвольными значениями цветов}

  procedure AddTextFieldDeluxe(St : string; Row, Col : Word;
                               var ColorAttrs,
                               MonoAttrs : FlexAttrs);
    {-Добавить текстовое поле со специальными цветами}

  function FindField(ID : Word) : SelectFieldPtr;
    {-Возвратить указатель на заданное поле}

  function FindTextField(ID : Word) : TextFieldPtr;
    {-Возвратить указатель на заданное текстовое поле}

  procedure SetNextField(ID : Word);
    {-Задать значение поля asNext}

  function GetCurrentID : Word;
    {-Получить идентификатор ID для текущего поля}

  function GetHelpIndex(ID : Word) : Word;
    {-Получить значение индекса подсказки для заданного поля}

  procedure SetAllFieldLinks(var LinksMap);
    {-Задать ссылки вперед и назад для всех полей}

  procedure SetFieldLinks(ID, Next, Prev : Word);
    {-Задать поля, к которым будет осуществляться переход по
      нажатию клавиш <Tab> или <ShTab> в данном поле}

  procedure ChangeProtection(ID : Word; On : Boolean);
    {-Изменить статус защиты для заданного поля}

  procedure ChangeHidden(ID : Word; On : Boolean);
    {-Изменить статус скрытого поля для заданного поля}

  procedure ChangeInvisibility(ID : Word; On : Boolean);
    {-Изменить статус невидимости для заданного поля}

  procedure PositionCursorAt(SFP : SelectFieldPtr); virtual;
    {-Устанавливает курсор на начало заданного поля}

  procedure VisitAllSelectFields(FProc : asFieldProc; var D);
    {-Вызвать указанную процедуру для всех полей в селекторе}

  procedure VisitAllTextFields(FProc : asTextFieldProc; var D);
    {-Вызвать указанную процедуру для всех текстовых полей

                            - 64 -
      в селекторе}

OpSelect      Объект Selector (селектор)
────────────────────────────────────────────────────────────────

  constructor Init(X1, Y1, X2, Y2 : Byte);
    {-Инициализировать селектор}

  constructor InitCustom(X1, Y1, X2, Y2 : Byte;
                         var Colors : ColorSet;
                         Options : LongInt);
    {-Инициализировать селектор с произвольными параметрами окна}

  procedure Process; virtual;
    {-Обработать команды выбора}

  procedure AddField(PromptRow, PromptCol : Word;
                     PromptWidth : Byte;
                     FieldRow, FieldCol : Word;
                     FieldWidth : Byte;
                     HelpIndex : Word);
    {-Добавить поле с заданными координатами и индексом подсказки}

  procedure slOptionsOn(OptionFlags : Byte);
    {-Задать несколько параметров-флагов}

  procedure slOptionsOff(OptionFlags : Byte);
    {-Отменить несколько параметров-флагов}

  function slOptionsAreOn(OptionFlags : Byte) : Boolean;
    {-Возвратить значение True (истинно), если все указанные
      параметры заданы}

  procedure slFieldOptionsOn(OptionFlags : LongInt);
    {-Задать несколько параметров-флагов}

  procedure slFieldOptionsOff(OptionFlags : LongInt);
    {-Отменить несколько параметров-флагов}

  function slFieldOptionsAreOn(OptionFlags : LongInt) : Boolean;
    {-Возвратить значение True (истинно), если все указанные
      параметры заданы}

  procedure SetGetFieldProc(GFP : GetFieldProc);
    {-Задать подпрограмму, которая вызывается для получения
      отображаемых строк}

  procedure SetActionProc(AP : SelectProc);
    {-Задать подпрограмму, которая вызывается, когда поле
      становится выбранным}

  procedure SetPreSelectProc(PSP : SelectProc);
    {-Задать подпрограмму, которая вызывается перед перемещением
      к новому полю}

                            - 65 -

  procedure SetPostSelectProc(PSP : SelectProc);
    {-Задать подпрограмму, которая вызывается перед перемещением
      к следующему полю}

  constructor Load(var S : IdStream);
    {-Загрузить селектор из потока}

  procedure Store(var S : IdStream);
    {-Занести селектор в поток}

OpSelect      Объект ScrollingSelector (селектор с прокруткой)
────────────────────────────────────────────────────────────────

  constructor Init(X1, Y1, X2, Y2 : Byte);
    {-Инициализировать селектор}

  constructor InitCustom(X1, Y1, X2, Y2 : Byte;
                         var Colors : ColorSet;
                         Options : LongInt);
    {-Инициализировать селектор с произвольными параметрами окна}

  destructor Done; virtual;
    {-Вернуть в систему память, которую занимали список полей и
      буферы экрана}

  procedure AllocateScreen;
    {-Call after last field added to allocate virtual screen}

  procedure VScreenToScreen; virtual;
    {-Копировать виртуальный экран на физический экран}

  constructor Load(var S : IdStream);
    {-Загрузить селектор из потока}

  procedure Store(var S : IdStream);
    {-Занести селектор в поток}

OpEntry       Объект EntryScreen (экран ввода)
────────────────────────────────────────────────────────────────

  constructor Init(X1, Y1, X2, Y2 : Byte);
    {-Инициализировать экран ввода}

  constructor InitCustom(X1, Y1, X2, Y2 : Byte;
                         var Colors : ColorSet;
                         Options : LongInt);
    {-Инициализировать экран ввода с произвольными параметрами окна}

  destructor Done; virtual;
    {-Вернуть в систему память, которую занимал экран ввода}

  procedure Process; virtual;
    {-Обработать команды ввода данных}

                            - 66 -

  procedure AddStringField(Prompt : string;
                           pRow, pCol : Word;
                           Picture : string;
                           fRow, fCol : Word;
                           fWidth : Byte;
                           HelpIndex : Word;
                           var EditSt : string);
    {-Добавить поле типа string (строка)}

  procedure AddSimpleStringField(Prompt : string;
                                 pRow, pCol : Word;
                                 PicChar : Char;
                                 fRow, fCol : Word;
                                 fWidth, MaxLen : Byte;
                                 HelpIndex : Word;
                                 var EditSt : string);
    {-Добавить поле типа string (простое)}

  procedure AddArrayField(Prompt : string;
                          pRow, pCol : Word;
                          Picture : string;
                          fRow, fCol : Word;
                          fWidth : Byte;
                          HelpIndex : Word;
                          var EditVar);
    {-Добавить поле типа массив (символов) array (of char)}

  procedure AddCharField(Prompt : string;
                         pRow, pCol : Word;
                         Picture : string;
                         fRow, fCol : Word;
                         HelpIndex : Word;
                         CharLo, CharHi : Char;
                         var EditChar : Char);
    {-Добавить поле типа char (символ)}

  procedure AddSimpleCharField(Prompt : string;
                               pRow, pCol : Word;
                               PicChar : Char;
                               fRow, fCol : Word;
                               HelpIndex : Word;
                               CharLo, CharHi : Char;
                               var EditChar : Char);
    {-Добавить поле типа char (символ) (простое)}

  procedure AddBooleanField(Prompt : string;
                            pRow, pCol : Word;
                            Picture : string;
                            fRow, fCol : Word;
                            HelpIndex : Word;
                            var EditBool : Boolean);
    {-Добавить поле типа boolean (логическое, булево)}


                            - 67 -
  procedure AddSimpleBooleanField(Prompt : string;
                                  pRow, pCol : Word;
                                  fRow, fCol : Word;
                                  HelpIndex : Word;
                                  var EditBool : Boolean);
    {-Добавить поле типа boolean (логическое, булево) (простое)}

  procedure AddYesNoField(Prompt : string;
                          pRow, pCol : Word;
                          Picture : string;
                          fRow, fCol : Word;
                          HelpIndex : Word;
                          var EditYesNo : Boolean);
    {-Добавить поле типа yes/no (да/нет)}

  procedure AddSimpleYesNoField(Prompt : string;
                                pRow, pCol : Word;
                                fRow, fCol : Word;
                                HelpIndex : Word;
                                var EditYesNo : Boolean);
    {-Добавить поле типа yes/no (да/нет) (простое)}

  procedure AddLongField(Prompt : string;
                         pRow, pCol : Word;
                         Picture : string;
                         fRow, fCol : Word;
                         HelpIndex : Word;
                         LongLo, LongHi : LongInt;
                         var EditLong : LongInt);
    {-Добавить поле типа LongInt (длинное целое)}

  procedure AddNumericLongField(Prompt : string;
                                pRow, pCol : Word;
                                Picture : string;
                                fRow, fCol : Word;
                                HelpIndex : Word;
                                LongLo, LongHi : LongInt;
                                var EditLong : LongInt);
    {-Добавить поле типа LongInt (длинное целое) (числовое)}

  procedure AddSimpleLongField(Prompt : string;
                               pRow, pCol : Word;
                               PicChar : Char;
                               fRow, fCol : Word;
                               fWidth : Byte;
                               HelpIndex : Word;
                               LongLo, LongHi : LongInt;
                               var EditLong : LongInt);
    {-Добавить поле типа LongInt (длинное целое) (простое)}

  procedure AddWordField(Prompt : string;
                         pRow, pCol : Word;
                         Picture : string;
                         fRow, fCol : Word;

                            - 68 -
                         HelpIndex : Word;
                         WordLo, WordHi : Word;
                         var EditWord : Word);
    {-Добавить поле типа word (слово)}

  procedure AddNumericWordField(Prompt : string;
                                pRow, pCol : Word;
                                Picture : string;
                                fRow, fCol : Word;
                                HelpIndex : Word;
                                WordLo, WordHi : Word;
                                var EditWord : Word);
    {-Добавить поле типа word (слово) (числовое)}

  procedure AddSimpleWordField(Prompt : string;
                               pRow, pCol : Word;
                               PicChar : Char;
                               fRow, fCol : Word;
                               fWidth : Byte;
                               HelpIndex : Word;
                               WordLo, WordHi : Word;
                               var EditWord : Word);
    {-Добавить поле типа word (слово) (простое)}

  procedure AddIntField(Prompt : string;
                        pRow, pCol : Word;
                        Picture : string;
                        fRow, fCol : Word;
                        HelpIndex : Word;
                        IntLo, IntHi : Integer;
                        var EditInt : Integer);
    {-Добавить поле типа integer (целое)}

  procedure AddNumericIntField(Prompt : string;
                               pRow, pCol : Word;
                               Picture : string;
                               fRow, fCol : Word;
                               HelpIndex : Word;
                               IntLo, IntHi : Integer;
                               var EditInt : Integer);
    {-Добавить поле типа integer (целое) (числовое)}

  procedure AddSimpleIntField(Prompt : string;
                              pRow, pCol : Word;
                              PicChar : Char;
                              fRow, fCol : Word;
                              fWidth : Byte;
                              HelpIndex : Word;
                              IntLo, IntHi : Integer;
                              var EditInt : Integer);
    {-Добавить поле типа integer (целое) (простое)}

  procedure AddByteField(Prompt : string;
                         pRow, pCol : Word;

                            - 69 -
                         Picture : string;
                         fRow, fCol : Word;
                         HelpIndex : Word;
                         ByteLo, ByteHi : Byte;
                         var EditByte : Byte);
    {-Добавить поле типа byte (байт)}

  procedure AddNumericByteField(Prompt : string;
                                pRow, pCol : Word;
                                Picture : string;
                                fRow, fCol : Word;
                                HelpIndex : Word;
                                ByteLo, ByteHi : Byte;
                                var EditByte : Byte);
    {-Добавить поле типа byte (байт) (числовое)}

  procedure AddSimpleByteField(Prompt : string;
                               pRow, pCol : Word;
                               PicChar : Char;
                               fRow, fCol : Word;
                               fWidth : Byte;
                               HelpIndex : Word;
                               ByteLo, ByteHi : Byte;
                               var EditByte : Byte);
    {-Добавить поле типа byte (байт) (простое)}

  procedure AddShortField(Prompt : string;
                          pRow, pCol : Word;
                          Picture : string;
                          fRow, fCol : Word;
                          HelpIndex : Word;
                          ShortLo, ShortHi : ShortInt;
                          var EditShort : ShortInt);
    {-Добавить поле типа shortint (короткое целое)}

  procedure AddNumericShortField(Prompt : string;
                                 pRow, pCol : Word;
                                 Picture : string;
                                 fRow, fCol : Word;
                                 HelpIndex : Word;
                                 ShortLo, ShortHi : ShortInt;
                                 var EditShort : ShortInt);
    {-Добавить поле типа shortint (короткое целое) (числовое)}

  procedure AddSimpleShortField(Prompt : string;
                                pRow, pCol : Word;
                                PicChar : Char;
                                fRow, fCol : Word;
                                fWidth : Byte;
                                HelpIndex : Word;
                                ShortLo, ShortHi : ShortInt;
                                var EditShort : ShortInt);
    {-Добавить поле типа shortint (короткое целое) (простое)}


                            - 70 -
  procedure AddRealField(Prompt : string;
                         pRow, pCol : Word;
                         Picture : string;
                         fRow, fCol : Word;
                         HelpIndex : Word;
                         RealLo, RealHi : Real;
                         Places : Byte;
                         var EditReal : Real);
    {-Добавить поле типа real (действительное)}

  procedure AddNumericRealField(Prompt : string;
                                pRow, pCol : Word;
                                Picture : string;
                                fRow, fCol : Word;
                                HelpIndex : Word;
                                RealLo, RealHi : Real;
                                Places : Byte;
                                var EditReal : Real);
    {-Добавить поле типа real (действительное) (числовое)}

  procedure AddSimpleRealField(Prompt : string;
                               pRow, pCol : Word;
                               PicChar : Char;
                               fRow, fCol : Word;
                               fWidth : Byte;
                               HelpIndex : Word;
                               RealLo, RealHi : Real;
                               Places : Byte;
                               var EditReal : Real);
    {-Добавить поле типа real (действительное) (простое)}

  procedure AddBcdField(Prompt : string;
                        pRow, pCol : Word;
                        Picture : string;
                        fRow, fCol : Word;
                        HelpIndex : Word;
                        BcdLo, BcdHi : BCD;
                        Places : Byte;
                        var EditBcd : BCD);
    {-Добавить поле типа BCD (двоично-десятичное)}

  procedure AddNumericBcdField(Prompt : string;
                               pRow, pCol : Word;
                               Picture : string;
                               fRow, fCol : Word;
                               HelpIndex : Word;
                               BcdLo, BcdHi : BCD;
                               Places : Byte;
                               var EditBcd : BCD);
    {-Добавить поле типа BCD (двоично-десятичное) (числовое)}

  procedure AddSimpleBcdField(Prompt : string;
                              pRow, pCol : Word;
                              PicChar : Char;

                            - 71 -
                              fRow, fCol : Word;
                              fWidth : Byte;
                              HelpIndex : Word;
                              BcdLo, BcdHi : BCD;
                              Places : Byte;
                              var EditBcd : BCD);
    {-Добавить поле типа BCD (двоично-десятичное) (простое)}

  procedure AddExtField(Prompt : string;
                        pRow, pCol : Word;
                        Picture : string;
                        fRow, fCol : Word;
                        HelpIndex : Word;
                        ExtLo, ExtHi : Extended;
                        Places : Byte;
                        var EditExt : Extended);
    {-Добавить поле типа extended}

  procedure AddNumericExtField(Prompt : string;
                               pRow, pCol : Word;
                               Picture : string;
                               fRow, fCol : Word;
                               HelpIndex : Word;
                               ExtLo, ExtHi : Extended;
                               Places : Byte;
                               var EditExt : Extended);
    {-Добавить поле типа extended (числовое)}

  procedure AddSimpleExtField(Prompt : string;
                              pRow, pCol : Word;
                              PicChar : Char;
                              fRow, fCol : Word;
                              fWidth : Byte;
                              HelpIndex : Word;
                              ExtLo, ExtHi : Extended;
                              Places : Byte;
                              var EditExt : Extended);
    {-Добавить поле типа extended (простое)}

  procedure AddDblField(Prompt : string;
                        pRow, pCol : Word;
                        Picture : string;
                        fRow, fCol : Word;
                        HelpIndex : Word;
                        DblLo, DblHi : Double;
                        Places : Byte;
                        var EditDbl : Double);
    {-Добавить поле типа double}

  procedure AddNumericDblField(Prompt : string;
                               pRow, pCol : Word;
                               Picture : string;
                               fRow, fCol : Word;
                               HelpIndex : Word;

                            - 72 -
                               DblLo, DblHi : Double;
                               Places : Byte;
                               var EditDbl : Double);
    {-Добавить поле типа double (числовое)}

  procedure AddSimpleDblField(Prompt : string;
                              pRow, pCol : Word;
                              PicChar : Char;
                              fRow, fCol : Word;
                              fWidth : Byte;
                              HelpIndex : Word;
                              DblLo, DblHi : Double;
                              Places : Byte;
                              var EditDbl : Double);
    {-Добавить поле типа double (числовое) (простое)}

  procedure AddSglField(Prompt : string;
                        pRow, pCol : Word;
                        Picture : string;
                        fRow, fCol : Word;
                        HelpIndex : Word;
                        SglLo, SglHi : Single;
                        Places : Byte;
                        var EditSgl : Single);
    {-Добавить поле типа single}

  procedure AddNumericSglField(Prompt : string;
                               pRow, pCol : Word;
                               Picture : string;
                               fRow, fCol : Word;
                               HelpIndex : Word;
                               SglLo, SglHi : Single;
                               Places : Byte;
                               var EditSgl : Single);
    {-Добавить поле типа single (числовое)}

  procedure AddSimpleSglField(Prompt : string;
                              pRow, pCol : Word;
                              PicChar : Char;
                              fRow, fCol : Word;
                              fWidth : Byte;
                              HelpIndex : Word;
                              SglLo, SglHi : Single;
                              Places : Byte;
                              var EditSgl : Single);
    {-Добавить поле типа single (простое)}

  procedure AddCompField(Prompt : string;
                         pRow, pCol : Word;
                         Picture : string;
                         fRow, fCol : Word;
                         HelpIndex : Word;
                         CompLo, CompHi : Comp;
                         var EditComp : Comp);

                            - 73 -
    {-Добавить поле типа comp}

  procedure AddNumericCompField(Prompt : string;
                                pRow, pCol : Word;
                                Picture : string;
                                fRow, fCol : Word;
                                HelpIndex : Word;
                                CompLo, CompHi : Comp;
                                var EditComp : Comp);
    {-Добавить поле типа comp (числовое)}

  procedure AddSimpleCompField(Prompt : string;
                               pRow, pCol : Word;
                               PicChar : Char;
                               fRow, fCol : Word;
                               fWidth : Byte;
                               HelpIndex : Word;
                               CompLo, CompHi : Comp;
                               var EditComp : Comp);
    {-Добавить поле типа comp (простое)}

  procedure AddDateField(Prompt : string;
                         pRow, pCol : Word;
                         Picture : DateString;
                         fRow, fCol : Word;
                         HelpIndex : Word;
                         DateLo, DateHi : Date;
                         var EditDate : Date);
    {-Добавить поле типа date (дата)}

  procedure AddDateStField(Prompt : string;
                           pRow, pCol : Word;
                           Picture : DateString;
                           fRow, fCol : Word;
                           HelpIndex : Word;
                           var EditDate : DateString);
    {-Добавить поле типа date string (строка даты)}

  procedure AddTimeField(Prompt : string;
                         pRow, pCol : Word;
                         Picture : DateString;
                         fRow, fCol : Word;
                         HelpIndex : Word;
                         TimeLo, TimeHi : Time;
                         var EditTime : Time);
    {-Добавить поле типа time (время)}

  procedure AddNestedField(Prompt : string;
                           pRow, pCol : Word;
                           Picture : string;
                           fRow, fCol : Word;
                           fWidth : Byte;
                           HelpIndex : Word);
    {-Добавить поле, которое связано с вложенной формой}

                            - 74 -

  procedure AddNestedStringField(Prompt : string;
                                 pRow, pCol : Word;
                                 Picture : string;
                                 fRow, fCol : Word;
                                 fWidth : Byte;
                                 HelpIndex : Word;
                                 var EditSt : string);
    {-Добавить строковое поле, которое связано с вложенной формой}

  procedure AddChoiceField(Prompt : string;
                           pRow, pCol : Word;
                           Picture : string;
                           fRow, fCol : Word;
                           HelpIndex : Word;
                           DataSize : Byte;
                           Increment : IncChoiceProc;
                           var EditVar);
    {-Добавить поле с несколькими вариантами выбора}

  procedure AddMultiLineField(Prompt : string;
                              pRow, pCol : Word;
                              PicChar : Char;
                              fRow, fCol : Word;
                              fWidth, fHeight : Byte;
                              HelpIndex : Word;
                              var EditVar);
    {-Добавить поле, состоящее из нескольких строк}

  procedure AddPickStringField(Prompt : string;
                               pRow, pCol : Word;
                               fRow, fCol : Word;
                               fWidth : Byte;
                               HelpIndex : Word;
                               var EditSt : string;
                               var PL : PickList);
    {-Добавить поле типа string (строка), которое должно
      редактироваться с помощью списка выбора}

  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);

                            - 75 -
    {-Добавить поле, тип которого определяется пользователем}

  procedure SetPreEditProc(PEP : esUserProc);
    {-Задать подпрограмму, которая должна вызываться непосредственно
      перед редактированием поля}

  procedure SetPostEditProc(PEP : esUserProc);
    {-Задать подпрограмму, которая должна вызываться непосредственно
      после редактирования каждого поля}

  procedure SetValidateFunc(UVF : esUserValidationFunc);
    {-Задать подпрограмму, которая должна вызываться перед выходом}

  procedure SetClearFirstFilter(CFF : ClearFirstFunc);
    {-Задать процедуру, которая должна вызываться для проверки
      на ClearFirstChar (удалить по первому символу)}

  procedure esOptionsOn(OptionFlags : Byte);
    {-Задать несколько параметров-флагов}

  procedure esOptionsOff(OptionFlags : Byte);
    {-Отменить несколько параметров-флагов}

  function esOptionsAreOn(OptionFlags : Byte) : Boolean;
    {-Возвратить значение True (истинно), если все указанные
      параметры заданы}

  procedure esFieldOptionsOn(OptionFlags : LongInt);
    {-Задать несколько параметров полей}

  procedure esFieldOptionsOff(OptionFlags : LongInt);
    {-Отменить несколько параметров полей}

  function esFieldOptionsAreOn(OptionFlags : LongInt) : Boolean;
    {-Возвратить значение True (истинно), если все указанные
      параметры полей заданы}

  procedure esSecFieldOptionsOn(OptionFlags : LongInt);
    {-Задать несколько вторичных параметров полей}

  procedure esSecFieldOptionsOff(OptionFlags : LongInt);
    {-Отменить несколько вторичных параметров полей}

  function esSecFieldOptionsAreOn(OptionFlags : LongInt) : Boolean;
    {-Возвратить значение True (истинно), если все указанные
      вторичные параметры полей заданы}

  procedure SetForceMode(Force, Overtype : Boolean);
    {-Устанавливать ли (Force) режим вставки или режим забивки
      (overtype), в противном случае использовать предыдущее значение
      параметра}

  procedure SetPadChar(Ch : Char);
    {-Задать символ, который используется для дополнения концов

                            - 76 -
      строк}

  procedure SetPasswordChar(Ch : Char);
    {-Задать символ, который используется в режиме пароля}

  procedure SetBeepOnError(On : Boolean);
    {-Задать/отменить параметр выдачи звукового сигнала при
      ошибке для всех полей}

  procedure SetDelimiters(Left, Right : Char);
    {-Задать разделители поля для экрана ввода (значение null
      (нулевое) соответствует отсутствию символа)}

  procedure SetDelimAttr(Color, Mono : Byte);
    {-Задать атрибуты для разделителей (невыбранных)}

  procedure SetSelectedDelimAttr(Color, Mono : Byte);
    {-Задать атрибуты для разделителей (выбранных)}

  procedure SetProtectedDelimAttr(Color, Mono : Byte);
    {-Задать атрибуты для разделителей (защищенных)}

  constructor Load(var S : IdStream);
    {-Загрузить экранный кадр из потока}

  procedure Store(var S : IdStream);
    {-Занести экранный кадр в поток}

  procedure SetUserRecord(var UserRec; UserRecSize : Word);
    {-Задать адрес и размер записи пользователя}

  function GetUserRecord : Pointer;
    {-Возвратить указатель на запись пользователя}

  function GetUserRecordSize : Word;
    {-Возвратить размер записи пользователя}

  procedure ChangeRequired(ID : Word; On : Boolean);
    {-Модифицировать статус "требуемый" поля после того
      как оно было добавлено}

  procedure ChangeValidation(ID : Word; VF : ValidationFunc);
    {-Изменить подпрограмму проверки допустимости для
      заданного поля}

  procedure ChangeConversion(ID : Word; CP : ConversionProc);
    {-Изменить подпрограмму преобразования для
      заданного поля}

  procedure ChangeRange(ID : Word; var RangeLo, RangeHi);
    {-Изменить диапазон допустимости значений для
      заданного поля}

  function CurrentFieldModified : Boolean;

                            - 77 -
    {-Возвратить значение True (истинно), если текущее поле было
      модифицировано. Вызывается только изнутри подпрограммы
      постредактирования.}

  function EvaluateCommand(var Cmd : Word) : Word;
    {-Для заданной команды возвращает идентификатор ID для того поля,
      к которому будет перемещен курсор. Команда Cmd может быть
      модифицирована при возврате. Эта подпрограмма предназначена
      для вызова только изнутри подпрограммы постредактирования!}

  procedure GetFieldCoordinates(var Row, Col, Wid : Byte);
    {-Возвращает абсолютные координаты экрана для текущего поля.
      Эта подпрограмма предназначена для вызова только изнутри
      подпрограммы предредактирования!}

  function GetLastField : EntryFieldPtr;
    {-Возвращает указатель на последнее поле в экране
      редактирования}

  function RevalidateAll(var EFP : EntryFieldPtr; var ErrCode : Word;
                         var ErrMsg : StringPtr) : Boolean;
    {-Осуществить повторную проверку допустимости всех незащищенных
      полей в экране ввода. Если обнаружена ошибка, функция, задан-
      ная переменной EFP, будет указывать на поле, которое вызвало
      ошибку, будут возвращены код ошибки и сообщение об ошибке,
      а функция RevalidateAll возвратит значение False (ложно).}

  procedure VisitAllEntryFields(FProc : esFieldProc; var D);
    {-Вызвать заданную процедуру для всех полей в экране ввода}

OpEntry       Объект ScrollingEntryScreen (экран ввода с прокруткой)
────────────────────────────────────────────────────────────────

  constructor Init(X1, Y1, X2, Y2 : Byte);
    {-Инициализировать экран ввода}

  constructor InitCustom(X1, Y1, X2, Y2 : Byte;
                         var Colors : ColorSet;
                         Options : LongInt);
    {-Инициализировать экран ввода с произвольными параметрами окна}

  destructor Done; virtual;
    {-Вернуть системе память, которую занимает список полей и
      буферы экрана}

  procedure AllocateScreen;
    {-Вызвать после того, как было добавлено последнее поле для
      того, чтобы выделить память для виртуального экрана}

  procedure VScreenToScreen; virtual;
    {-Копировать виртуальный экран на физический экран}

  constructor Load(var S : IdStream);
    {-Загрузить экран ввода с прокруткой из потока}

                            - 78 -

  procedure Store(var S : IdStream);
    {-Занести экран ввода с прокруткой в поток}

                            - 79 -

OpEdit        Объект LineEditor (строковый редактор)
────────────────────────────────────────────────────────────────

  constructor Init(var Colors : ColorSet);
    {-Задает стандартные значения для атрибутов и так далее}

  function GetLastCommand : Word;
    {-Возвратить последнюю команду, введенную пользователем}

  function GetLastKey : Word;
    {-Возвратить последний код клавиши, введенной пользователем}

  function GetLastError : Word;
    {-Возвратить код последней ошибки}

  procedure leEditOptionsOn(OptionFlags : LongInt);
    {-Задать несколько параметров-флагов}

  function leEditOptionsAreOn(OptionFlags : LongInt) : Boolean;
    {-Возвратить значение True (истинно), если все указанные
      параметры заданы}

  procedure leEditOptionsOff(OptionFlags : LongInt);
    {-Отменить несколько параметров-флагов}

  procedure leSecEditOptionsOn(OptionFlags : LongInt);
    {-Задать несколько вторичных параметров-флагов}

  function leSecEditOptionsAreOn(OptionFlags : LongInt) : Boolean;
    {-Возвратить значение True (истинно), если все указанные
      вторичные параметры заданы}

  procedure leSecEditOptionsOff(OptionFlags : LongInt);
    {-Отменить несколько вторичных параметров-флагов}

  procedure SetPadChar(Ch : Char);
    {-Задать символ, который заполняет пустоты в редактируемой строке}

  procedure SetPasswordChar(Ch : Char);
    {-Задать символ, который представляет текст в режиме ввода пароля}

  procedure SetHelpIndex(Index : Word);
    {-Задать индекс подсказки}

  procedure SetCommandProcessor(var CP : CommandProcessor);
    {-Задать используемый командный процессор}

  procedure SetErrorProc(EEP : ErrorProc);
    {-Задать процедуру, которая вызывается при возникновении ошибки}

  procedure SetClearFirstFilter(CFF : ClearFirstFunc);
    {-Задать процедуру, которая вызывается для проверки функцией
      ClearFirstChar}


                            - 80 -
  constructor Load(var S : IdStream);
    {-Загрузить строковый редактор из потока}

  procedure Store(var S : IdStream);
    {-Занести строковый редактор в поток}

  procedure ReadString(Prompt : string; Row, Col,
                       MaxLen, Width : Byte;
                       var St : string);
    {-Редактировать строку}

  procedure ReadSpecial(Prompt : string; Row, Col,
                        MaxLen, Width : Byte;
                        PictureChar : Char; var St : string);
    {-Редактировать строку}

  procedure ReadChar(Prompt : string; Row, Col : Byte;
                     ValidChars : CharSet; var Ch : Char);
    {-Отобразить запрос и ожидать ввода клавиши, которая принадлежит
      множеству символов, заданных в ValidChars}

  function YesOrNo(Prompt : string; Row, Col : Byte;
                   Default : Char) : Boolean;
    {-Возвратить значение true (истинно) (обозначающее yes (да)),
      или значение false (ложно) (обозначающее no (нет))}

  procedure ReadLongInt(Prompt : string; Row, Col, Width : Byte;
                        LLo, LHi : LongInt; var L : LongInt);
    {-Редактировать переменную типа long integer (длинное целое)}

  procedure ReadInteger(Prompt : string; Row, Col, Width : Byte;
                        NLo, NHi : Integer; var N : Integer);
    {-Редактировать переменную типа integer (целое)}

  procedure ReadWord(Prompt : string; Row, Col, Width : Byte;
                     WLo, WHi : Word; var W : Word);
    {-Редактировать переменную типа word (слово)}

  procedure ReadByte(Prompt : string; Row, Col, Width : Byte;
                     BLo, BHi : Byte; var B : Byte);
    {-Редактировать переменную типа byte (байт)}

  procedure ReadShortInt(Prompt : string; Row, Col, Width : Byte;
                         SLo, SHi : ShortInt; var SI : Shortint);
    {-Редактировать переменную типа ShortInt (короткое целое)}

  procedure ReadReal(Prompt : string; Row, Col, Width, Places : Byte;
                     RLo, RHi : Real; var R : Real);
    {-Редактировать переменную типа real (действительное)}

  procedure ReadBcd(Prompt : string; Row, Col, Width, Places : Byte;
                    BLo, BHi : Bcd; var B : BCD);
    {-Редактировать переменную типа BCD real
      (двоично-десятичное действительное)}

                            - 81 -

  procedure ReadExt(Prompt : string; Row, Col, Width, Places : Byte;
                    ELo, EHi : Extended; var E : Extended);
    {-Редактировать переменную типа extended}

  procedure ReadDbl(Prompt : string; Row, Col, Width, Places : Byte;
                    DLo, DHi : Double; var D : Double);
    {-Редактировать переменную типа double}

  procedure ReadSgl(Prompt : string; Row, Col, Width,
                    Places : Byte;
                    SLo, SHi : Single; var S : Single);
    {-Редактировать переменную типа single}

  procedure ReadComp(Prompt : string; Row, Col, Width : Byte;
                     CLo, CHi : Comp; var C : Comp);
    {-Редактировать переменную типа comp}

  procedure EditString(Prompt : string; Row, Col : Byte;
                       Picture : string;
                       Width : Byte; var St : string);
    {-Редактировать переменную типа string (строка)}

  procedure EditArray(Prompt : string; Row, Col : Byte;
                      Picture : string; Width : Byte; var A);
    {-Редактировать массив символов }

  procedure EditChar(Prompt : string; Row, Col : Byte;
                     Picture : string;
                     ChLo, ChHi : Char; var Ch : Char);
    {-Редактировать переменную типа char (символ)}

  procedure EditBoolean(Prompt : string; Row, Col : Byte;
                        Picture : string; var B : Boolean);
    {-Редактировать переменную типа boolean (булева)}

  procedure EditYesNo(Prompt : string; Row, Col : Byte;
                      Picture : string; var YN : Boolean);
    {-Редактировать переменную типа yes-no (да/нет)}

  procedure EditLongInt(Prompt : string; Row, Col : Byte;
                        Picture : string; LLo, LHi : LongInt;
                        var L : LongInt);
    {-Редактировать переменную типа long integer (длинное целое)}

  procedure EditNumericLongInt(Prompt : string; Row, Col : Byte;
                               Picture : string; LLo, LHi : LongInt;
                               var L : LongInt);
    {-Редактировать переменную типа long integer (числовую)}

  procedure EditInteger(Prompt : string; Row, Col : Byte;
                        Picture : string; NLo, NHi : Integer;
                        var N : Integer);
    {-Редактировать переменную типа integer (целое)}

                            - 82 -

  procedure EditNumericInteger(Prompt : string; Row, Col : Byte;
                               Picture : string; NLo, NHi : Integer;
                               var N : Integer);
    {-Редактировать переменную типа integer (целое) (числовую)}

  procedure EditWord(Prompt : string; Row, Col : Byte;
                     Picture : string; WLo, WHi : Word;
                     var W : Word);
    {-Редактировать переменную типа word (слово)}

  procedure EditNumericWord(Prompt : string; Row, Col : Byte;
                            Picture : string; WLo, WHi : Word;
                            var W : Word);
    {-Редактировать переменную типа word (слово) (числовую)}

  procedure EditByte(Prompt : string; Row, Col : Byte;
                     Picture : string; BLo, BHi : Byte;
                     var B : Byte);
    {-Редактировать переменную типа byte (байт)}

  procedure EditNumericByte(Prompt : string; Row, Col : Byte;
                            Picture : string; BLo, BHi : Byte;
                            var B : Byte);
    {-Редактировать переменную типа byte (байт) (числовую)}

  procedure EditShortInt(Prompt : string; Row, Col : Byte;
                         Picture : string; SLo, SHi : ShortInt;
                         var SI : Shortint);
    {-Редактировать переменную типа ShortInt (короткое целое)}

  procedure EditNumericShortInt(Prompt : string; Row, Col : Byte;
                                Picture : string;
                                SLo, SHi : ShortInt;
                                var SI : Shortint);
    {-Редактировать переменную типа ShortInt (короткое целое)
      (числовую)}

  procedure EditReal(Prompt : string; Row, Col : Byte;
                     Picture : string; Places : Byte;
                     RLo, RHi : Real; var R : Real);
    {-Редактировать переменную типа real (действительное)}

  procedure EditNumericReal(Prompt : string; Row, Col : Byte;
                            Picture : string; Places : Byte;
                            RLo, RHi : Real; var R : Real);
    {-Редактировать переменную типа real (действительное)
      (числовое)}

  procedure EditBcd(Prompt : string; Row, Col : Byte;
                    Picture : string;
                    Places : Byte; BLo, BHi : Bcd;
                    var B : BCD);
    {-Редактировать переменную типа BCD real

                            - 83 -
      (двоично-десятичное целое)}

  procedure EditNumericBcd(Prompt : string; Row, Col : Byte;
                           Picture : string;
                           Places : Byte; BLo, BHi : Bcd;
                           var B : BCD);
    {-Редактировать переменную типа BCD real
      (двоично-десятичное целое) (числовую)}

  procedure EditExt(Prompt : string; Row, Col : Byte;
                    Picture : string;
                    Places : Byte; ELo, EHi : Extended;
                    var E : Extended);
    {-Редактировать переменную типа extended}

  procedure EditNumericExt(Prompt : string; Row, Col : Byte;
                           Picture : string;
                           Places : Byte; ELo, EHi : Extended;
                           var E : Extended);
    {-Редактировать переменную типа extended (числовую)}

  procedure EditDbl(Prompt : string; Row, Col : Byte;
                    Picture : string;
                    Places : Byte; DLo, DHi : Double;
                    var D : Double);
    {-Редактировать переменную типа double}

  procedure EditNumericDbl(Prompt : string; Row, Col : Byte;
                           Picture : string;
                           Places : Byte; DLo, DHi : Double;
                           var D : Double);
    {-Редактировать переменную типа double (числовую)}

  procedure EditSgl(Prompt : string; Row, Col : Byte;
                    Picture : string;
                    Places : Byte; SLo, SHi : Single;
                    var S : Single);
    {-Редактировать переменную типа single}

  procedure EditNumericSgl(Prompt : string; Row, Col : Byte;
                           Picture : string;
                           Places : Byte; SLo, SHi : Single;
                           var S : Single);
    {-Редактировать переменную типа single (числовую)}

  procedure EditComp(Prompt : string; Row, Col : Byte;
                     Picture : string;
                     CLo, CHi : Comp; var C : Comp);
    {-Редактировать переменную типа comp}

  procedure EditNumericComp(Prompt : string; Row, Col : Byte;
                            Picture : string;
                            CLo, CHi : Comp; var C : Comp);
    {-Редактировать переменную типа comp (числовую)}

                            - 84 -

  procedure EditDate(Prompt : string; Row, Col : Byte;
                     Picture : string;
                     DLo, DHi : Date; var D : Date);
    {-Редактировать переменную типа date (дата)}

  procedure EditDateSt(Prompt : string; Row, Col : Byte;
                       Picture : DateString; var DS : DateString);
    {-Редактировать переменную типа date string (строка даты)}

  procedure EditTime(Prompt : string; Row, Col : Byte;
                     Picture : DateString;
                     TLo, THi : Time; var T : Time);
    {-Редактировать переменную типа time (время)}

  procedure EditChoice(Prompt : string; Row, Col : Byte;
                       Picture : string;
                       DataSize : Byte;
                       Increment : IncChoiceProc; var MC);
    {-Редактировать переменную с несколькими вариантами выбора}

  procedure EditMultiLine(Prompt : string; Row, Col : Byte;
                          Width, Height : Byte; var StArray);
    {-Редактировать поле, состоящее из нескольких строк}

OpSEdit       Объект SimpleLineEditor (простой строковый редактор)
────────────────────────────────────────────────────────────────

  constructor Init(var Colors : ColorSet);
    {-Задать стандартные значения для атрибутов и так далее}

  function GetLastCommand : Word;
    {-Возвратить последнюю команду, введенную пользователем}

  function GetLastKey : Word;
    {-Возвратить код последней клавиши, введенной пользователем}

  procedure ReadString(Prompt : string; Row, Col,
                       MaxLen, Width : Byte;
                       var S : string);
    {-Редактировать строку}

  procedure seOptionsOn(OptionFlags : LongInt);
    {-Установить несколько параметров-флагов}

  function seOptionsAreOn(OptionFlags : LongInt) : Boolean;
    {-Возвратить значение true, если все указанные
      параметры-флаги установлены}

  procedure seOptionsOff(OptionFlags : LongInt);
    {-Отменить несколько параметров-флагов}

  procedure SetPromptAttr(Color, Mono : Byte);
    {-Задать атрибуты для запросов}

                            - 85 -

  procedure SetFieldAttr(Color, Mono : Byte);
    {-Задать атрибуты для редактируемой строки}

  procedure SetCtrlAttr(Color, Mono : Byte);
    {-Задать атрибуты для управляющих символов}

  procedure SetHelpIndex(Index : Word);
    {-Задать индекс подсказки}

  procedure SetCommandProcessor(var CP : CommandProcessor);
    {-Задать используемый командный процессор}

  procedure SetClearFirstFilter(CFF : ClearFirstFunc);
    {-Задать процедуру, которая вызывается для проверки функцией
      ClearFirstChar}

OpDate        Процедуры и функции
────────────────────────────────────────────────────────────────

  function ValidDate(Day, Month, Year : Integer) : Boolean;
    {-Проверить, что день (day), месяц (month), год (year)
      задают достоверную дату}

  function DMYtoDate(Day, Month, Year : Integer) : Date;
    {-Преобразовать из значений day (день), month (месяц),
      year (год) в дату в Юлианском календаре}

  procedure DateToDMY(Julian : Date; var Day, Month, Year : Integer);
    {-Преобразовать из даты в Юлианском календаре в день (day),
      месяц (month) и год (year)}

  function IncDate(Julian : Date; Days, Months,
                   Years : Integer) : Date;
    {-Добавить (или вычесть) число дней (days), месяцев (months)
      и лет (years) к дате}

  function IncDateTrunc(Julian : Date; Months,
                        Years : Integer) : Date;
    {-Добавить (или вычесть) заданное число месяцев (months)
      и лет (years) к дате}

  procedure DateDiff(Date1, Date2 : Date;
                     var Days, Months, Years : Integer);
    {-Возвратить разницу в днях, месяцах и годах между двумя
      достоверными датами Юлианского календаря}

  function DayOfWeek(Julian : Date) : DayType;
    {-Возвратить день недели для заданной даты}

  function DayOfWeekDMY(Day, Month, Year : Integer) : DayType;
    {-Возвратить день недели для заданных дня, месяца и года}

  function DateStringToDate(Picture, S : DateString) : Date;

                            - 86 -
    {-Преобразовать S, строку в формате, который задается маской
      Picture, в дату Юлианского календаря.
      Маска Picture и строка S должны иметь равные длины}

  function DateToDateString(Picture : DateString;
                            Julian : Date) : DateString;
    {-Преобразовать Юлианскую дату в строку в формате, который
      задан маской Picture}

  function Today : Date;
    {-Возвратить сегодняшнюю дату в Юлианском календаре}

  function DateToSortString(Julian : Date) : string;
    {-Преобразовать дату в строку, пригодную для сортировки}

  function SortStringToDate(S : string) : Date;
    {-Преобразовать строку в формате, пригодном для сортировки,
      в дату}

  function IsLeapYear(Year : Integer) : Boolean;
    {-Возвратить True, если год Year является високосным}

  function DaysInMonth(Month, Year : Integer) : Integer;
    {-Возвратить число дней в заданно месяце month
      заданного года year}

  function DateStringToDMY(Picture, S : DateString;
                           var D, M, Y : Integer) : Boolean;
    {-Извлечь день (day), месяц (month), и год (year) из
      строки S, возвращая значение true (истинно), если строка
      является допустимой}

  function DMYtoDateString(Picture : DateString;
                           Day, Month,
                           Year : Integer) : DateString;
    {-Вставить месяц (month), день (day) и год (year)
      в строку, используя для этого маску picture}

  function TodayString(Picture : DateString) : DateString;
    {-Возвратить сегодняшнюю дату в виде строки заданного
      формата}

  function ValidTime(Hours, Minutes,
                     Seconds : Integer) : Boolean;
    {-Возвратить true (истинно), если время
      Hours:Minutes:Seconds (часы:минуты:секунды представляет
      достоверное время}

  procedure TimeToHMS(T : Time; var Hours,
                      Minutes, Seconds : Byte);
    {-Преобразовать переменную типа Time (время) в часы (Hours),
      минуты (Minutes) и секунды (Seconds)}

  function HMStoTime(Hours, Minutes, Seconds : Byte) : Time;

                            - 87 -
    {-Преобразовать часы (Hours), минуты (Minutes) и секунды
      (Seconds) в переменную типа Time (время)}

  function TimeStringToHMS(Picture, St : DateString;
                           var H, M, S : Integer) : Boolean;
    {-Извлечь часы (Hours), минуты (Minutes) и секунды
      (Seconds) из строки St, возвращая True (истинно), если
      строка достоверна}

  function TimeStringToTime(Picture, S : DateString) : Time;
    {-Преобразовать S, строку в формате, который задается маской
      Picture, в переменную типа Time}

  function TimeToTimeString(Picture : DateString;
                            T : Time) : DateString;
    {-Преобразовать T в строку в формате, который задается
      маской Picture}

  function TimeToAmPmString(Picture : DateString;
                            T : Time) : DateString;
    {-Преобразовать T в строку в формате, который задается
      маской Picture. Значения времени всегда отображаются
      в формате am/pm (до полудня/после полудня)}

  function CurrentTime : Time;
    {-Возвратить текущее время в секундах от полуночи}

  function CurrentTimeString(Picture : DateString) : DateString;
    {-Возвращает текущее время в виде строки заданного формата}

  procedure TimeDiff(Time1, Time2 : Time;
                     var Hours, Minutes, Seconds : Byte);
    {-Возвращает разницу в часах (hours), минутах (minutes) и
      секундах (seconds) между двумя значениями времени}

  function IncTime(T : Time; Hours, Minutes, Seconds : Byte) : Time;
    {-Добавить заданное число часов (hours), минут (minutes)
      и секунд (seconds) к переменной T и возвратить результат}

  function DecTime(T : Time; Hours, Minutes, Seconds : Byte) : Time;
    {-Вычесть заданное число часов (hours), минут (minutes) и
      секунд (seconds) из T и возвратить результат}

  function TimeToSortString(T : Time) : string;
    {-Преобразовать переменную типа time (время)
      в строку, которая пригодна к сортировке}

  function RoundToNearestHour(T : Time; Truncate : Boolean) : Time;
    {-Округлить значение T до ближайшего часа или обнулить число
      минут и секунд в значении T}

  function RoundToNearestMinute(T : Time; Truncate : Boolean) : Time;
    {-Округлить значение T до ближайшей минуты или обнулить число
      секунд в значении T}

                            - 88 -

  function SortStringToTime(S : string) : Time;
    {-Преобразовать пригодную к сортировке строку в переменную
      типа time (время)}

  procedure DateTimeDiff(DT1, DT2 : DateTimeRec;
                         var Days : Word;
                         var Secs : LongInt);
    {-Возвратить разницу в днях и секундах между двумя отметками
      времени}

  procedure IncDateTime(var DT1, DT2 : DateTimeRec;
                        Days : Integer; Secs : LongInt);
    {-Инкрементировать (или декрементировать) значение переменной DT1
      на заданное число дней и секунд и занести результат в перемен-
      ную DT2}

  function InternationalDate(WholeYear,
                             ZeroPad : Boolean) : DateString;
    {-Возвратить маску формата для строки даты, основываясь на
      коде страны, извлеченном из DOS}

  function InternationalTime(WithSeconds, ZeroPad : Boolean;
                             ExtraSpace,
                             WithEm : Boolean) : DateString;
    {-Возвратить маску формата для строки времени, основываясь на
      коде страны, извлеченном из DOS}

OpPrnLow      Объект BasePrinter (базовый принтер)
────────────────────────────────────────────────────────────────

  constructor Init(PrnName : PathStr;
                   TypeOfPrinter : PrnType);
    {-Инициализирует объект "принтер"}

  procedure PrnPutChar(Character : Char); Virtual;
    {-Выдает символ на устройство вывода}

  procedure PrnPutBlock(var Block; BlockSize : Word); Virtual;
    {-Выдает блок символов на устройство вывода}

  function PrnOpen : Boolean; Virtual;
    {-Открывает устройство вывода}

  procedure PrnClose; Virtual;
    {-Закрывает устройство вывода}

  function PrnStatus : Word; Virtual;
    {-Возвращает статус устройства}

  procedure PrnReset; Virtual;
    {-Производит реинициализацию устройства вывода}

  procedure PrnFlush; Virtual;

                            - 89 -
    {-Сбрасывает устройство}

  function PrnXlatErrorCode(Call : PrnCallType;
                         ErrorCode : Word) : Word; Virtual;
    {-Преобразует код-прототип ошибки в соответствующий
      пользовательский код ошибки}

  function CharXlat(C : Char) : Char; Virtual;
    {-Преобразует символ C в соответствии со встроенной таблицей
      преобразования}

  destructor Done; Virtual;
    {-Сбрасывает и закрывает принтер, а также возвращает системе
      память, которую занимал объект "принтер"}

  function TypeOfPrn : PrnType;
    {-Возвращает тип принтера}

  function NameOfPrn : String;
    {-Возвращает имя принтера}

  function PrnError  : Word;
    {-Возвращает последний код ошибки и сбрасывает значение
      pLastError в ноль}

  function PrnRawError : Word;
    {-Возвращает код-прототип ошибки, который был возвращен
      последней операцией}

  function PrnErrorOp : PrnCallType;
    {-Возвращает тип последней операции}

  function PrnLastPut : Word;
    {-Возвращает число символов, которое было успешно записано
      при последнем вызове процедуры PrnPutBlock}

  procedure XlatCharItem(CharIndex : Char; Character : Char);
    {-Изменить символ, который связан с кодом CharIndex
      таблицы ascii в код Character (символ)}

  procedure ClearXlatCharTable;
    {-Стирает таблицу преобразования (стандартное состояние)}

  procedure NewXlatCharTable(var Table : XlatCharTable);
    {-Задает всю таблицу типа XlatChar (таблица преобразования)}

  constructor Load(var S : IdStream);
    {-Загружает объект BasePrinter (базовый принтер
      из потока}

  procedure Store(var S : IdStream);
    {-Заносит объект BasePrinter (базовый принтер) в поток}

OpPrnLow      Объект DosPrinter (принтер DOS)

                            - 90 -
────────────────────────────────────────────────────────────────

  constructor Init(PrnName : PathStr;
                   TypeOfPrinter : PrnType);
    {-Инициализирует объект "принтер"}

OpPrnLow      Объект BiosPrinter (принтер Bios)
────────────────────────────────────────────────────────────────
              Примечание: Bios - базовая система ввода/вывода

  constructor Init(LPTNumber : LPTType);
    {-Инициализирует объект BiosPrinter (принтер Bios)}

  constructor InitCustom(LPTNumber : LPTType;
                         PrinterTestNumber, SuccessMask : Byte);
    {-Инициализирует объект BiosPrinter (принтер Bios) со
      специальной проверкой статуса}

  constructor Load(var S : IdStream);
    {-Загрузить объект BiosPrinter из потока}

  procedure PrnPutChar(Character : Char); Virtual;
    {-Выдает символ в устройство вывода}

  procedure Store(var S : IdStream);
    {-Занести объект BiosPrinter в поток}

  function GetLptPort : LPTType;
    {-Возвращает номер порта LPT (последовательного порта)
      для данного принтера}

  procedure SetLptPort(LPTNo : LPTType);
    {-Задает номер порта LPT (последовательного порта)
      для данного принтера}

  procedure SetXlatErrorFunc(Xlat : XlatFunc);
    {-Задает подпрограмму XlatError (преобразование ошибки)}

  function GetXlatErrorFunc : Pointer;
    {-Возвращает адрес подпрограммы XlatError (преобразование
      ошибки)}

  procedure GetTestAndMask(var PrinterTestNumber, Mask : Byte);
    {-Возвратить номер теста принтера и маску успешности}

  procedure SetTestAndMask(PrinterTestNumber, Mask : Byte);
    {-Задать номер теста принтера и маску успешности}

OpPrnLow      Процедуры и функции
────────────────────────────────────────────────────────────────

  procedure DefaultXlatCharTable(var Table : XlatCharTable);
    {-Инициализировать таблицу Table, установив ее в
      стандартное состояние}

                            - 91 -

  procedure AssignPrnObject(var F : Text;
                           var PrinterObj : BasePrinter);
    {-Аналогична процедуре assign (присвоить) в Turbo-системе
      за исключением того, что она связывает переменную
      Text (текст) с объектом "принтер"}

  function GetPrnObject(var F : Text) : BasePrinterPtr;
    {-Возвращает указатель на объект "принтер", связанный с
      файлом, который задан переменной типа Text. Возвращает
      значение Nil, если с объектом "принтер" связан файл,
      тип которого отличен от типа text}

  function CallPrnStatus(var F : Text) : Word;
    {-Вызвать метод PrnStatus для файла типа Text, который связан
      с объектом "принтер"}

OpPrinter     Объект Printer (Принтер)
────────────────────────────────────────────────────────────────

  constructor Init(Name : String; DeviceType : PrnType;
                   OptionFlags : Word);
    {-Инициализировать принтер}

  constructor InitCustom(Device : BasePrinterPtr;
                         LPI, CPI, Point, LPP : Dimension;
                         OptionFlags : Word);
    {-Инициализировать принтер с полным управлением Printer
      Device (устройство печати), и PrinterModes (режимы печати)}

  destructor Done; Virtual;
    {-Вернуть системе память, которую занимал объект "принтер"}

  procedure PrintStr(S : String); Virtual;
    {-Отпечатать строку в текущей позиции}

  procedure PrintStrPos(S : String;
                        Row, Col : Dimension;
                        Relative : RelativeType); Virtual;
    {-Отпечатать строку в заданной позиции}

  procedure Position(Row, Col : Dimension;
                     Relative : RelativeType); Virtual;
    {-Позиционировать принтер на требуемую позицию на странице}

  procedure FormFeed;
    {-Продвинуть бумагу на следующую страницу}

  procedure AdvanceLine(NumLines : Byte);
    {-Продвинуть бумагу на NumLines строк}

  procedure AdvanceSingleLine; Virtual;
    {-Переместить текущую позицию печати на начало
      следующей строки}

                            - 92 -

  procedure ResetPage;
    {-Сбрасывает информацию о позиции}

  procedure SetLPP(LPP : Dimension);
    {-Задает число строк на страницу}

  procedure SetYRatio(Ratio : Dimension);
    {-Задает коэффициент по оси Y принтера}

  procedure SetXRatio(Ratio : Dimension);
    {-Задает коэффициент по оси X принтера}

  function GetRegisteredType : Word;
    {-Возвращает тип аппаратного обеспечения, зарегистрированный
      для данного объекта "принтер"}

  procedure SetRegisteredType(HardwareType : Word);
    {-Задает зарегистрированный тип аппаратного обеспечения}

  function GetBasePrinter : BasePrinterPtr;
    {-Возвращает указатель на "базовый принтер" BasePrinterPtr}

  function GetCurrentFont : Byte;
    {-Возвращает идентификатор текущего режима шрифтов или
      ноль, если текущий шрифт не задан}

  procedure SetPrintErrorFunc(PEF : PrintErrorFunc);
    {-Задает функцию обработки ошибки принтера}

  procedure SetPositionPrim(PosFunc : PrinterPosFunc);
    {-Задает примитив позиции принтера}

  procedure AddPrintMode(Name,OnEscSeq,OffEscSeq : String;
                         Width, Height : Dimension;
                         ID : Byte; OptionFlags : Word);
    {-Добавить режим принтера к связному списку режимов}

  procedure SetDefaultFont(Attr : Byte);
    {-Задает стандартный шрифт для данного принтера}

  function GetDefaultFont : Byte;
    {-Возвращает атрибут Attr стандартного шрифта}

  procedure EnableDefaultFont;
    {-Задает использование стандартного шрифта}

  procedure TurnOnByID(ID : Byte);
    {-Включает режим печати по идентификатору ID}

  procedure TurnOffByID(ID : Byte);
    {-Выключает режим печати по идентификатору ID}

  procedure TurnOnByName(Name : String);

                            - 93 -
    {-Включает режим печати по имени Name}

  procedure TurnOffByName(Name : String);
    {-Выключает режим печати по имени Name}

  function PrinterReady : Boolean;
    {-Возвращает значение true (истинно), если принтер находится
      в состоянии готовности}

  procedure pOptionsOn(OptionFlags : Word);
    {-Задать несколько параметров работы принтера}

  procedure pOptionsOff(OptionFlags : Word);
    {-Отменить несколько параметров работы принтера}

  function pOptionsAreOn(OptionFlags : Word) : Boolean;
    {-Возвратить значение True (истинно), если все указанные
      параметры-флаги OptionFlags заданы}

  function pGetLastError : Word;
    {-Возвратить последний код ошибки и сбросить статусную
      переменную в ноль}

  function InLandscape : Boolean;
    {-Возвращает значение true (истинно), если принтер
      находится в пейзажном (Landscape) режиме (лист ориентирован
      горизонтально)}

  procedure TurnOffAllActiveModes;
    {-Выключить все активные в настоящий момент режимы
      печати}

  procedure DisposeAllModes;
    {-Возвращает системе память, которую занимали структуры,
      определяющие все режимы печати, связанные с данным
      принтером}

  constructor Load(var S : IdStream);
    {-Загрузить объект Printer (принтер) из потока}

  procedure Store(var S : IdStream);
    {-Занести объект Printer (принтер) в поток}

  procedure LinkToPrinter(Device : BasePrinterPtr);
    {-Связывает объект с заданным устройством Device}

  procedure LinkToModes(var Modes : SingleList);
    {-Связывает объект с заданным списком режимов печати}

OpDevice      Процедуры и функции
────────────────────────────────────────────────────────────────

  procedure Deregister(P : PrinterPtr);
    {-Отменяет любую заданную ранее регистрацию принтера}

                            - 94 -

  procedure LJRegister(P : PrinterPtr);
    {-Регистрирует данный принтер как совместимый с
      принтером HP Laserjet}

  procedure LJFontGRegister(P : PrinterPtr);
    {-Регистрирует наличие шрифтовой кассеты G для принтера LJ}

  function LJDeci2Row(Decipoints : Dimension;
                      P : PrinterPtr) : Dimension;
    {-Преобразует число с десятичной точкой в номер строки Row}

  function LJDeci2Col(Decipoints : Dimension;
                      P : PrinterPtr) : Dimension;
    {-Преобразует число с десятичной точкой в номер столбца Col}

  function LJRow2Deci(Row : Dimension;
                      P : PrinterPtr) : Dimension;
    {-Преобразует номер строки Row в число с десятичной точкой}

  function LJCol2Deci(Col : Dimension;
                      P : PrinterPtr) : Dimension;
    {-Преобразует номер столбца Col в число с десятичной точкой}

  procedure EpsonMXRegister(P : PrinterPtr);
    {-Регистрирует P как принтер, совместимый с принтером Epson MX}

  procedure EpsonLQRegister(P : PrinterPtr);
    {-Регистрирует P как принтер, совместимый с принтером Epson LQ}

  procedure ProPrinterIIRegister(P : PrinterPtr);
    {-Регистрирует P как принтер IBM Proprinter II}

  procedure GenericEpsonRegister(P : PrinterPtr);
    {-Регистрирует P как принтер, совместимый с
      обобщенным (Generic) принтером фирмы Epson}

  procedure HPDeskJetRegister(P : PrinterPtr);
    {-Регистрирует P как принтер, совместимый с принтером
      HP Deskjet}

  procedure KXP1093Register(P : PrinterPtr);
    {-Регистрирует P как принтер Panasonic KX-P1093}

  procedure ToshibaP321Register(P : PrinterPtr);
    {-Регистрирует P как принтер Toshiba P321SL или P341SL}

  procedure StarMicronicsRegister(P : PrinterPtr);
    {-Регистрирует P как принтер  Star Micronics}

  procedure Nec3510Register(P : PrinterPtr);
    {-Регистрирует P как принтер
      Nec 3510/3530/7710/7730/8830/8810}


                            - 95 -
  procedure Nec8800Register(P : PrinterPtr);
    {-Регистрирует P как принтер
      Nec 3510/3530/7710/7730/8830/8810}

  procedure ProwriterRegister(P : PrinterPtr);
    {-Регистрирует P как принтер C. Itoh 8510 Prowriter}

  procedure FacitRegister(P : PrinterPtr);
    {-Регистрирует P как принтер Facit 4512}

  procedure DataProductsRegister(P : PrinterPtr);
    {-Регистрирует P как принтер DataProducts DP}

  procedure LJDeviceStream(SPtr : IdStreamPtr);
    {-Регистрирует специфические для принтера LJ
      указатели на процедуры и функции}

OpForm        Объект PrintField (поле печати)
────────────────────────────────────────────────────────────────

  procedure pfOptionsOn(OptionFlags : LongInt);
    {-Задать несколько параметров-флагов}

  procedure pfOptionsOff(OptionFlags : LongInt);
    {-Отменить несколько параметров-флагов}

  function pfOptionsAreOn(OptionFlags : LongInt) : Boolean;
    {-Возвратить значение true, если все указанные
      параметры-флаги установлены}

  function Convert : Boolean; Virtual;
    {-Преобразовать из естественного типа в
      предназначенную для печати строку}

  procedure Print(PrinterP : PrinterPtr); Virtual;
    {-Отпечатать поле печати}

  procedure SetConversion(ConvertFunc : PrintConversionFunc);
    {-Задать подпрограмму преобразования}

  function GetFieldAttr : Byte;
    {-Возвратить атрибут печати для данного поля}

  procedure GetFieldPos(var Row, Col : Dimension);
    {-Возвратить номер строки row и столбца col для данного поля}

  procedure SetFieldPos(Row, Col : Dimension);
    {-Задать номер строки row и столбца col для данного поля}

OpForm        Объект PrintedForm (печатная форма)
────────────────────────────────────────────────────────────────

  constructor Init(FormID : Byte; PrinterP : PrinterPtr);
    {-Инициализировать объект PrintedForm (печатная форма)}

                            - 96 -

  constructor InitCustom(FormID : Byte;
                         TopMargin,BottomMargin,
                         LeftMargin,RightMargin : Dimension;
                         PrinterP : PrinterPtr);
    {-Инициализировать объект PrintedForm (печатная форма)
      с произвольными параметрами}

  destructor Done; Virtual;
    {-Удалить объект PrintedForm (печатная форма)}

  procedure Process; Virtual;
    {-Отпечатать форму}

  function fPrinterPtr : PrinterPtr;
    {-Возвращает указатель на объект "принтер" PrinterPtr
      для данной формы}

  function fGetLastError : Word;
    {-Возвращает код последней ошибки, и сбрасывает переменную
      в ноль}

  procedure NewBlock(BaseRow, BaseCol : Dimension;
                     BlockFunc : UserBlockFunc);
    {-Начинает новый блок}

  procedure SetUserRecord(var UserRec; UserRecSize : Word);
    {-Задать адрес и размер записи пользователя для
      текущего блока}

  function GetUserRecord : Pointer;
    {-Возвратить указатель на запись пользователя для
      текущего блока}

  function GetUserRecordSize : Word;
    {-Возвратить размер записи пользователя для текущего блока}

  procedure DupCurrentBlock(NewRow, NewCol : Dimension);
    {-Дублирует текущий блок с новыми координатами блока}

  procedure DupCurrentPage;
    {-Дублирует текущую страницу}

  procedure PromptOptionsOn(OptionFlags : LongInt);
    {-Задает параметры для запросов}

  procedure FieldOptionsOn(OptionFlags : LongInt);
    {-Задает параметры для полей}

  procedure PromptOptionsOff(OptionFlags : LongInt);
    {-Отменяет параметры для запросов}

  procedure FieldOptionsOff(OptionFlags : LongInt);
    {-Отменяет параметры для полей}

                            - 97 -

  function PromptOptionsAreOn(OptionFlags : LongInt) : Boolean;
    {-Возвратить True (истинно), указанные параметры для запросов
      заданы}

  function FieldOptionsAreOn(OptionFlags : LongInt) : Boolean;
    {-Возвратить True (истинно), указанные параметры для полей
      заданы}

  procedure AddTextField(pFieldID : Word; Prompt : String;
                         pRow, pCol : Dimension;
                         pAttr : Byte;
                         pWidth : Byte);
    {-Добавляет поле текстовой строки (без переменной пользователя)}

  procedure AddStringField(pFieldID : Word;
                           Prompt : String;
                           pRow, pCol : Dimension;
                           pAttr : Byte;
                           pWidth : Byte;
                           fFieldID : Word;
                           Picture : String;
                           fRow, fCol : Dimension;
                           fAttr : Byte;
                           fWidth : Byte;
                           var PrintSt : String);
    {-Добавляет запрос и поле типа string (строка)}

  procedure AddCharField(pFieldID : Word;
                         Prompt : String;
                         pRow, pCol : Dimension;
                         pAttr : Byte;
                         pWidth : Byte;
                         fFieldID : Word;
                         Picture : String;
                         fRow, fCol : Dimension;
                         fAttr      : Byte;
                         fWidth     : Byte;
                         var PrintChar : Char);
    {-Добавляет запрос и поле типа char (символ)}

  procedure AddBooleanField(pFieldID : Word;
                            Prompt : String;
                            pRow, pCol : Dimension;
                            pAttr : Byte;
                            pWidth : Byte;
                            fFieldID : Word;
                            Picture  : String;
                            fRow, fCol : Dimension;
                            fAttr : Byte;
                            fWidth : Byte;
                            var PrintBool : Boolean);
    {-Добавляет запрос и поле типа Boolean (булево)}


                            - 98 -
  procedure AddYesNoField(pFieldID : Word;
                          Prompt : String;
                          pRow, pCol : Dimension;
                          pAttr : Byte;
                          pWidth : Byte;
                          fFieldID : Word;
                          Picture : String;
                          fRow, fCol : Dimension;
                          fAttr : Byte;
                          fWidth : Byte;
                          var PrintYesNo : Boolean);
    {-Добавляет запрос и поле типа Yes/No (да/нет)}

  procedure AddLongField(pFieldID : Word;
                         Prompt : String;
                         pRow, pCol : Dimension;
                         pAttr : Byte;
                         pWidth : Byte;
                         fFieldID : Word;
                         Picture : String;
                         fRow, fCol : Dimension;
                         fAttr : Byte;
                         fWidth : Byte;
                         var PrintLong : LongInt);
    {-Добавляет запрос и поле типа LongInt (длинное целое)}

  procedure AddWordField(pFieldID : Word;
                         Prompt : String;
                         pRow, pCol : Dimension;
                         pAttr : Byte;
                         pWidth : Byte;
                         fFieldID : Word;
                         Picture : String;
                         fRow, fCol : Dimension;
                         fAttr : Byte;
                         fWidth : Byte;
                         var PrintWord : Word);
    {-Добавляет запрос и поле типа Word (слово)}

  procedure AddIntField(pFieldID : Word;
                        Prompt : String;
                        pRow, pCol : Dimension;
                        pAttr : Byte;
                        pWidth : Byte;
                        fFieldID : Word;
                        Picture : String;
                        fRow, fCol : Dimension;
                        fAttr : Byte;
                        fWidth : Byte;
                        var PrintInt : Integer);
    {-Добавляет запрос и поле типа Integer (целое)}

  procedure AddByteField(pFieldID : Word;
                         Prompt : String;

                            - 99 -
                         pRow, pCol : Dimension;
                         pAttr : Byte;
                         pWidth : Byte;
                         fFieldID : Word;
                         Picture : String;
                         fRow, fCol : Dimension;
                         fAttr : Byte;
                         fWidth : Byte;
                         var PrintByte : Byte);
    {-Добавляет запрос и поле типа Byte (байт)}

  procedure AddShortField(pFieldID : Word;
                          Prompt : String;
                          pRow, pCol : Dimension;
                          pAttr : Byte;
                          pWidth : Byte;
                          fFieldID : Word;
                          Picture : String;
                          fRow, fCol : Dimension;
                          fAttr : Byte;
                          fWidth : Byte;
                          var PrintShort : ShortInt);
    {-Добавляет запрос и поле типа ShortInt (короткое целое)}

  procedure AddRealField(pFieldID : Word;
                         Prompt : String;
                         pRow, pCol : Dimension;
                         pAttr : Byte;
                         pWidth : Byte;
                         fFieldID : Word;
                         Picture : String;
                         fRow, fCol : Dimension;
                         fAttr : Byte;
                         fDPlaces : Byte;
                         fWidth : Byte;
                         var PrintReal : Real);
    {-Добавляет запрос и поле типа Real (действительное)}

  procedure AddBCDField(pFieldID : Word;
                        Prompt : String;
                        pRow, pCol : Dimension;
                        pAttr : Byte;
                        pWidth : Byte;
                        fFieldID : Word;
                        Picture : String;
                        fRow, fCol : Dimension;
                        fAttr : Byte;
                        fDPlaces : Byte;
                        fWidth : Byte;
                        var PrintBCD : BCD);
    {-Добавляет запрос и поле типа BCD (двоично-десятичное)}

  procedure AddExtField(pFieldID : Word;
                        Prompt : String;

                            - 100 -
                        pRow, pCol : Dimension;
                        pAttr : Byte;
                        pWidth : Byte;
                        fFieldID : Word;
                        Picture : String;
                        fRow, fCol : Dimension;
                        fAttr : Byte;
                        fDPlaces : Byte;
                        fWidth : Byte;
                        var PrintExt : Extended);
    {-Добавляет запрос и поле типа Extended}

  procedure AddDblField(pFieldID : Word;
                        Prompt : String;
                        pRow, pCol : Dimension;
                        pAttr : Byte;
                        pWidth : Byte;
                        fFieldID : Word;
                        Picture : String;
                        fRow, fCol : Dimension;
                        fAttr : Byte;
                        fDPlaces : Byte;
                        fWidth : Byte;
                        var PrintDbl : Double);
    {-Добавляет запрос и поле типа Double}

  procedure AddSglField(pFieldID : Word;
                        Prompt : String;
                        pRow, pCol : Dimension;
                        pAttr : Byte;
                        pWidth : Byte;
                        fFieldID : Word;
                        Picture : String;
                        fRow, fCol : Dimension;
                        fAttr : Byte;
                        fDPlaces : Byte;
                        fWidth : Byte;
                        var PrintSgl : Single);
    {-Добавляет запрос и поле типа Single}

  procedure AddCompField(pFieldID : Word;
                         Prompt : String;
                         pRow, pCol : Dimension;
                         pAttr : Byte;
                         pWidth : Byte;
                         fFieldID : Word;
                         Picture : String;
                         fRow, fCol : Dimension;
                         fAttr : Byte;
                         fWidth : Byte;
                         var PrintComp : Comp);
    {-Добавляет запрос и поле типа Comp}

  procedure AddDateField(pFieldID : Word;

                            - 101 -
                         Prompt : String;
                         pRow, pCol : Dimension;
                         pAttr : Byte;
                         pWidth : Byte;
                         fFieldID : Word;
                         Picture : String;
                         fRow, fCol : Dimension;
                         fAttr : Byte;
                         fWidth : Byte;
                         var PrintDate : Date);
    {-Добавляет запрос и поле типа Date (дата)}

  procedure AddTimeField(pFieldID : Word;
                         Prompt : String;
                         pRow, pCol : Dimension;
                         pAttr : Byte;
                         pWidth : Byte;
                         fFieldID : Word;
                         Picture : String;
                         fRow, fCol : Dimension;
                         fAttr : Byte;
                         fWidth : Byte;
                         var PrintTime : Time);
    {-Добавляет запрос и поле типа Time (время)}

  procedure AddDirective(FieldID : Word;
                         Row,Col : Dimension;
                         On      : Boolean;
                         Attr    : Byte);
    {-Добавляет директиву печати}

  procedure AddLine(FieldID               : Word;
                    Row, Col              : Dimension;
                    Len,LineThickness     : Dimension;
                    Horizontal            : Boolean;
                    LineChar              : Char;
                    Attr                  : Byte);
    {-Добавляет поле-линию}

  procedure AddBox(FieldID : Word;
                   Row, Col       : Dimension;
                   Width, Height  : Dimension;
                   HLineThickness : Dimension;
                   VLineThickness : Dimension;
                   BoxChars : BoxCharSet;
                   Attr : Byte);
    {-Добавить поле-прямоугольник}

  procedure AddShaded(FieldID : Word;
                      Row,Col,
                      Width,Height : Dimension;
                      Intensity : Byte);
    {-Добавить поле-прямоугольник с затенением}


                            - 102 -
  procedure NewPage;
    {-Перейти на новую страницу}

  procedure AddPage(Page : PrintPagePtr);
    {-Добавить указатель существующей страницы к
      данной форме}

  procedure SetHeader(HeaderStr : String; Row, Col : Dimension;
                      HAttr : Byte);
    {-Описать верхний колонтитул для текущей страницы}

  procedure SetHeaderFunc(Picture : String;
                          HeadFunc : PrintConversionFunc);
    {-Задать указатель на функцию HeadFunc для текущей страницы}

  function GetHeader : String;
    {-Возвращает строку верхнего колонтитула для текущей страницы}

  procedure SetFooter(FooterStr : String; Row, Col : Dimension;
                      FAttr : Byte);
    {-Описать нижний колонтитул для текущей страницы}

  procedure SetFooterFunc(Picture : String;
                          FootFunc : PrintConversionFunc);
    {-Задать указатель на функцию FootFunc для текущей страницы}

  function GetFooter : String;
    {-Возвращает строку нижнего колонтитула для текущей страницы}

  procedure SetErrorHandler(ErrorFunc : PrintErrorFunc);
    {-Задает пользовательскую подпрограмму обработки ошибок}

  procedure AddPrintMode(Name,OnEscSeq,OffEscSeq : String;
                         Width, Height : Dimension;
                         ID : Byte; OptionFlags : Word);
    {-Добавить режим печати к связному списку режимов данного
      принтера}

  function FindField(FieldID : Word;
                     var Page : PrintPagePtr;
                     var Block : PrintBlockPtr) : PrintFieldPtr;
    {-Ищет первое поле с заданным идентификатором поля FieldID}

  function FindNextField(Field  : PrintFieldPtr;
                         var Page : PrintPagePtr;
                         var Block : PrintBlockPtr) : PrintFieldPtr;
    {-Ищет следующее поле с тем же самым идентификатором поля
      FieldID, что и идентификатор поля Field}

  procedure ChangeConversion(FieldID : Word;
                             ConvertFunc : PrintConversionFunc);
    {-Изменить подпрограмму преобразования поля}

  procedure SetUserData(P : Pointer);

                            - 103 -
    {-Задает поле данных пользователя}

  function GetUserData : Pointer;
    {-Возвращает поле данных пользователя}

  procedure SetPrePageFunc(ppFunc : UserPageFunc);
    {-Задает функцию, которая вызывается перед печатью текущей
      страницы}

  procedure SetPrePostFormFunc(ppFunc : UserFormFunc);
    {-Задает функцию, которая вызывается перед печатью формы и после
      печати формы}

  constructor Load(var S : IdStream);
    {-Загрузить объект PrintedForm (печатная форма) из потока}

  procedure Store(var S : IdStream);
    {-Занести объект PrintedForm (печатная форма) в поток}

OpForm        Объект Report (отчет)
────────────────────────────────────────────────────────────────

  constructor Init;
    {-Создать отчет}

  destructor Done; Virtual;
    {-Возвратить системе память, которую занимал объект
      report (отчет)}

  function rGetLastError : Word;
    {-Получить последний код ошибки и стереть его}

  procedure Process; Virtual;
    {-Отпечатать поле печати}

  procedure AddForm(fPtr : PrintedFormPtr);
    {-Добавить объект PrintedForm (печатная форма) к объекту
      Report (отчет) посредством указателя}

  function FindForm(FormID : Byte) : PrintedFormPtr;
    {-Возвратить указатель на объект PrintedForm (печатная форма),
      заданный посредством идентификатора ID}

  constructor Load(var S : IdStream);
    {-Загрузить отчет Report из потока}

  procedure Store(var S : IdStream);
    {-Занести отчет Report в поток}

OpRoot        Объект IdStream (поток)
────────────────────────────────────────────────────────────────

  function ReadString : String;
    {-Считать из потока очередную строку переменной длины}

                            - 104 -

  procedure ReadRange(var BufStart, BufBeyond);
    {-Считать Ofs(BufBeyond)-Ofs(BufStart) байтов по адресу
      BufStart}

  procedure WriteString(S : String);
    {-Занести в поток строку переменной длины}

  procedure WriteRange(var BufStart, BufBeyond);
    {-Занести в поток Ofs(BufBeyond)-Ofs(BufStart) байтов}

  function GetSize : Longint;
    {-Определить размер потока}

  procedure Seek(Pos : Longint);
    {-Задать текущую позицию потока равной значению Pos,
      задание происходит относительно начала потока}

  function GetPos : Longint; virtual;
    {-Возвратить текущую позицию в потоке}

  function GetStatus : Word;
    {-Возвратить статус потока}

  function PeekStatus : Word;
    {-Возвратить статус и не изменять внутреннюю переменную}

  procedure RegisterType(Code, Version : Word;
                         TypePtr, StorePtr, LoadPtr : Pointer);
    {-Регистрирует один тип объекта с указанной версией для
      ввода/вывода посредством IdStream. Статус Status может полу-
      чать ненулевое значение}

  procedure RegisterOldVersion(Code, Version : Word;
                               TypePtr, LoadPtr : Pointer);
    {-Регистрирует конструктор для альтернативной загрузки старой
      версии некоторого типа объекта}

  function TypeRegistered(TypePtr : Pointer) : Boolean;
    {-Возвращает значение True (истинно), если указанный тип
      зарегистрирован с указанием соответствующих ему подпрограмм
      store и load}

  function TypeVerRegistered(TypePtr : Pointer;
                             Version : Word) : Boolean;
    {-Возвратить значение True (истинно), если указанные тип и
      версия зарегистрированы для конструктора load}

  function CodeVerRegistered(Code, Version : Word) : Boolean;
    {-Возвратить значение True (истинно), если указанные тип и
      номер версии зарегистрированы}

  procedure RegisterHier(RProc : StreamRegisterProc);
    {-Вызывает заданную подпрограмму для регистрации иерархии

                            - 105 -
      типов объектов}

  procedure PutPtr(RPtr : RootPtr);
    {-Вызывает полиморфический метод Store для записи объекта RPtr^}

  function GetPtr : RootPtr;
    {-Вызывает полиморфический конструктор Load для выделения памяти
      под объект и считывания его}

  procedure Put(var R : Root);
    {-Вызывает полиморфический метод Store для записи объекта R}

  procedure Get(var R : Root);
    {-Вызывает полиморфический конструктор Load для считывания
      статического объекта R}

  procedure RegisterPointer(Code : Word; Ptr : Pointer);
    {-Регистрирует один указатель для ввода/вывода посредством
      IdStream}

  function PointerRegistered(Ptr : Pointer) : Boolean;
    {-Возвратить значение True, если заданный указатель зарегистри-
      рован для потока}

  procedure WritePointer(Ptr : Pointer);
    {-Записывает идентификатор указателя в поток}

  procedure WriteUserPointer(Ptr : Pointer; DefaultCode : Word);
    {-Записывает код указателя Ptr, если он зарегистрирован, иначе
      записывает стандартный код DefaultCode}

  function ReadPointer : Pointer;
    {-Считывает указатель из потока}

  function ReadUserPointer(DefaultPtr : Pointer) : Pointer;
    {-Считывает указатель и присваивает ему вместо значения nil
      стандартное значение}

  procedure Error(Code : Word); virtual;
    {-Сообщает об ошибке}

OpRoot        Объект DosIdStream (поток Dos)
────────────────────────────────────────────────────────────────

  constructor Init(FileName : String; Mode : Word);
    {-Открыть файл DOS в указанном режиме и инициализирует поток}

  destructor Done; virtual;
    {-Закрыть файл и вернуть системе память, которую занимал
      поток}

  procedure Read(var Buf; Count : Word); virtual;
    {-Считать байты из файла DOS}


                            - 106 -
  procedure Write(var Buf; Count : Word); virtual;
    {-Записать байты в файл DOS}

  procedure Truncate; virtual;
    {-Усечь файл в текущей позиции}

OpRoot        Объект BufIdStream (буферизованный поток)
────────────────────────────────────────────────────────────────

  constructor Init(FileName : String; Mode, Size : Word);
    {-Открыть файл DOS в заданном режиме и выделить буфер размером
      в Size байтов}

  destructor Done; virtual;
    {-Сбросить на диск содержимое буфера и закрыть файл, вернуть в
      систему память, которую занимали буфер и поток}

  procedure Flush; virtual;
    {-Сбросить на диск содержимое буфера}

  procedure Read(var Buf; Count : Word); virtual;
    {-Считать, используя при этом буфер}

  procedure Write(var Buf; Count : Word); virtual;
    {-Записать, используя при этом буфер}

OpRoot        Объект MemIdStream (поток в оперативной памяти)
────────────────────────────────────────────────────────────────

  constructor Init(BasePtr : Pointer; Size : Word);
    {-Инициализировать поток таким образом, чтобы он
      указывал на определенное место в памяти}

  procedure Read(var Buf; Count : Word); virtual;
    {-Считать байты из потока, расположенного в памяти}

  procedure Write(var Buf; Count : Word); virtual;
    {-Записать байты в поток, расположенный в памяти}

  procedure Truncate; virtual;
    {-Усечь в текущей позиции. Единственное действие заключается
      в уменьшении размера Size потока.}

OpRoot        Объект DirEntry (элемент директории)
────────────────────────────────────────────────────────────────

  constructor Init;
    {-Инициализировать пустой элемент директории}

  procedure Rename(Name : DirEntryName);
    {-Изменить имя элемента директории}

  procedure Update(Start, Len : LongInt; Code, Ver : Word); virtual;
    {-Скорректировать данные о начале объекта и его длине}

                            - 107 -

  procedure SetUserPointer(P : Pointer);
    {-Установить указатель пользователя в P}

  procedure deOptionsOn(Options : Word);
    {-Задать указанные параметры-флаги}

  procedure deOptionsOff(Options : Word);
    {-Стереть указанные параметры-флаги}

  function deOptionsAreOn(Options : Word) : Boolean;
    {-Возвращает значение True (истинно), если все указанные
      параметры-флаги заданы}

  function GetEntryName : DirEntryName;
    {-Возвратить имя элемента}

  function GetEntryStart : LongInt;
    {-Возвратить начальную точку элемента}

  function GetEntryLength : LongInt;
    {-Возвратить длину элемента}

  function GetUserPointer : Pointer;
    {-Возвратить значение указателя пользователя}

OpRoot        Объект Library (библиотека)
────────────────────────────────────────────────────────────────

  constructor Init(FileName : PathStr; Mode, BufferSize : Word;
                   Sig : LibrarySig);
    {-Открыть существующую библиотеку}

  constructor Create(FileName : PathStr; BufferSize : Word;
                     Sig : LibrarySig; Entries : Word);
    {-Создать новую библиотеку}

  destructor Done; virtual;
    {-Сбросить на диск содержимое буфера и закрыть файл биб-
      лиотеки, а также возвратить системе память, которую за-
      нимали директория и поток}

  procedure PutEntry(Name : DirEntryName; var R : Root);
    {-Вызывает полиморфический метод Store для записи объекта R}

  procedure GetEntry(Name : DirEntryName; var R : Root);
    {-Вызывает полиморфический конструктор Load для считывания
      статического объекта R}

  function GetEntryPtr(Name : DirEntryName) : RootPtr;
    {-Вызывает полиморфический конструктор Load для выделения па-
      мяти и считывания объекта}

  procedure DeleteEntry(Name : DirEntryName); virtual;

                            - 108 -
    {-Маркирует элемент с заданным именем как удаленный}

  procedure UndeleteEntry(Name : DirEntryName); virtual;
    {-Удалить признак удаленного элемента с заданного элемента}

  procedure KillEntry(Name : DirEntryName);
    {-Удалить насовсем элемент с заданным именем}

  procedure RenameEntry(OldName, NewName : DirEntryName); virtual;
    {-Переименовать указанный элемент}

  procedure GetCodeAndVersion(Name : DirEntryName; var Code,
                              Ver : Word);
    {-Возвратить номер кода и версию для заданного элемента}

  procedure Pack;
    {-Упаковать библиотеку}

  function PackedFileSize : LongInt;
    {-Возвращает размер библиотеки после упаковки}

  function FileNeedsPacking : Boolean;
    {-Возвращает значение True (истинно), если библиотека
      нуждается в упаковке}

  function FindEntryByIndex(N : Word) : DirEntryPtr;
    {-Возвратить указатель на N-ый элемент в директории}

  function FindDirectoryEntry(Name : DirEntryName) : DirEntryPtr;
    {-Возвратить указатель на элемент директории; nil, если
      элемент не обнаружен или удален}

  function FindAnyDirectoryEntry(Name : DirEntryName) : DirEntryPtr;
    {-Возвратить указатель на элемент директории; nil, если
      элемент не обнаружен}

  function MaxEntries : Word;
    {-Возвратить максимальное число элементов в директории
      библиотеки}

  function CurrentEntries : Word;
    {-Возвратить число использованных элементов в директории
      библиотеки, не включая удаленные элементы}

  function DeletedEntries : Word;
    {-Возвратить число удаленных элементов в директории библиотеки}

  function AvailableEntries : Word;
    {-Возвратить число доступных элементов в директории библиотеки}

OpRoot        Объект MemLibrary (библиотека в памяти)
────────────────────────────────────────────────────────────────

  constructor Init(BasePtr : Pointer; Size : Word);

                            - 109 -
    {-Открыть существующую в памяти библиотеку}

  procedure GetEntry(Name : DirEntryName; var R : Root);
    {-Вызывает полиморфический конструктор Load для считы-
      вания статического объекта R}

  function GetEntryPtr(Name : DirEntryName) : RootPtr;
    {-Вызывает полиморфический конструктор Load для выделе-
      ния памяти под объект и считывания его}

OpRoot        Объект PointerStack (стек указателей)
────────────────────────────────────────────────────────────────

  constructor Init(Max : Word);
    {-Выделить память под стек указателей, который может содержать
      максимально Max элементов}

  destructor Done; virtual;
    {-Возвратить в систему память, которую занимал стек}

  function Size : Word;
    {-Возвратить размер стека}

  procedure Push(P : RootPtr);
    {-Затолкнуть P на стек}

  function Pop : RootPtr;
    {-Вытолкнуть из стека самый верхний указатель RootPtr}

  function SP : Word;
    {-Вернуть индекс текущей вершины стека}

  function Peek(Index : Word) : RootPtr;
    {-Вернуть элемент стека в позиции Index}

  function PeekTop : RootPtr;
    {-Вернуть указатель, который сейчас находится на вершине стека}

  procedure Poke(P : RootPtr; Index : Word);
    {-Непосредственно задать элемент стека}

  procedure Clear;
    {-Удалить все элементы из стека}

  function GetStatus : Word;
    {-Возвратить последний код состояния с сбросить внутреннюю
      статусную переменную в ноль}

  function Resize(Max : Word) : Boolean;
    {-Увеличить или уменьшить стек, чтобы он мог максимально содержать
      Max указателей}

  constructor Load(var S : IdStream);
    {-Загрузить стек из потока}

                            - 110 -

  procedure Store(var S : IdStream);
    {-Занести стек в поток}

OpRoot        Объект StaticQueue (Статическая очередь)
────────────────────────────────────────────────────────────────

  constructor Init(NumElements, ElementSize : Word;
                   RejectIfFull : Boolean);
    {-Выделить память под статическую очередь}

  destructor Done; virtual;
    {-Вернуть системе память, которую занимала очередь}

  procedure PushTail(var Element);
    {-Добавить элемент к концу очереди}

  procedure PopTail(var Element);
    {-Удалить элемент из конца очереди}

  procedure PeekTail(var Element);
    {-Просмотреть элемента в конце очереди}

  procedure PopHead(var Element);
    {-Удалить элемент из начала очереди}

  procedure PeekHead(var Element);
    {-Просмотреть элемент в начале очереди}

  procedure Clear;
    {-Стереть все элементы в очереди}

  function Elements : Word;
    {-Возвращает число элементов, которые в настоящий момент
      находятся в очереди}

  function GetStatus : Word;
    {-Возвратить самый последний код состояния
      и сбросить внутреннюю статусную переменную в ноль}

  procedure Error(Code : Word); virtual;
    {-Сообщить об ошибке}

  constructor Load(var S : IdStream);
    {-Загрузить статическую очередь из потока}

  procedure Store(var S : IdStream);
    {-Занести статическую очередь в поток}

OpRoot        Объект SingleListNode (узел односвязного списка)
────────────────────────────────────────────────────────────────

  constructor Init;
    {-Инициализировать узел односвязного списка}

                            - 111 -

OpRoot        Объект SingleList (односвязный список)
────────────────────────────────────────────────────────────────

  constructor Init;
    {-Инициализировать пустой список элементов}

  destructor Done; virtual;
    {-Удалить список}

  function Size : Word;
    {-Возвратить размер текущего списка}

  procedure Append(P : SingleNodePtr);
    {-Добавить элемент к концу списка}

  procedure Insert(P : SingleNodePtr);
    {-Вставить элемент в начало списка}

  procedure Place(P, L : SingleNodePtr);
    {-Поместить элемент P в список _после_ существующего
      элемента L}

  procedure PlaceBefore(P, L : SingleNodePtr);
    {-Поместить элемент P в список _перед_ существующим
      элементом L}

  procedure Delete(P : SingleNodePtr);
    {-Удалить существующий элемент в списке, разрушая его
      содержимое}

  procedure Remove(P : SingleNodePtr);
    {-Удалить существующий элемент из списка, не разрушая
      его содержимое}

  function Head : SingleNodePtr;
    {-Возвратить указатель на начало списка}

  function Tail : SingleNodePtr;
    {-Возвратить указатель на конец списка}

  function Next(P : SingleNodePtr) : SingleNodePtr;
    {-Возвратить указатель на следующий узел}

  constructor Load(var S : IdStream);
    {-Загрузить список из потока}

  procedure Store(var S : IdStream);
    {-Занести список в поток}

OpRoot        Объект DoubleListNode (узел двусвязного списка)
────────────────────────────────────────────────────────────────

  constructor Init;

                            - 112 -
    {-Инициализировать узел двусвязного списка}

OpRoot        Объект DoubleList (двусвязный список)
────────────────────────────────────────────────────────────────

  constructor Init;
    {-Инициализировать пустой список элементов}

  destructor Done; virtual;
    {-Удалить список}

  function Size : Word;
    {-Возвратить размер текущего списка}

  procedure Append(P : DoubleNodePtr);
    {-Добавить элемент к концу списка}

  procedure Insert(P : DoubleNodePtr);
    {-Вставить элемент в начало списка}

  procedure Place(P, L : DoubleNodePtr);
    {-Поместить элемент P в список _после_ существующего
      элемента L}

  procedure PlaceBefore(P, L : DoubleNodePtr);
    {-Поместить элемент P в список _перед_ существующим
      элементом L}

  procedure Delete(P : DoubleNodePtr);
    {-Удалить существующий элемент в списке, разрушая его
      содержимое}

  procedure Remove(P : DoubleNodePtr);
    {-Удалить существующий элемент из списка, не разрушая
      его содержимое}

  function Head : DoubleNodePtr;
    {-Возвратить указатель на начало списка}

  function Tail : DoubleNodePtr;
    {-Возвратить указатель на конец списка}

  function Next(P : DoubleNodePtr) : DoubleNodePtr; virtual;
    {-Возвратить указатель на следующий узел}

  function Prev(P : DoubleNodePtr) : DoubleNodePtr; virtual;
    {-Возвратить указатель на предыдущий узел}

  constructor Load(var S : IdStream);
    {-Загрузить список из потока}

  procedure Store(var S : IdStream);
    {-Занести список в поток}


                            - 113 -
OpRoot        Объект CircularList (круговой (циклический) список)
────────────────────────────────────────────────────────────────

  function Next(P : DoubleNodePtr) : DoubleNodePtr; virtual;
    {-Возвращает указатель на следующий узел (осуществляет цик-
      лический переход в конце списка)}

  function Prev(P : DoubleNodePtr) : DoubleNodePtr; virtual;
    {-Возвращает указатель на предыдущий узел (осуществляет цик-
      лический переход в начале списка)}

  procedure Store(var S : IdStream);
    {-Занести список в поток}

                            - 114 -


OpRoot        Объект BitSet (битовое множество)
────────────────────────────────────────────────────────────────

  constructor Init(Max : LongInt);
    {-Выделить память для элементов}

  destructor Done; virtual;
    {-Удалить область данных}

  procedure ClearAll; virtual;
    {-Удалить все биты (присвоить ноль)}

  procedure SetAll; virtual;
    {-Установить все биты (присвоить единицу)}

  function MaxBits : LongInt;
    {-Возвратить емкость битового множества}

  procedure SetBit(Element : LongInt); virtual;
    {-Установить бит}

  procedure ClearBit(Element : LongInt); virtual;
    {-Удалить бит (присвоить ноль)}

  procedure ToggleBit(Element : LongInt);
    {-Инвертировать состояние бита}

  procedure ControlBit(Element : LongInt; State : Boolean);
    {-Установить или удалить бит в зависимости от значения
      переменной State (состояние)}

  function TestSetBit(Element : LongInt) : Boolean;
    {-Возвратить текущее состояние бита и установить его
      (присвоить значение единица)}

  function TestClearBit(Element : LongInt) : Boolean;
    {-Возвратить текущее состояние бита и удалить его
      (присвоить значение ноль)}

  function BitIsSet(Element : LongInt) : Boolean; virtual;
    {-Возвратить значение True (истинно), если бит
      установлен (имеет значение единица)}

  function NextSet(Element : LongInt) : LongInt; virtual;
    {-Возвратить индекс следующего установленного бита или
      значение NoMoreBits, если установленных битов нет}

  function NextClear(Element : LongInt) : LongInt; virtual;
    {-Возвратить индекс следующего удаленного бита или
      значение NoMoreBits, если удаленных битов нет}

  function PrevSet(Element : LongInt) : LongInt; virtual;
    {-Возвратить индекс предыдущего установленного бита
      или значение NoMoreBits, если установленных битов
      больше нет}

  function PrevClear(Element : LongInt) : LongInt; virtual;
    {-Возвратить индекс предыдущего удаленного бита или
      значение NoMoreBits, если удаленных битов больше нет}

  function BitsSet : LongInt; virtual;
    {-Возвратить число установленных битов}

  function FirstSet : LongInt;
    {-Возвратить индекс первого установленного бита
      или значение NoMoreBits, если установленных битов нет}

  function LastSet : LongInt;
    {-Возвратить индекс последнего установленного бита или
      значение NoMoreBits, если установленных битов нет}

  function FirstClear : LongInt;
    {-Возвратить индекс первого удаленного бита или значение
      NoMoreBits, если удаленных битов нет}

  function LastClear : LongInt;
    {-Возвратить индекс последнего удаленного бита или значение
      NoMoreBits, если удаленных битов нет}

  constructor Load(var S : IdStream);
    {-Загрузить битовое множество из потока}

  procedure Store(var S : IdStream);
    {-Занести битовое множество в поток}

OpRoot        Объект LagreBitSet (большое битовое множество)
────────────────────────────────────────────────────────────────

  constructor Init(Max : LongInt);
    {-Выделить пространство под элементы}

  function Resize(Max : LongInt) : Boolean;
    {-Увеличить или уменьшить объект LagreBitSet (большое
      битовое множество), чтобы он мог хранить максимально
      Max битов}

  function GetStatus : Word;
    {-Возвратить последний код состояния и сбросить внутреннюю
      статусную переменную в ноль}

  procedure Error(Code : Word); virtual;
    {-Сообщить об ошибке}

  constructor Load(var S : IdStream);
    {-Загрузить битовое множество из потока}

  procedure Store(var S : IdStream);
    {-Занести битовое множество в поток}

OpRoot        Объект StringDict (словарь строк)
────────────────────────────────────────────────────────────────

  constructor Init;
    {-Выделить пул хэш-памяти для словаря строк}

  destructor Done; virtual;
    {-Удалить пул}

  procedure Add(S : String; Value : LongInt);
    {-Добавить строку и связанное с ней значение в словарь}

  function Member(S : String; var Value : LongInt) : Boolean;
    {-Возвратить значение true и связанное значение value, если
      S является элементом словаря}

  procedure Update(S : String; Value : LongInt);
    {-Изменить значение данных, связанное со строкой}

  procedure Remove(S : String);
    {-Удалить строку из словаря}

  procedure Clear;
    {-Удалить все строки из словаря}

  function GetStatus : Word;
    {-Возвратить код состояния и сбросить внутреннюю статус-
      ную переменную в ноль}

  constructor Load(var S : IdStream);
    {-Загрузить словарь строк из потока}

  procedure Store(var S : IdStream);
    {-Занести словарь строк в поток}

  function Hash(var S : String) : Word; virtual;
    {-Возвратить хэш-код для заданной строки}

  function Equal(var S, T : String) : Boolean; virtual;
    {-Возвратить значение True, если заданные две строки
      сочтены равными}

  procedure Error(Code : Word); virtual;
    {-Сообщить об ошибке}

OpRoot        Объект StringSet (строковое множество)
────────────────────────────────────────────────────────────────

  procedure Add(S : String);
    {-Добавить строку к множеству}

  function Member(S : String) : Boolean;
    {-Возвратить true, если S является элементом множества}

  constructor Load(var S : IdStream);
    {-Загрузить список из потока}

  procedure Store(var S : IdStream);
    {-Занести список в поток}

OpRoot        Объект StringArray (массив строк)
────────────────────────────────────────────────────────────────

  constructor Init(StrMax, Amount : Word);
    {-Выделить память для StrMax строк, которые будут
      занимать Amount байт памяти}

  constructor ReadText(FileName : PathStr);
    {-Инициализировать упакованный массив из
      текстового файла}

  destructor Done; virtual;
    {-Удалить упакованный массив}

  procedure WriteText(FileName : PathStr);
    {-Занести упакованный массив в текстовый файл}

  constructor Load(var S : IdStream);
    {-Загрузить двоичный упакованный массив из потока}

  procedure Store(var S : IdStream);
    {-Занести упакованный строковый массив во поток}

  function GetString(Which : Word) : String; virtual;
    {-Возвратить строку из упакованного массива}

  function GetStringPtr(Which : Word) : StringPtr;
    {-Возвратить указатель на строку из упакованного массива}

  function Shrink : Boolean;
    {-Удалить лишнее пространство в упакованном массиве}

  function AddString(St : String) : Word;
    {-Добавить новую строку, возвращая ее индекс или 0
      в случае ошибки}

  function NumStrings : Word;
    {-Возвратить число строк в упакованном массиве}

  function Size : Word;
    {-Возвратить число байтов, используемых строками}

OpLarray      Объект AbstractArray (абстрактный массив)
────────────────────────────────────────────────────────────────

  constructor Init(Rows, Cols : Word; ElementSize : Word;
        HeapToUse : LongInt; ArrayOptions : Byte);
    {-Создать новый массив}

  constructor LoadA(HeapToUse : LongInt; ArrayOptions : Byte);
    {-Загрузить массив с диска}

  destructor Done; Virtual;
    {-Удалить массив}

  function ErrorA : Word;
    {-Возвратить последний код ошибки (0 означает отсутствие
      ошибки)}

  procedure SetA(Row, Col : Word; var Value); Virtual;
    {-Задать значение элемента массива}

  procedure RetA(Row, Col : Word; var Value); Virtual;
    {-Возвратить значение элемента массива}

  procedure SafeSetA(Row, Col : Word; var Value); Virtual;
    {-Задать значение элемента массива при безопасной работе
      с ситуациями выхода координат за границы диапазонов}

  procedure SafeRetA(Row, Col : Word; var Value); Virtual;
    {-Возвратить значение элемента массива при безопасной
      работе с ситуациями выхода координат за границы диапазонов}

  procedure ClearA(var Value; Initialize : InitType); Virtual;
    {-Стереть значения массива}

  procedure StoreA(FileName : String); Virtual;
    {-Занести большой массив в файл}

  procedure CloseA; Virtual;
    {-Закрыть массив и обнулить его содержимое}

  procedure FlushA; Virtual;
    {-Сбросить изменения на диск}

  function RangeError(Row, Col : Word) : Boolean; Virtual;
    {-Возвращает значение true (истинно), если переданные
      значения строки Row или столбца Col находятся вне
      границ диапазона}

  function TypeOfArray : ArrayType;
    {-Возвращает тип массива}

  procedure SetErrorProc(EP : ErrorProc);
    {-Задать пользовательскую процедуру обработки ошибок
      errorproc}

  procedure GetErrorProc(var EP : ErrorProc);
    {-Получить текущую процедуру обработки ошибок errorproc}

  procedure ArrayDimensions(var Rows,Cols : Word);
    {-Возвратить значения размеров массива}

  procedure lOptionsOn(OptionCodes : Word);
    {-Задать параметры-флаги массива}

  procedure lOptionsOff(OptionCodes : Word);
    {-Отменить параметры-флаги массива}

  function lOptionsAreOn(OptionCodes : Word) : Boolean;
    {-Проверить состояние параметров-флагов}

OpLarray      Объект RamArray (массив в памяти)
────────────────────────────────────────────────────────────────

  constructor Init(Rows, Cols : Word; ElementSize : Word;
                   HeapToUse : LongInt; ArrayOptions : Byte);
    {-Создать новый массив}

  constructor LoadA(FileName : String; HeapToUse : LongInt;
                    ArrayOptions : Byte);
    {-Загрузить массив с диска}

OpLarray      Объект RamRCArray (массив в памяти с
              проверкой диапазонов)
────────────────────────────────────────────────────────────────

  constructor Init(Rows, Cols : Word; ElementSize : Word;
                   HeapToUse : LongInt; ArrayOptions : Byte);
    {-Создать новый массив}

  constructor LoadA(FileName : String; HeapToUse : LongInt;
                    ArrayOptions : Byte);
    {-Загрузить массив с диска}

OpLarray      Объект EmsArray (массив в EMS памяти)
────────────────────────────────────────────────────────────────

  constructor Init(Rows, Cols : Word; ElementSize : Word;
                   HeapToUse : LongInt; ArrayOptions : Byte);
    {-Создать новый массив}

  constructor LoadA(FileName : String; HeapToUse : LongInt;
                    ArrayOptions : Byte);
    {-Загрузить массив с диска}

OpLarray      Объект EmsRCArray (массив в EMS памяти
              с проверкой диапазонов)
────────────────────────────────────────────────────────────────

  constructor Init(Rows, Cols : Word; ElementSize : Word;
                   HeapToUse : LongInt; ArrayOptions : Byte);
    {-Создать новый массив}

  constructor LoadA(FileName : String; HeapToUse : LongInt;
                    ArrayOptions : Byte);
    {-Загрузить массив с диска}

OpLarray      Объект VirtualArray (виртуальный массив)
────────────────────────────────────────────────────────────────

  constructor Init(Rows, Cols : Word; ElementSize : Word;
                   FileName : String; HeapToUse : LongInt;
                   ArrayOptions : Byte);
    {-Создать новый массив}

  constructor LoadA(FileName : String; HeapToUse : LongInt;
                    ArrayOptions : Byte);
    {-Загрузить массив с диска}

OpLarray      Объект PrimitiveArray (массив-примитив)
────────────────────────────────────────────────────────────────

  constructor Init(RowsInPage : Word;
                   ColsInPage : Word;
                   PagesDown : Word;
                   PagesAcross : Word;
                   ElementSize : Word;
                   FileName : string;
                   HeapToUse : LongInt;
                   ArrayOptions : Byte);
    {-Создать новый массив}

OpLarray      Объект VirtualRCArray (виртуальный массив
              с проверкой диапазонов)
────────────────────────────────────────────────────────────────

  constructor Init(Rows, Cols : Word; ElementSize : Word;
                   FileName : String; HeapToUse : LongInt;
                   ArrayOptions : Byte);
    {-Создать новый массив}

  constructor LoadA(FileName : String; HeapToUse : LongInt;
                    ArrayOptions : Byte);
    {-Загрузить массив с диска}

OpLarray      Объект OpArray (массив)
────────────────────────────────────────────────────────────────

  constructor Init(Rows, Cols : Word; ElementSize : Word;
                    FileName : String; HeapToUse : LongInt;
                    ArrayOptions : Byte;
                    var Priority : AutoPriority);
    {-Создать новый массив}

  constructor LoadA(FileName : String; HeapToUse : LongInt;
                    ArrayOptions : Byte;
                    var Priority : AutoPriority);
    {-Загрузить массив с диска}

OpLarray      Процедуры и функции
────────────────────────────────────────────────────────────────

  procedure DisplayLErrorProc(UnitCode : Byte;
                              var ErrorCode : Word;
                              ErrorMsg : String);
    {-Процедура обработки ошибок, которая отображает стандартное
      сообщение об ошибке, которую генерирует данный модуль.
      Останова при возникновении ошибки не происходит.}

OpString      Процедуры и функции
────────────────────────────────────────────────────────────────

  function HexB(B : Byte) : string;
    {-Возвратить строку с шестнадцатеричным
      значением байта}

  function HexW(W : Word) : string;
    {-Возвратить строку с шестнадцатеричным
      значением слова}

  function HexL(L : LongInt) : string;
    {-Возвратить строку с шестнадцатеричным
      значением длинного целого}

  function HexPtr(P : Pointer) : string;
    {-Возвратить строку с шестнадцатеричным
      значением указателя}

  function BinaryB(B : Byte) : string;
    {-Возвратить строку с двоичным значением байта}

  function BinaryW(W : Word) : string;
    {-Возвратить строку с двоичным значением слова}

  function BinaryL(L : LongInt) : string;
    {-Возвратить строку с двоичным значением длинного целого}

  function OctalB(B : Byte) : string;
    {-Возвратить строку с восьмеричным значением байта}

  function OctalW(W : Word) : string;
    {-Возвратить строку с восьмеричным значением слова}

  function OctalL(L : LongInt) : string;
    {-Возвратить строку с восьмеричным значением
      длинного целого}

  function Str2Int(S : string; var I : Integer) : Boolean;
    {-Преобразовать строку в целое, возвращая значение
      true при успешном завершении}

  function Str2Word(S : string; var I : Word) : Boolean;
    {-Преобразовать строку в слово, возвращая значение
      true при успешном завершении}

  function Str2Long(S : string; var I : LongInt) : Boolean;
    {-Преобразовать строку в длинное целое, возвращая значение
      true при успешном завершении}

  function Str2Real(S : string; var R : Float) : Boolean;
    {-Преобразовать строку в действительное, возвращая значение
      true при успешном завершении}

  function Long2Str(L : LongInt) : string;
    {-Преобразовать длинное целое/слово/целое/байт/короткое
      целое в строку}

  function Real2Str(R : Float; Width : Byte;
                    Places : ShortInt) : string;
    {-Преобразовать действительное число в строку}

  function Form(Mask : string; R : Float) : string;
    {-Возвращает форматированную строку с цифрами, полученными
      из R путем наложения маски Mask}

  function LongIntForm(Mask : string; L : LongInt) : string;
    {-Возвращает форматированную строку с цифрами, полученными
      из L путем наложения маски Mask}

  function UpCaseMac(Ch : Char) : Char;
    {-Макрос преобразования в символы верхнего регистра без
      поддержки международной таблицы символов}

  function LoCaseMac(Ch : Char) : Char;
    {-Макрос преобразования в символы нижнего регистра без
      поддержки международной таблицы символов}

  function Upcase(Ch : Char) : Char;
    {-Возвратить символ в верхнем регистре с поддержкой
      международной таблицы символов}

  function StUpcase(S : string) : string;
    {-Возвратить строку в верхнем регистре с поддержкой
      международной таблицы символов}

  function LoCase(Ch : Char) : Char;
    {-Возвратить символ в нижнем регистре с поддержкой
      международной таблицы символов}

  function StLocase(S : string) : string;
    {-Возвратить строку в нижнем регистре с поддержкой
      международной таблицы символов}

  function CharStr(Ch : Char; Len : Byte) : string;
    {-Возвратить строку длиной len, заполненную символом ch}

  function PadCh(S : string; Ch : Char; Len : Byte) : string;
    {-Возвратить строку, которая справа дополнена до длины
      len символами ch}

  function Pad(S : string; Len : Byte) : string;
    {-Возвратить строку, которая справа дополнена до длины
      len символами пробела}

  function LeftPadCh(S : string; Ch : Char;
                     Len : Byte) : string;
    {-Возвратить строку, которая слева дополнена до длины
      len символами ch}

  function LeftPad(S : string; Len : Byte) : string;
    {-Возвратить строку, которая слева дополнена до длины
      len символами пробела}

  function TrimLead(S : string) : string;
    {-Возвратить строку, в которой удалены начальные символы
      пробела}

  function TrimTrail(S : string) : string;
    {-Возвратить строку, в которой удалены завершающие символы
      пробела}

  function Trim(S : string) : string;
    {-Возвратить строку, в которой удалены начальные и завер-
      шающие пробельные символы (символы пустого пространства)}

  function TrimSpaces(S : string) : string;
    {-Возвратить строку, в которой удалены начальные и завер-
      шающие символы пробелов}

  function CenterCh(S : string; Ch : Char; Width : Byte) : string;
    {-Вернуть строку, центрированную в строке, заполненной сим-
      волами Ch и имеющей длину width}

  function Center(S : string; Width : Byte) : string;
    {-Вернуть строку, центрированную в строке, заполненной сим-
      волами пробела и имеющей длину width}

  function Entab(S : string; TabSize : Byte) : string;
    {-Преобразовывать пробелы в строке в табуляционные метки
      с интервалом табуляции равным TabSize}

  function Detab(S : string; TabSize : Byte) : string;
    {-Преобразовать метки табуляции в строке в пробелы при интер-
      вале табуляции равном TabSize}

  function WordCount(S : string; WordDelims : CharSet) : Byte;
    {-Для заданного набора разделителей слов возвращает число
      слов в строке S}

  function WordPosition(N : Byte; S : string;
                        WordDelims : CharSet) : Byte;
    {-Для заданного набора разделителей слов возвращает началь-
      ную позицию N-ого слова в строке S}

  function ExtractWord(N : Byte; S : string;
                       WordDelims : CharSet) : string;
    {-Для заданного набора разделителей слов возвращает N-ое
      слово в строке S}

  procedure WordWrap(InSt : string; var OutSt, Overlap : string;
                     Margin : Byte; PadToMargin : Boolean);
   {-Осуществляет перенос входной строки InSt у поля Margin,
     занося результат в строку OutSt и остаток в строку Overlap}

  function CompString(S1, S2 : string) : CompareType;
    {-Возвращает значение less (меньше), equal (равно) или
      greater (больше), если s1<s2, s1=s2, или s1>s2 соответ-
      ственно}

  function CompUCString(S1, S2 : string) : CompareType;
    {-Сравнить две строки безотносительно к регистру букв}

  function CompStruct(var S1, S2; Size : Word) : CompareType;
    {-Сравнить две структуры фиксированного размера}

  function Search(var Buffer; BufLength : Word;
                  var Match; MatLength : Word) : Word;
   {-Искать в буфере Buffer подходящий объект. BufLength
     является длиной диапазона поиска. MatLength представ-
     ляет длину строки, используемой для поиска. Возвращает
     число байтов, просмотренных в целях обнаружения объекта
     Match или значение $FFFF, если объект не найден.}

  function SearchUC(var Buffer; BufLength : Word;
                    var Match; MatLength : Word) : Word;
   {-Искать в буфере Buffer объект Match, НЕЧУВСТВИТЕЛЬНА
     К РЕГИСТРУ БУКВ. В остальных отношениях аналогична
     функции Search.}

  procedure BMMakeTable(MatchString : string; var BT : BTable);
    {-Построить таблицу связи Бойера-Мура}

  function BMSearch(var Buffer; BufLength : Word;
                    BT : BTable;
                    MatchString : string) : Word;
    {-Искать в буфере Buffer подходящую строку MatchString.
      BufLength является длиной диапазона поиска. Возвращает
      число байтов, просмотренных для обнаружения строки
      MatchString или значение $FFFF, если строка не об-
      наружена}

  function BMSearchUC(var Buffer; BufLength : Word;
                      BT : BTable; MatchString : string) : Word;
   {-Искать в буфере Buffer подходящую строку MatchString.
     НЕЧУВСТВИТЕЛЬНА К РЕГИСТРУ БУКВ. Подразумевает, что
     строка MatchString уже находится в верхнем регистре.
     В остальных отношениях аналогична функции BMSearch}

  function Soundex(S : string) : string;
    {-Возвращает состоящую из 4 символов фонему (soundex)
      входной строки}

  function MakeLetterSet(S : string) : LongInt;
    {-Возвратить длинное целое с побитовым отображением,
      в котором хранятся отдельные буквы, содержащиеся
      в строке S}

  function CompareLetterSets(Set1, Set2 : LongInt) : Word;
    {-Возвратить сумму значений букв, общих в наборах
      Set1 и Set2}

  function StringToHeap(S : string) : StringPtr;
    {-Выделить память для строки s и возвратить указатель
      на нее}

  function StringFromHeap(P : StringPtr) : string;
    {-Возвратить строку, на которую указывает p}

  procedure DisposeString(P : StringPtr);
    {-Освободить память, занимаемую строкой, на которую
      указывает p}

  function DefaultExtension(Name : string;
                            Ext : ExtStr) : string;
    {-Возвратить имя файла с присоединенным к нему стандартным
      расширением файла}

  function ForceExtension(Name : string;
                          Ext : ExtStr) : string;
    {-Присоединить указанное расширение к имени файла}

  function JustFilename(PathName : string) : string;
    {-Возвратить только имя файла и расширение маршрутного
      имени}

  function JustName(PathName : string) : string;
    {-Возвратить только имя (без расширения, без маршрута
      от маршрутного имени}

  function JustExtension(Name : string) : ExtStr;
    {-Возвратить только расширение от маршрутного имени}

  function JustPathname(PathName : string) : string;
    {-Возвратить только компонент диск:директория от
      маршрутного имени}

  function AddBackSlash(DirName : string) : string;
    {-Добавить стандартную обратную косую к имени директории}

  function CleanPathName(PathName : string) : string;
    {-Возвратить имя файла в том виде, в котором его
      возвращает DOS}

  function FullPathName(FName : string) : string;
    {-Для заданного имени файла FName (гарантированно
      существующего), возвратить полное маршрутное имя}

OpAsciiz      Процедуры и функции
────────────────────────────────────────────────────────────────

  function Asc2Str(var A : Asciiz) : string;
    {-Преобразовать Asciiz строку в строку формата Turbo,
      усекая ее, если ее длина превышает 255 символов}

  procedure Str2Asc(S : string; var A : Asciiz);
    {-Преобразовать строку формата Turbo в строку формата Asciiz}

  function LenAsc(A : Asciiz) : Word;
    {-Возвратить длину строки формата Asciiz}

  procedure CopyAsc(var A : Asciiz; Start, Len : Word;
                    var O : Asciiz);
    {-Возвратить подстроку строки a. Отметьте возможность условия
      start=0 для первого символа в строке a}

  procedure DeleteAsc(var A : Asciiz; Start, Len : Word);
    {-Удалить len символов строки a, начиная с позиции start}

  procedure ConcatAsc(var A, B, C : Asciiz);
    {-Конкатенировать две строки в формате Asciiz,
      возвращая третью строку}

  procedure ConcatStr(var A : Asciiz; S : string; var C : Asciiz);
    {-Конкатенировать строку в строку формата asciiz,
      возвращая новую строку в формате asciiz}

  procedure InsertAsc(var Obj, A : Asciiz; Start : Word);
    {-Вставить объект obj в формате asciiz в позицию start
      строки a}

  procedure InsertStr(Obj : string; var A : Asciiz; Start : Word);
    {-Вставить объект obj типа string в позицию start
      строки a}

  function PosStr(Obj : string; var A : Asciiz) : Word;
    {-Возвратить позицию строки obj в строке a,
      возвратить значение NotFound, если искомая подстрока не
      найдена}

  function PosAsc(var Obja, A : Asciiz) : Word;
    {-Возвратить позицию объекта obja в строке a,
      возвратить значение NotFound, если искомая подстрока не
      найдена}

  function AscToHeap(var A : Asciiz) : AsciizPtr;
    {-Занести переменную в формате Asciiz в "кучу" (динами-
      ческую память, возвратить указатель или значение
      nil при нехватке памяти}

  procedure AscFromHeap(P : AsciizPtr; var A : Asciiz);
    {-Возвратить строку в формате Asciiz, расположенную в
      динамической памяти или пустую строку, если указатель
      имеет значение nil}

  procedure DisposeAsc(P : AsciizPtr);
    {-Вернуть системе область памяти, на которую указывает P}

  function ReadLnAsc(var F : Text; var A : Asciiz) : Boolean;
    {-Считать строку в формате Asciiz из текстового файла,
      возвратить значение true в случае успешного завершения}

  function WriteAsc(var F : Text; var A : Asciiz) : Boolean;
    {-Записать строку в формате Asciiz в текстовый файл,
      возвратить значение true в случае успешного завершения}

  procedure AscUpcase(var A, B : Asciiz);
    {-Преобразовать в символы верхнего регистра строку
      в формате Asciiz с именем a, возвращая строку b}

  procedure AscLocase(var A, B : Asciiz);
    {-Преобразовать в символы нижнего регистра строку
      в формате Asciiz с именем a, возвращая строку b}

  procedure AscCharStr(Ch : Char; Len : Word; var A : Asciiz);
    {-Возвратить строку формата Asciiz длиной len,
      заполненную символами ch}

  procedure AscPadCh(var A : Asciiz; Ch : Char;
                     Len : Word; var B : Asciiz);
    {-Дополнить справа строку формата Asciiz до длины len
      символами ch, возвращая b}

  procedure AscPad(var A : Asciiz; Len : Word; var B : Asciiz);
    {-Дополнить справа строку формата Asciiz до длины len
      символами пробела, возвращая b}

  procedure AscLeftPadCh(var A : Asciiz; Ch : Char; Len : Word;
                         var B : Asciiz);
    {-Дополнить слева строку формата Asciiz до длины len
      символами ch, возвращая b}

  procedure AscLeftPad(var A : Asciiz; Len : Word; var B : Asciiz);
    {-Дополнить слева строку формата Asciiz до длины len
      символами пробела, возвращая b}

  procedure AscTrimLead(var A, B : Asciiz);
    {-Возвратить строку формата Asciiz с удаленными начальными
      символами пробела}

  procedure AscTrimTrail(var A, B : Asciiz);
    {-Возвратить строку формата Asciiz с удаленными конечными
      символами пробела}

  procedure AscTrim(var A, B : Asciiz);
    {-Возвратить строку формата Asciiz с удаленными начальными
      и конечными символами пробела}

  procedure AscCenterCh(var A : Asciiz; Ch : Char; Width : Word;
                        var B : Asciiz);
    {-Возвратить строку формата Asciiz центрированную в строке
      формата Asciiz заданной ширины width, которая заполнена
      символами Ch}

  procedure AscCenter(var A : Asciiz; Width : Word;
                      var B : Asciiz);
    {-Возвратить строку формата Asciiz центрированную в строке
      формата Asciiz заданной ширины width, которая заполнена
      символами пробела}

  function CompAsc(var a1, a2 : Asciiz) : AscCompareType;
    {-Возвратить значение less (меньше), equal (равно) или
      greater (больше), если выполняется условие a1<a2, a1=a2,
      или a1>a2 соответственно}

  function CompUCAsc(var a1, a2 : Asciiz) : AscCompareType;
    {-Сравнить две строки формата Asciizs без учета регистра
      букв}

OpStrDev      Процедуры и функции
────────────────────────────────────────────────────────────────

  procedure ReadStr(var S : string);
    {-'Считать' строку в S из выделенного строкового буфера}

  function ReturnStr : string;
    {-Возвратить содержимое выделенного строкового буфера}

OpDos         Процедуры и функции
────────────────────────────────────────────────────────────────

  function DosVersion : Word;
    {-Возвращает номер версии DOS. Старший байт содержит
      целую часть номера версии, младший - дробную часть
      номера версии. Например, DOS 3.1 => $0301.}

  function NumberOfDrives : Byte;
    {-Возвращает число логических дисководов}

  procedure SelectDrive(Drive : Char);
    {-Выбирает указанный дисковод в качестве используемого
      по умолчанию (при возможности)}

  function DefaultDrive : Char;
    {-Возвращает идентификатор используемого по умолчанию
      дисковода в виде буквы верхнего регистра}

  function ValidDrive(Drive : Char) : Boolean;
    {-Возвращает значение True, если указанный дисковод
      существует}

  function GetDiskInfo(Drive : Byte; var ClustersAvailable,
                       TotalClusters,
                       BytesPerSector,
                       SectorsPerCluster : Word) : Boolean;
    {-Возвращает техническую информацию относительно
      указанного дисковода}

  function GetDiskClass(Drive : Char;
                        var SubstDriveChar : Char) : DiskClass;
    {-Возвращает класс дискового устройства для дисковода,
      который задан буквой}

  function ReadDiskSectors(Drive : Word; FirstSect : Longint;
                           NumSects : Word; var Buf) : Boolean;
    {-Считывает абсолютные секторы диска.}

  function WriteDiskSectors(Drive : Word; FirstSect : Longint;
                            NumSects : Word; var Buf) : Boolean;
    {-Записывает абсолютные секторы на диск.}

  function GetFileMode(FName : string; var Attr : Word) : Byte;
    {-Возвращает атрибут файла в переменной Attr и код ошибки
      DOS в качестве результата функции.}

  function FlushDosBuffers(var F) : Boolean;
    {-Сбрасывает буферы DOS для указанного файла}

  function FileHandlesLeft : Byte;
    {-Возвращает число доступных дескрипторов файлов}

  function FileHandlesOpen(CountDevices : Boolean) : Byte;
    {-Возвращает число открытых файлов, которыми
      владеет программа}

  procedure SetDta(DTAptr : Pointer);
    {-Задает DOS DTA как указатель DTAptr}

  procedure GetDta(var DTAptr : Pointer);
    {-Возвратить значение указателя DOS DTA}

  function ParsePath(var InputPath, SearchPath,
                     LeadInPath : string) : Boolean;
    {-Получает заданный пользователем маршрут, удаляет пробелы
      и возвращает достоверный глобальный маршрут поиска и
      достоверный локальный маршрут.}

  function PrintInstalled : Boolean;
    {-Возвратить значение True, если установлена утилита
      PRINT.COM}

  function SubmitPrintFile(FileName : string) : Byte;
    {-Данная процедура передает файл в утилиту параллельной печати
      операционной системы PC DOS версии 3.0 или более поздней.}

  procedure CancelPrintFile(FileMask : string);
    {-Отменяет печать файлов, которые соответствуют маске,
      переданной в параметре FileMask.}

  procedure CancelAllPrintFiles;
    {-Отменяет печать всех файлов, находящихся в очереди печати}

  function GetPrintStatus(var QPtr : Pointer) : Byte;
   {-Прекращает печать, возвращает текущий статус ошибки, при-
     сваивает переменной QPtr значение указателя на очередь
     имен файлов. Имена файлов в очереди являются 64-байтовыми
     строками в формате ASCIIZ. Конец очереди маркируется именем,
     которое начинается с нулевого символа.}

  procedure EndPrintStatus;
    {-Деблокирует спулер (блок подкачки), заблокированный
      процедурой GetPrintStatus.}

  function GetEnvironmentString(SearchString : string) : string;
    {-Возвращает строку среды}

  function SetBlock(var Paragraphs : Word) : Boolean;
    {-Изменить размер блока памяти DOS, который выделен для
      этой программы}

  procedure NoExecDosProc(ActionCode : ActionCodeType;
                          Param : Word);
    {-Процедура ExecDosProc, которая не выполняет никаких
      действий}

  function ExecDos(Command : string; UseSecond : Boolean;
                   EDP : ExecDosProc) : Integer;
   {-Выполнить любую команду DOS. Если параметр Command = '',
     то запускается новая оболочка.}

  function TextSeek(var F : Text; Target : LongInt) : Boolean;
   {-Позиционирование для текстового файла, который открыт для
     ввода. Возвращает значение False в случае ошибки
     ввода/вывода.}

  function TextFileSize(var F : Text) : LongInt;
    {-Возвратить размер текстового файла F. Возвращает значение
      -1 в случае ошибки ввода/вывода.}

  function TextPos(var F : Text) : LongInt;
   {-Возвратить текущую позицию логического файлового указателя
     (то есть, позицию физического указателя файла, скорректи-
     рованного с учетом буферизации. Возвращает -1 в случае
     ошибки ввода/вывода.}

  function TextFlush(var F : Text) : Boolean;
    {-Сбрасывает буфер (буферы), отведенные для текстового
      файла. Возвращает значение False в случае ошибки
      ввода/вывода.}

  function OpenStdDev(var F : Text; StdHandle : Word) : Boolean;
    {-Назначает текстовый файл на стандартное устройство DOS:
      0, 1, 2, или 4}

  function HandleIsConsole(Handle : Word) : Boolean;
    {-Возвратить значение true, если дескриптор назначен
      на консольное устройство}

  procedure SetRawMode(var F : Text; On : Boolean);
    {-Задает "прототипный" режим для заданного текстового файла
      (должен представлять собой устройство)}

  function ExistFile(FName : string) : Boolean;
    {-Возвратить значение true, если файл найден}

  function ExistOnPath(FName : string;
                       var FullName : string) : Boolean;
    {-Возвратить значение true, если файл найден в:
     a) текущей директории
     b) директории программы (только DOS версии 3.X)
     c) любой директории DOS, заданной маршрутом
    и возвратить полное маршрутное имя файла}

  function IsDirectory(FName : String) : Boolean;
    {-Возвратить значение true, если FName является
      директорией}

  function SameFile(FilePath1,FilePath2 : String;
                    var ErrorCode : Word) : Boolean;
    {-Возвратить значение true, если FilePath1 и FilePath2
      относятся к одному и тому же физическому файлу.
      Коды ошибок:
        0 - успешное завершение (ошибок нет)
        1 - Неверный маршрут файла FilePath
    }

  function CopyFile(SrcPath, DestPath : String;
                    Buffer : Pointer;
                    BufferSize : Word) : Word;
    {-Копировать файл, заданный посредством SrcPath в файл
      DestPath.}

  function TimeMs : LongInt;
    {-Возвратить время дня в виде числа миллисекунд, истекших
      с полуночи}

  procedure MasterEnv(var Env : EnvRec);
    {-Возвратить основную запись среды}

  procedure CurrentEnv(var Env : EnvRec);
    {-Возвратить текущую запись среды}

  procedure ParentEnv(var Env : EnvRec);
    {-Возвратить запись среды программы-родителя}

  procedure NewEnv(var Env : EnvRec; Size : Word);
    {-Выделить новую среду в динамической области}

  procedure DisposeEnv(var Env : EnvRec);
    {-Вернуть системе память, которая была ранее выделена
      для переменных среды в динамической области}

  procedure SetCurrentEnv(Env : EnvRec);
    {-Задать другую среду для текущей программы}

  procedure CopyEnv(Src, Dest : EnvRec);
    {-Скопировать содержимое среды Src в среду Dest}

  function EnvFree(Env : EnvRec) : Word;
    {-Возвратить число свободных байтов в среде}

  function GetEnvStr(Env : EnvRec; Search : string) : string;
    {-Возвратить строку из среды}

  function SetEnvStr(Env : EnvRec; Search,
                     Value : string) : Boolean;
    {-Задать строку среды, возвращая значение true в случае
      успешного завершения}

  procedure DumpEnv(Env : EnvRec);
    {-Выдать содержимое среды на экран}

  function GetProgramStr(Env : EnvRec) : string;
    {-Возвратить имя программы, которая является владельцем
      среды Env или '', если версия DOS < 3.0 или неизвестна}

  function SetProgramStr(Env : EnvRec;
                         Path : string) : Boolean;
    {-Добавить имя программы в конец среды при наличии
      достаточного объема памяти}

  function ShellWithPrompt(Prompt : string;
                           EDP : ExecDosProc) : Integer;
    {-Выйти в оболочку DOS с новым запросом}

OpExec        Процедуры и функции
────────────────────────────────────────────────────────────────

  procedure SetSwapMsgOn(On : Boolean);
    {-Включает или выключает сообщение о своппинге}

  procedure ExecWithSwap(Path, CmdLine : String);
    {-Выйти в оболочку DOS со своппингом в EMS память
      или на диск}

  function PrepareExecWithSwap(LastToSave : Pointer;
                               SwapFileName : PathStr) : Boolean;
    {-Осуществить настройку на выход в оболочку со своппингом,
      возвращая значение true в случае успешного завершения}

  procedure RemoveExecWithSwap;
    {-Вернуть системе область EMS памяти или стереть
      использовавшийся для своппинга файл (в зависимости от того,
      что было выделено}

  function ExecDosSwap(Command : string;
                       UseSecond : Boolean;
                       EDP : Pointer;
                       SwapFName : PathStr) : Integer;
   {-Выполнить произвольную команду DOS.}

OpEnhKbd      Процедуры и функции
────────────────────────────────────────────────────────────────

  procedure RestoreKbdVectors;
    {-Восстановить оригинальные вектора для прерываний INT $09
      и INT $16}

  procedure InitKbdVectors;
    {-Сохранить и задать вектора прерываний. Данная подпрограмма
      должна вызываться только в том случае, если ранее была
      вызвана подпрограмма RestoreKbdVectors!!}

OpInt         Процедуры и функции
────────────────────────────────────────────────────────────────

  procedure InterruptsOn;
    {-Задать прерывания}

  procedure InterruptsOff;
    {-Отменить прерывания}

  procedure SendEOI;
    {-Послать команду End Of Interrupt (конец прерывания)
      в программируемый контроллер прерываний}

  procedure IntReturn(var IntRegs : IntRegisters);
    {-Осуществить возврат из прерывания. Требуется только в том
      случае, если был изменен стек.}

  procedure ChainInt(var Regs : IntRegisters;
                     JumpAddr : Pointer);
    {-Восстанавливает стек, регистры на основе Regs
      и осуществляет "переход" по адресу перехода JumpAddr}

  procedure SwapStackAndCallNear(Routine : Word; SP : Pointer;
    var Regs : IntRegisters);
    {-Переключает на стек, заданный посредством указателя стека
      SP и вызывает подпрограмму с регистрами Regs в качестве
      параметра. Эта подпрограмма должна являться ближним (NEAR)
      вызовом из текущего ISR.}

  procedure SwapStackAndCall(Routine, SP : Pointer;
                             var Regs : IntRegisters);
    {-Переключает на стек, заданный посредством указателя стека
      SP и вызывает подпрограмму с регистрами Regs в качестве
      параметра. Эта подпрограмма должна являться дальним (FAR)
      вызовом из текущего ISR.}

  procedure EmulateInt(var Regs : IntRegisters; IntAddr : Pointer);
    {-Эмулирует прерывание путем занесения в регистры центрального
      процессора значений в Regs, отмены прерываний, вталкивания
      в стек регистра флагов и дальнего вызова по адресу прерывания
      IntAddr.}

  function InitVector(IntNumber, Handle : Byte;
                      UserRoutine : Pointer) : Boolean;
    {-Задает сервисную подпрограмму обработки прерывания}

  procedure RestoreVector(Handle : Byte);
    {-Восстанавливает вектор прерывания, задавая ему оригинальное
      значение}

  procedure RestoreAllVectors;
    {-Восстанавливает все захваченные вектора прерываний.}

  function AllocateStack(var P : Pointer;
                         SizeInBytes : Word) : Boolean;
    {-Выделяет стек размера SizeInBytes}

  procedure DeallocateStack(P : Pointer);
    {-Удаляет выделенный стек}

OpTsr         Процедуры и функции
────────────────────────────────────────────────────────────────

  function ParagraphsToKeep : Word;
    {-Возвращает число параграфов, которые в настоящий момент
      используются для кода, данных, стека и динамической
      области.}

  function MaxParagraphsToKeep : Word;
    {-Максимальное число параграфов, которые необходимо оставить
      при переходе в резидентное состояние}

  procedure StayRes(ParasToKeep : Word; ExitCode : Byte);
   {-Завершить выполнение и остаться резидентной, освобождая всю
     память за исключением ParasToKeep. Возврат управления
     происходит только в том случае, если программа не может
     остаться резидентной.}

  procedure PopupsOn;
    {-Включить "всплывание"}

  procedure PopupsOff;
    {-Отключить "всплывание"}

  function DefinePopProc(var Handle : Byte;
                         Routine : PopupProc;
                         StackPtr : Pointer) : Boolean;
   {-Описывает подпрограмму, которая может быть триггерно
     активизирована путем вызова SetPopTicker. Возвращает
     значение false, если больше нет доступных дескрипторов
     "всплывающих" (Popup) программ.}

  procedure DeletePopProc(Handle : Byte);
   {-Удаляет всплывающую подпрограмму, которая описана с
     помощью DefinePopProc. Впоследствие ее дескриптор
     может быть использован для других "всплывающих" программ.}

  function DefinePop(HotKey : Word; Routine : PopupProc;
                     StackPtr : Pointer;
                     DosWait : Boolean) : Boolean;
   {-Описывает всплывающую подпрограмму, которая связана с кон-
     кретной клавишей активизации. Возвращает значение False,
     если больше нет доступных дескрипторов "всплывающих"
     (Popup) программ.}

  procedure DeletePop(HotKey : Word);
   {-Удаляет всплывающую подпрограмму, которая связана с
     клавишей активизации HotKey. Впоследствие ее дескриптор
     может быть использован для других "всплывающих" программ.}

  function ChangeHotKey(OldHotKey, NewHotKey : Word) : Boolean;
    {-Изменить значение клавиши активизации (hotkey) резидентной
      (всплывающей) программы с значения OldHotKey (старая клавиша
      активизации) на значение NewHotKey (новая клавиша
      активизации)}

  function AddHotKey(PrimaryHotKey,
                     SecondaryHotKey : Word) : Boolean;
    {-Добавить вторую клавишу активизации для всплывающей
      программы, которая имеет указанную первичную клавишу
      активизации}

  procedure SetPopTicker(Handle : Byte; TimeOut : Word);
   {-Задает временной интервал для указанной процедуры,
     отменяет прерывания, затем осуществляет возврат. Проверка
     диапазонов не выполняется.}

  procedure RemovePops;
   {-Удаляет из системы все всплывающие (резидентные) программы
     и освобождает все связанные вектора прерываний}

  procedure InitPops;
    {-Должна быть вызвана перед другими специфическим для
      резидентных (всплывающих) программ подпрограммами}

  function DisableTSR : Boolean;
    {-Удалить резидентную программу путем восстановления векторов
      прерываний и освобождения памяти. Это действие не приводит
      к прекращению выполнения программы. Возвращает значение
      False, если указанные действия небезопасны.}

  function SafeToDisable : Boolean;
    {-Возвращает значение True, если удаление резидентной программы
      не представляет опасности}

  procedure InstallModule(var ModuleName : string;
                          CmdEntryRoutine : Pointer);
   {-Инсталлирует данную программу как резидентный модуль, место-
     положение которого может быть определено, и к которому можно
     обращаться из других программ.}

  procedure UninstallModule;
    {-Удаляет данный модуль из связного списка модулей}

  function ModulePtrByName(var ModuleName : string) : IfcPtr;
    {-Возвращает указатель на запись IfcRecord для модуля
      с именем ModuleName или значение Nil}

  function ModuleInstalled(var ModuleName : string) : Boolean;
    {-Возвращает значение true, если модуль с именем
      ModuleName инсталлирован.}

  function DosBusyFlag : Byte;
    {-Возвращает текущее значение флага занятости DOS}

  function DosCriticalFlag : Byte;
    {-Возвращает текущее значение флага критических ситуаций DOS}

  function GetPSP : Word;
    {-Возвращает текущий префикс сегмента программы}

  procedure SetPSP(PSP : Word);
    {-Задает текущий префикс сегмента программы}

OpSwap        Процедуры и функции
────────────────────────────────────────────────────────────────

  procedure SetPopTicker(TimeOut : Word);
    {-Задает интервал времени для процедуры CmdEntry,
      отменяет прерывания, затем возвращает управление.}

OpSwap1       Процедуры и функции
────────────────────────────────────────────────────────────────

  function AllocateStack(var P : Pointer;
                         SizeInBytes : Word) : Boolean;
    {-Выделить стек размером SizeInBytes}

  procedure DeallocateStack(P : Pointer);
    {-Удалить выделенных стек}

  procedure PopupsOn;
    {-Разрешить всплывание резидентных программ}

  procedure PopupsOff;
    {-Запретить всплывание резидентных программ}

  function ChangeHotKey(OldHotKey,
                        NewHotKey : Word) : Boolean;
    {-Изменить клавишу активизации всплывающей программы
      со старой клавиши OldHotKey на новую клавишу NewHotKey}

  function AddHotKey(PrimaryHotKey,
                     SecondaryHotKey : Word) : Boolean;
    {-Добавить вторую клавишу активации для всплывающей
      резидентной программы с указанной первичной клавишей
      активации}

  function DefinePop(HotKey : Word; Routine : PopupProc;
                     StackPtr : Pointer) : Boolean;
   {-Описывает всплывающую подпрограмму, которая связана с кон-
     кретной клавишей активизации. Возвращает значение False,
     если больше нет доступных дескрипторов "всплывающих"
     резидентных (Popup) программ.}

  procedure RestoreAllVectors;
    {-Restores all captured interrupt vectors}

  function SwapSize(ParasToKeep : Word) : LongInt;
    {-Возвратить размер в байтах той области памяти, которая
      должна быть своппирована (откачана)}

  function WillSwapUseEms(ParasToKeep : Word) : Boolean;
    {-Возвращает значение True, если модуль OpSwap будет исполь-
      зовать EMS память для своппинга}

  function ParagraphsToKeep : Word;
    {-Возвращает число параграфов, которые в настоящий момент
      используются для кода, данных, стека и динамической
      области.}

  function MaxParagraphsToKeep : Word;
    {-Максимальное число параграфов, которые необходимо оставить
      при переходе в резидентное состояние}

  procedure StayResSwap(ParasToKeep : Word;
                        ExitCode : Byte;
                        SwapFileName1,
                        SwapFileName2 : String;
                        UseSwapping : Boolean);
   {-Завершить выполнение и остаться резидентной.
     Если параметр UseSwapping имеет значение False, то
     резидентная программа (TSR) не использует методы своппинга
     и ведет себя как обычная резидентная программа, написанная
     с помощью модуля OpTSR (или TpTSR) }

  function DisableTSR : Boolean;
    {-Удалить резидентную программу путем восстановления векторов
      прерываний и освобождения памяти. Это действие не приводит
      к прекращению выполнения программы. Возвращает значение
      False, если указанные действия небезопасны.}

  function SafeToDisable : Boolean;
    {-Возвращает значение True, если удаление резидентной программы
      не представляет опасности}

  procedure DisablePopup;
   {-Внешняя интерфейсная процедура, которая пытается удалить
     всплывающую резидентную программу и сообщает о результатах
     в поле UserData записи IfcRecord. Поле UserData в случае
     успешного завершения получает значение 1.}

  procedure InstallModule(var ModName : string;
                          CmdEntryPtr : PopupProc);
   {-Инсталлирует данную программу как резидентный модуль, место-
     положение которого может быть определено, и к которому можно
     обращаться из других программ.}

  procedure UninstallModule;
    {-Удаляет данный модуль из связного списка модулей}

  procedure SetSwapMsgAttr(Attr : Byte);
    {-Задает атрибут, используемый менеджером своппинга
      для сообщений о своппинге}

  procedure SetSwapMsgOn(On : Boolean);
    {-Включает или выключает отображение сообщения о своппинге}

  procedure SetSwapMsgRow(Row : Byte);
    {-Задает строку экрана, в которой должно появляться
      сообщение о своппинге}

  procedure SetUserExitProc(UserExitProc : PopupProc);
    {-Задает указатель на дальнюю (far) процедуру, которая
      должна быть вызвана перед удалением резидента}

  function ModulePtrByName(var ModuleName : string) : IfcPtr;
    {-Возвращает указатель на запись IfcRecord для модуля с
      именем ModuleName или значение Nil.}

  function ModuleInstalled(var ModuleName : string) : Boolean;
    {-Возвращает значение true, если модуль с именем
      ModuleName инсталлирован.}

  procedure EmulateInt(var Regs : IntRegisters; IntAddr : Pointer);
    {-Эмулирует прерывание путем занесения в регистры центрального
      процессора значений в Regs, отмены прерываний, вталкивания
      в стек регистра флагов и дальнего вызова по адресу прерывания
      IntAddr.}

  function DosBusyFlag : Byte;
    {-Возвращает текущее значение флага занятости DOS}

  procedure SetVecOnReturn(IntNum : Byte; ISR : Pointer);
    {-Задает вектор прерывания в таблице ISR (используется
      при возврате управления от всплывающей резидентной программы)}

  procedure InterruptsOn;
    {-Разрешить прерывания}

  procedure InterruptsOff;
    {-Запретить прерывания}

Op8087        Процедуры и функции
────────────────────────────────────────────────────────────────

  procedure Save8087(var SaveBuf : SaveBuffer8087);
    {-Сохраняет значения регистров сопроцессора 80x87
      в резервном буфере.}

  procedure Restore8087(var SaveBuf : SaveBuffer8087);
    {-Восстанавливает значения регистров сопроцессора 80x87
      из резервного буфера.}

  function Installed8087 : Boolean;
    {-Возвращает значение true, если сопроцессор 80x87
      установлен в системе.}

  procedure Exceptions8087(On : Boolean);
    {-Разрешает или отменяет прерывания по исключительным
      ситуациям}

  function Error8087 : Word;
    {-Возвращает значение статуса ошибки сопроцессора
      80x87 и обнуляет статус}

  procedure Reinit8087;
    {-Реинициализировать микросхему 8087}

  procedure ReinitEmulator;
    {-Реинициализировать эмулятор}

  function UseEmulator : Boolean;
    {-Возвратить значение True, если процедура ReinitEmulator
      должна быть использована вместо процедуры Reinit8087}

OpEms         Процедуры и функции
────────────────────────────────────────────────────────────────

  function EmsInstalled : Boolean;
    {-Возвращает значение true, если менеджер EMM установлен.}

  function EmmSigFound : Boolean;
    {-Возвращает значение True, если обнаружена сигнатура
      менеджера EMM}

  function EmsStatusOK : Boolean;
    {-Возвращает значение true, если статус менеджера EMM
      свидетельствует об отсутствии ошибок.}

  function EmsPagesAvail : Word;
   {-Возвращает число доступных страниц менеджера отображаемой
     памяти (expanded memory manager), или код ошибки
     EmsErrorCode в случае ошибки.}

  function EmsTotalPages : Word;
   {-Возвращает общее число страниц памяти EMS, включая выделен-
     ные страницы или код ошибки EmsErrorCode в случае ошибки.}

  function EmsPageFramePtr : Pointer;
    {-Возвращает адрес базы страничного кадра (параграфа) в виде
      указателя на страничный кадр (параграф).}

  function AllocateEmsPages(NumPages : Word) : Word;
   {-Выделяет указанное число страниц и возвращает дескриптор.
     Возвращает код ошибки EmsErrorCode в случае ошибки.}

  function MapEmsPage(Handle, LogicalPage : Word;
                      PhysicalPage : Byte) : Boolean;
   {-Отображает заданную логическую страницу LogicalPage,
     связанную с дескриптором Handle, в физическую страницу
     PhysicalPage (0-3). Возвращает значение true в случае
     успешного завершения операции.}

  function DeallocateEmsHandle(Handle : Word) : Boolean;
    {-Освобождает указанный дескриптор и связанную с ним память.}

  function EmsVersion : Byte;
   {-Возвращает номер версии менеджера отображаемой памяти (EMM) в
     виде двоично-десятичного числа (BCD). Для проверки на версию
     3.2 или большую, например, следует использовать:
     'if EmsVersion >= $32 then'. Возвращает 0 в случае ошибки.}

  function SaveEmsContext(Handle : Word) : Boolean;
   {-Сохраняет контекст EMM для резидентных программ. Переданный
     дескриптор handle должен быть выделен посредством вызова
     AllocateEmsPages. Возвращает значение true  в случае успеш-
     ного завершения.}

  function RestoreEmsContext(Handle : Word) : Boolean;
   {-Возвращает контекст памяти для драйвера менеджера EMM
     по указанному дескриптору handle. Этот дескриптор должен
     быть тем же самым, который использовался в предыдущем вызове
     функции SaveEmsContext. Возвращает значение true  в случае
     успешного завершения.}

  function EmsActiveHandles : Word;
    {-Возвращает число активных дескрипторов памяти EMS или код
      ошибки EmsErrorCode в случае ошибки}

  function EmsPagesOwned(Handle : Word) : Word;
    {-Возвращает число страниц, которыми владеет дескриптор Handle
      или код ошибки EmsErrorCode в случае ошибки.}

OpExtMem      Процедуры и функции
────────────────────────────────────────────────────────────────

  function PtrToHuge(P : Pointer) : HugePtr;
    {-Преобразует указатель (тип pointer) в линейный (huge)
      указатель. Указатель должен быть в диапазоне от
      $0:$0 до $FFFF:$000F.}

  procedure MoveExtMem(Src, Dest : HugePtr; WCount : Word);
    {-Переместить WCount слов расширенной памяти из Src в Dest.}

  function ExtMemTotal : LongInt;
    {-Возвращает общее число байтов расширенной памяти в системе.}

  function ExtMemAvail : Word;
    {-Возвращает число Килобайтов расширенной памяти, которая
      на настоящий момент свободна.}

  function GetExtMem(N : Word) : HugePtr;
    {-Выделить N Kбайт расширенной памяти. Возвращает значение Nil
      в случае нехватки памяти.}

  function FreeExtMem(P : HugePtr) : Boolean;
    {-Освобождает расширенную память, которая была выделена с помощью
      функции GetExtMem. Данная функция работает только в том случае,
      если освобождаемый блок является последним блоком, выделенным
      вашей программой или любой другой. Возвращает значение false,
      если освобождение прошло безуспешно.}

  procedure MarkExtMem(var P : HugePtr);
    {-Занести адрес следующего блока расширенной памяти в P}

  procedure ReleaseExtMem(P : HugePtr);
    {-Освободить всю расширенную память, которая была выделена
      выше адреса P. P *должен* быть задан посредством процедуры
      MarkExtMem. Этим указателем не может являться линейный
      указатель, возвращаемый функцией GetExtMem.}

OpMacro       Процедуры и функции
────────────────────────────────────────────────────────────────

  function DefineMacro(Key : Word; var Macro) : Boolean;
    {-Определить новый макрос или удалить существующий.}

  function MacroAddress(Key : Word) : Pointer;
    {-Возвратить указатель на макрос, назначенный клавише
      или значение nil, если клавиша не задана.}

  function MacroCount : Word;
    {-Возвращает число макросов, которые были определены}

  function AllocateMacro(Key : Word; var Macro;
                         var Name : string) : Byte;
    {-Отвести память для макроса в динамической области и воз-
      вратить одно из следующих значений:
       0 : Макрос размещен
       1 : Таблица макросов заполнена
       2 : Недостаточно памяти в динамической области
       3 : Текст макроса пуст}

  function DeallocateMacro(Key : Word) : Boolean;
    {-Если макрос существует, то данная подпрограмма удаляет его
      и освобождает занимаемую им память. Возвращает значение
      False, если макрос не был найден.}

  function AssignMacroName(Key : Word;
                           var Name : string) : Boolean;
    {-Назначить имя Name макросу, удаляя существующее имя,
      назначенное макросу (если таковое существовало).
      Возвращает значение false в случае нехватки памяти
      или если макрос не был обнаружен.}

  function ReadMacroFile(FName : string; Merge : Boolean) : Byte;
    {-Считать файл макросов. Возвращает значение 0 в случае успеш-
      ного выполнения, $FF, если формат файла не соответствует файлу
      макросов, $FE в случае нехватки памяти или значение IOresult
      в ином случае. Если параметр Merge (слияние) имеет значение
      false, все существующие макросы перед считыванием файла
      будут удалены.}

  function WriteMacroFile(FName : string) : Byte;
    {-Осуществить запись файла макросов. Возвращает 0 в случае
      успешного завершения, в противном случае значение перемен-
      ной IOresult (результат операции ввода/вывода.}

  procedure ClearMacros;
    {-Удаляет текущий макрос.}

  procedure MacrosOn;
    {-Включает обработку макросов}

  procedure MacrosOff;
    {-Выключает обработку макросов}

  procedure MacroRecordingOn;
    {-Включает запись макроса}

  procedure MacroRecordingOff;
    {-Выключает запись макроса}

  procedure StartMacro(Macro : Pointer);
    {-Начинает выполнение указанного макроса. Если макрос уже вы-
      полняется, он будет немедленно заменен переданным макросом.}

  procedure StartMacroByKey(Key : Word);
    {-Начинает выполнение макроса, подсоединенного к клавише (если
      таковая имеется). Если макрос уже выполняется, он будет
      немедленно заменен переданным макросом.}

  procedure RemoveMacros;
    {-Восстанавливает все вектора, связанные с макросами.}

  procedure SetEndOfMacroProc(P : Pointer);
    {-Задает указатель на процедуру, которая должна быть
      вызвана при достижении конца макроса}

  function FindMacroIndex(Key : Word) : Word;
    {-Найти индекс в массиве для макроса, назначенного на
      клавишу. Возвращает 0, если индекс не найден.}

  function InitMacros : Boolean;
    {-Инициализирует макросы. После того, как данная подпрограмма
      была вызвана, никакие макросы не будут определены, а отра-
      ботка макросов и запись макросов будут выключены. Возвращает
      значение false, если прерывание INT $16 не может быть пере-
      определено.}

  function CharToMacro(MacroChar : Char) : Word;
    {-Преобразует символ в представление клавиатурный код/символ.
      Данная таблица хранит все значения скан-кодов для ASCII
      символов от 0 до 63. Все алфавитные символы могут быть
      отображены на эту таблицу путем вычитания числа, делимого
      нацело на 32, что приведет к попаданию кода этого символа
      в диапазон 0..63.}

  procedure StringToMacro(S : string; MRP : MacroRecPtr;
                          MaxKeys : Word);
    {-Инициализировать MRP^ с помощью строки}

  procedure StringToScrapMacro(S : string);
    {-Инициализировать ScrapMacro с помощью строки}

  procedure KeyToString(Key : Word; var S : string;
                        var Special : Boolean);
    {-Возвращает строку (S), представляющую некоторую клавишу Key.
      Переменной Special присваивается значение False, если
      возвращается простой символ.}

OpMacEd       Процедуры и функции
────────────────────────────────────────────────────────────────

  function EditKeys(Key : Word; var Macro : MacroRec;
                    MinCol, MinRow, MaxCol, MaxRow,
                    Dim, Bright : Byte;
                    var Modified : Boolean) : MacroRecPtr;
    {-Редактировать макрос, связанный с клавишей Key.}

OpReplay      Процедуры и функции
────────────────────────────────────────────────────────────────

  procedure StartMacro(Macro : MacroRecPtr);
    {-Начать выполнение указанного макроса}

  function CharToMacro(MacroChar : Char) : Word;
    {-Преобразует символ в представление клавиатурный код/символ.
      Данная таблица хранит все значения скан-кодов для ASCII
      символов от 0 до 63. Все алфавитные символы могут быть
      отображены на эту таблицу путем вычитания числа, делимого
      нацело на 32, что приведет к попаданию кода этого символа
      в диапазон 0..63.}

  procedure StringToScrapMacro(S : string);
    {-Инициализировать буферный макрос ScrapMacro на основе строки}

  procedure StringToMacro(S : string; MRP : MacroRecPtr;
                          MaxKeys : Word);
    {-Инициализировать MRP^ на основе строки}

  procedure Int16;
    {-Менеджер обработки макросов, используемый для воспроизве-
      дения нажатий клавиш. В компетенцию пользователя входит
      задание и отмена данной подпрограммы обработки прерываний.}

  procedure SetEndOfMacroProc(P : Pointer);
    {-Задать указатель на процедуру, которая должна вызываться
      по достижении конца макроса}

  procedure InitScrapMacroPtr;
    {-Инициализировать ScrapMacroPtr}

OpBcd         Процедуры и функции
────────────────────────────────────────────────────────────────

  procedure RealToBCD(R : Real; var B : BCD);
    {-Преобразовать действительное число (real) в
      двоично-десятичное (BCD)}

  procedure LongintToBCD(L : LongInt; var B : BCD);
    {-Преобразовать длинное целое (Longint) в
      двоично-десятичное (BCD)}

  function BCDtoReal(B : BCD) : Real;
    {-Преобразовать двоично-десятичное число (BCD)
      в действительное (real)}

  function StrBCD(B : BCD; Width, Places : Byte) : string;
    {-Возвратить двоично-десятичное число (BCD) в виде строки
      (string)}

  function StrExpBCD(B : BCD; Width : Byte) : string;
    {-Возвратить B в виде строки с экспоненциальным форматом}

  procedure ValBCD(S : string; var B : BCD; var Code : Word);
    {-Преобразовать строку в двоично-десятичное число (BCD)}

  procedure AbsBCD(B1 : BCD; var B2 : BCD);
    {-Возвратить абсолютное значение B1 в B2}

  procedure FracBCD(B1 : BCD; var B2 : BCD);
    {-Возвратить дробную часть B1 в B2}

  procedure IntBCD(B1 : BCD; var B2 : BCD);
    {-Возвращает целую часть B1 в B2}

  function RoundBCD(B1 : BCD) : LongInt;
    {-Возвращает значение B1, округленное до ближайшего длинного
      целого (long integer)}

  function TruncBCD(B1 : BCD) : LongInt;
    {-Возвращает максимальное длинное целое (long integer),
      меньшее чем или равное B1}

  function Form(Mask : string; B : BCD) : string;
    {-Возвращает форматированную строку с цифрами, взятыми
      B, полученную путем наложения маски Mask}

  procedure AddBCD(B1, B2 : BCD; var B3 : BCD);
    {-Прибавить B1 к B2 и поместить результат в B3}

  procedure SubBCD(B1, B2 : BCD; var B3 : BCD);
    {-Вычесть B2 из B1 и занести результат в B3}

  procedure MultBCD(B1, B2 : BCD; var B3 : BCD);
    {-Умножить B1 на B2 и занести результат в B3}

  procedure DivBCD(B1, B2 : BCD; var B3 : BCD);
    {-Разделить B1 на B2 и занести результат в B3}

  function EqualBCD(B1, B2 : BCD) : Boolean;
    {-Возвращает значение true, если B1 = B2}

  function NotEqualBCD(B1, B2 : BCD) : Boolean;
    {-Возвращает значение true, если B1 <> B2}

  function GreaterBCD(B1, B2 : BCD) : Boolean;
    {-Возвращает значение true, если B1 > B2}

  function GreaterEqualBCD(B1, B2 : BCD) : Boolean;
    {-Возвращает значение true, если B1 >= B2}

  function LessBCD(B1, B2 : BCD) : Boolean;
    {-Возвращает значение true, если B1 < B2}

  function LessEqualBCD(B1, B2 : BCD) : Boolean;
    {-Возвращает значение true, если B1 <= B2}

  procedure ArcTanBCD(B1 : BCD; var B2 : BCD);
    {-Возвращает арктангенс B1 в B2}

  procedure CosBCD(B1 : BCD; var B2 : BCD);
    {-Возвращает косинус B1 в B2}

  procedure ExpBCD(B1 : BCD; var B2 : BCD);
    {-Возвращает показательную (экспоненциальную)
      функцию B1 в B2}

  procedure LnBCD(B1 : BCD; var B2 : BCD);
    {-Возвращает натуральный логарифм B1 в B2}

  procedure SinBCD(B1 : BCD; var B2 : BCD);
    {-Возвращает синус B1 в B2}

  procedure SqrBCD(B1 : BCD; var B2 : BCD);
    {-Возвращает квадрат (вторую степень) B1 в B2}

  procedure SqrtBCD(B1 : BCD; var B2 : BCD);
    {-Возвращает квадратный корень B1 в B2}

OpClone       Объект Cloner (Клонер)
────────────────────────────────────────────────────────────────

  constructor Init(FName : string; DUT : DateUpdateType);
    {-Открыть файл для клонирования}

  constructor InitCustom(FName : string; DUT : DateUpdateType;
                         BufSize : Word);
    {-Открыть файл для клонирования}

  constructor InitAndFind(FName : string; DUT : DateUpdateType;
                          var ID; IdSize : Word);
    {-Открыть файл и найти идентификатор ID. Использует
      функцию FindDefaultsEnd}

  destructor Done; virtual;
    {-Закрывает файл клонирования, корректирует метку времени
      и освобождает буфер}

  function FindDefaultsEnd(var ID; IdSize : Word;
                           Skip : LongInt) : Boolean;
    {-Найти идентификатор ID в файле клонирования, осуществляя
      поиск от конца в обратном направлении}

  function FindDefaultsStart(var ID; IdSize : Word;
                             Skip : LongInt) : Boolean;
    {-Найти идентификатор ID в файле клонирования, осуществляя
      поиск от начала в прямом направлении}

  function GetLastError : Word;
    {-Получить код последней ошибки}

  function GetPos : LongInt;
    {-Получить позицию, где была обнаружена строка ID
      (возвращаемое смещение является началом строки
      идентификатора ID)}

  procedure LoadDefaults(FileOfs : LongInt; var Defaults;
                         Bytes : Word);
    {-Установить файловый указатель на позицию FileOfs и
      считать расположенные там стандартные параметры}

  procedure StoreDefaults(FileOfs : LongInt; var Defaults;
                          Bytes : Word);
    {-Установить файловый указатель на позицию FileOfs и
      занести туда стандартные параметры}

OpErrHan      Процедуры и функции
────────────────────────────────────────────────────────────────

  procedure ErrorRecovery(On : Boolean; UserRoutine : Pointer);
    {-Включает или выключает восстановление при ошибках и подсоеди-
      няет заданную пользователем подпрограмму обработки ошибок}

OpInline      Процедуры и функции
────────────────────────────────────────────────────────────────

  function SetJump(var JumpDest : JumpRecord) : Word;
    {-Сохранить текущие значения SP и BP и перейти к
      указанному адресу}

  procedure LongJump(var JumpDest : JumpRecord; Result : Word);
    {-Восстановить значения SP и BP и перейти к адресу
      JumpDest.JmpPt}

  procedure FarCall(ProcAddr : Pointer);
    {-ProcAddr является адресом подпрограммы, которая должна
      быть вызвана с использованием длинного (far) указателя.
      Может использоваться для реализации таблицы переходов, если
      процедуры не получают никаких параметров.}

  procedure NearCall(ProcOfs : Word);
    {-ProcOfs является смещением подпрограммы, которая должна
      быть вызвана с помощью ближнего (near) указателя.}

  procedure JumpToOldIsr(OldIsr : Pointer);
    {-Перейти к предыдущему ISR из процедуры обработки прерывания.}

  function MakeLongInt(H, L : Word) : LongInt;
    {-Создает длинное целое (LongInt) из двух слов (Word)}

  function MakeInteger(H, L : Byte): Integer;
    {-Создает целое (integer) из двух байтов}

  function MakeWord(H, L : Byte) : Word;
    {-Создает слово из двух байтов}

  function Array2Str(var A; Len : Byte) : string;
    {-Преобразовать массив символов в строку}

  procedure CallOldIsr(OldIsr : Pointer);
    {-Вызвать предыдущее ISR из процедуры обработки прерывания.
      Изменяет содержимое регистра BX.}

  procedure Reboot;
    {-Осуществить перезагрузку машины}

  function HiWord(L : LongInt) : Word;
    {-Возвратить старшее слово L}

  function LoWord(L : LongInt) : Word;
    {-Возвратить младшее слово L}

  function SwapNibble(B : Byte) : Byte;
    {-Поменять местами старшую и младшую половинки
      байта B: SwapNibble($F0) возвращает $0F.}

  function SwapWord(L : LongInt) : LongInt;
    {-Поменять местами младшее и старшее слова L}

  function Normalized(P : Pointer) : Pointer;
    {-Возвратить P в виде нормализованного указателя}

  procedure SetFlag(var Flags : Word; FlagMask : Word);
    {-Задать бит (биты), заданные посредством маски флагов
      FlagMask в переменной Flags}

  procedure ClearFlag(var Flags : Word; FlagMask : Word);
    {-Удаляет бит (биты), заданные посредством маски флагов
      FlagMask в переменной Flags}

  function FlagIsSet(Flags, FlagMask : Word) : Boolean;
    {-Возвращает True, если бит, заданный посредством
      FlagMask в параметре Flags задан}

  procedure SetByteFlag(var Flags : Byte; FlagMask : Byte);
    {-Задать бит (биты), заданные посредством маски флагов
      FlagMask в переменной Flags}

  procedure ClearByteFlag(var Flags : Byte; FlagMask : Byte);
    {-Стереть бит (биты), заданные посредством маски флагов
      FlagMask в переменной Flags}

  function ByteFlagIsSet(Flags, FlagMask : Byte) : Boolean;
    {-Возвращает True, если бит, заданный посредством
      FlagMask в параметре Flags задан}

  procedure SetLongFlag(var Flags : LongInt; FlagMask : LongInt);
    {-Задать бит (биты), заданные посредством маски флагов
      FlagMask в переменной Flags}

  procedure ClearLongFlag(var Flags : LongInt; FlagMask : LongInt);
    {-Стереть бит (биты), заданные посредством маски флагов
      FlagMask в переменной Flags}

  function LongFlagIsSet(Flags, FlagMask : LongInt) : Boolean;
    {-Возвращает True, если бит, заданный посредством
      FlagMask в параметре Flags задан}

  procedure ExchangeBytes(var I, J : Byte);
    {-Обменять содержимое байтов I и J}

  procedure ExchangeWords(var I, J : Word);
    {-Обменять содержимое слов I и J}

  procedure ExchangeLongInts(var I, J : LongInt);
    {-Обменять содержимое длинных целых I и J}

  procedure ExchangeStructs(var I, J; Size : Word);
    {-Обменять содержимое структур I и J. Полезно при сортировке}

  function MinWord(A, B : Word) : Word;
    {-Возвращает меньшее из A и B}

  function MaxWord(A, B : Word) : Word;
    {-Возвращает большее из A и B}

  function MinLong(A, B : LongInt) : LongInt;
    {-Возвращает меньшее из A и B}

  function MaxLong(A, B : LongInt) : LongInt;
    {-Возвращает большее из A и B}

  procedure FillWord(var Dest; Count, Filler : Word);
    {-Заполнить память, начиная с адреса Dest Count
      экземплярами слова-заполнителя Filler}

  procedure FillStruct(var Dest; Count : Word;
                       var Filler; FillerSize : Word);
    {-Заполнить память, начиная с адреса Dest Count
      экземплярами слова-заполнителя Filler}

  function AddWordToPtr(P : Pointer; W : Word) : Pointer;
    {-Добавить слово к указателю. Не производится нормализация
      и проверка циклического перехода через нуль}

  function PtrToLong(P : Pointer) : LongInt;
    {-Преобразовать указатель в диапазоне от $0:$0 до
      $FFFF:$000F в длинное целое (LongInt)}

  function LongToPtr(L : LongInt) : Pointer;
    {-Преобразовать длинное целое (LongInt) L в нормализованный
      указатель}

  function PtrDiff(P1, P2 : Pointer) : LongInt;
    {-Возвратить число байтов между P1^ и P2^}

  function AddLongToPtr(P : Pointer; L : LongInt) : Pointer;
    {-Добавить длинное целое (LongInt) к указателю, возвращая
      нормализованный указатель}

OpSort        Процедуры и функции
────────────────────────────────────────────────────────────────

  function PutElement(var X) : Boolean;
    {-Поместить сортируемый элемент в массив сортировки}

  function GetElement(var X) : Boolean;
    {-Получить следующий элемент из массива сортировки}

  function Sort(Elements    : Word;
                ElementSize : Word;
                GetElements : GetPutProc;
                LessFunc    : UserLessFunc;
                PutElements : GetPutProc
                ) : SortStatus;
    {-Сортировать группу элементов}
