Power-Programmierung

home *** CD-ROM | disk | FTP | other *** search

/ Power-Programmierung / CD2.mdf / c / library / dos / database / tcu32_db / tcu.doc < prev next >

Wrap

Text File | 1991-08-01 | 101.0 KB | 2,380 lines

=========================== Turbo-C Utilities - TCU 3.2 =========================== + Database Option =========================== Foreword -------- Further information, support and product registration should be addressed to the address given below. Karl Keyte Gross-Gerauer Strasse 10 D-6108 Weiterstadt Germany Voice : +(49) 6150 2499 All memory models other than TINY (which is not supported) are supplied with this version. Compilations with ALL memory models MUST use the WORD ALIGN option or else the programs WILL NOT WORK. If you use this product, please be sure to register by writing to the address given above. Disclaimer ---------- No responsibility taken for anything which may result from using the TCU package. If anything unusual does result, please contact me on the above e-Mail address with full details. Introduction ------------ TCU is a library for Turbo-C v2.0 or Turbo/Borland C++ to provide a number of services relating to menus, prompt and notice windows, form entry and databases. This document offers a full description of each of the services, their syntax and operation. The following text describes each section briefly. It for the user to write full test and application programs to demonstrate fully the use of each. Menus ----- The TCU menu system offers pop-up menus and pulldown menus. Pulldown menus utilise normal pop-up menus for each of the choices. A pop-up menu is defined with the 'tcu_define_menu' service and may be displayed on the screen with 'tcu_display_menu'. A choice from the menu is read with 'tcu_read_menu_selection'. The menu is removed from the screen with the 'tcu_remove_menu' service. Each menu should be declared in the calling program as type TCU_MENU before being defined. A pulldown menu is a set of title options, and each option may have an associated pop-up menu which will be displayed beneath the pulldown option when selected. Items in pop-up menus may be set as 'unavailable', making that option non selectable. This option may be toggled on and off. Prompts and Notices ------------------- A notice is a set of lines of text which is displayed in a notice window. The notice must be cleared from the screen by the user pressing the RETURN key or the ESCAPE key. A notice is initiated (though not displayed) with the 'tcu_prepare_notice' service, and each line of text is added to the notice using 'tcu_notice_text'. When the notice has been fully built it may be displayed with 'tcu_display_notice'. When it is no longer needed it should be cleared with the 'tcu_clear_notice' service. A prompt is simply a notice with a single input field. The input field is defined (in colour and size) with the 'tcu_prompt_input' service. As soon as a call to 'tcu_prompt_input' is made, the notice becomes a prompt. This call must be made prior to the call to 'tcu_display_notice'. A prompt is completed by the user entering the prompt field and pressing the RETURN key. Forms ----- The forms package is a complete form entry system allowing fixed text and variable input areas to be defined in a form. The attributes of the form are written in a CUF ('C' Utilities Form) file and compiled into an object form (CFO - 'C' Form Object) or a relocatable object file using the provided Forms Compiler. The compiler checks the syntax and validity of each of the entries in the form source file, and if no errors are found the object is generated. This object may then be loaded by an application using the 'tcu_load_form' or 'tcu_load_image_form' service. This former gives the application the flexibility not to depend on the exact form content which may be modified without having to recompile or link any code (unless major changes are made to the form structure). Full details of the form source syntax are available in the Forms Compiler documentation. Each field in a form is addressed by its 'form id' number, which is not specified in the form source, but is assigned at run-time. In order to allow applications to refer to known fields, fields may be given a name which may be used with the 'tcu_get_field_id' service to obtain the applicable form id. Fields may be one of 7 types, or 6 basic types: Numeric - 2 types, 1 integer and 1 floating point. String - Character strings Date - Dates in US or European format Logical - True/False, Yes/No, etc. Choice - Enumerated selection types Button - Selection buttons Fixed text within a form is declared as TEXT rather than FIELD. Each field or text item may be assigned a colour attribute, defining its foreground and background colours. The COLOUR and INPUT keywords may be used to assign default colour attributes for items not having a specific colour attribute; this is the normal case. Many operations exist with the services provided to change attributes and behaviour of the fields. These are described fully in the following text. Note that in the interest of retaining as much available dynamic memory as possible for the application, forms should be unloaded after use with the 'tcu_unload_form' option. If a form is used repeatedly it is probably not worth unloading it until the program is to terminate. Databases --------- The TCU database system is closely integrated with TCU forms. It is meant to allow forms to be used to specify a record format conveniently and to supplement this by allowing form records to be stored in a database with keyed access. This offers the advantage that forms may be designed in the traditional way, displayed and edited as usual, and saved and recalled by using the TCU database services. Normally the forms will be displayed, but it is also possible to use the form services to simply define record structures on which the database services will operate. This implies that a 'tcu_load_form' call will be made but no 'tcu_display_form'. The indexing strategy in TCU uses a fast, cached b-tree+ method to allow rapid access to records of the database. The database may have up to 16 keys (which must be named fields of the form), with the first key acting as the primary key. Searches are performed on the primary key, but the full set of keys is used in ordering the records in the database. Note that buttons, for obvious reasons, cannot be used as index keys. Keys may additionally be specified to take ascending or descending sort order. The form must always be loaded when performing database functions. The usual sequence of calls will be: stat = tcu_load_form (&my_form, "testform"); stat = tcu_db_open (&my_db, &my_form, "testdb", 1); : : : : : stat = tcu_db_close (&my_db); stat = tcu_unload_form (&my_form); The database system maintains a concept of 'current location' which defines which record is currently referenced. For example, calling 'tcu_db_read' will read the 'current' record into the form structure (which in turn will be displayed directly if the form is present on the screen). There are services to move the pointer around the database and to move to a record under search. A TCU database file is specified by a filepath without extension. Two files will be generated when 'tcu_db_create' is called, one index with the filetype '.cix' and one main database file with the filetype '.cdb'. Services -------- The following services should provide enough flexibility for you to define and use some nice little menus, prompts, notices and forms in some of your applications. If you get stuck and need an example, send me details and I'll try to help with the problem. Database Services ----------------- tcu_db_close Close the database files tcu_db_create Create a new indexed database tcu_db_delete Delete the current record tcu_db_find Search for record with matching key tcu_db_first Move DB pointer to first record tcu_db_last Move DB pointer to last record tcu_db_next Move DB pointer to next record tcu_db_open Open an existing database tcu_db_previous Move DB pointer to previous record tcu_db_read Read the current record into form tcu_read_index_field Reads an index of the current record tcu_db_remove Remove a database completely from disc tcu_db_rewrite Rewrite an existing record to the DB tcu_db_save Flush vital buffers to disc for safety tcu_db_search Search for record with next highest key tcu_db_set_search_mode Change the mode for indexed searches tcu_db_write Write a new record to the database Menu Services ------------- tcu_change_menu_attribs Changes colour attributes of menu tcu_change_menu_escapes Change valid menu escape keys tcu_clear_menu_in_pulldown Remove submenu of pulldown menu tcu_define_menu Define a menu format tcu_define_pulldown Define a pulldown menu tcu_display_pulldown_header Display header line of pulldown tcu_display_menu Display menu on screen tcu_escape_fkey Find last used function key number tcu_new_pulldown_cover Reload screen memory under pulldown tcu_read_menu_selection Get user's menu choice tcu_read_pulldown_selection Get choice from pulldown menus tcu_remove_menu Remove menu from screen tcu_remove_pulldown Remove pulldown menu & submenus tcu_set_menu_help Define help function for pulldown tcu_set_menu_option Enable or disable menu options tcu_set_pulldown_help Define help function for pulldown Prompt Services --------------- tcu_clear_notice Clear a prepared notice tcu_display_notice Display notice on screen tcu_get_confirm Get user confirmation/rejection tcu_notice_text Add line of text to prepared notice tcu_prepare_notice Initialise notice creation tcu_prompt_input Enter an input area in a notice Form Services ------------- tcu_display_form Display defined form on screen tcu_edit_form Interactive form edit tcu_form_record_size Returns the size of a form record tcu_get_field Obtain field value from form tcu_get_field_choice_string Return the text of a Choice field tcu_get_field_id Obtain numeric field ID from name tcu_get_field_info Obtains field information block tcu_get_form_info Obtains form infomation block tcu_load_form Load form from .CFO form object tcu_load_image_form Load form from linked-in module tcu_put_field Put value into form field tcu_read_formrec Reads a form record from a buffer tcu_remove_form Remove displayed form from screen tcu_select_field Selects a field from a form tcu_set_button_fn Defines a form button field handler tcu_set_field_attrib Set colour attributes of field tcu_set_field_mode Set field characteristics tcu_set_field_verify Define field verification function tcu_set_form_fnkey_fn Establish fn. key handler for form tcu_set_form_help Define help function for form tcu_set_form_mode Set form characteristics tcu_unload_form Unload form from memory tcu_write_formrec Writes a form record to a buffer Window Services --------------- tcu_change_colour Change colours for subsequent I/O tcu_clear_window Clear window and home cursor tcu_close_window Remove window from screen tcu_open_window Display window on screen tcu_position_cursor Set cursor position in window tcu_wprintf Formatted window output tcu_wgets Editable window input Miscellaneous Services ---------------------- tcu_colour_attrib Get colour code for b/f colours tcu_date_string Returns string form of a date type tcu_date_value Returns date type of string form tcu_get_user_keypress Returns the last user defined key used tcu_hash_value Return a hash-code for a string tcu_restore_environment Restores screen environment tcu_save_environment Saves screen environment tcu_set_idle_loop Establishes an idle loop handler tcu_set_mouse_mode Enables and disables mouse support tcu_set_user_key_handler Establishes an Escape/Accept key handler tcu_warnbeep Produce standard TCU warning beep _TCU_version Constant defining the version of TCU Mouse Support ------------- The presence of a mouse driver is detected automatically by TCU and used by default. The 'tcu_set_mouse_mode' service may be used to enable and disable the mouse. The mouse may be used for menu option selection and form field selection. The mouse mode may be interactively toggled on and off by using the ALT-M key. | Left Button Right Button --------------------+---------------------------------------------------- Pulldown Menu Bar | Option Select No Action Pop-Up menu | Option Select Menu Dismiss Notices | Clears Notice Clears Notice Form Edit | Move to selected field. Move to first field | If button, selects it. Field Select | Select Field Move to first field Confirmation Box | Confirm Reject tcu_change_colour ----------------- Function Changes the background and foreground colours for window I/O Syntax #include <usr\tcu.h> int tcu_change_colour (TCU_WINDOW *window, unsigned char attribute) Remarks 'window' defines the window to be affected. 'attribute' is the colour attribute and may be obtained with the 'colour_attrib' service. Return Value Returns TCU_OK on success, TCU_ERROR on error. tcu_change_menu_attribs ----------------------- Function Changes a colour attribute of a menu. The menu must be defined but need not be displayed. Syntax #include <usr\tcu.h> int tcu_change_menu_attribs (TCU_MENU *menu, int item, unsigned char attribute) Remarks 'item' identifies the attribute to change and must be one of the following defined in 'TCU.H': TCU_MENU_TITLE Title of the menu TCU_MENU_BOX Surrounding box of the menu TCU_MENU_OPTION Option lines TCU_MENU_SELECT Currently selected option line TCU_MENU_UNAVAIL Unavailable option lines 'attribute' describes the new colour attribute to be used for the selected item. It may be formed by using the 'menu_attrib' function. If the menu is currently displayed, the attribute will take effect on the screen immediately. Return Value Returns TCU_OK if the attribute change was successful and TCU_ERROR if an error was encountered. An error is likely to be due to a bad item specification or an undefined menu. tcu_change_menu_escapes ----------------------- Function Changes the valid escape keys for a menu. Syntax #include <usr\tcu.h> int tcu_change_menu_escapes (TCU_MENU *menu, unsigned char escape_keys) Remarks The escape keys define which keys are allowed to terminate the interactive menu selection called with 'tcu_read_menu_selection'. 'escape_keys' is formed by logically ORing the following: TCU_ESC_ESC ESC key TCU_ESC_PGUP PgUp (Page Up) key TCU_ESC_PGDN PgDn (Page Down) key TCU_ESC_CLEFT Left arrow key TCU_ESC_CRIGHT Right arrow key TCU_ESC_FUNC Function key (F2 - F12) or User Key TCU_ESC_CNTL_C CNTL/C key (ASCII 3) The RETURN key is always a valid escape key, selecting the currently selected menu option. Note that F1 is reserved for help activation. The TCU_ESC_FUNC mask allows either function keys or user defined escape/accept keys to exit the menu select. Return Value If the escape key change was successful, TCU_OK is returned, otherwise TCU_ERROR is returned. tcu_clear_menu_in_pulldown -------------------------- Function Removes a menu which is displayed under control of a pulldown menu line. Syntax #include <usr\tcu.h> int tcu_clear_menu_in_pulldown (TCU_PULLDOWN *pmenu); Remarks This service should be used when a pop-up menu displayed under control of a pulldown menu is to be removed from the screen. Do not try to call 'tcu_remove_menu' directly as the pulldown menu will become inconsistent with what is on the screen. Return Value TCU_OK if the call was successful, otherwise TCU_ERROR. tcu_clear_notice ---------------- Function Removes a notice/prompt definition from memory. Syntax #include <usr\tcu.h> int tcu_clear_notice (TCU_NOTICE *notice) Remarks The definition of a notice or prompt is removed with the call to 'tcu_clear notice'. An intervening 'tcu_prepare_notice' call is required before using 'tcu_display_notice'. Return Value Returns TCU_OK if the service was executed successfully, otherwise TCU_ERROR is returned. tcu_clear_window ---------------- Function Clears the window and homes the cursor. Syntax #include <usr\tcu.h> int tcu_clear_window (TCU_WINDOW *window) Remarks The window is cleared with the currently active background colour. The cursor is relocated to (1,1) relative to the window. Return Value Returns TCU_OK on success, TCU_ERROR on error. tcu_close_window ---------------- Function Close and remove a window from the screen. Syntax #include <usr\tcu.h> int tcu_close_window (TCU_WINDOW *window) Remarks The window is removed from the screen, the old screen contents restored and the window memory is released to the system. Return Value Returns TCU_OK on success, TCU_ERROR on error. tcu_colour_attrib ----------------- Function Forms a colour attribute from the foreground and background colour attributes. Syntax #include <usr\tcu.h> unsigned char tcu_colour_attrib (int foreground, int background) Remarks 'tcu_colour_attrib' may be used to form the colour attribute required by other menu and notice services. 'background' and 'foreground' represent the foreground colour and background background colour respectively. Any colour defined in 'conio.h' may be used if it is valid with the hardware being used. The standard symbol BLINK may be added to the foreground colour to obtain a blinking foreground. Return Value Returns a compound colour attribute code. tcu_date_string --------------- Function Obtains the character string representation of a date value. Syntax #include <usr\tcu.h> char *tcu_date_string (unsigned short date, unsigned char presentation); Remarks Returns a pointer to a static string buffer of 8 characters which is overwritten with each call. 'date' specifies the date value, i.e. val.v_date of TCU_FIELD_VALUE. 'presentation' specifies either TCU_FLD_DAYFIRST or TCU_FLD_MONTHFIRST. Return Value Returns a pointer to the static date string data. tcu_date_value -------------- Function Returns a date type of a character date string. Syntax #include <usr\tcu.h> unsigned short tcu_date_value (char *date, unsigned char presentation); Remarks Returns the date value of type val.v_date of TCU_FIELD_VALUE for the specified string 'date'. 'presentation' specifies either TCU_FLD_DAYFIRST or TCU_FLD_MONTHFIRST. Return Value Returns the date type. tcu_db_close ------------ Function Closes an open TCU database. Syntax #include <usr\tcu.h> int tcu_db_close (TCU_DB *db) Remarks The database file and its associated index are closed. Return Value TCU_OK if successful, TCU_ERROR is an error is encountered. tcu_db_create ------------- Function Creates a new TCU database or overwrites an existing one. Syntax #include <usr\tcu.h> int tcu_db_create (TCU_DB *db, TCU_FORM *form, char *dbname, int duplicates, char *idx_name_1, [char *idx_name_2,] [...,] NULL) Remarks This service creates the index file and main database file associated with the specified 'form'. The user declared 'db' structure is initialised. The database name, 'dbname' is used to create the index (filetype .cix) and the database (.cdb). 'duplicates' should be set to 0 to disable records with duplicate primary keys and 1 to allow duplicates. One or more form field names must be specified as key fields terminated with NULL. The specified names must match the names given in the form definition file. The first key is the prime key which is used for search operations. Records are sorted in the database according to all indices specified. Up to 16 indices may be specified in the call. The default index order is for ascendng keys. If an index should be ordered as a descending key, the '^' character should be added to the form field name as a suffix. For example, if the prime key is to be a date field defined in the form file as 'ORD_DATE' and it is to be keyed as a descending key, it should be specified as "ORD_DATE^" in the call to 'tcu_db_create'. Following the creation of the database, it remains open until a call to 'tcu_db_close' is made. Return Value TCU_OK indicates successful creation. TCU_ERROR indicates an error condition. The most likely error cases are: o Form specified is not open (loaded); o One or more of the specified indices has a name which is either invalid or not part of the form; o Too few (<1) or too many (>16) indices specified; o The total key size exceeds the maximum key size; o Filing error, write-protect, disc full, etc. tcu_db_delete ------------- Function Deletes the current record from the database. Syntax #include <usr\tcu.h> int tcu_db_delete (TCU_DB *db) Remarks Removes the current record from 'db'. If no current record is defined service will fail. After deletion, the current record pointer will point to the record after that which was deleted. If the deleted record was at the end of the database, the current record pointer becomes undefined. Return Value TCU_OK if successful deletion, TCU_ERROR if an error occurred, most likely from an attempt to make a deletion when the current record pointer was undefined. tcu_db_find ----------- Function Locates a record with matching primary key in the database. Syntax #include <usr\tcu.h> int tcu_db_find (TCU_DB *db, TCU_FIELD_VALUE *val) Remarks 'val' must be preloaded with the correct type for the primary key of 'db'. The service finds the first record with a matching primary key. For string field searches, the default is for a search ignoring trailing spaces, but case significant. These defaults may be overridden with the 'tcu_db_set_search_mode' service. Return Value TCU_OK if a match was found, else TCU_ERROR and the current record pointer remains unchanged. tcu_db_first ------------ Function Moves record pointer to the first record in the database. Syntax #include <usr\tcu.h> int tcu_db_first (TCU_DB *db) Remarks Moves the current record pointer to the first record in 'db'. If no records exist, the service will fail. Return Value TCU_OK if successful, TCU_ERROR if no records in the database. tcu_db_last ----------- Function Moves record pointer to the last record in the database. Syntax #include <usr\tcu.h> int tcu_db_last (TCU_DB *db) Remarks Moves the current record pointer to the last record in 'db'. If no records exist, the service will fail. Return Value TCU_OK if successful, TCU_ERROR if no records in the database. tcu_db_next ----------- Function Moves record pointer to the next record in the database. Syntax #include <usr\tcu.h> int tcu_db_next (TCU_DB *db) Remarks Moves the current record pointer to the next record in 'db'. If the pointer was already at the end of the database, it becomes undefined with this call and the call fails. Return Value TCU_OK if successful, TCU_ERROR if no records or already at end of database. tcu_db_open ----------- Function Opens an existing TCU database. Syntax #include <usr\tcu.h> int tcu_db_open (TCU_DB *db, TCU_FORM *form, char *dbname, int duplicates) Remarks Opens 'dbname' using 'form'. The specified 'form' must be the same as the form used at creation time. The form need not be identical, but must possess the same fields with the same types and lengths as when the database was created. The form must already be open. The user defined structure 'db' is loaded with the initial database data which is required for subsequent calls to database services. If records with duplicate keys are to be permitted, 'duplicates' should be 1, else it should be 0. Return Value TCU_OK if the open was successful, else TCU_ERROR. Most likely failure cases are: o Form specified is not open (loaded); o One or more of the indices in the database is not part of the form; o The total key size exceeds the maximum key size or the total form record size is different to that when the database was created; o The database and/or index header is invalid; o Filing error, write-protect, disc full, etc. tcu_db_previous --------------- Function Moves record pointer to the previous record in the database. Syntax #include <usr\tcu.h> int tcu_db_previous (TCU_DB *db) Remarks Moves the current record pointer to the previous record in 'db'. If the pointer was already at the start of the database, it becomes undefined with this call and the call fails. Return Value TCU_OK if successful, TCU_ERROR if no records or already at start of database. tcu_db_read ----------- Function Reads the current database record into the form. Syntax #include <usr\tcu.h> int tcu_db_read (TCU_DB *db) Remarks Loads the current record into the form structure which was specified at creation or open time. Fields are validated in the usual way according to form range specifications and/or user defined verification functions. If the form is currently displayed, it will be updated with the new fields immediately with this call. Return Value TCU_OK if the read was successful, TCU_ERROR if the current record pointer is undefined. tcu_db_read_index_field ----------------------- Function Reads an index field of the current record. Syntax #include <usr\tcu.h> int tcu_db_read_index_field (TCU_DB *db, int index_id, TCU_FIELD_VALUE *val) Remarks This service loads the 'val' structure with the value of the specified index field of database 'db'. 'index_id' specifies which index field is to be obtained. 1 represents the first and primary index, 2 the next, etc. If the current record pointer is undefined the service will fail. Return Value TCU_OK if the field was successfully read else TCU_ERROR if the current record pointer is undefined. tcu_db_remove ------------- Function Erases a database from disc. Syntax #include <usr\tcu.h> int tcu_db_remove (char *dbname) Remarks The database should be closed. This service physically removes the database and its associated index from disc. Return Value TCU_OK if successful, TCU_ERROR if an error occurred. tcu_db_rewrite -------------- Function Writes an existing form record to the database. Syntax #include <usr\tcu.h> int tcu_db_rewrite (TCU_DB *db) Remarks This service writes the contents of the form to the database. The key fields in the form should constitute a record which already exists in the database. The current field pointer is adjusted to point at the newly added record. 'tcu_db_rewrite' is normally used for performing in-place updates of records. Return Value TCU_OK if the write was successful, TCU_ERROR if an error occurred or if a record with similar key does not exist in the database. tcu_db_save ----------- Function Flushes critical database buffers to disc. Syntax #include <usr\tcu.h> int tcu_db_save (TCU_DB *db) Remarks This service is used for force all control data for an open database to be written to disc. It does not change the current record pointer, nor does it close the database. The call should be made when a failure or program crash could cost database integrity. E.g. a call could be made to 'tcu_db_save' before performing any service which could allow DOS to abort the program through its critical error handler. The service is an alternative to closing and reopening the database, and has the advantage that it maintains the current record pointer. Return Value TCU_OK if the flush was successful, else TCU_ERROR. tcu_db_search ------------- Function Locates a record with equal or higher primary key. Syntax #include <usr\tcu.h> int tcu_db_search (TCU_DB *db, TCU_FIELD_VALUE *val) Remarks The search function attempts to locate a record with an equal or higher primary key. It is convenient when only the first part of the key is known. If the call is successful, the current record pointer will point to the record found. Return Value TCU_OK if a record is located else TCU_ERROR with no change in the current record pointer. tcu_db_set_search_mode ---------------------- Function Changes search mode for string keys. Syntax #include <usr\tcu.h> int tcu_db_set_search_mode (TCU_DB *db, int mode) Remarks The usual search mode for strings is to ignore trailing spaces but to be case sensitive. These defaults may be changed by specifiying 'mode' for the database. 'mode' should be one of the following: TCU_DB_TRIM_SPACES Ignore trailing spaces TCU_DB_NO_TRIM_SPACES Treat all spaces as significant TCU_DB_IGNORE_CASE Ignore case TCU_DB_NO_IGNORE_CASE Treat case as significant Return Value TCU_OK if the mode was successfully changed else TCU_ERROR. tcu_db_write ------------ Function Writes a form record to the database. Syntax #include <usr\tcu.h> int tcu_db_write (TCU_DB *db) Remarks The form record is written to the database indexed on the fields specified at database creation time. The current record pointer is moved to the newly written record. If the record is a duplicate and the database was created or opened with no duplicates specified then the call will fail. Return Value TCU_OK if the record was successfully written. TCU_ERROR if an error occurred or a duplicate record clash was detected. tcu_define_menu --------------- Function Establish a definition for a menu, comprising characteristics and content. Syntax #include <usr\tcu.h> int tcu_define_menu (TCU_MENU *menu, char *title, unsigned char title_attrib, unsigned char box_attrib, unsigned char option_attrib, unsigned char select_attrib, unsigned char unavail_attrib, unsigned char escape_keys, unsigned char box_type, char *options[], unsigned char hot_key_attrib) Remarks Uses the user declared element 'menu' to build a menu prototype for subsequent menu functions. 'menu' is the address of a MENU type. It is initialised with the call to define_menu and used in subsequent menu functions. 'title' is an optional title for the menu which, if present, will be displayed in the menu header line. 'title_attrib' defines the colour attributes of the title of the menu. 'box_attrib' defines the attributes of the menu border. 'option_attrib' defines the attributes of the choices of the menu. 'select_attrib' defines the attributes of the currently selected menu option. 'unavail_attrib' defines the attributes of menu options currently unavailable. 'escape_keys' defines the set of keys permitted to exit from the menu select. 'box_type' defines the type of the surrounding menu box. The attributes may be formed by using the function 'menu_attrib' which builds the attribute byte. The two parameters are foreground colour and background colour, and the return value is of type attribute, i.e. unsigned char. 'escape_keys' is formed by logically ORing the following, depending on which should be permitted to exit the menu choice. The RETURN key is always valid for actively selecting the current choice. TCU_ESC_ESC ESCAPE key TCU_ESC_PGUP Page Up key TCU_ESC_PGDN Page Down key TCU_ESC_CLEFT Left arrow key TCU_ESC_CRIGHT Right arrow key TCU_ESC_FUNC An unshifted function key F2 - F12 TCU_ESC_CNTL_C The CNTL/C key (ASCII 3) Note that F1 is reserved for help activation. 'box_type' defines whether the box is singly or doubly lined and is one of the following: TCU_BOX_SINGLE Single line surround TCU_BOX_DOUBLE Double line surround TCU_BOX_BLANK Surrounded by blank spaces 'options' is a pointer to an array of the character strings defining the menu choices. If 'hot_key_attrib' is non-zero it should be a valid colour attribute used to display the hot key character of a menu selection. When hot keys are used, the FIRST character of each of the menu option strings should be used to identify the character occurring in the rest of the option string which is to be used as the hot key. E.g., the string "PDisPlay Customer" would use 'P' as the hot-key. Note that only the first character matching the hot-key may be used. If 'hot_key_attrib' is zero, no hot-keys will be used at all. Return Value define_menu returns TCU_OK if the call was successful or TCU_ERROR if an error was detected in the processing. tcu_define_pulldown ------------------- Function Defines a pulldown menu ready for display and activation. Syntax #include <usr\tcu.h> int tcu_define_pulldown (TCU_PULLDOWN *pmenu, unsigned char line_colour, unsigned char option_colour, unsigned char select_colour, char *titles[], unsigned char hot_key_attrib, TCU_MENU *menus[]); Remarks Defines a pulldown menu. 'pmenu' specifies the menu to be defined, and should be declared by the caller. 'line_colour', 'option_colour' and 'select_colour' specify the colours of the pulldown header line, the title texts and the currently selected title respectively. The function 'tcu_colour_attrib' may be used to obtain the compound colour codes for these colours. 'titles' is an array of strings which contain the titles used in the header line. This list must be terminated with a NULL pointer. If 'hot_key_attrib' is non-zero it should be a valid colour attribute used to display the hot key character of a pulldown menu selection. When hot keys are used, the FIRST character of each of the title strings should be used to identify the character occurring in the rest of the title string which is to be used as the hot key. E.g., the string "fConfiguration Menu" would use 'f' as the hot-key and will highlight that character with the specified attributes in the title when not selected. Note that only the first character matching the hot-key may be used. If 'hot_key_attrib' is zero, no hot-keys will be used at all. 'menus' is a pointer to an array of menus. These menus are normal menus defined with 'tcu_define_menu', and may also be used outside the control of the pulldown menu. Note that if a pulldown menu title is to have no associated menu, the pointer in that position should contain NULL. Return Value Returns TCU_OK if the definition was successful, otherwise returns TCU_ERROR. tcu_display_form ---------------- Function Displays a loaded form on the screen. Syntax #include <usr\tcu.h> int tcu_display_form (TCU_FORM *form, int x_pos, int y_pos) Remarks The form to be displayed must have been loaded with a call to 'tcu_load_form'. 'form' specifies the address of a form object. 'x_pos' and 'y_pos' specify the top-left corner of the form. It is the callers responsibility to ensure that the form to be displayed has room on the screen for the specified position. Return Value Returns TCU_OK is successful, otherwise TCU_ERROR. tcu_display_menu ---------------- Function Uses a predefined menu to display the menu on the screen ready for interactive selection. Syntax #include <usr\tcu.h> int tcu_display_menu (TCU_MENU *menu, int x_pos, int y_pos) Remarks Displays a menu on the screen. No waiting for user input is performed; the menu is displayed and control returns to the caller. 'menu' is the address of a MENU type initialised with the 'tcu_define_menu' service. 'x_pos' and 'y_pos' define the screen position of the top-left corner of the menu. Note that the top-left corner of the screen is (1, 1). Return Value The service returns TCU_OK if the menu was successfully displayed and TCU_ERROR if an error condition was encountered. tcu_display_notice ------------------ Function Displays a notice or prompt on the screen. Syntax #include <usr\tcu.h> int tcu_display_notice (TCU_NOTICE *notice, int x_pos, int y_pos) Remarks The notice/prompt is displayed with the top-left corner at the position specified by 'x_pos' and 'y_pos'. If the notice includes a prompt field, it may be interactively edited after this call. The completion of a prompt input completes this service and removes the prompt from the screen (though does not remove its definition from memory until a call to the 'tcu_clear_notice' service. If the notice contains no prompt input the user must press to RETURN key, the ESC key or a mouse button to complete the call. Note that with prompts, if the input field returns with a length of -1, the user cancelled the input with the ESC key. Since the length is a character type the caller must be sure that the test against -1 is performed as a 'signed char' test, either by using default signed characters, casting or testing against the value 0xFF rather than -1. Return Value TCU_OK if successful, else TCU_ERROR. tcu_display_pulldown_header --------------------------- Function Displays the header line of a pulldown menu without waiting for a selection. Syntax #include <usr\tcu.h> int tcu_display_pulldown_header (TCU_PULLDOWN *pulldown) Remarks The header line for the pulldown menu 'pulldown' is displayed. The pulldown menu must already have been defined. The function is exactly as 'tcu_read_pulldown_selection' without the actual selection of an item. Return Value Returns TCU_OK if successful, else TCU_ERROR. tcu_edit_form ------------- Function Interactively edit a loaded and displayed form. Syntax #include <usr\tcu.h> int tcu_edit_form (TCU_FORM *form, int start_field_id, int *keypress) Remarks The form may be interactively edited using the form and field attributes and characteristics that exist at the time of the call. 'form' specifies the address of a form object. The start field-ID may be specified with 'start_field_id'. If set to 1, the first valid field will be used. 'keypress' specifies the address of an integer which will indicate the key used to escape from the form input. 'keypress' will be one of the following symbols: TCU_FLD_ESCESC ESCAPE key used to quit TCU_FLD_ESCCNTL CNTL/C key used to abort TCU_FLD_FNKEYESC ESCAPE requested from function key handler TCU_FLD_BUTTONESC ESCAPE requested from button handler TCU_FLD_ESCPGUP PgUp key TCU_FLD_ESCPGDN PgDn key TCU_FLD_FNKEYSAVE PgUp requested from function key handler TCU_FLD_BUTTONSAVE PgUp requested from button handler The first four codes reflect that the form was exited abnormally and the field values remain as they were before the edit. The latter four are normal returns, and the form will have been updated to reflect the edits made. If the form has been set to 'no escape keys' mode with 'tcu_set_form_mode' and the TCU_FORM_NOESCS parameter, only the button and function keys returns will be returned as the keyboard escape keys are blocked at a lower level. NOTE: Editing keys in a form are as follows: -> : Move right one character <- : Move left one character Up Arrow : Move to previous field Down Arrow : Move to next field Home : Move to first character in field End : Move to last character in field CNTL PgUp : Move to first field in form CNTL PgDn : Move to last field in form F1 : Help CNTL Home : Restore contents of field as when entered CNTL End : Clear field INSERT : Toggle insert mode BACKSPACE : Delete character to the left of the cursor Del : Delete character under the cursor ESC : Escape (cancel) form edit CNTL/C : Escape (abort) form edit PgUp : Accept form edit PgDn : Accept form edit Return Value TCU_OK if the edit was successful, otherwise TCU_ERROR. tcu_escape_fkey --------------- Function Returns the last function key number used to escape a menu. Syntax #include <usr\tcu.h> int tcu_escape_fkey (void) Remarks If the function key escape mode is enabled, i.e., the option TCU_MENU_FUNC is set in the escape keys of the menu, and the menu was terminated with a FN key ('tcu_read_menu_selection' returned -TCU_ESC_FUNC), 'tcu_escape_fkey' will return the function key used to leave the menu. Return Value Returns 0 if no function key has been used, otherwise the number of the function key, 1 = F2, 2 = F2, etc. 12 is the last function key used. Keys F11 and F12 on may only be used on machines with BIOS support for extended keyboards. Note that the F1 key is reserved for activation of a user defined help function. tcu_form_record_size -------------------- Function Obtains the size in bytes of a complete form record. Syntax #include <usr\tcu.h> int tcu_form_record_size (TCU_FORM *form) Remarks This service is used to obtain the size of a buffer required to hold the fields of a complete form. It is normally used in conjunction with the 'tcu_read_formrec' service and the 'tcu_write_formrec' service. Return Value Returns the size in bytes of a complete form record or -1 if an error was encountered. tcu_get_confirm --------------- Function Queries the user for confirmation or rejection Syntax #include <usr\tcu.h> int tcu_get_confirm (int x, int y, unsigned char box_attrib, unsigned char text_attrib, char *text, ...) Remarks Queries the user for confirmation of the 'text' which is displayed in a box with colour attributes 'box_attrib' at position (x,y). The text is displayed with attributes 'text_attrib'. The user may enter 'y', 'Y', 'n', 'N' or a mouse button (left = confirm, right = reject) to confirm or reject. If the confirmation box would lie outside the screen area, the confirmation text is changed automatically to the string "Confirm (Y,N)?" and placed in the upper-left corner of the screen. Return Value Returns 0 for rejection or 1 for confirmation. tcu_get_field ------------- Function Obtains a value for a form field. Syntax #include <usr\tcu.h> int tcu_get_field (TCU_FORM *form, int field, TCU_FIELD_VALUE *val) Remarks 'form' specifies the form object. 'field' is the field ID of the field of which the value is to be obtained. 'val' is the address of a TCU_FIELD_VALUE type object. The field value is a structure which must be addressed according to the type of the field (which should be known by the caller). The fields of the structure are: v_int : 32-bit signed integer for integers v_float : 64-bit floating value for real types v_string : Pointer to the string value v_date : 16-bit integer coded date v_logical : 8-bit data, 0 = FALSE, 1 = TRUE v_choice.sel : 16-bit integer enumerated pointer String values are copied into the user's calling address. This means that 'v_string' should be set to point at the address where the string is to be received. Failing to do this will use a default pointer and will probably end in tears! Date types represent the number of days since the start of the 19th century. This need not be known, though may be useful to know that arithmetic operations on these types will represent days. Choice types are addressed using the sub-element 'v_choice.sel' which is an index into the list of choices. I.e. 1 represents the first selection, 2 the second, etc. 'v_choice.max' contains the maximum valid index for the choice selection, though this must not be modified by the application. Return Value TCU_OK if the field was returned successfully, else TCU_ERROR. tcu_get_field_choice_string --------------------------- Function Obtains the text string associated with a field of 'Choice' type. Syntax #include <usr\tcu.h> int tcu_get_field_choice_string (TCU_FORM *form, int field, char *string); Remarks 'form' specifies the form where field 'field' resides. The field must be of type 'Choice' or the call will fail. The string associated with the current selection will be placed at the address specified as 'string'. Return Value Returns TCU_OK if the call was successful, else TCU_ERROR. tcu_get_field_id ---------------- Function Obtains the field ID for a named field. Syntax #include <usr\tcu.h> int tcu_get_field_id (TCU_FORM *form, char *field_name, int *field_id) Remarks Fields in forms may optionally be named. This allows the caller to use meaningful names for fields rather than have to know the logical field ID. 'form' identifies the form object, 'field_name' points to the name of the field for which the ID is required. Case is NOT significant. 'field_id' points to the integer into which the ID will be written. This may then be used for subsequent field related operations. If 'field_id' is NULL, it is not used. Return Value Returns the ID of the field if present, else 0 if either an error occurred or the field was not found. tcu_get_field_info ------------------ Function Fills a struture with information about the specified field Syntax #include <usr\tcu.h> int tcu_get_field_info (TCU_FORM *form, int field_id, TCU_FIELD_INFO *info); Remarks The function fills the user-declared structure 'info' with information about field 'field_id' in form 'form'. The structure has the following fields: typedef struct { char name[9]; /* Field name */ unsigned char type, /* Type of field */ size, /* Width of field on screen */ decimal, /* Decimal places if numeric */ present, /* Presentation form of data */ xpos, /* Window x-coordinate */ ypos, /* Window y-coordinate */ usemin, /* 1 if minimum range active */ usemax, /* 1 if maximum range active */ useval, /* 1 if initial value used */ usetmp; /* 1 if string template used */ union { struct { long min, /* Minimum value */ max; /* Maximum value */ } i; struct { double min, /* Minimum value */ max; /* Maximum value */ } f; struct { unsigned short min, /* Minimum value */ max; /* Maximum value */ } d; } range; unsigned char colour; /* Colour attributes */ struct { unsigned int ronly : 1, /* Read only flag */ noecho : 1, /* No-echo input flag */ fixtext : 1, /* Fixed text field flag */ param : 1, /* Non-editable variable field */ confirm : 1; /* ENTER confirmation needed flag */ } attr; TCU_FIELD_VALUE val; /* Value of field */ } TCU_FIELD_INFO; The fields in this structure represent the current state of the form field. Use this service to obtain information about a field rather than trying to access the field directly through the form structure. Return Value Returns TCU_OK if the field information was obtained without error, else returns TCU_ERROR. tcu_get_form_info ----------------- Function Fills a structure with information about the specified form Syntax #include <usr\tcu.h> int tcu_get_form_info (TCU_FORM *form, TCU_FORM_INFO *info); Remarks The function fills the user-declared structure 'info' with information about form 'form'. The structure has the following fields: typedef struct { unsigned int num_fields; /* Number of fields */ char *title; /* Title string of form */ unsigned char text_colour, /* Colour attribute */ field_colour, /* Input field colour default */ title_colour, /* Title string colour */ edit_colour, /* Colour of field under edit */ xpos, /* x-coordinate on screen */ ypos, /* y-coordinate on screen */ height, /* Height of form */ width, /* Width of form */ box_type, /* Form surround type */ mode, /* Flags whether in use/displayed */ verify_fn, /* 1 if verify function active */ help_fn, /* 1 if help function active */ fn_key_fn; /* 1 if fn. key handler active */ button_fn; /* 1 if button select handler */ struct { unsigned int ronly : 1, /* Form is read only */ no_esc : 1; /* Escape keys disabled */ } attr; } TCU_FORM_INFO; The fields in this structure represent the current state of the form. Use this service to obtain information about the form rather than trying to access the information directly through the form structure. Return Value Returns TCU_OK if no error was encountered, else FORK_ERROR. tcu_get_user_keypress --------------------- Function Returns the last used user defined key Syntax #include <usr\tcu.h> unsigned short tcu_get_user_keypress (void) Remarks The function is used with the user key handler (set with the 'tcu_set_user_key_handler' service) to return the actual scancode of the last user defined key used. A user defined key is one which is processed with a user key handler and not ignored, i.e. the handler does not return 0. Return Value User key scancode or 0 if no user key has been used. tcu_hash_value -------------- Function Returns a hash value associated with a string Syntax #include <usr\tcu.h> unsigned long tcu_hash_value (char *string, unsigned long range) Remarks This function calculates and returns a hash value for a given string between 0 and range-1. The hash value may be used to index a table for data retrieval purposes. Return Value Returns the hash value. tcu_load_form ------------- Function Loads a form from the .CFO form object file into a form object. Syntax #include <usr\tcu.h> int tcu_load_form (TCU_FORM *form, char *filename) Remarks This function operates on form object files which are produced from the .CUF source files by the forms compiler. Form objects normally have the type .CFO. 'form' identifies the form object into which the form is to be loaded. 'filename' specifies the name of the object file. See the forms compiler documentation for further details and a description of the source file format. Return Value Returns TCU_OK if the form was loaded successfully, else TCU_ERROR. TCU_ERROR will normally indicate an internal error such as memory allocation problems, though it is possible that a range error in date fields was invalidated. For example, if a field was specified in the .CUF source file as: FIELD = @10,10; Date (MonthFirst); Range (Today, 12/31/90) then an error will occur trying to load this on or after the date 12/31/90 as the range is invalidated. tcu_load_image_form ------------------- Function Loads a form from a form image linked with the application. Syntax #include <usr\tcu.h> extern TCU_FORM FORM_IMAGE; int tcu_load_image_form (TCU_FORM *form, TCU_FORM *FORM_IMAGE) Remarks This function is directly equivalent to 'tcu_load_form', only it loads forms internally from object modules linked in with the application. 'form' specifies the form object with which the form will later be addressed. 'FORM_IMAGE' specifies the external form image data which should be declared elsewhere as a type of 'extern TCU_FORM FORM_IMAGE'. This service offers the advantage over the 'tcu_load_form' service that an application may be completely self-contained with no external form files to supply. A disadvantage is that the application must be relinked if the form definition changes. Use the /OBJECT or /LOADNAME options of the forms compiler to generate linkable object modules instead of the normal object files. 'FORM_IMAGE' is the loadname of the object module which defaults to the file name part of the original .CUF form definition file, but may be specified using the /LOADNAME option of the forms compiler. Return Value See 'tcu_load_form' tcu_new_pulldown_cover ---------------------- Function Reloads the saved screen cover under pulldown menus. Syntax #include <usr\tcu.h> int tcu_new_pulldown_cover (TCU_PULLDOWN *pmenu); Remarks This service should be used when the screen is changed outside the control of a pulldown menu but while the menu is displayed. This ensures that the further manipulation of the screen by the pulldown menu services will result in a consistent display. 'pmenu' specifies the pulldown menu object. Return Value TCU_OK is successful, else TCU_ERROR. tcu_notice_text --------------- Function Formats a string for inclusion in the body of a notice or prompt. Syntax #include <usr\tcu.h> int tcu_notice_text (TCU_NOTICE *notice, char *fmt, ...) Remarks The parameter list is identical to that of the 'printf' function, and any valid 'printf' format control facilities may be used with the exception of control codes such as '\n' and '\b'. Blank lines are obtained by using an empty string, as in status = notice_text (&my_notice, ""); Each call to 'tcu_notice_text' represents a line in the notice or prompt. The size of the notice is automatically computed to allow the longest line registered with 'tcu_notice_text'. Return Value TCU_OK if the call was successful, else TCU_ERROR. tcu_open_window --------------- Function Opens a window and displays it on the screen. Syntax #include <usr\tcu.h> int tcu_open_window (TCU_WINDOW *window, int xpos, int ypos, int xsize, int ysize, char *title, unsigned char box_attrib, unsigned char window_attrib, unsigned char title_attrib, unsigned char box_type); Remarks Opens a window of outside size 'xsize' x 'ysize' characters at location (xpos,ypos). 'title' defines a textual title to appear in the header line of the window, or may be omited by either specifying NULL or a zero length string. 'box_attrib', 'window_attrib' and 'title_attrib' define the colour attributes of the surrounding box, the window body and the title text respectively. 'box_type' is one of: TCU_BOX_SINGLE Single line surround TCU_BOX_DOUBLE Double line surround TCU_BOX_BLANK Surrounded by blank spaces The user declared entity 'window' is filled with the initalised window data and passed to subsequent windowing services. Note that the window ALWAYS has a one character border, and the size is including this border. A window of size 40 x 10 will have a usable size 38 x 8, and this will be the maximum cursor address. (1,1) always represents the top-left corner of USABLE window space. Return Value Returns TCU_OK on success, TCU_ERROR on error. An error will normally be the result of specifying bad parameters or a memory overflow. Bad parameters will often be caused by specifying part of the window to be out of range of the screen. tcu_position_cursor ------------------- Function Moves a window cursor to a specified point in the window. Syntax #include <usr\tcu.h> int tcu_position_cursor (TCU_WINDOW *window, int x, int y) Remarks Moves the cursor to the specified location in the window. Return Value Returns TCU_OK on success, TCU_ERROR on error. An error will normally be attributable to an attempt to move the cursor outside the window area. tcu_prepare_notice ------------------ Function Initialises a notice/prompt. Syntax #include <usr\tcu.h> int tcu_prepare_notice (TCU_NOTICE *notice, char *title, unsigned char title_colour, unsigned char box_colour, unsigned char notice_colour, unsigned char box_type) Remarks A notice or prompt is initialised with this service. The parameters 'box_colour', 'notice_colour' and 'title_colour' specify the colours of the surrounding box, the main notice panel and the title string respectively. 'box_type' is one of the following and defines the form of the perimeter box: TCU_BOX_SINGLE : Single lined box TCU_BOX_DOUBLE : Double lined box TCU_BOX_BLANK : Surrounded by blank spaces Text may be added to the notice with the 'tcu_notice_text' service and the notice become complete at the call to 'tcu_display_notice'. When the notice has been removed by the user, it remains defined until a 'tcu_clear_notice' call is made. This allows a notice to be used more than once without redefinition. If no title is to be used, it should be specified as "", i.e. an empty string. In this case the 'title_colour' parameter is ignored. Return Value Returns TCU_OK if successful, else TCU_ERROR. tcu_prompt_input ---------------- Function Adds an input field area to a notice. Syntax #include <usr\tcu.h> int tcu_prompt_input (TCU_NOTICE *notice, int xpos, int ypos, char *buffer, unsigned char prompt_colour) Remarks Only one input field may be present in a notice. If an input field is specified, the notice becomes a 'prompt'. 'xpos' and 'ypos' specify the start position of the input area in the notice panel. 'buffer' is a pointer to a user area where the input is to be put. 'buffer' has the same form as the buffer used in the library function 'cgets', i.e. buffer[0] must specify the maximum length of the input field, and the actual data is returned from buffer[2]. buffer[1] contains the number of characters in the input field. This means 'buffer' must be large enough to hold the maximum input string + 3 (to include buffer[0], buffer[1] and the terminating '\0'. When the call is made, the default string displayed will the contents of the buffer at locations buffer[2] onwards. buffer[2] must be set to '\0' if this feature is not required. 'prompt_colour' defined the colours to use for the prompt area. When a notice has been converted to a prompt, the call to 'tcu_display_notice' will allow the user to enter the input string. The notice disappears when the input is complete, whereas a notice with no prompt area disappears when the user presses the RETURN key or the ESCAPE key. Return Value TCU_OK if the call was successful, TCU_ERROR if an error occurred. tcu_restore_environment ----------------------- Function Restores the screen environment Syntax #include <usr\tcu.h> void tcu_restore_environment (void) Remarks This call should be made after the 'tcu_saqve_environment' call in an idle loop interrupt handler which changes the screen in some fashion. The calls which may alter the screen should be between 'tcu_save_environment' and 'tcu_restore_environment'. Return Value None. tcu_put_field ------------- Function Loads a value into a field of a form. Syntax #include <usr\tcu.h> int tcu_put_field (TCU_FORM *form, int field, TCU_FIELD_VALUE *val) Remarks 'form' identifies the form into which the value is to be loaded. 'field' is the field ID of the field, which may be obtained by 'tcu_get_field_id' if the field is named in the CUF file. 'val' is a pointer to a user declared TCU_FIELD_VALUE type which contains the value to be loaded. The value must comply with the type of the field and any range declaration which has been made in the CUF file. String lengths are checked, but compliance with string templates are not. See 'tcu_get_field' for details on how the field values in a form are addressed. If the form is currently displayed, the field is updated immediately. Return Value Returns TCU_OK if the call was successful, else TCU_ERROR. tcu_read_formrec ---------------- Function Reads a complete form from a buffer. Syntax #include <usr\tcu.h> int tcu_read_formrec (TCU_FORM *form, char *buffer) Remarks 'form' identifies the form into which the 'buffer' is to be read. An implicit call to 'tcu_put_field' is made for each field to ensure integrity. Return Value Returns TCU_OK if the call was successful, else TCU_ERROR. An error condition is likely to indicate that one of the fields in the buffer is invalid for the form by being of an invalid type or out of the range specified in the form definition. tcu_read_menu_selection ----------------------- Function Returns the user selection from a defined and displayed menu. If the user escapes from the menu with one of the permitted escape keys, the key code is returned, otherwise the selected menu option is returned. Syntax #include <usr\tcu.h> int tcu_read_menu_selection (TCU_MENU *menu) Remarks 'tcu_read_menu_selection' is an interactive function to obtain a user selection from a displayed menu. Only valid escape keys may be used to leave the interactive selection procedure. Return Value If a valid menu option is selected, it is returned as a positive integer; 1 represents the first choice, 2 the second, etc. If an option is unavailable for selection, it will simply not be returned under any circumstances. The numbering of the options is sequential, including unavailable options; i.e. If the menu has three possible options, the second of which is unavailable, the third has the logical sequence number '3' even though it is the second valid selection. If the return is 0, an error was encountered. This will most likely be due to either the menu not having been defined, or not yet displayed. If the return is negative, it represents the negative value of the escape key used to leave the selection. E.g. to determine if the ESC key was used to leave the menu, the following code extract could be used: selection = tcu_read_menu_selection (&mymenu); if (!selection) ERROR_CONDITION; else if (selection > 0) NORMAL_SELECTION_MADE; else if (selection == -TCU_ESC_ESC) ESCAPE_KEY_USED; else ...SOME_OTHER_ESCAPE_KEY_USED; Note that for function keys and user defined escape keys the two services 'tcu_escape_fkey' and 'tcu_get_user_keypress' may be used to determine the exact keypress used. In these cases, the return code from 'tcu_read_menu_selection' would be either -TCU_ESC_FUNC (for function keys) or -TCU_ESC_USERKEY (for user defined escape keys). tcu_read_pulldown_selection --------------------------- Function Returns a menu option selected under control of a pulldown menu. Syntax #include <usr\tcu.h> int tcu_read_pulldown_selection (TCU_PULLDOWN *pmenu, int *menu, int *option); Remarks 'pmenu' specifies the pulldown menu which is to be activated and from which an option is to be read. The menu must have been already defined with 'tcu_define_pulldown'. 'menu' returns the menu from the pulldown header from which the selection was made (in the range 1..No_of_menus) and 'option' returns the actual option within the menu (in the range 1..No_of_options_in_menu). If 'option' is zero and 'menu' is non-zero, the pulldown menu option selected did not have an associated menu. If 'menu' is zero the pulldown menu selection was aborted with the ESC key and no selection was made. Note that 'tcu_read_pulldown_selection' does not clear the menu(s) from the screen on completion of the call (to allow a sequence of user defined events to take place on selection of an option), and may be called in sequence with intervening actions. Do NOT attempt to perform operations using menus within the pulldown system BETWEEN calls to the 'tcu_read_pulldown_selection' other than the provided 'tcu_clear_menu_in_pulldown' and 'tcu_new_pulldown_cover' services. Use 'tcu_remove_pulldown' to clear the pulldown from the screen. Return Value Returns TCU_OK if the call was successful, else TCU_ERROR. tcu_remove_form --------------- Function Removes a form from the screen. Syntax #include <usr\tcu.h> int tcu_remove_form (TCU_FORM *form) Remarks 'form' specifies the form which is to be removed. The definition is not removed; a 'tcu_display_form' is all that is required to redisplay the form. Return Value Returns TCU_OK if successful, TCU_ERROR if an error occurred. tcu_remove_menu --------------- Function Removes a displayed menu from the screen, restoring the original screen contents. Syntax #include <usr\tcu.h> int tcu_remove_menu (TCU_MENU *menu) Remarks If the menu to be removed is overlaid with another menu, the restoration of the screen will be incorrect. The user should ensure that selections from overlaid menus are satisfied by 'tcu_read_menu_selection' and 'remove_menu' in the reverse order to that in which they were displayed with 'tcu_display_menu'. Return Value Returns TCU_OK if successful, or TCU_ERROR is unsuccessful. If unsuccessful the menu is logically flagged as removed, thus only leaving the screen incomplete. tcu_remove_pulldown ------------------- Function Removes a pulldown menu from the screen, restoring the old screen contents. Syntax #include <usr\tcu.h> int tcu_remove_pulldown (TCU_PULLDOWN *pmenu); Remarks 'pmenu' specifies the pulldown to be removed. Note that the pulldown remains defined and may be activated again with the 'tcu_read_pulldown_selection' service. Return Value TCU_OK if successful, or TCU_ERROR if an error occurred. tcu_save_environment -------------------- Function Saves the screen environment. Syntax #include <usr\tcu.h> int tcu_push_environment (void) Remarks This service saves the screen environment for use inside idle loop handler functions which change the screen in some fashion. The calls which may alter the screen should be between 'tcu_save_environment' and 'tcu_restore_environment'. Return Value None. tcu_select_field ---------------- Function Selects a single field from a form returning the field ID. Syntax #include <usr\tcu.h> int tcu_select_field (TCU_FORM *form, int start_field_id, int *exitkey); Remarks The service behaves exactly as 'tcu_edit_form', though disallowing any editing of fields and terminating at the first field select with the RETURN key. The form 'form' must be displayed. A start field 'start_field_id' determines which field will be the first one in which the cursor appears. If set to 1, the first valid field will be used. 'exitkey' will return with the field-ID of the field selected, or if negative will be one of the escape codes listed for 'tcu_edit_form' Return Value Returns with TCU_OK if no error, else TCU_ERROR. tcu_set_button_fn ----------------- Function Establishes a button handler for a form. Syntax #include <usr\tcu.h> int tcu_set_button_fn (TCU_FORM *form, int far (*handler) (TCU_FORM *, int)); Remarks 'form' specifies the form for which the handler is to be activated. 'handler' is the handler to which control is passed when any button field on the form is selected. The two parameters passed by the system to the handler specify the form and the current button field ID. The handler must return one of three possible values according to the desired action: 0 = Continue as if no key had been pressed, i.e. no actions subsequent to the handler will be made as a result of the selection. 1 = Treat the keypress as a PgUp, i.e. save the results of the form and exit. The exit code is TCU_FLD_BUTTONSAVE. 2 = Treat the keypress as an ESC, i.e. abort the form entry and exit. The exit code is TCU_FLD_BUTTONESC. To remove an existing handler, set the function to NULL. If the handler code is to operate on objects outside the form in which the button exists (e.g. creates a new menu), the calls to services acting on the objects should be surrounded by calls to 'tcu_save_environment' and 'tcu_restore_environment'. Return Value Returns TCU_OK if the handler was successfully installed, or TCU_ERROR if an error was encountered. tcu_set_field_attrib -------------------- Function Sets the foreground and background colours of a field in a form. Syntax #include <usr\tcu.h> int tcu_set_field_attrib (TCU_FORM *form, int field, unsigned char new_colour) Remarks 'form' identifies the form. 'field' is the field ID of the field to be changed. This may be returned by 'tcu_get_field_id' if the field is a named field. 'new_colour' specifies the new colours of the field, which may be obtained with the 'tcu_colour_attrib' function. If the form is displayed, the colours are updated immediately. Return Value Returns TCU_OK if successful, TCU_ERROR if an error occurred. tcu_set_field_mode ------------------ Function Sets a field attribute for a field in a form. Syntax #include <usr\tcu.h> int tcu_set_field_mode (TCU_FORM *form, int field, int mode) Remarks 'form' specifies the form. 'field' is the field ID of the field. 'mode' is one of the following: TCU_FORM_EDIT (def) : Allow the field to be changed TCU_FORM_NOEDIT : Do not allow the field to be edited TCU_FORM_ECHO (def) : Show field in form TCU_FORM_NOECHO : Do not display contents of field TCU_FORM_ENTER (def) : Cursor may enter field during edit TCU_FORM_NOENTER : Cursor passes field by during edit TCU_FORM_CONFIRM : Needs ENTER to confirm field entry TCU_FORM_NOCONFIFM (dflt) : Prev. & next field confirm entry If the field is set NOEDIT, attempting to change the value of the field results in a tone. Return Value Returns TCU_OK if the mode was successfully set, else returns TCU_ERROR. tcu_set_field_verify -------------------- Function Sets a verification function for a field. Syntax #include <usr\tcu.h> int tcu_set_field_verify (TCU_FORM *form, int far (*verify_fn) (TCU_FORM *, int, TCU_FIELD_VALUE *)) Remarks 'form' specifies the form. 'verify_fn' is the address of an integer function to perform the field verification. The function is passed the form address, an integer value which is the field ID and a pointer to the TCU_FIELD_VALUE structure of the field. The value must not be changed in the handler routine, other that by using 'tcu_put_field' with the passed 'form' parameter. The function should return 0 if the field failed verification and 1 if it verified successfully. If no field verification is specified, the range constraints on the field (if any) are the only checks made when the field is completed. Field verification is checked when an attempt to change the value of a field is made. This includes interactive form editing and changes with 'tcu_put_field'. Return Value Returns TCU_OK if verification was established successfully or TCU_ERROR if an error occurred. tcu_set_form_fnkey_fn --------------------- Function Establishes a function key handler function for form entry. Syntax #include <usr\tcu.h> int tcu_set_form_fnkey_fn (TCU_FORM *form, int far (*handler) (TCU_FORM *, int, int)); Remarks 'form' specifies the form for which the handler is to be activated. 'handler' is the handler to which control is passed for all function keys. F1 is excluded as this is used exclusively for help invokation. The parameters passed by the system to the handler specify the form, the current field of the form and the actual function key (2-12) in that order. The handler must return one of three possible values according to the desired action: 0 = Continue as if no key had been pressed, i.e. no actions subsequent to the function key handler will be made as a result of the keypress. 1 = Treat the keypress as a PgUp, i.e. save the results of the form and exit. The exit code is TCU_FLD_FNKEYSAVE. 2 = Treat the keypress as an ESC, i.e. abort the form entry and exit. The exit code is TCU_FLD_ENKEYESC. 3 = Same as 0, but update the field being edited with the value set with a 'tcu_put_field'. This is used when a 'tcu_put_field' is called from within a function key handler and the form is currently under edit. To remove an existing handler, set the function to NULL. Return Value Returns TCU_OK if the handler was successfully installed, or TCU_ERROR if an error was encountered. tcu_set_form_help ----------------- Function Associates a help function with a form. Syntax #include <usr\tcu.h> int tcu_set_form_help (TCU_FORM *form, void far (*help_fn)(TCU_FORM *, int)) Remarks 'form' specifies the form, 'help_fn' is the address of a void function which will be called when the F1 key is pressed when the user is editing the form. The function is passed a single integer value which is the field ID. This allows the function to determine which field was selected when the help key was pressed. If no help function is defined for a field, the F1 key will generate a warning beep. Return Value Returns TCU_OK if the function was registered correctly, else TCU_ERROR. tcu_set_form_mode ----------------- Function Sets the form edit mode for a complete form. Syntax #include <usr\tcu.h> int tcu_set_form_mode (TCU_FORM *form, int mode) Remarks 'form' specifies the form. 'mode' is one of the following: TCU_FORM_EDIT (default) : Form fields may be edited TCU_FORM_NOEDIT : Form fields may not be edited TCU_FORM_ESCS (default) : Allow standard escape keys TCU_FORM_NOESCS : Disable all direct escape keys If the form mode is set to EDIT, the field modes may still prevent editing of individual fields. The escape keys include ESC, CNTL/C, PgUp and PgDn. Disabling these keys allows the form to be controlled from handler functions returning appropriate continuation or escape codes. Return Value Returns TCU_OK if the mode was successfully set, else returns TCU_ERROR. tcu_set_idle_loop ----------------- Function Establishes an idle processing handler Syntax #include <usr\tcu.h> int tcu_set_idle_loop (int far (*handler)(unsigned long)) Remarks 'handler' specifies the idle loop handler function to be installed. If a handler is present, it is called by TCU services every 10ms while waiting for a keypress or mouse click. It is passes a single unsigned long integer parameter which is the time in 10ms units that the system has been idle. If the handler wishes to emulate a keypress, it should return the scan-code of the key. If it returns zero, processing will continue. If the handler wishes to perform some activity which will change the contents of the screen, it should first save the screen environment with the 'tcu_save_environment' service. On completion of the screen updates, the 'tcu_restore_environment' call must be made. The idle processing function must be careful not to perform functions which alter parts of the screen being affected by currently executing foreground activities. Furthermore, should the idle handler need to operate on a form which is being edited when the handler is entered, it must use the special symbol '_TCU_UPDATE_form' as the FORM * type parameter to any form functions. Return Value Returns TCU_OK if the handler was successfully installed, else returns TCU_ERROR. tcu_set_menu_help ----------------- Function Associates a help function with a menu. Syntax #include <usr\tcu.h> int tcu_set_menu_help (TCU_MENU *menu, void far (*handler)(int)); Remarks 'menu' specifies the menu to which the user defined help function, 'handler', is to refer. Pressing the F1 function key while in the specified menu will activate this function, passing the currently selected menu option as a single integer parameter to the help function to allow an option specific action to be taken. Use NULL as a 'handler' value to remove the help function. If F1 is pressed when no help function is available, a single tone will be sounded. Return Value TCU_OK if the help function was successfully installed, else TCU_ERROR. tcu_set_menu_option ------------------- Function Enables or disables an option within a menu. Syntax #include <usr\tcu.h> int tcu_set_menu_option (TCU_MENU *menu, int choice, int mode) Remarks 'choice' identifies the menu choice to be changed. 'mode' is 0 to make a choice unavailable and 1 to enable a choice option. Return Value Returns TCU_OK if the call was successful, TCU_ERROR if an error was encountered. tcu_set_mouse_mode ------------------ Function Enables or disables mouse support for menus and forms. Syntax #include <usr\tcu.h> int tcu_set_mouse_mode (unsigned char mode) Remarks The presence of a mouse is automatically detected and overrides any selection made with this service. By default mouse support if switched ON. If mode is 0, mouse support will be disabled. If 1, it will be re-enabled. Note that the mouse mode may be toggled interactively by using the ALT-M key. Return Value TCU_OK if the service request was successful. TCU_ERROR means that no mouse was detected, though does not constitute a real error. tcu_set_pulldown_help --------------------- Function Associates a help function with a pulldown menu. Syntax #include <usr\tcu.h> int tcu_set_pulldown_help (TCU_PULLDOWN *pmenu, void far (*handler)(int)); Remarks 'menu' specifies the pulldown menu to which the user defined help function, 'handler', is to refer. Pressing the F1 function key while on any pulldown title will activate this function, passing the currently selected menu option as a single integer parameter to the help function to allow an option specific action to be taken. Use NULL as a 'handler' value to remove the help function. If F1 is pressed when no help function is available, a single tone will be sounded. Return Value TCU_OK if the help function was successfully installed, else TCU_ERROR. tcu_set_user_key_handler ------------------------ Function Establishes a handler function to implement user defined keys Syntax #include <usr\tcu.h> int tcu_set_user_key_handler (int far (*handler)(unsigned short *)); Remarks Establishes 'handler' as a function which will be invoked each time a key is pressed. The function is passed a pointer to the key scancode, the dereferenced value of which may be altered if required, to allow it to decide how to process the keypress. The function will normally not alter the scancode. The function should return 0 if no further action is required on behalf of the user defined keypress, 1 if the key is to be treated as an accept key (TCU_FLD_USERSAVE) and 2 if it is to be an escape key (TCU_FLD_USERESC). The actual meaning of the returned value is dependent on the context. E.g. TCU_FLD_USERSAVE during form entry will be treated exactly as TCU_FLD_ESCPGUP or TCU_FLD_ESCPGDN whilst TCU_FLD_USERESC is treated as TCU_FLD_ESCCNTLC. This allows the user to implement individual key codes. The actual key used by the user may be obtained with the 'tcu_get_user_keypress' service which returns the scancode. Note that the scancodes are standard, i.e. ALT-F1 is 104 (dec). Use NULL as the value of the function to be set to clear the present handler. Return Value TCU_OK if the help function was successfully installed, else TCU_ERROR. _TCU_version ------------ Function Constant defining the version number of TCU Syntax #include <usr\tcu.h> extern unsigned char _TCU_version; Remarks The high-order nibble defines the major version number and the low-order nibble the minor version number. printf ("This is TCU v%d.%d\n", _TCU_version >> 4, _TCU_version & 0x0F); Return Value N/A tcu_warnbeep ------------ Function Produce TCU standard warning beep sound Syntax #include <usr\tcu.h> void tcu_warnbeep (void) Remarks Sounds the warning beep used by TCU internals for such things as attempt to type into read-only form field, etc. Return Value None tcu_wgets --------- Function Receives user input from a window area. Syntax #include <usr\tcu.h> int tcu_wgets (TCU_WINDOW *window, int maxlength, char *buffer, int *actuallength) Remarks Provides an editable input inside a window area. The input field must be on one line and may not extend beyond the window boundary. 'maxlength' specifies the maximum number of characters to input. 'buffer' is the address of a buffer to receive the input and should be at least maxlength+1 characters in length to include the null terminator. 'actuallength' is returned to indicate how many characters were present in the input field. The input buffer may be pre-loadad to give an inital input string. If the field should be empty, 'buffer' should be a zero length string. If the length is returned as -1, the user cancelled the input operation with ESC and the input string will be an empty string. Return Value TCU_OK on success, TCU_ERROR on error. Errors are likely to be the result of specifying an input area outside the boundary of the window. tcu_write_formrec ----------------- Function Writes a complete form to a buffer. Syntax #include <usr\tcu.h> int tcu_write_formrec (TCU_FORM *form, char *buffer) Remarks 'form' identifies the form which will be written to the 'buffer'. It is the caller's responsibility to ensure that the buffer points to sufficient free space to hold the form fields. The size may be obtained with the 'tcu_form_record_size' service. Return Value Returns TCU_OK if the call was successful, else TCU_ERROR. tcu_wprintf ----------- Function Formatted output to a window. Syntax #include <usr\tcu.h> int tcu_wprintf (TCU_WINDOW *window, char *format, arg1, arg2, arg3, ...) Remarks As the C run-time library 'printf' function but to a window. Long lines will wrap around. Return Value TCU_OK on success, TCU_ERROR on error.