[an error occurred while processing this directive]

HP OpenVMS Systems Documentation

Content starts here

OpenVMS/Hangul RTL Korean Screen Management (SMG$) Manual


Previous Contents


SMG$CREATE_KEY_TABLE

The Create Key Table routine creates a table for key definitions.

Format

SMG$CREATE_KEY_TABLE key-table-id


RETURNS


OpenVMS usage cond_value
type longword (unsigned)
access write only
mechanism by value


Arguments

key-table-id


OpenVMS usage identifier
type longword (unsigned)
access write only
mechanism by reference

Receives the identifier of the newly created key table. The key-table-id argument is the address of an unsigned longword into which is written the key table identifier.

Description

SMG$CREATE_KEY_TABLE creates a key definition table. Key definitions can then be added to this table with the SMG$ADD_KEY_DEF, SMG$LOAD_KEY_DEFS, and SMG$DEFINE_KEY routines, and used with the SMG$READ_COMPOSED_LINE routine.

Condition Values Returned

SS$_NORMAL Normal successful completion.
SMG$_WRONUMARG Wrong number of arguments.
LIB$_INSVIRMEM Insufficient virtual memory.

SMG$CREATE_MENU

The Fill the Virtual Display with a Menu routine displays menu choices in the virtual display indicated, starting at the specified row.

Format

SMG$CREATE_MENU display-id ,choices [,menu-type] [,flags] [,row] [,rendition-set] [,rendition-complement]


RETURNS


OpenVMS usage cond_value
type longword (unsigned)
access write only
mechanism by value


Arguments

display-id


OpenVMS usage identifier
type longword (unsigned)
access read only
mechanism by reference

Display identifier of the virtual display in which the menu is created. The display-id argument is the address of an unsigned longword containing this identifier.

choices


OpenVMS usage static array of char_string
type character string
access read only
mechanism by descriptor

Static array in which each element corresponds to an item to be displayed in the menu. The choices argument is the address of a descriptor pointing to this static array of character strings. Note that blank menu items are ignored.

menu-type


OpenVMS usage longword_unsigned
type longword (unsigned)
access read only
mechanism by reference

Optional bit mask specifying the type of menu to be displayed. The menu-type argument is the address of a longword bit mask that specifies this menu type. Valid values are as follows:
SMG$K_BLOCK The menu items are displayed in matrix format (default).
SMG$K_VERTICAL Each menu item is displayed on its own line.
SMG$K_HORIZONTAL The menu items are displayed all on one line.

flags


OpenVMS usage mask_longword
type longword (unsigned)
access read only
mechanism by reference

Optional bit mask specifying the attributes to be used for the menu. The flags argument is the address of an unsigned longword that contains the flag. Valid values are as follows:
SMG$M_DOUBLE_SPACE Double-spaced rows of menu items. The default is single spaced.
SMG$M_FIXED_FORMAT Each menu item is in a fixed-length field. The field is the size of the largest menu item. The default is compress.
SMG$M_WIDE_MENU Wide characters are used in the menu items. The default is normal sized characters.

row


OpenVMS usage longword_signed
type longword (signed)
access read only
mechanism by reference

Optional row number in the specified virtual display at which the first menu item is displayed. The row argument is the address of a signed longword that contains this row number. If row is omitted, the first row of the virtual display's scrolling region is used.

rendition-set


OpenVMS usage mask_longword
type longword (unsigned)
access read only
mechanism by reference

Attribute specifier. The optional rendition-set argument is the address of a longword bit mask in which each attribute set causes the corresponding attribute to be used when writing out the menu choices. The following attributes can be specified using the rendition-set argument:
SMG$M_BLINK Displays blinking characters.
SMG$M_BOLD Displays characters in higher-than-normal intensity.
SMG$M_REVERSE Displays characters in reverse video, that is, using the opposite of the default rendition of the virtual display.
SMG$M_UNDERLINE Displays underlined characters.
SMG$M_USER1 through
SMG$M_USER8
Displays user-defined attributes.

