home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Interactive Guide / c-cplusplus-interactive-guide.iso / c_ref / csource1 / program3 / subcalls.pas < prev   
Encoding:
Pascal/Delphi Source File  |  1993-11-23  |  32.7 KB  |  491 lines
  1. {| Unit: subcalls
  2.  | Version: 1.00
  3.  | translated from file subcalls.H
  4.  | Original translation: Peter Sawatzki (ps)
  5.  | Contributing:
  6.  |   (fill in)
  7.  |
  8.  | change history:
  9.  | Date:    Ver: Author:
  10.  | 11/13/93 1.00 ps     original translation by ps
  11. }
  12. Unit subcalls;
  13. Interface
  14. Uses
  15.   Os2Def;
  16. Type
  17.   CursorData = Record
  18.     cur_start,                          { Cursor start line }
  19.     cur_end,                            { Cursor end line }
  20.     cur_width,                          { Cursor width }
  21.     cur_attribute: Word                 { Cursor attribute }
  22.   End;
  23.   KbdStatus = Record
  24.     length,                             { length in words of data structure }
  25.     bit_mask,                           { bit mask }
  26.     turn_around_char,                   { turnaround character }
  27.     interim_char_flags,                 { interim character flags }
  28.     shift_state: Word                   { shift state }
  29.   End;
  30.   KbdTRANS = Record
  31.     char_code,                          { ASCII character code }
  32.     scan_code,                          { scan code }
  33.     status,                             { indicates state of char }
  34.     nls_shift: Byte;                    { reserved }
  35.     shift_state: Word;                  { state of the shift keys }
  36.     time: LongInt;                      { timestamp of keystroke }
  37.     kbdDDflags,                         { flags for monitor packet }
  38.     xlt_flags,                          { Xlate flags }
  39.     xlt_shift_state,                    { Xlate shift state }
  40.     xlt_rsrv_0: Word                    { reserved = 0 }
  41.   End;
  42.   pKeyData = ^KeyData;
  43.   KeyData = Record
  44.     char_code,                          { ASCII character code }
  45.     scan_code,                          { scan code }
  46.     status,                             { indicates state of the character }
  47.     nls_shift: Byte;                    { reserved }
  48.     shift_state: Word;                  { state of the shift keys }
  49.     time: LongInt                       { time stamp of the keystroke }
  50.   End;
  51.   ModeData = Record
  52.     length: Word;                       { Length of structure }
  53.     _type,                              { Text or graphics }
  54.     color: Byte;                        { Color or monochrome }
  55.     col,                                { Column resolution }
  56.     row,                                { Row resolution }
  57.     hres,                               { horizontal resolution }
  58.     vres: Word;                         { vertical resolution }
  59.     fmt_ID,                             { Format ID }
  60.     attrib: Byte;                       { Attribute count }
  61.     buf_addr,                           { 32-bit Buffer Physical Address }
  62.     buf_length,                         { Buffer Length }
  63.     full_length,                        { Full Buffer Length }
  64.     partial_length: LongInt;            { Partial Buffer Length }
  65.     ext_data_addr: pChar                { Address of Extended Data Area }
  66.   End;
  67.   PVBData = Record
  68.     pvb_size: Word;                     { size of the structure }
  69.     pvb_ptr: LongInt;                   { returns pointer to the pvb buffer }
  70.     pvb_length,                         { length of PVB }
  71.     pvb_rows,                           { buffer dimension (rows) }
  72.     pvb_cols: Word;                     { buffer dimension (cols) }
  73.     pvb_type: Byte                      { color or mono }
  74.   End;
  75.   PhysBufData = Record
  76.     buf_start,                          { Physical address of buffer }
  77.     buf_length: LongInt;                { Size of buffer (in bytes) }
  78.     selectors: Array[0..1] Of Word      { 1 or more selectors (assume 2) }
  79.   End;
  80.   ConfigData = Record
  81.     length,                             { Length of the structure in bytes }
  82.     adapter_type,                       { specifies the video adapter type }
  83.     display_type: Word;                 { specifies the video display type }
  84.     memory_size: LongInt;               { number of bytes in display memory }
  85.     Configuration,                      { Configuration number }
  86.     VDHVersion,                         { VDH version number }
  87.     Flags: Word;                        { Flags }
  88.     HWBufferSize,                       { Environment Buffer size }
  89.     FullSaveSize,                       { Full save size }
  90.     PartSaveSize: LongInt;              { Partial save size }
  91.     EMAdaptersOFF,                      { Offset to emulated adapters }
  92.     EMDisplaysOFF: Word                 { Offset to emulated displays }
  93.   End;
  94.   VIOFONT = Record
  95.     length,                             { Length of the struct (14) }
  96.     req_type,                           { 0=current font, 1=ROM font }
  97.     pel_cols,                           { character cell width }
  98.     pel_rows: Word;                     { character cell height }
  99.     font_data: LongInt;                 { far ptr to font data area }
  100.     font_len: Word                      { num. bytes of font data }
  101.   End;
  102.   VIOSTATE = Record
  103.     length,                             { structure length (max 38) }
  104.     req_type,                           { 0 = set palette regs }{ 1 = set overscan color }
  105.     double_defined,                     { req_type = 0 : }
  106.                                         {first palette reg to set }
  107.                                         { req_type = 1 : }
  108.                                         {  border (overscan) color }
  109.     palette0,                           { color value }
  110.     palette1,                           { color value }
  111.     palette2,                           { color value }
  112.     palette3,                           { color value }
  113.     palette4,                           { color value }
  114.     palette5,                           { color value }
  115.     palette6,                           { color value }
  116.     palette7,                           { color value }
  117.     palette8,                           { color value }
  118.     palette9,                           { color value }
  119.     palette10,                          { color value }
  120.     palette11,                          { color value }
  121.     palette12,                          { color value }
  122.     palette13,                          { color value }
  123.     palette14,                          { color value }
  124.     palette15: Word                     { color value }
  125.   End;
  126.   EventInfo = Record
  127.     Mask: Word;
  128.     Time: LongInt;
  129.     Row,
  130.     Col: Word
  131.   End;
  132.   NoPointer = Record
  133.     Row,
  134.     Col,
  135.     Height,
  136.     Width: Word
  137.   End;
  138.   PtrImage = Record
  139.     TotLength,
  140.     Col,
  141.     Row,
  142.     ColOffset,
  143.     RowOffset: Word
  144.   End;
  145.   PtrLoc = Record
  146.     RowPos,
  147.     ColPos: Word
  148.   End;
  149.   QueInfo = Record
  150.     Events,
  151.     QSize: Word
  152.   End;
  153.   ScaleFact = Record
  154.     RowScale,
  155.     ColScale: Word
  156.   End;
  157.   KbdStringInLength = Record
  158.     Length,
  159.     LengthB: Word
  160.   End;
  161.   KbdHWID = Record
  162.     length,
  163.     kbd_id,
  164.     reserved1,
  165.     reserved2: Word
  166.   End;
  167.   Function KBDREGISTER (Par1,                               { Module name }
  168.                         Par2: pChar;                        { Entry point name }
  169.                         Par3: LongInt): Word;               { Function mask    }
  170.   Function KBDDEREGISTER: Word;                             { No Parameters }
  171.   Function KBDCHARIN (Var Par1: KeyData;                       { Buffer for character code }
  172.                       Par2,                                 { I/O wait - 0=wait for a }{ character, 1=no wait }
  173.                       Par3: Word): Word;                    { keyboard handle }
  174.   Function KBDFLUSHBUFFER (Par1: Word): Word;                     { keyboard handle }
  175.   Function KBDGETSTATUS (Var Par1: KbdStatus;          { data structure }
  176.                          Par2: Word): Word;                     { Keyboard device handle }
  177.   Function KBDPEEK (Var Par1: KeyData;                 { buffer for data }
  178.                     Par2: Word): Word;                     { keyboard handle }
  179.   Function KBDSETFGND: Word;                         { No Parameters }
  180.   Function KBDSETSTATUS (Var Par1: KbdStatus;          { data structure }
  181.                          Par2: Word): Word;                     { device handle }
  182.   Function KBDSTRINGIN (Par1: pChar; Var Par2: KbdStringInLength; Par3,Par4: Word): Word;
  183.   Function KBDOPEN (Var Par1: Word): Word;               { addr. of returned handle }
  184.   Function KBDCLOSE (Par1: Word): Word;                     { keyboard handle }
  185.   Function KBDGETFOCUS (Par1,                               { wait/nowait indicator }
  186.                         Par2: Word): Word;                     { keyboard handle }
  187.   Function KBDFREEFOCUS (Par1: Word): Word;                     { keyboard handle }
  188.   Function KBDGETCP (Par1: LongInt;                         { reserved }
  189.                      Var Par2: Word;                      { addr. of returned ID }
  190.                      Par3: Word): Word;                     { keyboard handle }
  191.   Function KBDSETCP (Par1,                                  { reserved }
  192.                      Par2,                                  { translate table ID }
  193.                      Par3: Word): Word;                     { keyboard handle }
  194.   Function KBDXLATE (Var Par1: KbdTRANS;               { translation record }
  195.                      Par2: Word): Word;                     { keyboard handle }
  196.   Function KBDSETCUSTXT (Var Par1: Word;                  { translation table }
  197.                          Par2: Word): Word;                     { keyboard handle }
  198.   Function KBDSYNCH (Par1: Word): Word;                     { IOwait word 0 or 1              }
  199.                                         { 0 = requestor will wait for the }
  200.                                         { access to the router            }
  201.                                         { 1 = requestor will not wait for }
  202.                                         { access to the router            }
  203.   Function KBDGETHWID (Var Par1: KbdHWID;              { Hardware record (returned) }
  204.                        Par2: Word): Word;                     { keyboard handle }
  205.   Function VIOREGISTER (Par1,                               { Module name }
  206.                         Par2: pChar;                       { Entry Point name }
  207.                         Par3,                               { Function mask 1 }
  208.                         Par4: LongInt): Word;                { Function mask 2 }
  209.   Function VIODEREGISTER: Word;                         { No Parameters }
  210.   Function VIOGLOBALREG (Par1,                              { Module name }
  211.                          Par2: pchar;                      { Entry Point name }
  212.                          Par3,                              { Function mask 1 }
  213.                          Par4,                              { Function mask 2 }
  214.                          Par5: LongInt): Word;                         { Reserved (must be 0) }
  215.   Function VIOGETBUF (Var Par1: LongInt;                { Will point to logical video buffer }
  216.                       Var Par2: Word;                     { Length of Buffer }
  217.                       Par3: Word): Word;                     { Vio Handle }
  218.   Function VIOGETCURPOS (Var Par1,                              { Current row position }
  219.                              Par2: Word;                  { Current column position }
  220.                          Par3: Word): Word;                     { Vio Handle }
  221.   Function VIOGETCURTYPE (Var Par1: CursorData;        { Cursor characteristics }
  222.                           Par2: Word): Word;                     { Vio Handle }
  223.   Function VIOGETMODE (Var Par1: ModeData;             { Length of Buffer }
  224.                        Par2: Word): Word;                     { Vio Handle }
  225.   Function VIOGETPHYSBUF (Var Par1: PhysBufData;       { VIO Physical Buffer Info }
  226.                           Par2: Word): Word;                     { Reserved (must be 0) }
  227.   Function VIOREADCELLSTR (Par1: pchar;                    { Character Buffer }
  228.                            Var Par2: Word;                { Length of cell string buffer }
  229.                            Par3,                            { Starting location (row) }
  230.                            Par4,                            { Starting location (col) }
  231.                            Par5: Word): Word;                     { Vio Handle }
  232.   Function VIOREADCHARSTR (Par1: pchar;                    { Character Buffer }
  233.                            Var Par2: Word;                { Length of cell string buffer }
  234.                            Par3,                            { Starting location (row) }
  235.                            Par4,                            { Starting location (col) }
  236.                            Par5: Word): Word;                     { Vio Handle }
  237.   Function VIOSCROLLDN (Par1,                               { Top row of section to scroll }
  238.                         Par2,                               { Left column of section to scroll }
  239.                         Par3,                               { Bottom row of section to scroll }
  240.                         Par4,                               { Right column of section to scroll }
  241.                         Par5: Word;                         { Number of blank lines at bottom }
  242.                         Par6: pchar;                       { pointer to blank Char,Attr }
  243.                         Par7: Word): Word;                     { Vio Handle }
  244.   Function VIOSCROLLUP (Par1,                               { Top row of section to scroll }
  245.                         Par2,                               { Left column of section to scroll }
  246.                         Par3,                               { Bottom row of section to scroll }
  247.                         Par4,                               { Right column of section to scroll }
  248.                         Par5: Word;                         { Number of blank lines at bottom }
  249.                         Par6: pchar;                       { pointer to blank Char,Attr }
  250.                         Par7: Word): Word;                     { Vio Handle }
  251.   Function VIOSCROLLLF (Par1,                               { Top row of section to scroll }
  252.                         Par2,                               { Left column of section to scroll }
  253.                         Par3,                               { Bottom row of section to scroll }
  254.                         Par4,                               { Right column of section to scroll }
  255.                         Par5: Word;                         { Number of blank columsn at right }
  256.                         Par6: pchar;                       { pointer to blank Char,Attr }
  257.                         Par7: Word): Word;                     { Vio Handle }
  258.   Function VIOSCROLLRT (Par1,                               { Top row of section to scroll }
  259.                         Par2,                               { Left column of section to scroll }
  260.                         Par3,                               { Bottom row of section to scroll }
  261.                         Par4,                               { Right column of section to scroll }
  262.                         Par5: Word;                         { Number of blank columsn at left }
  263.                         Par6: pchar;                       { pointer to blank Char,Attr }
  264.                         Par7: Word): Word;                     { Vio Handle }
  265.   Function VIOSETCURPOS (Par1,                              { Row return data }
  266.                          Par2,                              { Column return data }
  267.                          Par3: Word): Word;                     { Vio Handle }
  268.   Function VIOSETCURTYPE (Var Par1: CursorData;        { Cursor characteristics }
  269.                           Par2: Word): Word;                     { Vio Handle }
  270.   Function VIOSETMODE (Var Par1: ModeData;             { Mode characteristics }
  271.                        Par2: Word): Word;                     { Vio Handle }
  272.   Function VIOSHOWBUF (Par1,                                { Offset into buffer }
  273.                        Par2,                                { Length of area to be updated }
  274.                        Par3: Word): Word;                     { Vio Handle }
  275.   Function VIOWRTCELLSTR (Par1: pchar;                     { String to be written }
  276.                           Par2,                             { Length of string }
  277.                           Par3,                             { Starting position for output (row) }
  278.                           Par4,                             { Starting position for output (col) }
  279.                           Par5: Word): Word;                     { Vio Handle }
  280.   Function VIOWRTCHARSTR (Par1: pchar;                     { String to be written }
  281.                           Par2,                             { Length of string }
  282.                           Par3,                             { Starting position for output (row) }
  283.                           Par4,                             { Starting position for output (col) }
  284.                           Par5: Word): Word;                     { Vio Handle }
  285.   Function VIOWRTCHARSTRATT (Par1: pchar;                  { String to be written }
  286.                              Par2,                          { Length of string }
  287.                              Par3,                          { Starting position for output (row) }
  288.                              Par4: Word;                    { Starting position for output (col) }
  289.                              Par5: pchar;                  { Attribute to be replicated }
  290.                              Par6: Word): Word;                     { Vio Handle }
  291.   Function VIOWRTNATTR (Par1: pchar;                       { Attribute to be written }
  292.                         Par2,                               { Length of write }
  293.                         Par3,                               { Starting position for output (row) }
  294.                         Par4,                               { Starting position for output (col) }
  295.                         Par5: Word): Word;                     { Vio Handle }
  296.   Function VIOWRTNCELL (Par1: pchar;                       { Cell to be written }
  297.                         Par2,                               { Length of write }
  298.                         Par3,                               { Starting position for output (row) }
  299.                         Par4,                               { Starting position for output (col) }
  300.                         Par5: Word): Word;                     { Vio Handle }
  301.   Function VIOWRTNCHAR (Par1: pchar;                       { Character to be written }
  302.                         Par2,                               { Length of write }
  303.                         Par3,                               { Starting position for output (row) }
  304.                         Par4,                               { Starting position for output (col) }
  305.                         Par5: Word): Word;                     { Vio Handle }
  306.   Function VIOWRTTTY (Par1: pchar;                         { String to be written }
  307.                       Par2,                                 { Length of string }
  308.                       Par3: Word): Word;                     { Vio Handle }
  309.   Function VIOSETANSI (Par1,                                { ON (=1) or OFF (=0) indicator }
  310.                        Par2: Word): Word;                     { Vio Handle }
  311.   Function VIOGETANSI (Var Par1: Word;                    { ANSI state (returned) }
  312.                        Par2: Word): Word;                     { Vio Handle }
  313.   Function VIOPRTSC (Par1: Word): Word;                     { Vio Handle }
  314.   Function VIOPRTSCTOGGLE (Par1: Word): Word;                     { Vio Handle }
  315.   Function VIOSAVREDRAWWAIT (Par1: Word;                    { Save/Redraw Indicator }
  316.                              Var Par2: Word;              { Notify type (returned) }
  317.                              Par3: Word): Word;                     { Vio Handle }
  318.   Function VIOSAVREDRAWUNDO (Par1,                          { Ownership Indicator }
  319.                              Par2,                          { Terminate Indicator }
  320.                              Par3: Word): Word;                     { Vio Handle }
  321.   Function VIOMODEWAIT (Par1: Word;                         { Request type }
  322.                         Var Par2: Word;                   { Notify type (returned) }
  323.                         Par3: Word): Word;                     { Reserved (must be 0) }
  324.   Function VIOMODEUNDO (Par1,                               { Ownership indicator }
  325.                         Par2,                               { Terminate indicator }
  326.                         Par3: Word): Word;                     { Reserved (must be 0) }
  327.   Function VIOSCRLOCK (Par1: Word;                          { Wait Flag }
  328.                        Var Par2: Word;               { Status of lock (returned) }
  329.                        Par3: Word): Word;                     { Vio Handle }
  330.   Function VIOSCRUNLOCK (Par1: Word): Word;                     { Vio Handle }
  331.   Function VIOPOPUP (Var Par1: Word;                      { Wait/Nowait Bit flags }
  332.                      Par2: Word): Word;                     { Vio Handle }
  333.   Function VIOENDPOPUP (Par1: Word): Word;                     { Vio Handle }
  334.   Function VIOGETCONFIG (Par1: Word;                        { Reserved - must be 0 }
  335.                          Var Par2: ConfigData;         { Pointer to data buffer }
  336.                          Par3: Word): Word;                     { VIO handle }
  337.   Function VIOGETFONT (Var Par1: VIOFONT;              { request block }
  338.                        Par2: Word): Word;                     { VIO handle }
  339.   Function VIOGETCP (Par1: Word;                            { Reserved - must be 0 }
  340.                      Var Par2: Word;                      { Ptr to returnd codepageID }
  341.                      Par3: Word): Word;                     { VIO handle }
  342.   Function VIOSETCP (Par1,                                  { Reserved - must be 0 }
  343.                      Par2,                                  { codepage ID }
  344.                      Par3: Word): Word;                     { VIO handle }
  345.   Function VIOSETFONT (Var Par1: VIOFONT;              { request block }
  346.                        Par2: Word): Word;                     { VIO handle }
  347.   Function VIOGETSTATE (Var Par1: VIOSTATE;            { request block }
  348.                         Par2: Word): Word;                     { VIO handle }
  349.   Function VIOSETSTATE (Var Par1: VIOSTATE;            { request block }
  350.                         Par2: Word): Word;                     { VIO handle }
  351.   Function MOUREGISTER (Par1,                               { Module name }
  352.                         Par2: pchar;                       { Entry Point name }
  353.                         Par3: LongInt): Word;                { Function mask }
  354.   Function MOUDEREGISTER: Word;                         { No Parameters }
  355.   Function MOUFLUSHQUE (Par1: Word): Word;                     { Mouse device handle }
  356.   Function MOUGETHOTKEY (Var Par1: Word;                  { mask of which key is the hot key }
  357.                          Par2: Word): Word;                     { Mouse device handle }
  358.   Function MOUSETHOTKEY (Var Par1: Word;                  { Mouse Button Mask }
  359.                          Par2: Word): Word;                     { Mouse Device Handle }
  360.   Function MOUGETPTRPOS (Var Par1: PtrLoc;             { Pointer Location Record (returned) }
  361.                          Par2: Word): Word;                     { Mouse device handle }
  362.   Function MOUSETPTRPOS (Var Par1: PtrLoc;             { Pointer Location Record }
  363.                          Par2: Word): Word;                     { Mouse device handle }
  364.   Function MOUGETPTRSHAPE (Par1: pchar;           { Pointer Shape Buffer (returned) }
  365.                            Var Par2: PtrImage;         { Pointer Definition Record }
  366.                            Par3: Word): Word;                     { Mouse device handle }
  367.   Function MOUSETPTRSHAPE (Par1: pchar;           { Pointer Shape Buffer }
  368.                            Var Par2: PtrImage;         { Pointer Definition Record }
  369.                            Par3: Word): Word;                     { Mouse device handle }
  370.   Function MOUGETDEVSTATUS (Var Par1: Word;               { Current status flags (returned) }
  371.                             Par2: Word): Word;                     { Mouse Device Handle }
  372.   Function MOUGETNUMBUTTONS (Var Par1: Word;              { Number of mouse buttons (returned) }
  373.                              Par2: Word): Word;                     { Mouse Device Handle }
  374.   Function MOUGETNUMMICKEYS (Var Par1: Word;              { Number of Mickeys/cm (returned) }
  375.                              Par2: Word): Word;                     { Mouse Device Handle }
  376.   Function MOUREADEVENTQUE (Var Par1: EventInfo;       { Event Queue Entry (returned) }
  377.                             Var Par2: Word;               { Type of read operation }
  378.                             Par3: Word): Word;                     { Mouse Device Handle }
  379.   Function MOUGETNUMQUEEL (Var Par1: QueInfo;          { Queue Information (returned) }
  380.                            Par2: Word): Word;                     { Mouse Device Handle }
  381.   Function MOUGETEVENTMASK (Var Par1: Word;               { Event Mask (returned) }
  382.                             Par2: Word): Word;                     { Mouse Device Handle }
  383.   Function MOUSETEVENTMASK (Var Par1: Word;               { Event Mask }
  384.                             Par2: Word): Word;                     { Mouse Device Handle }
  385.   Function MOUGETSCALEFACT (Var Par1: ScaleFact;       { Scaling Factors (returned) }
  386.                             Par2: Word): Word;                     { Mouse Device Handle }
  387.   Function MOUSETSCALEFACT (Var Par1: ScaleFact;       { Scaling Factors }
  388.                             Par2: Word): Word;                     { Mouse Device Handle }
  389.   Function MOUOPEN (Par1: pchar;                           { Pointer draw device name }
  390.                     Var Par2: Word): Word;               { Mouse Device Handle (returned) }
  391.   Function MOUCLOSE (Par1: Word): Word;                     { Mouse Device Handle }
  392.   Function MOUREMOVEPTR (Var Par1: NoPointer;          { Pointer Area }
  393.                          Par2: Word): Word;                     { Mouse Device Handle }
  394.   Function MOUDRAWPTR (Par1: Word): Word;                     { Mouse Device Handle }
  395.   Function MOUSETDEVSTATUS (Var Par1: Word;               { status flags }
  396.                             Par2: Word): Word;                     { Mouse Device Handle }
  397.   Function MOUINITREAL (Par1: pChar): Word;                   { Pointer draw driver name }
  398.   Function MOUSYNCH (Par1: Word): Word;                     { I/O Wait - indicate wait/nowait }
  399.  
  400. Implementation
  401.   Function KBDCHARIN;                     External 'KBDCALLS' Index    4;
  402.   Function KBDCLOSE;                      External 'KBDCALLS' Index   17;
  403.   Function KBDDEREGISTER;                 External 'KBDCALLS' Index   20;
  404.   Function KBDFLUSHBUFFER;                External 'KBDCALLS' Index   13;
  405.   Function KBDFREEFOCUS;                  External 'KBDCALLS' Index   18;
  406.   Function KBDGETCP;                      External 'KBDCALLS' Index    3;
  407.   Function KBDGETFOCUS;                   External 'KBDCALLS' Index   12;
  408.   Function KBDGETHWID;                    External 'KBDCALLS' Index   24;
  409.   Function KBDGETSTATUS;                  External 'KBDCALLS' Index   10;
  410.   Function KBDOPEN;                       External 'KBDCALLS' Index   23;
  411.   Function KBDPEEK;                       External 'KBDCALLS' Index   22;
  412.   Function KBDREGISTER;                   External 'KBDCALLS' Index    8;
  413.   Function KBDSETCP;                      External 'KBDCALLS' Index    5;
  414.   Function KBDSETCUSTXT;                  External 'KBDCALLS' Index    1;
  415.   Function KBDSETFGND;                    External 'KBDCALLS' Index   21;
  416.   Function KBDSETSTATUS;                  External 'KBDCALLS' Index   11;
  417.   Function KBDSTRINGIN;                   External 'KBDCALLS' Index    9;
  418.   Function KBDSYNCH;                      External 'KBDCALLS' Index    7;
  419.   Function KBDXLATE;                      External 'KBDCALLS' Index   14;
  420.   Function MOUCLOSE;                      External 'MOUCALLS' Index    9;
  421.   Function MOUDEREGISTER;                 External 'MOUCALLS' Index   14;
  422.   Function MOUDRAWPTR;                    External 'MOUCALLS' Index   26;
  423.   Function MOUFLUSHQUE;                   External 'MOUCALLS' Index    7;
  424.   Function MOUGETDEVSTATUS;               External 'MOUCALLS' Index   22;
  425.   Function MOUGETEVENTMASK;               External 'MOUCALLS' Index   15;
  426.   Function MOUGETHOTKEY;                  External 'MOUCALLS' Index    4;
  427.   Function MOUGETNUMBUTTONS;              External 'MOUCALLS' Index    8;
  428.   Function MOUGETNUMMICKEYS;              External 'MOUCALLS' Index    3;
  429.   Function MOUGETNUMQUEEL;                External 'MOUCALLS' Index   13;
  430.   Function MOUGETPTRPOS;                  External 'MOUCALLS' Index   19;
  431.   Function MOUGETPTRSHAPE;                External 'MOUCALLS' Index    1;
  432.   Function MOUGETSCALEFACT;               External 'MOUCALLS' Index    6;
  433.   Function MOUINITREAL;                   External 'MOUCALLS' Index   27;
  434.   Function MOUOPEN;                       External 'MOUCALLS' Index   17;
  435.   Function MOUREADEVENTQUE;               External 'MOUCALLS' Index   20;
  436.   Function MOUREGISTER;                   External 'MOUCALLS' Index   24;
  437.   Function MOUREMOVEPTR;                  External 'MOUCALLS' Index   18;
  438.   Function MOUSETDEVSTATUS;               External 'MOUCALLS' Index   25;
  439.   Function MOUSETEVENTMASK;               External 'MOUCALLS' Index   16;
  440.   Function MOUSETHOTKEY;                  External 'MOUCALLS' Index   10;
  441.   Function MOUSETPTRPOS;                  External 'MOUCALLS' Index   21;
  442.   Function MOUSETPTRSHAPE;                External 'MOUCALLS' Index    2;
  443.   Function MOUSETSCALEFACT;               External 'MOUCALLS' Index   11;
  444.   Function MOUSYNCH;                      External 'MOUCALLS' Index   23;
  445.   Function VIODEREGISTER;                 External 'VIOCALLS' Index    6;
  446.   Function VIOENDPOPUP;                   External 'VIOCALLS' Index    1;
  447.   Function VIOGETANSI;                    External 'VIOCALLS' Index    3;
  448.   Function VIOGETBUF;                     External 'VIOCALLS' Index   31;
  449.   Function VIOGETCONFIG;                  External 'VIOCALLS' Index   46;
  450.   Function VIOGETCP;                      External 'VIOCALLS' Index   40;
  451.   Function VIOGETCURPOS;                  External 'VIOCALLS' Index    9;
  452.   Function VIOGETCURTYPE;                 External 'VIOCALLS' Index   27;
  453.   Function VIOGETFONT;                    External 'VIOCALLS' Index   29;
  454.   Function VIOGETMODE;                    External 'VIOCALLS' Index   21;
  455.   Function VIOGETPHYSBUF;                 External 'VIOCALLS' Index    2;
  456.   Function VIOGETSTATE;                   External 'VIOCALLS' Index   49;
  457.   Function VIOGLOBALREG; Begin Unknown('VIOGLOBALREG','SubCalls') End;
  458.   Function VIOMODEUNDO;                   External 'VIOCALLS' Index   35;
  459.   Function VIOMODEWAIT;                   External 'VIOCALLS' Index   37;
  460.   Function VIOPOPUP;                      External 'VIOCALLS' Index   11;
  461.   Function VIOPRTSC;                      External 'VIOCALLS' Index    8;
  462.   Function VIOPRTSCTOGGLE;                External 'VIOCALLS' Index   50;
  463.   Function VIOREADCELLSTR;                External 'VIOCALLS' Index   24;
  464.   Function VIOREADCHARSTR;                External 'VIOCALLS' Index   30;
  465.   Function VIOREGISTER;                   External 'VIOCALLS' Index   45;
  466.   Function VIOSAVREDRAWUNDO;              External 'VIOCALLS' Index   28;
  467.   Function VIOSAVREDRAWWAIT;              External 'VIOCALLS' Index   25;
  468.   Function VIOSCRLOCK;                    External 'VIOCALLS' Index   23;
  469.   Function VIOSCROLLDN;                   External 'VIOCALLS' Index   47;
  470.   Function VIOSCROLLLF;                   External 'VIOCALLS' Index   44;
  471.   Function VIOSCROLLRT;                   External 'VIOCALLS' Index   12;
  472.   Function VIOSCROLLUP;                   External 'VIOCALLS' Index    7;
  473.   Function VIOSCRUNLOCK;                  External 'VIOCALLS' Index   18;
  474.   Function VIOSETANSI;                    External 'VIOCALLS' Index    5;
  475.   Function VIOSETCP;                      External 'VIOCALLS' Index   42;
  476.   Function VIOSETCURPOS;                  External 'VIOCALLS' Index   15;
  477.   Function VIOSETCURTYPE;                 External 'VIOCALLS' Index   32;
  478.   Function VIOSETFONT;                    External 'VIOCALLS' Index   33;
  479.   Function VIOSETMODE;                    External 'VIOCALLS' Index   22;
  480.   Function VIOSETSTATE;                   External 'VIOCALLS' Index   51;
  481.   Function VIOSHOWBUF;                    External 'VIOCALLS' Index   43;
  482.   Function VIOWRTCELLSTR;                 External 'VIOCALLS' Index   10;
  483.   Function VIOWRTCHARSTR;                 External 'VIOCALLS' Index   13;
  484.   Function VIOWRTCHARSTRATT;              External 'VIOCALLS' Index   48;
  485.   Function VIOWRTNATTR;                   External 'VIOCALLS' Index   26;
  486.   Function VIOWRTNCELL;                   External 'VIOCALLS' Index   52;
  487.   Function VIOWRTNCHAR;                   External 'VIOCALLS' Index   53;
  488.   Function VIOWRTTTY;                     External 'VIOCALLS' Index   19;
  489. End.
  490.  
  491.