        Using Clarion Internal Functions in Clarion Database Developer
==============================================================================

This document is a guide to using some of the Clarion internal library
functions within Clarion Database Developer applications.  These functions are
used internally by Clarion language statements, therefore, there is no excess
"overhead" involved in their use in your applications.

This document directly covers only those internal library functions which
should prove most useful to a Clarion programmer.  These functions fall into
two categories:  General functions, and Screen handling functions.  The
prototypes for all these functions are provided on this disk in the
CLA_LIB.INC file.

Also included in this document are descriptions of some internal global
variables which may be useful in Clarion applications.  The declarations for
all these functions are provided on this disk in the GLOB_VAR.INC file.

These functions and variables may also be referenced by any C, Pascal, or
Modula-2 code linked into a Clarion program.  The function prototypes and
variable declarations for these languages are contained in CLA.H, CLA.ITF, and
CLA.DEF (execpt for the CheckHlpFileDates procedure, whose prototype is
contained in HLP.ITF and HLP.DEF for Pascal and Modula-2).


General Functions
=================

------------------------------------------------------------------------------

ValidPathname     FUNCTION

  C prototype:
      unsigned Cla$validpathname(const char *path);
  Modula-2 prototype:
      PROCEDURE validpathname(path :ARRAY OF CHAR): CARDINAL;
  Pascal prototype:
      function validpathname(var path): word;
  Clarion prototype:
      ValidPathname(*CSTRING),USHORT,RAW,NAME('Cla$validpathname')

Indicates the validity of the syntax of DOS filename passed to it in the path
parameter.

      path        Pointer to the null terminated path string.

      Return Value:

            Returns a bitmap indicating the validity of the path:
            x x x x x x x x x x x x x x x x
                    | | |   | | | | | | | |- path terminated by a backslash
                    | | |   | | | | | | |--- wild cards in filename
                    | | |   | | | | | |----- 'path' was 0 length
                    | | |   | | | | |------- file/directory name > 12 bytes
                    | | |   | | | |--------- path string > 64 bytes
                    | | |   | | |----------- drive specifier not alphabetic
                    | | |   | |------------- invalid filename character
                    | | |   |--------------- extension > 3 characters
                    | | |
                    | | |------------------- ':' found not in column 2
                    | |--------------------- double backslashes
                    |----------------------- more than one period in a unit

------------------------------------------------------------------------------

DataPack    FUNCTION

  C prototype:
      unsigned Cla$pack(const char *src, char *dst, unsigned len);
  Modula-2 prototype:
      PROCEDURE pack(
            src: ARRAY OF CHAR;
            VAR dst: ARRAY OF CHAR;
            len: CARDINAL): CARDINAL;
  Pascal prototype:
      function pack(src: string; var dst: string; len: word): word;
  Clarion prototype:
      DataPack(*STRING,*STRING,USHORT),USHORT,RAW,NAME('Cla$pack')

Performs a simple, very fast, common character compression on arbitrary data.
This has been renamed to prevent clash with the Clarion PACK statement.

      src         Buffer containing the data to be compressed.

      dst         Buffer to contain the compressed data.  The first two bytes
                  is a USHORT containing the actual length of the compressed
                  data.

      len         Length of the source data, in bytes.

      Return Value:

            Returns the actual size of the destination buffer.  It is possible
            for the "compressed" data block to be larger than the source
            block.  This may result if there are no duplicate characters to
            compress, the size of the destination buffer will increase by 2
            bytes to accomodate the prepended USHORT containing the size.  It
            may also happen when the source buffer contains a "large" number
            of bytes with the value 0EBh (decimal 235 -- the compressed
            character flag) relative to the number of duplicate characters
            compressed.

------------------------------------------------------------------------------

DataUnPack  FUNCTION

  C prototype:
      unsigned Cla$unpack(const char *src, const char *dst);
  Modula-2 prototype:
      PROCEDURE unpack(src: ARRAY OF CHAR; VAR dst: ARRAY OF CHAR): CARDINAL;
  Pascal prototype:
      function unpack(src: string; var dst: string): word;
  Clarion prototype:
      DataUnPack(*STRING,*STRING),USHORT,RAW,NAME('Cla$unpack')

Decompresses data previously packed by the DataPack function.

      src         Buffer containing the compressed data.

      dst         Buffer to contain the decompressed data.

      Return Value:

            Returns the actual size of the destination buffer.

------------------------------------------------------------------------------

CRC16       FUNCTION

  C prototype:
      unsigned Cla$crc16(unsigned crc, unsigned len, const void *buffer);
  Modula-2 prototype:
      PROCEDURE crc16(crc, len: CARDINAL; buffer: ADDRESS): CARDINAL;
  Pascal prototype:
      function crc16(crc, len: word; var buffer): word;
  Clarion prototype:
      CRC16(USHORT,USHORT,*STRING),USHORT,RAW,NAME('Cla$crc16')

This is a very fast 16-bit cyclic redundancy checksum function.

      crc         An initial CRC value (usually 0, but may be any value).

      len         Length of the block of bytes to be checked

      buffer      The data to checksum.

      Return Value:

            Returns the 16-bit checksum of the data.


------------------------------------------------------------------------------

CRC32       FUNCTION

  C prototype:
      unsigned long Cla$crc32(
            const char *buf,
            unsigned len,
            unsigned long crc);
  Modula-2 prototype:
      PROCEDURE crc32(buf: ADDRESS; len: CARDINAL; crc: LONGCARD): LONGCARD;
  Pascal prototype:
      function crc32(var buf; len: word; crc: integer): integer;
  Clarion prototype:
      CRC32(*STRING,USHORT,ULONG),ULONG,RAW,NAME('Cla$crc32')

This is a 32-bit cyclic redundancy checksum function.  This is slower than
CRC16.

      buf         The data to checksum.

      len         Length of the block of bytes to be checked

      crc         An initial CRC value (usually 0, but may be any value).

      Return Value:

            Returns the 32-bit checksum of the data.

------------------------------------------------------------------------------

FullPath    FUNCTION

  C prototype:
      int Cla$fullpath(const char *fname, char fullpath[64]);
  Modula-2 prototype:
      PROCEDURE fullpath(
            fname: ARRAY OF CHAR;
            VAR _fullpath: FULLPATH): INTEGER;
  Pascal prototype:
      function fullpath(var fname, _fullpath): int16;
  Clarion prototype:
      FullPath(*CSTRING,*CSTRING),SHORT,RAW,NAME('Cla$fullpath')