The display-id argument must be specified when you use the rendition-set argument.

rendition-complement


OpenVMS usage mask_longword
type longword (unsigned)
access read only
mechanism by reference

Attribute complement specifier. The optional rendition-complement argument is the address of a longword bit mask in which each attribute set causes the corresponding attribute to be complemented in the display. All of the attributes that can be specified with the rendition-set argument can be complemented with the rendition-complement argument. The display-id argument must be specified when you use the rendition-complement argument.

The optional arguments rendition-set and rendition-complement let the user control the attributes of the virtual display. The rendition-set argument sets certain virtual display attributes, while rendition-complement complements these attributes. If the same bit is specified in both the rendition-set and rendition-complement parameters, rendition-set is evaluated first, followed by rendition-complement. By using these two parameters together, the user can control each virtual display attribute in a single procedure call. On a single-attribute basis, the user can cause the following transformations:

Set Complement Action
0 0 Attribute set to default
1 0 Attribute on
0 1 Attribute set to complement of default setting
1 1 Attribute off

Description

SMG$CREATE_MENU displays a list of menu choices in the virtual display's virtual scrolling region, starting in a specified row. Menu items start in the second column of the virtual display. Multiple menu items on the same row are separated by four spaces.

The choices are displayed with the specified rendition attributes in any one of the following formats:

Vertical Each menu item is on its own line.
Horizontal The menu items are all on one line.
Block The menu items appear in matrix format.

Any menu items that do not fit within the bounds of the virtual display are not displayed, but are saved for later scrolling by SMG$SELECT_FROM_MENU. The choices will be single spaced by default, but if requested this can be changed to double spaced. Four spaces separate each menu item horizontally. If requested, the items can also be displayed in fixed format columns where the width of the column is equal to the size of the largest string passed.

After a call to SMG$CREATE_MENU, the user must not output any characters to the display that will disturb the rows containing the newly created menu. If characters are output that do interfere with the menu, unpredictable results will be generated. Use the SMG$SELECT_FROM_MENU routine to select an item from this menu.

SMG$CREATE_MENU supports one-dimensional NCA and VSA string arrays. NCA and VSA string arrays include all string arrays generated by VAX Ada, VAX BASIC, VAX DIBOL, DEC Fortran, VAX Pascal, and VAX PL/I. (Note that if you are calling SMG$CREATE_MENU from VAX BASIC you must still use a MAP statement to declare the array.)

The character set attribute of the menu items are decided by that of the virtual display on which the menu items are displayed.


Condition Values Returned

SS$_NORMAL Normal successful completion.
SMG$_INVDIS_ID The display identifier is invalid or contains a viewport.
LIB$_xxxx Any condition value returned by LIB$CREATE_VM_ZONE, LIB$GET_VM, and LIB$FREE_VM.
SMG$_xxxx Any condition value returned by SMG$PUT_CHARS, SMG$BEGIN_DISPLAY_UPDATE, and SMG$END_DISPLAY_UPDATE.

Example


#module menu "001"

/*****************/
/* INCLUDE FILES */
/*****************/

#include <descrip.h>
#include <smgdef.h>

/************************/
/* EXTERNAL DEFINITIONS */
/************************/

globalvalue SS$_NORMAL;

extern int SMG$CREATE_MENU();
extern int SMG$SELECT_FROM_MENU();
extern int SMG$CREATE_PASTEBOARD();
extern int SMG$CREATE_VIRTUAL_DISPLAY();
extern int SMG$CREATE_VIRTUAL_KEYBOARD();
extern int SMG$PASTE_VIRTUAL_DISPLAY();
extern int SMG$PUT_LINE();
extern int LIB$SIGNAL();
extern int LIB$SFREE1_DD();

/*********************/
/* MACRO DEFINITIONS */
/*********************/

#define K_NUM_STRINGS 13

/****************/
/* MAIN PROGRAM */
/****************/

