(C) Copyright 1985-1996 Modular Software Corporation. All rights reserved. Version 2.0 for AP - February 14, 1996
Goto: Table of Contents Index Chapter: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
FV-INIT
is used to load FULL-VIEW into the system MONITOR area. This command is normally executed during the system COLDSTART proceedure. You can also execute the command at other times if necessary from system maintenance functions, but this is rarely necessary.
FV-TERM
This command is intended for system maintenance functions only. This command should only be used if the system is unstable with Windowing active and you are trying to shut the system down.
FV-INITPORT
must be executed. This command will initialize the FULL-VIEW environment for the current port.Most FULL-VIEW functions will not operate without windowing active.
FV-TERMPORT
This command will de-activate the windowing functions of FULL-VIEW and restore stadard system operation. If you need to deactivate windowing for another port (becuase of some sort of port hang), you can execute:
FV-TERMPORT port_no
START-WINDOW {X0,X1,Y0,Y1}
This TCL function will establish a new pane with parameters X0,X1,Y0,Y1. X0 refers to the left edge of the window active area, X1 refers to the right edge, Y0 to the top, and Y1 to the bottom. All references are relative to the upper left hand corner (0,0). The window will be created with a border, the contents of the window will be cleared, and the cursor will be positioned in the upper left hand corner of the window. This window will remain in effect until another window is established.Executing START-WINDOW without any parameters will establish a full-screen pane.
If you attempt to create a window with parameters which are not compatible with the CRT in use (i.e. the window is too big or improperly positioned), the START-WINDOW command will exit with an error message.
CALL START.WINDOW.SUB(X0,X1,Y0,Y1)
This BASIC subroutine allows a bordered window to be created by a BASIC program and operates exactly as the START-WINDOW TCL command.If the X0 parameter is NULL (an empty string or ""), this subroutine will establish a full-screen pane.
If you attempt to create a window with parameters which are not compatible with the CRT in use (i.e., the window is too big or improperly positioned), the START.WINDOW.SUB subroutine will exit with an error message.
This function may also be coded with an optional fifth parameter as:
CALL START.WINDOW.SUB(X0,X1,Y0,Y1,SCR)
In this case, SCR is a variable that will contain a print string that can be used to remove the created window.
START-CHILD command . . .
This TCL function will execute COMMAND in a full-screen pane and upon completion of this CHILD function, will restore the screen to it's original status and return to the calling PROC or to TCL.The called command may be any valid VERB or PROC. This function utilizes the BASIC EXECUTE function and has the same limitations. These include the inability to execute a LOGTO or OFF command and then expect to return to the calling application.
CALL START.CHILD.SUB(command)
This BASIC subroutine will execute COMMAND in a full-screen pane and upon completion of this CHILD function, will restore the screen to it's original status and return to the calling PROC or to TCL.The called command may be any valid VERB or PROC. This function utilizes the BASIC EXECUTE function and has the same limitations. These include the inability to execute a LOGTO or OFF command and then expect to return to the calling application.
START-WINDOW-CHILD X0,X1,Y0,Y1 command . . .
This TCL function will execute COMMAND in a pane with parameters X0,X1,Y0,Y1 and upon completion of this CHILD function, will restore the screen to it's original status and return to the calling PROC or to TCL. The numeric parameters will be used to create a bordered window using the START.WINDOW.SUB subroutine.The called command may be any valid VERB or PROC. This function utilizes the BASIC EXECUTE function and has the same limitations. These include the inability to execute a LOGTO or OFF command and then expect to return to the calling application.
If the command contains the option string:
`W
START-WINDOW-CHILD will only restore the created window and not the entire screen. This is useful when you are sure that the executed command will not alter the terminal's display outside of the created window.
CALL START.WINDOW.CHILD.SUB(X0,X1,Y0,Y1,command)
This BASIC subroutine will execute COMMAND in a pane with parameters X0,X1,Y0,Y1 and upon completion of this CHILD function, will restore the screen to it's original status and return to the calling PROC or to TCL. The numeric parameters will be used to create a bordered window using the START.WINDOW.SUB subroutine.The called command may be any valid VERB or PROC. This function utilizes the BASIC EXECUTE function and has the same limitations. These include the inability to execute a LOGTO or OFF command and then expect to return to the calling application.
The START.WINDOW.CHILD.SUB subroutine will also accept the `W option specified in the START-WINDOW-CHILD TCL command above.
You may wish to note that this TCL shell is a simulated TCL. Because of this, several characteristics may be noted:
TCL-SHELL
This TCL command will execute a TCL SHELL function which allows the user to execute any valid TCL command. The user may type the special command 'EXIT' to leave this SHELL function. The original screen's contents are not restored with this function when the function is exited.
CALL TCL.SUB
This is a BASIC subroutine version of TCL-SHELL. The subroutine does not have a parameter list and when the TCL SHELL is exited, the screen's contents will not be restored.
Implementing Hot-Keys within an application merely requires that the programs be compiled with the FULL-VIEW 'PC' verb. No changes to code structure or syntax are necessary in order to implement Hot-Keys.
Which Hot-Keys are active and which functions they activate are defined with either TCL commands or by external subroutine calls. This allows an application to change the available Hot-Key functions depending upon application context.
The keys specified in the Hot-Key setup functions are those generated by the FULL-VIEW terminal table for function, control, and other keys. This table is described elsewhere, but in general specification of standardized ASCII values for control, function, editing, and cursor keys. Hot-Keys are typically assigned to function keys, or to editing keys like SEND and PRINT.
This command is used to set Hot-Key definitions for the current port:
SET-HOT-KEY . . . . .
This function can specify multiple items, each separated by a semi-colon ';'. The following phrases are available:
HSET-HOT-KEY D ;
H 251 = MENU MENU.SHELL O ;
H 250 = RUN FV.BP PRINT-SCR ;
H 139 = RUN FV.BP CALC ;
H 140 = RUN FV.BP TCL-SHELL ;
This BASIC subroutine allows the Hot-Key function to be set for the port from within a BASIC program without having to EXECUTE the SET-HOT-KEY TCL statement. To set the GLOBAL FUNCTION for F1 to the TCL SHELL would require the BASIC statement:
CALL SET.HOT.KEY.SUB('129 = TCL-SHELL')
This function makes it easier to utilize function keys from within BASIC programs. This function causes the BASIC INPUT statement to automatically terminate whenever the user presses any of the defined function (or other) keys. To use this function execute the following TCL statement before your BASIC program executes:
SET-FN-KEY ...
This VERB has available options which are:
SET-FN-KEY D 129 130
This will cause a BASIC INPUT statement to terminate whenever F1 or F2 are pressed. A version of this routine is also available as a BASIC subroutine called SET.FN.KEY.SUB. The subroutine version is called as:
CALL SET.FN.KEY.SUB('D 129 130')
For additional information on how to interface to this function, refer to the example programs in DEMO.BP in the FV.DEMO account.
PRINT CHAR(128)
PRINT CHAR(129)
PRINT CHAR(130)
PRINT CHAR(131)
PRINT CHAR(132)
PRINT CHAR(133)
PRINT CHAR(134)
PRINT CHAR(135)
PRINT CHAR(136)
PRINT CHAR(137)
PRINT CHAR(138)
There is a direct method of setting the current pane size by printing a control string. A statement in the form . . .
PRINT ESC:'W':CHAR(X0):CHAR(X1):CHAR(Y0):CHAR(Y1):
. . . will change the active pane's size and position to the value specified by X0,X1,Y0,Y1 where X0 is the left edge coordinate, X1 is the right edge coordinate, Y0 is the top edge coordinate, and Y1 is the bottom edge coordinate.When a new pane is established in this manner, the cursor will be positioned at the upper left hand corner of the new pane (0,0) and the contents of the new pane will not be cleared.
If the specified parameters do not fit within the current screen size, the offending parameters will be adjusted to the value of the screen's edge.
There is a direct method of setting the video attribute without using all of the @(-xx) functions. This operates by using a print statement:
PRINT ESC : 'C' : CHAR(x) :
Here 'x' is a bit map of the video attribute that you wish to set. The bits are:
PRINT ESC : 'C' : CHAR(0) :
may be used to clear the current attribute setting to the default value.
FULL-VIEW normally operates within a pane as if the pane were a small CRT. When the cursor gets to the bottom of the pane and a character is printed in the lower right hand corner, the panes contents will scroll. Sometimes, however, it is desirable to print in this square and prevent the screen from scrolling. This can be accomplished in the following manner.
At the beginning of the print string which is intended not to scroll, print the following sequence:
PRINT ESC : 'N' : . . . :
This will prevent any lines which wrap in the last line of the window from causing the window to scroll and will allow printing in the lower right corner of the window.This option actually remains in effect until the first cursor position or cursor movement command (i.e. CR, LF, or @(x,y) function ).
CALL GET.SCR(SCR)
This function will return in SCR a compressed print string of the contents of the entire screen including the current window settings, the current cursor position, and the current video attribute. This function can be used in situation like:
CALL GET.SCR(SCR)
PRINT @(-1) : ' . . .
INPUT VAR , 10 :
.
.
.
PRINT SCR :
CALL GET.WINDOW(SCR)
This routine operates in the same way as GETSCR(...) with the exception that only the current window's contents will be in the print string. This function may also be coded as:
CALL GET.WINDOW(SCR,X0,X1,Y0,Y1)
in which case the specified window area will be retrieved.
CALL GET.SCR.DATA(DATA)
This routine will return the contents of the current display memory map as a dynamic array containing two attributes. Attribute one contains a linear string of characters representing the character content of the screen. Attribute two contains a linear string of characters representing the video attribute content of the screen. This function is typically used to obtain information from the screen for later use in printed output.An example of the use of this function is best illustrated by detailing how you would use this function to format the screen to build a print job. This example assumes an 80x24 screen.
CALL GET.SCR.DATA(DATA)
PRINTER ON
FOR I = 0 TO 23
PRINT DATA[I*80+1,80]
NEXT I
PRINTER OFF
PRINTER CLOSE
CALL GET.SCR.PARMS(PARMS)
This routine will return a dynamic array of the current screen parameters as:
PARMS<1> =
PARMS<2> =
PARMS<3> =
PARMS<4> =
PARMS<5> =
PARMS<6> =
PARMS<7> =
PARMS<8> =
PARMS<9> =
PARMS<10> =
PARMS<11> =
CALL GET.SCR.STATUS(STR)
This function will return in STR a print string which can be used to re-position the cursor to it's current position and attribute value. This function is typically used to return the cursor and window statuses to a previous value.
Goto: Table of Contents Index Chapter: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15