Expands a partial path to a full path, if the path exists.  This does not
determine the existence of a file, only the path.

      fname       The partial path to expand (including a filename). This may
                  also be a full path.

      fullpath    A 64 byte buffer which will receive the expanded full path,
                  including drive, if the path exists.  This will include the
                  filename, but does not determine its existence.  If the
                  expanded path does not exist, fullpath is left unmodified.

      Return Value:

            Returns 1 if the expanded path exists, and 0 if no such path
            exists.

------------------------------------------------------------------------------

FindClose   PROCEDURE

  NOTICE! This function is obsolete, in the DOS library.  It is not needed
  because the library now uses a re-useable (system wide) directory handle.
  
  C prototype:
      void findclose(struct ffblk *buffer);
  Modula-2 prototype:
      PROCEDURE findclose(VAR buffer: ffblk);
  Pascal prototype:
      procedure findclose(var buffer: ffblk);
  Clarion prototype:
      FindClose(*STRING),RAW,NAME('findclose')

Terminates FindFirst/FindNext processing in protected mode.  This function is
only required for protected mode programs which use FindFirst without
terminating the FindNext sequence (automatically terminated when 'no nore
files' is returned by FindNext).

      buffer      The same structure used by FindFirst and FindNext.  This
                  contains information about the file (name, size, attributes,
                  etc.).  The ffblk structure is defined as:

                  C structure:                  Clarion Structure:
                  ------------                  ------------------
                  struct ffblk {                FileInfo      GROUP
                    char ff_reserved[21];                       BYTE,DIM(21)
                    char ff_attrib;             Attributes      BYTE
                    int  ff_ftime;              TimeStamp       SHORT
                    int  ff_fdate;              DateStamp       SHORT
                    long ff_fsize;              Filesize        LONG
                    char ff_fname[13];          FileName        CSTRING(13)
                  };                                          END

      Return Value:

            None.  This function must be used in Clarion code in the same
            manner as a Clarion PROCEDURE.  This means it must be called as a
            separate command statement -- it cannot be used in expressions or
            passed as a parameter.

------------------------------------------------------------------------------

NextWordTok FUNCTION

  C prototype:
      char *Cla$nextwordtok(const char *loc, char *word, const char *toks);
  Modula-2 prototype:
      PROCEDURE nextwordtok(
            loc: ARRAY OF CHAR;
            VAR _word: ARRAY OF CHAR;
            toks: ARRAY OF CHAR): ADDRESS;
  Pascal prototype:
      function nextwordtok(var loc, _word, toks): address;
  Clarion prototype:
      NextWordTok(*CSTRING,*CSTRING,*CSTRING),ULONG,  |
            RAW,NAME('Cla$nextwordtok')

Retrieves values from a string, where the values are delimited by the
character specified in the toks parameter.  Used in a loop, this provides
basic parsing functionality.

      loc         The string to parse.

      word        The output buffer which will hold the parsed value.

      toks        A character string of delimiter tokens.

      Return Value:

            Returns a pointer to the delimiter token in the string which is at
            the end of the parsed value (the starting point for the next
            iteration).

------------------------------------------------------------------------------

SetError    PROCEDURE

  C prototype:
      void Cla$seterror(int err);
  Modula-2 prototype:
      PROCEDURE seterror(err: INTEGER);
  Pascal prototype:
      procedure seterror(err: int16);
  Clarion prototype:
      SetError(SHORT),NAME('Cla$seterror')

Sets the value returned by the Clarion ERRORCODE() function, which
automatically changes the message returned by the ERROR() function.  If set to
an undefined error code, the ERROR() function returns 'UNKNOWN ERROR'.  User
defined error codes are reserved in the range 301 to 350.

      err         The error code to set.

      Return Value:

            None.  This function must be used in Clarion code in the same
            manner as a Clarion PROCEDURE.  This means it must be called as a
            separate command statement -- it cannot be used in expressions or
            passed as a parameter.

------------------------------------------------------------------------------

ClearError  PROCEDURE

  C prototype:
      void Cla$clearerror(void);
  Modula-2 prototype:
      PROCEDURE clearerror();
  Pascal prototype:
      procedure clearerror;
  Clarion prototype:
      ClearError,NAME('Cla$clearerror')

Sets the value returned by the Clarion ERRORCODE() function to zero (0), which
indicates that no error has occurred.  This also clears the message returned
by the ERROR() function to ''.

      Return Value:

            None.  This function must be used in Clarion code in the same
            manner as a Clarion PROCEDURE.  This means it must be called as a
            separate command statement -- it cannot be used in expressions or
            passed as a parameter.

------------------------------------------------------------------------------

MatchSpec   FUNCTION

  C prototype:
      int Cla$matchspec(const char *spec, const char *name);
  Modula-2 prototype:
      PROCEDURE matchspec(spec, name: ARRAY OF CHAR): INTEGER;
  Pascal prototype:
      function matchspec(var spec, name): int16;
  Clarion prototype:
      MatchSpec(*CSTRING,*CSTRING),SHORT,RAW,NAME('Cla$matchspec')

Compares strings using wild cards.

      spec        A string containing wild card specifiers. The strict
                  definition of specifiers is as follows:

                  '*'   Any number of any characters at this position in
                        string.
                  '?'   One of any character at this position in string.
                  Any other character must match exactly at that position.

                  DOS does not conform strictly to these definitions; for
                  example, *XYZ.DAT is equivalent to *.DAT.  This function
                  conforms strictly to the CPM definition.

      name        String being matched for compliance to specifiers.

      Return Value:

            Returns one (1) if the name parameter complies with the spec
            parameter, otherwise it returns zero (0).

------------------------------------------------------------------------------


Screen Functions
================

------------------------------------------------------------------------------

RepositionScreen  PROCEDURE

  C prototype:
      void Cla$reposition_screen(
            unsigned char row,
            unsigned char col,
            unsigned char ylen,
            unsigned char xlen);
  Modula-2 prototype:
      PROCEDURE reposition_screen(row, col, ylen, xlen: SHORTCARD);
  Pascal prototype:
      procedure reposition_screen(row, col, ylen, xlen: byte);
  Clarion prototype:
      RepositionScreen(BYTE,BYTE,BYTE,BYTE),NAME('Cla$reposition_screen)

Repositions virtual screen offsets to make sure that the passed row, col,
rows, cols will be visible.

      row         Specifies the beginning row position which must be visible.

      col         Specifies the beginning column position which must be
                  visible.

      ylen        Specifies numbers of rows which must be visible.

      xlen        Specifies numbers of columns which must be visible.

      Return Value:

            None.  This function must be used in Clarion code in the same
            manner as a Clarion PROCEDURE.  This means it must be called as a
            separate command statement -- it cannot be used in expressions or
            passed as a parameter.

------------------------------------------------------------------------------

DisableScroll     PROCEDURE

  C prototype:
      void Cla$disable_scroll(void);
  Modula-2 prototype:
      PROCEDURE disable_scroll();
  Pascal prototype:
      procedure disable_scroll;
  Clarion prototype:
      DisableScroll,NAME('Cla$disable_scroll')

Disables virtual screen scrolling.

      Return Value:

            None.  This function must be used in Clarion code in the same
            manner as a Clarion PROCEDURE.  This means it must be called as a
            separate command statement -- it cannot be used in expressions or
            passed as a parameter.

------------------------------------------------------------------------------

EnableScroll      PROCEDURE

  C prototype:
      void Cla$enable_scroll(void);
  Modula-2 prototype:
      PROCEDURE enable_scroll();
  Pascal prototype:
      procedure enable_scroll;
  Clarion prototype:
      EnableScroll,NAME('Cla$enable_scroll')

Enables virtual screen scrolling which was previously disabled by
DisableScroll.

      Return Value:

            None.  This function must be used in Clarion code in the same
            manner as a Clarion PROCEDURE.  This means it must be called as a
            separate command statement -- it cannot be used in expressions or
            passed as a parameter.

------------------------------------------------------------------------------

SetList     PROCEDURE

  C prototype:
      void Cla$SETLIST(unsigned fldno, unsigned bar, unsigned elem);
  Modula-2 prototype:
      PROCEDURE SETLIST(fldno, bar, elem: CARDINAL);
  Pascal prototype:
      procedure SETLIST(fldno, bar, elem: word);
  Clarion prototype:
      SetList(USHORT,USHORT,USHORT),NAME('Cla$SETLIST')

Sets a LIST field's highlight bar and first display element position.

      fldno       Field equate label of the LIST field.

      bar         Specify the highlight bar position within the LIST.

      elem        Specify QUEUE entry to display at the top of the LIST.

      Return Value:

            None.  This function must be used in Clarion code in the same
            manner as a Clarion PROCEDURE.  This means it must be called as a
            separate command statement -- it cannot be used in expressions or
            passed as a parameter.

------------------------------------------------------------------------------

GetList     PROCEDURE

  C prototype:
      void Cla$GETLIST(unsigned fldno, unsigned *bar, unsigned *elem);
  Modula-2 prototype:
      PROCEDURE GETLIST(fldno: CARDINAL; VAR bar, elem: CARDINAL);
  Pascal prototype:
      procedure GETLIST(fldno: word; var bar, elem: word);
  Clarion prototype:
      GetList(USHORT,*USHORT,*USHORT),NAME('Cla$GETLIST')

Gets a LIST field's highlight bar and first display element position.

      fldno       Field equate label of the LIST field.

      bar         Receives current highlight bar position within the LIST
                  display.

      elem        Receives the number of the QUEUE entry displayed at the top
                  of the LIST.

      Return Value:

            None.  This function must be used in Clarion code in the same
            manner as a Clarion PROCEDURE.  This means it must be called as a
            separate command statement -- it cannot be used in expressions or
            passed as a parameter.

------------------------------------------------------------------------------

DimRadio    PROCEDURE

  C prototype:
      void Cla$dim_radio(unsigned fldnum, unsigned radionum);
  Modula-2 prototype:
      PROCEDURE dim_radio(fldnum, radionum: CARDINAL);
  Pascal prototype:
      procedure dim_radio(fldnum, radionum: word);
  Clarion prototype:
      DimRadio(USHORT,USHORT),NAME('Cla$dim_radio')

Disables a single RADIO button.

      fldnum      Field equate label of the OPTION structure containing the
                  RADIO field to disable.

      radionum    Specify which RADIO button to disable.  This must be a
                  number in the range 1 to the total number of RADIO fields in
                  the OPTION structure.

      Return Value:

            None.  This function must be used in Clarion code in the same
            manner as a Clarion PROCEDURE.  This means it must be called as a
            separate command statement -- it cannot be used in expressions or
            passed as a parameter.

------------------------------------------------------------------------------

UnDimRadio  PROCEDURE

  C prototype:
      void Cla$undim_radio(unsigned fldnum, unsigned radionum);
  Modula-2 prototype:
      PROCEDURE undim_radio(fldnum, radionum: CARDINAL);
  Pascal prototype:
      procedure undim_radio(fldnum, radionum: word);
  Clarion prototype:
      UnDimRadio(USHORT,USHORT),NAME('Cla$undim_radio')

Enables a single RADIO button previous disabled by DimRadio.

      fldnum      Field equate label of the OPTION structure containing the
                  RADIO field to enable.

      radionum    Specify which RADIO button to enable.  This must be a number
                  in the range 1 to the total number of RADIO fields in the
                  OPTION structure.

      Return Value:

            None.  This function must be used in Clarion code in the same
            manner as a Clarion PROCEDURE.  This means it must be called as a
            separate command statement -- it cannot be used in expressions or
            passed as a parameter.

------------------------------------------------------------------------------

CheckHlpFileDates       PROCEDURE

  C prototype:
      void Hlp$check_file_dates(const char *filename);
  Modula-2 prototype:
      PROCEDURE check_file_dates(filename: ARRAY OF CHAR);
  Pascal prototype:
      procedure check_file_dates(filename: string);
  Clarion prototype:
      CheckHlpFileDates(*CSTRING),RAW,NAME('Hlp$check_file_dates')

Checks the date/time stamp of all the help text files associated with the help
file (.HLP) specified as the filename parameter.  If any text file has been
changed, the help indexes are rebuilt.

      filename    The name of the help file (.HLP) to check text file
                  references against.

      Return Value:

            None.  This function must be used in Clarion code in the same
            manner as a Clarion PROCEDURE.  This means it must be called as a
            separate command statement -- it cannot be used in expressions or
            passed as a parameter.

------------------------------------------------------------------------------

ClarionKey  FUNCTION

  C prototype:
      unsigned Cla$clarionkey(unsigned keycode);
  Modula-2 prototype:
      PROCEDURE clarionkey(keycode: CARDINAL): CARDINAL;
  Pascal prototype:
      function  clarionkey(keycode: word): word;
  Clarion prototype:
      ClarionKey(USHORT),USHORT,NAME('Cla$clarionkey')

Translates a DOS keyboard scan code to the value that would be returned by the
Clarion KEYCODE() function.

      keycode     The DOS scan code to translate.

      Return Value:

            Returns the Clarion KEYCODE in a USHORT.

------------------------------------------------------------------------------

DeAlert     PROCEDURE

  C prototype:
      void Cla$de_alert(unsigned klow, unsigned khigh);
  Modula-2 prototype:
      PROCEDURE de_alert(klow, khigh: CARDINAL);
  Pascal prototype:
      procedure de_alert(klow, khigh: word);
  Clarion prototype:
      DeAlert(USHORT,USHORT),NAME('Cla$de_alert')

De-alerts a range of keys previously alerted by the ALERT statement.  If both
keycode parameters are the same, only one keycode is de-alerted.

      klow        The lowest keycode in the range to de-alert.

      khigh       The highest keycode in the range to de-alert.

      Return Value:

            None.  This function must be used in Clarion code in the same
            manner as a Clarion PROCEDURE.  This means it must be called as a
            separate command statement -- it cannot be used in expressions or
            passed as a parameter.

------------------------------------------------------------------------------

SmoothMouseOff    PROCEDURE

  C prototype:
      void Cla$smooth_mouse_off(void);
  Modula-2 prototype:
      PROCEDURE smooth_mouse_off();
  Pascal prototype:
      procedure smooth_mouse_off;
  Clarion prototype:
      SmoothMouseOff,NAME('Cla$smooth_mouse_off')

Turns the smooth mouse off.  This makes the mouse cursor a solid block.

      Return Value:

            None.  This function must be used in Clarion code in the same
            manner as a Clarion PROCEDURE.  This means it must be called as a
            separate command statement -- it cannot be used in expressions or
            passed as a parameter.

------------------------------------------------------------------------------

SmoothMouseOn     PROCEDURE

  C prototype:
      void Cla$smooth_mouse_on(void);
  Modula-2 prototype:
      PROCEDURE smooth_mouse_on();
  Pascal prototype:
      procedure smooth_mouse_on;
  Clarion prototype:
      SmoothMouseOn,NAME('Cla$smooth_mouse_on')

Turns the smooth mouse on.

      Return Value:

            None.  This function must be used in Clarion code in the same
            manner as a Clarion PROCEDURE.  This means it must be called as a
            separate command statement -- it cannot be used in expressions or
            passed as a parameter.

------------------------------------------------------------------------------

WaitPos     PROCEDURE

  C prototype:
      void Cla$wait_pos(void);
  Modula-2 prototype:
      PROCEDURE wait_pos();
  Pascal prototype:
      procedure wait_pos;
  Clarion prototype:
      WaitPos,NAME('Cla$wait_pos')

Waits for the mouse to move to a different row or column position.

      Return Value:

            None.  This function must be used in Clarion code in the same
            manner as a Clarion PROCEDURE.  This means it must be called as a
            separate command statement -- it cannot be used in expressions or
            passed as a parameter.

------------------------------------------------------------------------------

SavePallette      PROCEDURE

  C prototype:
      void Cla$SAVE_PALETTE(void);
  Modula-2 prototype:
      PROCEDURE SAVE_PALLETTE();
  Pascal prototype:
      procedure SAVE_PALLETTE;
  Clarion prototype:
      SavePalette,NAME('Cla$SAVE_PALLETTE')

Saves the currently set color palette for text or graphics modes.

      Return Value:

            None.  This function must be used in Clarion code in the same
            manner as a Clarion PROCEDURE.  This means it must be called as a
            separate command statement -- it cannot be used in expressions or
            passed as a parameter.

------------------------------------------------------------------------------

RestorePallette   PROCEDURE

  C prototype:
      void Cla$RESTORE_PALETTE(void);
  Modula-2 prototype:
      PROCEDURE RESTORE_PALLETTE();
  Pascal prototype:
      procedure RESTORE_PALLETTE;
  Clarion prototype:
      RestorePalette,NAME('Cla$RESTORE_PALLETTE')

Restores the last color palette saved by Cla$SAVE_PALETTE.

      Return Value:

            None.  This function must be used in Clarion code in the same
            manner as a Clarion PROCEDURE.  This means it must be called as a
            separate command statement -- it cannot be used in expressions or
            passed as a parameter.

------------------------------------------------------------------------------

ShowPage    PROCEDURE

  C prototype:
      void Cla$showpage(int attr);
  Modula-2 prototype:
      PROCEDURE showpage(attr: INTEGER);
  Pascal prototype:
      procedure showpage(attr: int16);
  Clarion prototype:
      ShowPage(SHORT),NAME('Cla$showpage')

Copies the current screen from the virtual screen buffer to the physical
screen.

      attr        Must always be set to 1.

      Return Value:

            None.  This function must be used in Clarion code in the same
            manner as a Clarion PROCEDURE.  This means it must be called as a
            separate command statement -- it cannot be used in expressions or
            passed as a parameter.

------------------------------------------------------------------------------

OnScreen    FUNCTION

  C prototype:
      int Cla$onscreen(unsigned char y, unsigned char x);
  Modula-2 prototype:
      PROCEDURE onscreen(y, x: SHORTCARD): INTEGER;
  Pascal prototype:
      function onscreen(y, x: byte): int16;
  Clarion prototype:
      OnScreen(BYTE, BYTE),SHORT,NAME('Cla$onscreen')

Determines if the coordinates specified by the x and y parameters are
currently visible on the physical screen.

      y           Row position.

      x           Column position.

      Return Value:

            Returns one (1) if the position is visible and zero (0) if it is
            not visible.

------------------------------------------------------------------------------

PanLeft     PROCEDURE

  C prototype:
      void Cla$pan_left(int num);
  Modula-2 prototype:
      PROCEDURE pan_left(num: INTEGER);
  Pascal prototype:
      procedure pan_left(num: int16);
  Clarion prototype:
      PanLeft(SHORT),NAME('Cla$pan_left')

Moves the physical screen "viewport" left the number of characters specified
by the num parameter.

      num         The number of columns to move.

      Return Value:

            None.  This function must be used in Clarion code in the same
            manner as a Clarion PROCEDURE.  This means it must be called as a
            separate command statement -- it cannot be used in expressions or
            passed as a parameter.

------------------------------------------------------------------------------

PanRight    PROCEDURE

  C prototype:
      void Cla$pan_right(int num);
  Modula-2 prototype:
      PROCEDURE pan_right(num: INTEGER);
  Pascal prototype:
      procedure pan_right(num: int16);
  Clarion prototype:
      PanRight(SHORT),NAME('Cla$pan_right')

Moves the physical screen "viewport" right the number of characters specified
by the num parameter.

      num         The number of columns to move.

      Return Value:

            None.  This function must be used in Clarion code in the same
            manner as a Clarion PROCEDURE.  This means it must be called as a
            separate command statement -- it cannot be used in expressions or
            passed as a parameter.

------------------------------------------------------------------------------

PanUp       PROCEDURE

  C prototype:
      void Cla$pan_up(int num);
  Modula-2 prototype:
      PROCEDURE pan_up(num: INTEGER);
  Pascal prototype:
      procedure pan_up(num: int16);
  Clarion prototype:
      PanUp(SHORT),NAME('Cla$pan_up')

Moves the physical screen "viewport" up the number of characters specified by
the num parameter.

      num         The number of rows to move.

      Return Value:

            None.  This function must be used in Clarion code in the same
            manner as a Clarion PROCEDURE.  This means it must be called as a
            separate command statement -- it cannot be used in expressions or
            passed as a parameter.

------------------------------------------------------------------------------

PanDown     PROCEDURE

  C prototype:
      void Cla$pan_down(int num);
  Modula-2 prototype:
      PROCEDURE pan_down(num: INTEGER);
  Pascal prototype:
      procedure pan_down(num: int16);
  Clarion prototype:
      PanDown(SHORT),NAME('Cla$pan_down')

Moves the physical screen "viewport" down the number of characters specified
by the num parameter.

      num         The number of rows to move.

      Return Value:

            None.  This function must be used in Clarion code in the same
            manner as a Clarion PROCEDURE.  This means it must be called as a
            separate command statement -- it cannot be used in expressions or
            passed as a parameter.

------------------------------------------------------------------------------

SaveScreen  PROCEDURE

  C prototype:
      void Cla$savescreen(
            unsigned lin,
            unsigned col,
            unsigned nol,
            unsigned noc,
            struct SSSTRK *buf,
            unsigned char ctl);
  Modula-2 prototype:
      PROCEDURE savescreen(
            lin, col, nol, noc: CARDINAL;
            VAR buf: SSSTRK;
            ctl: SHORTCARD);
  Pascal prototype:
      procedure savescreen(
            lin, col, nol, noc: word;
            var buf: ssstrk;
            ctl: byte);
  Clarion prototype:
      SaveScreen(USHORT,USHORT,USHORT,USHORT,*STRING,BYTE),  |
            RAW,NAME('Cla$savescreen')

Saves an area of video (in either text or graphics).

      lin         The physical row position of the top edge of the screen area
                  to save.

      col         The physical row position of the left edge of the screen
                  area to save.

      nol         The number of screen rows to save.

      noc         The number of screen columns to save.

      buf         Save buffer for information required by any subsequent call
                  to RestoreScreen (internally handled).

                  C structure:                  Clarion Structure:
                  ------------                  ------------------
                  struct SSSTRK {               ScreenSave    GROUP
                    unsigned      lin;          Line            USHORT
                    unsigned      col;          Column          USHORT
                    unsigned      noc;          NumberOfCols    USHORT
                    unsigned      nol;          NumberOfLines   USHORT
                    //Graphics ONLY------       !Graphics ONLY------
                    char *piece[40];            SavePieces      ULONG,DIM(40)
                    unsigned char piece_count;  NumberOfPieces  USHORT
                    unsigned lsize;             PieceSize       USHORT
                    unsigned rsize;             LastPieceSize   USHORT
                    unsigned rlines;            LinesPerPiece   USHORT
                    //-------------------       !-------------------
                    char *text;                 TextScreenSave  ULONG
                    char     cursor[4];         CursorShape     STRING(4)
                  };

      ctl         a bitmap of savescreen options
                      x x x x x x x x
                                |   |- Use conventional memory for save
                                |
                                |----- Don't allocate memory

      Return Value:

            None.  This function must be used in Clarion code in the same
            manner as a Clarion PROCEDURE.  This means it must be called as a
            separate command statement -- it cannot be used in expressions or
            passed as a parameter.

------------------------------------------------------------------------------

RestoreScreen     PROCEDURE

  C prototype:
      void Cla$rstscreen(struct SSSTRK *buf, unsigned char ctl);
  Modula-2 prototype:
      PROCEDURE rstscreen(VAR buf: SSSTRK; ctl: SHORTCARD);
  Pascal prototype:
      procedure rstscreen(var buf: ssstrk; ctl: byte);
  Clarion prototype:
      RestoreScreen(*STRING,BYTE),RAW,NAME('Cla$rstscreen')

Restores an area of video (in either text or graphics mode) previously saved
with SaveScreen.

      buf         The save buffer previously used by SaveScreen (internally
                  handled).

                  C structure:                  Clarion Structure:
                  ------------                  ------------------
                  struct SSSTRK {               ScreenSave    GROUP
                    unsigned      lin;          Line            USHORT
                    unsigned      col;          Column          USHORT
                    unsigned      noc;          NumberOfCols    USHORT
                    unsigned      nol;          NumberOfLines   USHORT
                    //Graphics ONLY------       !Graphics ONLY------
                    char *piece[40];            SavePieces      ULONG,DIM(40)
                    unsigned char piece_count;  NumberOfPieces  USHORT
                    unsigned lsize;             PieceSize       USHORT
                    unsigned rsize;             LastPieceSize   USHORT
                    unsigned rlines;            LinesPerPiece   USHORT
                    //-------------------       !-------------------
                    char *text;                 TextScreenSave  ULONG
                    char     cursor[4];         CursorShape     STRING(4)
                  };

      ctl         a bitmap of restore screen options
                      x x x x x x x x
                              |   |
                              |   |--- Don't free memory
                              |
                              |------- Free memory only

      Return Value:

            None.  This function must be used in Clarion code in the same
            manner as a Clarion PROCEDURE.  This means it must be called as a
            separate command statement -- it cannot be used in expressions or
            passed as a parameter.

------------------------------------------------------------------------------

UnLoadSymbols     PROCEDURE

  C prototype:
      void Cla$UNLOADSYMBOLS(void);
  Modula-2 prototype:
      PROCEDURE UNLOADSYMBOLS();
  Pascal prototype:
      procedure UNLOADSYMBOLS;
  Clarion prototype:
      UnLoadSymbols,NAME('Cla$UNLOADSYMBOLS')

Unloads the symbols set by a previous LOADSYMBOLS statement.

      Return Value:

            None.  This function must be used in Clarion code in the same
            manner as a Clarion PROCEDURE.  This means it must be called as a
            separate command statement -- it cannot be used in expressions or
            passed as a parameter.

------------------------------------------------------------------------------

MapCharacter      PROCEDURE

  C prototype:
      void map_character(
            const unsigned char *newmap,
            unsigned char c, char map);
  Modula-2 prototype:
      PROCEDURE map_character(VAR newmap: BITMAP; c: SHORTCARD; map: CHAR);
  Pascal prototype:
      procedure map_character(var newmap: bitmap; c: byte; map: char);
  Clarion prototype:
      MapCharacter(*STRING,BYTE,BYTE),NAME('map_character'),RAW

Remaps a character in the display font to the bitmap contained in the newmap
parameter (in text-mode only).

      newmap      pointer to the new character's bitmap (a 16-byte array)

      c           ASCII code of the character to be remapped

      map         which hardware character map to use (almost always 0)

      Return Value:

            None.  This function must be used in Clarion code in the same
            manner as a Clarion PROCEDURE.  This means it must be called as a
            separate command statement -- it cannot be used in expressions or
            passed as a parameter.

------------------------------------------------------------------------------

QShow       PROCEDURE

  C prototype:
      void Cla$qshow(
            const void *daddr,
            unsigned line,
            unsigned col,
            unsigned len,
            unsigned char attr,
            unsigned style);
  Modula-2 prototype:
      PROCEDURE qshow(
            daddr: ARRAY OF CHAR;
            line, col, len: CARDINAL;
            attr: SHORTCARD;
            style: CARDINAL);
  Pascal prototype:
      procedure qshow(var daddr; line, col, len: word; attr: byte; style:
word);
  Clarion prototype:
      QShow(*STRING,USHORT,USHORT,USHORT,BYTE,USHORT),RAW,NAME('Cla$qshow')

Low level show which copies the text in the daddr parameter to both physical
and virtual screen memory.

      daddr       The text to show (should be string data).

      line        Row position at which to show data.

      col         Column position at which to show data.

      len         Length of data to show.

      attr        Color attribute to show.

      style       A bitmap of options defined as follows:
                  x x x x x x x x x x
                      | | | | | | | |- Use passed attr parameter
                      | | | | | | |--- Reverse color
                      | | | | | |----- No background color (graphic mode only)
                      | | | | |------- Blink
                      | | | |--------- Don't show anything for nulls
                      | | |----------- Don't show attributes
                      | |------------- data is in bytes format: DATA,ATTRIBUTE
                      |--------------- Pad string with blanks to passed length

      Return Value:

            None.  This function must be used in Clarion code in the same
            manner as a Clarion PROCEDURE.  This means it must be called as a
            separate command statement -- it cannot be used in expressions or
            passed as a parameter.

------------------------------------------------------------------------------

VidOutA     PROCEDURE

  C prototype:
      void Cla$vidouta(unsigned line, unsigned col, unsigned len, char *ptr);
  Modula-2 prototype:
      PROCEDURE vidouta(
            line, col, len: CARDINAL;
            VAR ptr: ARRAY OF SCREENFIELD);
  Pascal prototype:
      procedure vidouta(line, col, len: word;var ptr);
  Clarion prototype:
      VidOutA(USHORT,USHORT,USHORT,*CSTRING),RAW,NAME('Cla$vidouta')

Retrieves data from the screen in DATA,ATTRIBUTE format and saves it in the
variable specified by the ptr parameter.

      line        Row position from which to get data.

      col         Column position from which to get data.

      len         Length of data to get.

      ptr         The save buffer for the data.  This must be a variable at
                  least twice as large as the len parameter, since the data is
                  retrieved as 2 bytes per character.

      Return Value:

            None.  This function must be used in Clarion code in the same
            manner as a Clarion PROCEDURE.  This means it must be called as a
            separate command statement -- it cannot be used in expressions or
            passed as a parameter.

------------------------------------------------------------------------------

GetCurs     PROCEDURE

  C prototype:
      void Cla$getcurs(unsigned char *row, unsigned char *col);
  Modula-2 prototype:
      PROCEDURE getcurs(VAR row, col: SHORTCARD);
  Pascal prototype:
      procedure getcurs(var row, col: byte);
  Clarion prototype:
      GetCurs(*CSTRING,*CSTRING),RAW,NAME('Cla$getcurs')

Gets the current cursor position.  This is the physical screen position, not
its position relative to the Clarion SCREEN structure coordinates.

      row         Variable to receive the row position.

      col         Variable to receive the column position.

      Return Value:

            None.  This function must be used in Clarion code in the same
            manner as a Clarion PROCEDURE.  This means it must be called as a
            separate command statement -- it cannot be used in expressions or
            passed as a parameter.

------------------------------------------------------------------------------


Global Variables
================

------------------------------------------------------------------------------

UserBreak         Enables/disables CTRL-BREAK by the user at runtime.  CTRL-
                  BREAK handling is disabled when non-zero.
  C definition:
      unsigned char Cla$UserBreak;
  Modula-2 declaration:
        Cla$UserBreak    : SHORTCARD;
  Pascal declaration:
        Cla$UserBreak    : byte;
  Clarion declaration:
      UserBreak         BYTE,NAME('Cla$UserBreak'),EXTERNAL

------------------------------------------------------------------------------

Alerts            The array of keys currently alerted by the ALERT statement.
  C definition:
      unsigned Alerts[500];
  Modula-2 declaration:
      Alerts           : ARRAY [0..499] OF CARDINAL;
  Pascal declaration:
      Alerts           : array [0..499] of word;
  Clarion declaration:
      Alerts            USHORT,DIM(500),NAME('Alerts'),EXTERNAL

------------------------------------------------------------------------------

AlertCount        The number of currently alerted keys.
  C definition:
      unsigned Alertcount;
  Modula-2 declaration:
      Alertcount       : CARDINAL;
  Pascal declaration:
      Alertcount       : word;
  Clarion declaration:
      AlertCount        USHORT,NAME('Alertcount'),EXTERNAL

------------------------------------------------------------------------------

ScreenMemory            The address of virtual screen memory.
  C definition:
      char *SMEM;
  Modula-2 declaration:
      SMEM             : ADDRESS;
  Pascal declaration:
      SMEM             : address;
  Clarion declaration:
      ScreenMemory      ULONG,NAME('_SMEM'),EXTERNAL

------------------------------------------------------------------------------

ClaColors         The internal color style codes array.
  C definition:
      unsigned char CLACOLORS[256];
  Modula-2 declaration:
      CLACOLORS        : ARRAY [0..255] OF SHORTCARD;
  Pascal declaration:
      CLACOLORS        : array [0..255] of byte;
  Clarion declaration:
      ClaColors   BYTE,DIM(256),NAME('CLACOLORS'),EXTERNAL

------------------------------------------------------------------------------

RealYMax          Physical screen rows.
  C definition:
      int REAL_Y_MAX;
  Modula-2 declaration:
      REAL_Y_MAX       : INTEGER;
  Pascal declaration:
      REAL_Y_MAX       : int16;
  Clarion declaration:
      RealYMax    SHORT,NAME('REAL_Y_MAX'),EXTERNAL

------------------------------------------------------------------------------

LastVideoRow      Last video row position written to (used for floating window
                  positioning).
  C definition:
      unsigned char LASTVIDEOROW;
  Modula-2 declaration:
      LASTVIDEOROW     : SHORTCARD;
  Pascal declaration:
      LASTVIDEOROW     : byte;
  Clarion declaration:
      LastVideoRow      BYTE,NAME('LASTVIDEOROW'),EXTERNAL

------------------------------------------------------------------------------

LastVideoCol      Last video column position written to (used for floating
                  window positioning).
  C definition:
      unsigned char LASTVIDEOCOL;
  Modula-2 declaration:
      LASTVIDEOCOL     : SHORTCARD;
  Pascal declaration:
      LASTVIDEOCOL     : byte;
  Clarion declaration:
      LastVideoCol      BYTE,NAME('LASTVIDEOCOL'),EXTERNAL

------------------------------------------------------------------------------

LastVideoLen      Length of data written to last video position (used for
                  floating window positioning).
  C definition:
      unsigned char LASTVIDEOLEN;
  Modula-2 declaration:
      LASTVIDEOLEN     : SHORTCARD;
  Pascal declaration:
      LASTVIDEOLEN     : byte;
  Clarion declaration:
      LastVideoLen      BYTE,NAME('LASTVIDEOLEN'),EXTERNAL

------------------------------------------------------------------------------

FirstWin    First open window flag.  0 = No windows opened yet, 1 = a window
            has been opened
  C definition:
      char FIRSTWIN;
  Modula-2 declaration:
      FIRSTWIN         : CHAR;
  Pascal declaration:
      FIRSTWIN         : char;
  Clarion declaration:
      FirstWin    BYTE,NAME('FIRSTWIN'),EXTERNAL

------------------------------------------------------------------------------

XOffset     Current column offset of the virtual screen (starts at 0).
  C definition:
      int XOFFSET;
  Modula-2 declaration:
      XOFFSET          : INTEGER;
  Pascal declaration:
      XofFSET          : int16;
  Clarion declaration:
      XOffset     SHORT,NAME('_XOFFSET'),EXTERNAL

------------------------------------------------------------------------------

YOffset     Current row offset of the virtual screen (starts at 0).
  C definition:
      int YOFFSET;
  Modula-2 declaration:
      YOFFSET          : INTEGER;
  Pascal declaration:
      YofFSET          : int16;
  Clarion declaration:
      YOffset     SHORT,NAME('_YOFFSET'),EXTERNAL

------------------------------------------------------------------------------

SpeedIndex        Used with screen opening effects (ZOOM, FADE, WIPE, FALL)
                  for timing purposes.
  C definition:
      int SPEED_INDEX;
  Modula-2 declaration:
      SPEED_INDEX      : INTEGER;
  Pascal declaration:
      SPEED_INDEX      : int16;
  Clarion declaration:
      SpeedIndex  SHORT,NAME('_SPEED_INDEX'),EXTERNAL

------------------------------------------------------------------------------

CharLines         Graphics mode -- number of lines per character.
  C definition:
      char CHAR_LINES;
  Modula-2 declaration:
      CHAR_LINES       : CHAR;
  Pascal declaration:
      char_LINES       : char;
  Clarion declaration:
      CharLines   BYTE,NAME('_CHAR_LINES'),EXTERNAL

------------------------------------------------------------------------------

VRam        Contains the memory address of Graphics-mode video memory.
  C definition:
      char *VRAM;
  Modula-2 declaration:
      VRAM             : ADDRESS;
  Pascal declaration:
      VRAM             : address;
  Clarion declaration:
      VRam        ULONG,NAME('_VRAM'),EXTERNAL

------------------------------------------------------------------------------

CTable      Graphics mode address of the character table.
  C definition:
      char *c_table;
  Modula-2 declaration:
      c_table          : ADDRESS;
  Pascal declaration:
      c_table          : address;
  Clarion declaration:
      CTable      ULONG,NAME('_c_table'),EXTERNAL

------------------------------------------------------------------------------

VirtualScreen     Flags virtual screen use.  1 = Virtual screen in use
                  (usually always on), 0 = Virtual screens turned off.
  C definition:
      char VIRTUAL_SCREEN;
  Modula-2 declaration:
      VIRTUAL_SCREEN   : CHAR;
  Pascal declaration:
      VIRTUAL_SCREEN   : char;
  Clarion declaration:
      VirtualScreen     BYTE,NAME('VIRTUAL_SCREEN'),EXTERNAL

------------------------------------------------------------------------------

AltTrack    Alternate "thin border" track characters.
  C definition:
      unsigned char ALT_TRACK[9];
  Modula-2 declaration:
      ALT_TRACK        : ARRAY [0..8] OF CHAR;
  Pascal declaration:
      ALT_TRACK        : array [0..8] of char;
  Clarion declaration:
      AltTrack    BYTE,DIM(9),NAME('ALT_TRACK'),EXTERNAL

------------------------------------------------------------------------------

DisableWindowMove       Flag to enable/disable window move with the mouse.
                        0 = Allow windows to be moved, 1 = Don't allow windows
                        to be moved.
  C definition:
      char DisableWindowMove;
  Modula-2 declaration:
      DisableWindowMove: CHAR;
  Pascal declaration:
      DisableWindowMove: char;
  Clarion declaration:
      DisableWindowMove BYTE,NAME('DisableWindowMove'),EXTERNAL

------------------------------------------------------------------------------

CUA         Flag to enable/disable CUA field navigation for current screen.
            0 = Clarion 2.1 style field processing for current screen, 1 = CUA
            field processing for current screen.
  C definition:
      char CUA;
  Modula-2 declaration:
      CUA              : CHAR;
  Pascal declaration:
      CUA              : char;
  Clarion declaration:
      CUA         BYTE,NAME('CUA'),EXTERNAL

------------------------------------------------------------------------------

MsgRow            Current MSG attribute display row position.
  C definition:
      int MSGROW;
  Modula-2 declaration:
      MSGROW           : INTEGER;
  Pascal declaration:
      MSGROW           : int16;
  Clarion declaration:
      MsgRow      SHORT,NAME('MSGROW'),EXTERNAL

------------------------------------------------------------------------------

MsgCol            Current MSG attribute display column position.
  C definition:
      int MSGCOL;
  Modula-2 declaration:
      MSGCOL           : INTEGER;
  Pascal declaration:
      MSGCOL           : int16;
  Clarion declaration:
      MsgCol      SHORT,NAME('MSGCOL'),EXTERNAL

------------------------------------------------------------------------------

MsgLen            Current MSG attribute display length.
  C definition:
      int MSGLEN;
  Modula-2 declaration:
      MSGLEN           : INTEGER;
  Pascal declaration:
      MSGLEN           : int16;
  Clarion declaration:
      MsgLen      SHORT,NAME('MSGLEN'),EXTERNAL

------------------------------------------------------------------------------

ClickDelay        Mouse double-click time wait (default is 45 hundreths of a
                  second).
  C definition:
      int CLICK_DELAY;
  Modula-2 declaration:
      CLICK_DELAY      : INTEGER;
  Pascal declaration:
      CLICK_DELAY      : int16;
  Clarion declaration:
      ClickDelay  SHORT,NAME('CLICK_DELAY'),EXTERNAL

------------------------------------------------------------------------------

HelpWindow        The currently active help window ID.
  C definition:
      char HELPWINDOW[64];
  Modula-2 declaration:
      HELPWINDOW       : ARRAY [0..63] OF CHAR;
  Pascal declaration:
      HELPWINDOW       : array [0..63] of char;
  Clarion declaration:
      HelpWindow  CSTRING(64),NAME('HELPWINDOW'),EXTERNAL

------------------------------------------------------------------------------

SmoothMouse       Flag to enable/disable smooth mouse cursor. 0 = Smooth mouse
                  not active, 1 = Smooth mouse active.
  C definition:
      char SMOOTH_MOUSE;
  Modula-2 declaration:
      SMOOTH_MOUSE     : CHAR;
  Pascal declaration:
      SMOOTH_MOUSE     : char;
  Clarion declaration:
      SmoothMouse       BYTE,NAME('SMOOTH_MOUSE'),EXTERNAL

------------------------------------------------------------------------------

ScrollType        Flag to enable/disable "pressure sensitive" virtual screen
                  scrolling. 0 = Original virtual screen scrolling (mouse at
                  edge), 1 = "Pressure sensitive" virtual screen scrolling.
  C definition:
      char SCROLL_TYPE;
  Modula-2 declaration:
      SCROLL_TYPE      : CHAR;
  Pascal declaration:
      SCROLL_TYPE      : char;
  Clarion declaration:
      ScrollType        BYTE,NAME('SCROLL_TYPE'),EXTERNAL

------------------------------------------------------------------------------

RadioOff1         Bitmap for the left side of an unselected RADIO button.
  C definition:
      unsigned char roff1[16] =
            { 0,3,0xc,16,16,32,32,32,32,16,16,0xc,3,0,0,0 };
  Modula-2 declaration:
      roff1            : ARRAY [0..15] OF SHORTCARD;

  Pascal declaration:
      roff1            : array [0..15] of byte;
  Clarion declaration:
      RadioOff1         BYTE,DIM(16),NAME('roff1'),EXTERNAL

------------------------------------------------------------------------------

RadioOff2         Bitmap for the right side of an unselected RADIO button.
  C definition:
      unsigned char roff2[16] =
            { 0,0xe0,0x18,4,4,2,2,2,2,4,4,0x18,0xe0,0,0,0 };
  Modula-2 declaration:
      roff2            : ARRAY [0..15] OF SHORTCARD;
  Pascal declaration:
      roff2            : array [0..15] of byte;
  Clarion declaration:
      RadioOff2         BYTE,DIM(16),NAME('roff2'),EXTERNAL

------------------------------------------------------------------------------

RadioOn1          Bitmap for the left side of a selected RADIO button.
  C definition:
      unsigned char ron1[16] =
            { 0,3,0xc,16,0x13,0x27,0x27,0x27,0x27,0x13,16,0xc,3,0,0,0 };
  Modula-2 declaration:
      ron1             : ARRAY [0..15] OF SHORTCARD;
  Pascal declaration:
      ron1             : array [0..15] of byte;
  Clarion declaration:
      RadioOn1          BYTE,DIM(16),NAME('ron1'),EXTERNAL

------------------------------------------------------------------------------

RadioOn2          Bitmap for the right side of a selected RADIO button.
  C definition:
      unsigned char ron2[16] =
            { 0,0xe0,0x18,4,0xe4,0xf2,0xf2,0xf2,0xf2,0xe4,4,0x18,0xe0,0,0,0 };
  Modula-2 declaration:
      ron2             : ARRAY [0..15] OF SHORTCARD;
  Pascal declaration:
      ron2             : array [0..15] of byte;
  Clarion declaration:
      RadioOn2          BYTE,DIM(16),NAME('ron2'),EXTERNAL

------------------------------------------------------------------------------

CheckOff1         Bitmap for the left side of an unselected CHECK box.
  C definition:
      unsigned char checkoff1[16] =
            { 0,0x3f,32,32,32,32,32,32,32,32,32,32,0x3f,0,0,0 };
  Modula-2 declaration:
      checkoff1        : ARRAY [0..15] OF SHORTCARD;
  Pascal declaration:
      checkoff1        : array [0..15] of byte;
  Clarion declaration:
      CheckOff1         BYTE,DIM(16),NAME('checkoff1'),EXTERNAL

------------------------------------------------------------------------------

CheckOff2         Bitmap for the right side of an unselected CHECK box.
  C definition:
      unsigned char checkoff2[16] =
            { 0,0xf8,8,8,8,8,8,8,8,8,8,8,0xf8,0,0,0 };
  Modula-2 declaration:
      checkoff2        : ARRAY [0..15] OF SHORTCARD;
  Pascal declaration:
      checkoff2        : array [0..15] of byte;
  Clarion declaration:
      CheckOff2         BYTE,DIM(16),NAME('checkoff2'),EXTERNAL

------------------------------------------------------------------------------

CheckOn1          Bitmap for the left side of a selected CHECK box.
  C definition:
      unsigned char checkon1[16] =
      { 0,0x3f,0x30,0x28,0x24,0x22,0x21,0x21,0x22,0x24,0x28,0x30,0x3f,0,0,0 };
  Modula-2 declaration:
      checkon1         : ARRAY [0..15] OF SHORTCARD;
  Pascal declaration:
      checkon1         : array [0..15] of byte;
  Clarion declaration:
      CheckOn1          BYTE,DIM(16),NAME('checkon1'),EXTERNAL

------------------------------------------------------------------------------

CheckOn2          Bitmap for the right side of a selected CHECK box.
  C definition:
      unsigned char checkon2[16] =
            { 0,0xf8,0x18,0x28,0x48,0x88,8,8,0x88,0x48,0x28,0x18,0xf8,0,0,0 };
  Modula-2 declaration:
      checkon2         : ARRAY [0..15] OF SHORTCARD;
  Pascal declaration:
      checkon2         : array [0..15] of byte;
  Clarion declaration:
      CheckOn2          BYTE,DIM(16),NAME('checkon2'),EXTERNAL