int
main (argc, argv)

unsigned int    argc;
char    **argv;
{

struct dsc$descriptor_s s_desc;
struct dsc$descriptor_a array_desc;
int     pbid, kbid, did, did1, sts, s, a_size, n = 0, max_len = 0;
char    *array, *p;
char    *months[K_NUM_STRINGS] = {"January", "February", "March",
                "April", "May", "June","July","August","September",
                "October", "November", "December", "Exit menu"};

/***********************************************************/
/* Set up the string descriptor for the returned menu item */
/***********************************************************/

s_desc.dsc$w_length  = 0;
s_desc.dsc$b_dtype   = DSC$K_DTYPE_T;
s_desc.dsc$b_class   = DSC$K_CLASS_D;
s_desc.dsc$a_pointer = 0;

/*********************************/
/* find length of largest string */
/*********************************/

for (s=0; s<K_NUM_STRINGS; s++)
    max_len = max_len > strlen(months[s]) ? max_len : strlen(months[s]);

/******************************/
/* put the menu choices in vm */
/******************************/

a_size = max_len * K_NUM_STRINGS;

p = array = malloc(a_size);

for (s=0; s<K_NUM_STRINGS; s++)
    {
    strncpy(p, months[s], max_len);
    p += max_len;
    };

/***********************************************************/
/* Set up the string array descriptor for the menu choices */
/***********************************************************/

array_desc.dsc$w_length  = max_len;
array_desc.dsc$b_dtype   = DSC$K_DTYPE_T;
array_desc.dsc$b_class   = DSC$K_CLASS_A;
array_desc.dsc$a_pointer = array;
array_desc.dsc$b_aflags.dsc$v_fl_bounds = 0;
array_desc.dsc$b_dimct   = 1;
array_desc.dsc$l_arsize  = a_size;

/*********************************************************/
/* set up the pasteboard, keyboard, and virtual displays */
/*********************************************************/

sts = SMG$CREATE_PASTEBOARD(&pbid);
if (sts != SS$_NORMAL) s = LIB$SIGNAL(sts);

sts = SMG$CREATE_VIRTUAL_KEYBOARD(&kbid);
if (sts != SS$_NORMAL) s = LIB$SIGNAL(sts);

sts = SMG$CREATE_VIRTUAL_DISPLAY(&6, &50, &did, &SMG$M_BORDER);
if (sts != SS$_NORMAL) s = LIB$SIGNAL(sts);

sts = SMG$CREATE_VIRTUAL_DISPLAY(&6, &50, &did1, &SMG$M_BORDER);
if (sts != SS$_NORMAL) s = LIB$SIGNAL(sts);

sts = SMG$PASTE_VIRTUAL_DISPLAY(&did, &pbid, &2, &2);
if (sts != SS$_NORMAL) s = LIB$SIGNAL(sts);

sts = SMG$PASTE_VIRTUAL_DISPLAY(&did1, &pbid, &10, &2);
if (sts != SS$_NORMAL) s = LIB$SIGNAL(sts);

/*******************/
/* set up the menu */
/*******************/

sts = SMG$CREATE_MENU(&did1, &array_desc, &SMG$K_BLOCK,
                        &SMG$M_DOUBLE_SPACE, 0, &SMG$M_BOLD);
if (sts != SS$_NORMAL) s = LIB$SIGNAL(sts);

while (n<13)
    {
    sts = SMG$SELECT_FROM_MENU(&kbid, &did1, &n, 0, 0, 0, 0, 0, &s_desc);
    if (sts != SS$_NORMAL) s = LIB$SIGNAL(sts);

    sts = SMG$PUT_LINE(&did, &s_desc);
    if (sts != SS$_NORMAL) s = LIB$SIGNAL(sts);
    }

/*************************/
/* Free unneeded storage */
/*************************/

free(array);
sts = LIB$SFREE1_DD(&s_desc);
if (sts != SS$_NORMAL) s = LIB$SIGNAL(sts);

return;
}



      


SMG$CREATE_PASTEBOARD

The Create Pasteboard routine creates a pasteboard and returns its assigned pasteboard identifier.

Format

SMG$CREATE_PASTEBOARD pasteboard-id [,output-device] [,number-of-pasteboard-rows] [,number-of-pasteboard-columns] [,flags] [,type-of-terminal] [,device-name]


RETURNS


OpenVMS usage cond_value
type longword (unsigned)
access write only
mechanism by value


Arguments

pasteboard-id


OpenVMS usage identifier
type longword (unsigned)
access write only
mechanism by reference

Receives the identifier of the newly created pasteboard. The pasteboard-id argument is the address of an unsigned longword into which is written the new pasteboard identifier.

output-device


OpenVMS usage device_name
type character string
access read only
mechanism by descriptor

Specifies the file specification or logical name to which the output associated with this pasteboard will be written. The output-device argument is the address of a descriptor that points to the name of the output device. If omitted, output is sent to SYS$OUTPUT.

Note

An RMS file is not supported as an output device in Korean Screen Management Facility.

number-of-pasteboard-rows


OpenVMS usage longword_signed
type longword (signed)
access write only
mechanism by reference

Receives the number of rows on the device specified in the output-device argument. The number-of-pasteboard-rows argument is the address of a signed longword into which is written the number of rows on the specified device, which will be the number of rows in the pasteboard.

number-of-pasteboard-columns


OpenVMS usage longword_signed
type longword (signed)
access write only
mechanism by reference

Receives the number of columns on the device specified in the output-device argument. The number-of-pasteboard-columns argument is the address of a signed longword into which is written the number of columns on the specified device.

flags


OpenVMS usage mask_longword
type longword (unsigned)
access read only
mechanism by reference

Specifies the attributes to be used in the pasteboard. The flags argument is the address of an unsigned longword that contains the flag. The default action is to clear the screen when the pasteboard is created.

Valid value is:

SMG$M_KEEP_CONTENTS The screen is not initially cleared. The Screen Management Facility works best when it can manage the entire screen. Therefore, using SMG$M_KEEP_CONTENTS is discouraged.

type-of-terminal


OpenVMS usage mask_longword
type longword (unsigned)
access write only
mechanism by reference

Receives the SMG$ internal device type to which the output associated with this pasteboard will be written. The type-of-terminal argument is the address of an unsigned longword into which is written the terminal type.

The returned values are as follows:

SMG$K_UNKNOWN
SMG$K_VTFOREIGN
SMG$K_HARDCOPY
SMG$K_VTTERMTABLE

If a value other than SMG$K_VTTERMTABLE is returned, you must use SMG$SNAPSHOT to output the contents of the pasteboard.

Note

SMG$SNAPSHOT is not supported in Korean Screen Management Facility.

Description

SMG$CREATE_PASTEBOARD creates a new pasteboard, associates it with the device specified by output-device, and returns its assigned pasteboard-id. Note that if you request a pasteboard on a device that already has a pasteboard assigned, this routine returns the pasteboard-id of the existing pasteboard and returns the SMG$_PASALREXI status code.

If a program calls both SMG$CREATE_PASTEBOARD and SMG$CREATE_VIRTUAL_KEYBOARD, make sure SMG$CREATE_PASTEBOARD is called first. The program will not function correctly if SMG$CREATE_VIRTUAL_KEYBOARD is called before SMG$CREATE_PASTEBOARD.


Condition Values Returned

SS$_NORMAL Normal successful completion.
SMG$_PASALREXI Successful completion. A pasteboard already exists for this device.
SMG$_WRONUMARG Wrong number of arguments.
LIB$_INSVIRMEM Insufficient virtual memory to allocate needed buffer.

Any condition values returned by LIB$GET_EF, LIB$GET_VM, $QIO, $GETDVI, $ASSIGN.


    0    |    1    |    2    |    3    |    4    |    5    |    6    |
1234567890123456789012345678901234567890123456789012345678901234567890

Examples

#1



     C* RPG example for SMG$CREATE_PASTEBOARD.
     C           CREPAS    EXTRN'SMG$CREATE_PASTEBOARD'
     C           CREDIS    EXTRN'SMG$CREATE_VIRTUAL_DISPLAY'
     C           PUTCHA    EXTRN'SMG$PUT_CHARS'
     C           PASDIS    EXTRN'SMG$PASTE_VIRTUAL_DISPLAY'
     C                     Z-ADD0         ZERO    90
     C                     Z-ADD1         LINCOL  90
     C                     Z-ADD2         LINE    90
     C                     Z-ADD5         COLUMN  90
     C                     MOVE 'Menu'    OUT     4
     C* Create the pasteboard.
     C                     CALL CREPAS
     C                     PARM           PASTID  90 WL
     C                     PARMV          ZERO
     C                     PARM           HEIGHT  90 WL
     C                     PARM           WIDTH   90 WL
     C* Create the virtual display.
     C                     CALL CREDIS
     C                     PARM           HEIGHT     RL
     C                     PARM           WIDTH      RL
     C                     PARM           DISPID  90 WL
     C* Output the 'Menu'.
     C                     CALL PUTCHA
     C                     PARM           DISPID     RL
     C                     PARMD          OUT
     C                     PARM           LINE       RL
     C                     PARM           COLUMN     RL
     C* Paste the virtual display.
     C                     CALL PASDIS
     C                     PARM           DISPID     RL
     C                     PARM           PASTID     RL
     C                     PARM           LINCOL     RL
     C                     PARM           LINCOL     RL
     C                     SETON                     LR



      

The RPG II program above displays 'Menu' beginning at line 2, column 5.

#2


C+                                            SMG1.FOR
C This DEC Fortran example program demonstrates the use of
C SMG$CREATE_PASTEBOARD.
C-

        IMPLICIT INTEGER*4 (A-Z)
        SMG$M_BOLD = 1
        SMG$M_REVERSE = 2
        SMG$M_BLINK = 4
        SMG$M_UNDERLINE = 8
C+
C Establish the terminal screen as a pasteboard
C by calling SMG$CREATE_PASTEBOARD.
C-

        STATUS = SMG$CREATE_PASTEBOARD (NEW_PID,,,)
        IF (.NOT. STATUS) CALL LIB$STOP(%VAL(STATUS))
C+
C Establish a virtual display region by calling
C SMG$CREATE_VIRTUAL_DISPLAY.
C-

        STATUS = SMG$CREATE_VIRTUAL_DISPLAY (5,80,DISPLAY_ID,,,)
        IF (.NOT. STATUS) CALL LIB$STOP(%VAL(STATUS))
C+
C Paste the virtual display to the screen, starting at
C row 10, column 15 using SMG$PASTE_VIRTUAL_DISPLAY.
C-

        STATUS = SMG$PASTE_VIRTUAL_DISPLAY(DISPLAY_ID,NEW_PID,10,15)
        IF (.NOT. STATUS) CALL LIB$STOP(%VAL(STATUS))
C+
C Write three lines to the screen using SMG$PUT_LINE.
C-

        STATUS = SMG$PUT_LINE (DISPLAY_ID,'This line is underlined',2,
        1                               SMG$M_UNDERLINE,0,,)
        IF (.NOT. STATUS) CALL LIB$STOP(%VAL(STATUS))

        STATUS = SMG$PUT_LINE (DISPLAY_ID,'This line is blinking',2,
        1                               SMG$M_BLINK,0,,)
        IF (.NOT. STATUS) CALL LIB$STOP(%VAL(STATUS))

        STATUS = SMG$PUT_LINE (DISPLAY_ID,'This line is reverse video',2,
        1                               SMG$M_REVERSE,0,,)
        IF (.NOT. STATUS) CALL LIB$STOP(%VAL(STATUS))

        END

      


Previous Next Contents