JP3105749B2 - Screen display conversion method - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a screen conversion method for converting a screen displayed on a display.
The present invention relates to a screen conversion method for converting a screen of an application program displayed on a bitmap display connected to a computer system. More specifically, the present invention is directed to an application program that originally provides a text-based screen, such as a 3270 terminal emulator, and the text-based screen information transmitted from the host application. To a GUI-like screen display (GUI-flavored
host screen) and mouse type input (Mouse)
-oriented operation).

[0002]

2. Description of the Related Art Recent technological innovations have brought personal
The use of computers (PCs) has been diversified.

[0003] One of the usage modes of a PC is ES900.
0 or S / 390 connected to a host system via a network, and an input / output terminal (for example, 3
270 terminal) (see FIG. 3).
4). In this case, in terms of hardware, the PC communicates with the host system via a communication line (for example, a coaxial cable) by installing a communication adapter card for transmitting and receiving communication data (for example, a 3270 data stream). And the software is 32
A program for emulating 70 terminals or the like (hereinafter, referred to as “emulation program” or “emulator”) is one of the application programs.
It is assumed that they are supported as one (see FIG. 2). The 3270 terminal emulator is an example of an emulation program, and a host application (eg, VM / CM) sent from the host system.
3270 terminal for host mainframe, such as displaying the output of an application program running on a host operating system such as S) and sending data input on the PC to the host. Software that provides almost all of the functions of

[0004] In recent years, the number of PCs equipped with a bitmap display format has increased in terms of hardware. In terms of software, OS / 2
(Trademark of IBM Corp.) and MS-Windows (Micr
An operating system (OS) that supports a bitmap display format and can provide multiple windows, such as osoft Corp., has become mainstream. These latest operating systems are generally based on graphical user
An interface (GUI) is incorporated. GUI
Can transmit a coordinate value input by a mouse, a joystick, or the like to an application program. Therefore, the user can easily input his or her own intention not only with the keyboard but also with the mouse.

[0005] Some of the application programs running on such a state-of-the-art OS include a display screen that attracts the user's eyes and facilitates input operations by receiving bitmap display and GUI flow. Some are offered. FIG. 36 shows an example of such an application program. As can be seen at a glance, the area on the screen that prompts the user for input (such as the "iconize" button, "maximum display" button in the upper right corner of the window, "OK" button in the dialog box, and "Cancel" button ) Are enclosed in a frame and have a three-dimensional shading (hereinafter referred to as a “HotSpot” or “3D button” in the iconized area surrounded by the frame on the screen) On such a screen, the user moves the mouse pointer into a desired 3D button area and clicks the mouse button to perform the 3D button operation.
The same operation as the key input corresponding to the D button can be performed. The 3D button display not only gives the user the impression that the application is up-to-date (next generation), but also alerts the user to visual attention for mouse input. I can say that.

The display screen provided by the above-mentioned 3270 terminal emulator (hereinafter, also simply referred to as “3270 screen”) is generally a two-dimensional text-based (or character-based) old-fashioned one. It is presented in a simple format. On the 3270 terminal,
The user is only allowed to input and operate from the keyboard (character user interface:
CUI), GUI input using a mouse or the like is not possible. The reason is that the 3270 data stream is
It can be said that it consists only of data.
Here, considering that the emulator is also one of the application programs running on the OS of the PC and the above-mentioned multi-window environment, 3D
The window related to the latest application employing the button display and the window related to the old-fashioned emulator are crowded on the same display screen,
You can easily imagine that. MS-Win
Windows, OS / 2 Presentation Manager (PM), AIX (trademark of IBM Corp.), etc. that support bitmap display type GUI environment,
The 3270 terminal emulator is already implemented, and the presence of 3270 screens in a multi-window environment is a practical matter. Text-based 3270
The presence of the screen is not only inconvenient for the user,
The impression of the multiwindow itself can become obsolete.

As an existing method for converting a two-dimensional 3270 screen into a 3D button display and enabling GUI-like mouse input, a program for screen conversion is developed for each emulator screen type. It is mentioned. In this case, the screen conversion program requests the emulator to copy the contents of the screen buffer, scans the screen buffer to extract desired character strings (corresponding to function keys), and Is converted into a three-dimensional shaded display.

[0008] Such an existing screen conversion program,
It is customized so that it is created for each type of screen, so that an emulator screen optimal for the user can be obtained. However, the task of developing a conversion program for each screen type requires a great deal of effort. For example, if there are many types of screens provided by the host system, the user's willingness to develop programs is immediately lost. Note that there are already application programs for automatically converting desired character strings and the like into 3D buttons, but current programs simply follow the character strings and thus often cause erroneous conversion.

[0009]

SUMMARY OF THE INVENTION An object of the present invention is to provide a screen conversion method for automatically converting a screen according to an application program displayed on a bitmap display connected to a computer system. It is in.

A further object of the present invention is to enable a user to automatically convert a screen related to a text-based or character-based application program such as a 3270 terminal emulator without any modification or change by the user. It is to provide a screen conversion method.

A further object of the present invention is to display text-based and character-based screen information sent from a host application on a GUI-like screen display (GUI-f).
It is an object of the present invention to provide a screen conversion method for converting a screen into a lavored host screen and enabling a mouse-oriented operation.

[0012]

SUMMARY OF THE INVENTION The present invention has been made in view of the above problems, and a first aspect of the present invention relates to a screen display conversion method for converting and displaying screen information. A first step of searching the screen information for a collective character string including a character string whose character string is to be converted (hereinafter, referred to as a character string to be converted), and the collective character strings extracted in the first step A second step of determining the arrangement relationship in the screen information, and converting the converted character string in each collective character string into a predetermined display format if the determination result in the second step is positive. And a third step of converting the screen display.

According to a second aspect of the present invention, in a screen display conversion method for converting and displaying screen information, a character string whose display format is to be converted within the screen information (hereinafter referred to as Attentio).
n IDKey. PFn, FP for Attention ID Key
n, Fn, n, PAn and the like. However, a first step of searching for a character string (hereinafter, referred to as an "aidkeyexpression") that is treated as a unit including n (an integer of 1 to 24) based on a predetermined conditional expression, and "aidkeyexpressi" in one line
The second stage of estimating a row including a plurality of on as a row of the horizontal array, and the Attention ID of the row estimated as the horizontal array
aidkeyex containing PFn, FPn, Fn or n as key
A third step of negating the estimation for a row that includes two or more pressions in one row and n is not arranged in a positive order from left to right, and each Attent included in a row of the horizontal arrangement
a fourth step of converting the ion ID key into a predetermined display format;
Is a screen display conversion method characterized by including the following.

According to a third aspect of the present invention, in a screen display conversion method for converting and displaying screen information, a character string whose display format is to be converted within the screen information (hereinafter referred to as Attentio).
n IDKey. Attention ID key is PFn, FP
n, Fn, n, PAn and the like. However, a first stage of searching for a character string (hereinafter, referred to as an “aidkeyexpression”) that is treated as a unit including n (an integer from 1 to 24) based on a predetermined conditional expression, and a case where a plurality of lines including only one “aidkeyexpression” A second step of determining whether or not each row is continuous and estimating each continuous row as a row of the vertical array; and PFn, FP among the rows estimated as the vertical array.
If there are two or more rows containing n, Fn or n, P
Fn, FPn, Fn or a third step of negating the estimation if the positions of n from the left end or right end of the screen do not match, and PFn, FP among the lines estimated as the vertical type array
When there are two or more rows containing n, Fn or n, n of each row
A fourth step of negating the estimation if the images are not arranged in the normal order from the top to the bottom of the screen, and a fifth step of converting each Attention ID Key included in the row of the vertical arrangement into a predetermined display format.
And a screen display conversion method.

A fourth aspect of the present invention relates to a text and a field attribute (however, the field attribute defines a field on a screen and defines whether each field is an input enabled field or an input prohibited field, etc.). In the screen display conversion method for converting and displaying the screen information composed of the following two values: whether or not a combination of character strings specified in advance exists in one line or in two consecutive lines in the screen information. And a second step of determining whether a plurality of rows having the same field structure formed by the field attribute are continuous if the result of the first step is positive. And if the result of the second step is affirmative, a third step of converting at least the first input-capable field of each successive line into a predetermined display format When a screen display conversion method, which comprises a.

According to a fifth aspect of the present invention, a text and a field attribute (however, the field attribute is used to set a field on a screen and define whether each field is an input-capable field or an input-inhibited field, etc.) In the screen display conversion method for converting and displaying the screen information composed of the values of (i) and (ii), it is determined whether or not the top row of the non-blank lines in the screen information includes two or more input-capable fields. A first step, and if the result of the first step is positive, a second step of determining whether the structure of the field in the top row matches the nearest non-blank row, If the result of the second step is negative, a third step of converting the top row to a predetermined display format is included.

According to the first to third aspects of the present invention, however, a character string which is particularly desired to be made into a 3D button on a screen is provided.
Instead of directly searching the Attention ID Key from the 3270 screen (presentation space) and converting the display, the character string that is handled as a whole including the Attention ID Key is "aidkeyexpression" (Attention ID Key Expr
ession), and once from 3270 screen aidkeyexpress
search for ion, and each extracted aidkeyexpress
By verifying the arrangement relationship between ions, the desired Atten
Only the Option ID Key is made into a 3D button (see FIGS. 29 and 30). For example, each date in the calendar on the screen shown in FIG. 22 is a candidate for AttentionID Key, but a series of character strings including the date is aidkeyexpression
Does not apply, so that there is no chance that a 3D button is erroneously formed (see FIG. 29).

According to a fourth aspect of the present invention, FIG.
The cursor position designation type area in the 3270 screen as shown in FIGS. 4 and 27 can be appropriately made into a 3D button as shown in FIGS. 31 and 32.

According to a fifth aspect of the present invention, FIG.
As shown in FIG. 33, each input item in the menu bar in the 3270 screen as shown in FIG. 8 can be appropriately made into a 3D button.

Still other objects, features and advantages of the present invention are:
It will become apparent from the following more detailed description based on the embodiments of the present invention and the accompanying drawings.

[0021]

【Example】

Embodiments of the present invention will be described in terms of the following items. A. Hardware configuration of personal computer B. C. Software configuration of personal computer Data flow between host and PC C-1.3270 Data screen display processing C-2. Processing of screen information input on PC side D. Display conversion processing of 3270 screen D-1.3 Area to be converted to 3D button display D-2. Screen conversion processing routine D-3. Screen conversion release key

A. Personal computer hardware
1. Hardware Configuration FIG. 1 schematically shows a hardware configuration of a personal computer (PC) 20 provided for implementing the present invention.

Reference numeral 1 denotes a CPU for controlling the operation of the entire system 20. The CPU 1 is connected to the address / data bus 2 for communication with each input / output device, and is also connected to the main memory 4 via the memory bus 3. The main memory 4 usually has a DR
It is a writable memory such as AM. Main memory 4
Is a BIOS (Basic Input / Outp) stored in the ROM 5.
ut System) and system software such as an operating system (OS) stored in a hard disk drive (HDD) 6 and various applications are loaded in response to a user request. In the main memory 4, a work area for the CPU 1 to execute the software is secured.

One of the input / output devices communicating with the address / data bus 2 is a video controller (VGA).
7 The video controller 7 is for writing screen information to a screen buffer (VRAM) 8 according to a drawing command from the CPU 1 and controlling to display image data according to the contents of the screen buffer 8. The system 20 is provided with a liquid crystal display (LCD) 11 via an LCD controller 10 or a CRT display 12 via a digital / analog conversion circuit (DAC) 10 as a display device. In addition,
In order to implement this embodiment, the video controller 7
It is assumed that the liquid crystal display device 11 and the display 12 support bitmap display.

The address / data bus 2 has 1
Serial port 13 for transferring data in bit units, parallel port for transferring data in byte units
A communication adapter card (for example, a 3270 adapter card, a token ring card, a card for SDLC) 15 for exchanging 3270 data with a port 14 or a host system (not shown) such as the ES9000. Is connected.

In practice, there are a number of I / Fs (interfaces) in addition to the above hardware elements, but these are well-known to those skilled in the art, so that the description of this embodiment will be simplified. It is omitted for convenience.

B. Personal computer software
E A configuration diagram 2 is obtained schematically shows the hierarchical structure of software that is loaded on the main memory 3. The software layer includes an application program 33 layer, an operating system 32 layer, and a BIOS layer 31 as a hardware control layer from the upper layer.

The application programs 33 are:
It is loaded from an external storage device such as the HDD 6 or FDD in response to a user request, and corresponds to a document processing, a database management, a spreadsheet, a 3270 terminal emulator, or the like. Each application 33
... may be displayed as a multi-window on the display 11 (or 12) as shown in FIG. 36, for example.

The 3270 terminal emulator is one of the application programs 33..., And a host program (for example, VM / VM) sent from a host system connected via the communication adapter card 15.
The PC 20 executes 3270 commands such as executing a command of a host operating system (CMS or the like) and sending data input on the PC 20 to the host.
It provides a function for operating as a terminal.
Also, it should be understood that a screen conversion program for converting text-based 3270 screen information (hereinafter referred to as “3D button subroutine”) is incorporated as one module in the 3270 emulator 33.

Operating system (OS) 32
Is software for controlling the operation of each application program 33, and performs resource management, device management, file management, and the like. In order to implement the present invention, it is indispensable for the OS 32 to be able to control the display while controlling the contents of the VRAM 8 (that is, to support the bitmap display), and to support a graphical user interface (GUI). is there.
Such OSs include, for example, MS-Windows and O
S / 2, AIX.

The BIOS 31 includes software layers 31 and 3
2 and the hardware layer,
It is composed of codes for interpreting commands of general characteristics sent from the application programs 33 and the OS 32 and converting them into commands for operating hardware of each input / output device.

C. Data between host system and PC
flow

C-1 . Screen Display Processing of 3270 Data FIG. 3 schematically shows a processing flow in which a 3270 data stream sent from the host system is performed by the 3270 terminal emulator 33 and the operating system 32 on the PC side. FIG.

(1) Step 13 The 3270 data stream is sent to the PC 20 sequentially (that is, as a one-dimensional character code flow) via a communication line. The data stream is temporarily stored in the communication buffer in order to absorb the difference in data transfer speed between the host and the PC. This communication buffer is actually a memory provided in the adapter card 15 or an area mapped in the main memory 4.

(2) Step 2 Next, the 3270 data stream is interpreted by the 3270 terminal emulator 33, and the text plane information and the attribute plane (at
tribute plane) information and reorganized as two-dimensional screen information
S). The presentation space is actually an area mapped in the main memory 4, and one presentation space corresponds to information for one 3270 screen. Here, the text plane is for designating a character string to be displayed on the screen and an inputtable position. Characters and field attributes are written at positions corresponding to the 3270 screen. (However, in order to speed up the processing, field attributes may also be written on one independent plane). The field attribute divides the 3270 screen into areas called fields (field length is arbitrary), and each field is a field in which key input is possible (inputable field) or a field in which key input is prohibited ( It is used to specify whether the field is an input prohibition field or a protection field. The attribute plane is mainly for defining attributes (character attributes) such as the color of each character in the text plane, and the character plane is located at a position corresponding to each character on the text plane. The attribute is written. In this embodiment, one attribute plane is provided for each presentation space for ease of explanation. However, if there are many parameters to be specified, a plurality of attribute planes may be provided for each presentation space. It may be provided.

The host system (host application) has complete control over the contents of the presentation space created by the 3270 terminal emulator. That is, the host system can instruct the PC 20 to write part or all of the presentation space, and conversely, the PC 20 reads the content written in the presentation space by a key input operation of the user or the like. Can be. However, the presentation space itself is
It should be noted that this is merely an old-fashioned two-dimensional screen information of the base.

(3) Step 3 Next, the operating system writes screen information to the screen buffer (VRAM) 8 in order to display the contents of the presentation space on the display 11 (or 12).

The conventional 3270 terminal emulator receives the 3270 data received from the host application.
The stream was simply interpreted as two-dimensional data (ie, writing the text data into the presentation space) and no further processing was performed. Therefore, the operating system has no choice but to write the contents of the presentation space directly to the VRAM 8, and the 3270 displayed on the display 12 is displayed.
The screen was the same as the content written in the presentation space (ie, the old-fashioned text-based two-dimensional screen).

On the other hand, the 3270 terminal emulator 33 according to the present embodiment passes predetermined information to the operating system 32 after performing predetermined preprocessing on the presentation space. The pre-processing here means that the contents of the presentation space are sequentially scanned, and the area to be converted into the 3D button display from the text-based screen information (for example, corresponds to the “Attention ID Key” such as a function key) (Character string) is searched, and information necessary for forming a 3D button, such as the contents of the character string, the xy coordinates and the height and width of the upper left corner of the character string, is constructed for each area (this preprocessing) Is described in detail in section D-2). Then, when writing to the VRAM 8, the operating system 32 appropriately converts the screen information into a 3D button display based on the information constructed by the 3270 terminal emulator 33.
Operating systems that support bitmap display, such as MS-Windows and OS / 2, support the function of converting a specified area into a shaded 3D button. Then, the display 11 (or 1
2) is to actually display the screen that has been subjected to the 3D button processing according to the contents of the VRAM 8.

The contents of the VRAM 8 need not be seen from the 3270 terminal emulator 33 or the host system. This is because writing from the presentation space to the VRAM 8 is performed by the operating system (described above). The host system itself
It can only communicate with the user of the PC 20 via the presentation space.
(In other words, the converted 3270 screen actually displayed on the display 11 (or 12))
Neither can it be written, and conversely, the contents written by the user can be read directly.

C-2. Processing of screen information input on PC side
Physical Figure 4 is a diagram schematically showing a flow for sending to the host system the information inputted in the PC side as 3270 data stream.

If the PC supports only the conventional 3270 terminal emulation program, the 3270 screen displayed on the displays 11 and 12 is 3270
This is an old-fashioned two-dimensional screen based on a data stream (described above). Further, the user's input operation is limited to input of a function key (specified on the screen) or key input in an input enabled field defined by field attributes. This is because the 3270 terminal emulator or the host application cannot directly read the contents of the VRAM 8, and only the contents of the keys input to the presentation space can be passed to the host application as a 3270 data stream.

On the other hand, the 3270 terminal emulator 33 according to the present embodiment allows the user to input a mouse. When the user clicks the mouse on an arbitrary 3D button (for example, a PF1 key surrounded by a shaded frame) (step 4), the operating system executes
Necessary parameters such as the coordinate value clicked along with the event of the click operation are stored in the 3270 terminal emulator
3 is notified (step 5). Next, the 3270 terminal emulator 33 senses what the input key corresponds to the click operation, creates the same 3270 data stream as when the input key is pressed, and sends it to the communication buffer (step 6). . Thus, the host application need only receive the 3270 data stream and perform conventional processing. In other words, the host system displays the 3D button-displayed 3D button.
That is, the input data on the PC side can be processed without being aware of the contents of the 270 screen.

D. Display Conversion Processing of 3270 Screen This section describes in detail a processing procedure for converting a text-based 3270 screen into a screen including 3D buttons. FIGS. 15 to 28 show an example of a text-based (ie, before 3D button processing) 3270 screen. It should be understood that the contents of the 3270 screen before the 3D button processing are equivalent to the contents of the text plane in the presentation space.

D-1.3 Area to be Converted to 3D Button Display Areas to be converted to 3D button display in the text-based 3270 screen include the following.

(1) Attention ID Key: The first area to be made into a 3D button is an area related to the Attention ID Key. Here, the Attention ID Key is a literal key such as a function key ("PFn", "Fn", "n", "PAn" (where n is a number)) or an "ENTER" or "CLEAR" key. Is an input key that does not require the input of a character key.

The area where the Attention ID Key is displayed on the screen is also an area where the user wants to pay particular attention. However, if the character strings corresponding to all the Attention ID Keys are converted into 3D buttons, the screen may be difficult to see. Because it is just a comment statement, Atte that does not evoke the user's input action
This is because there is also an ntion ID Key display. Further, if the Attention ID Key is searched only for the degree of matching of a lexical character of about two to three characters, there is a possibility that even those that are not Attention ID Keys are extracted and turned into 3D buttons. Therefore, in the present embodiment, a character string that includes the Attention ID Key on the screen and is treated as one is called “aidkeyexpression” (Attention ID Ke
y Expression), and search for the aidkey expression from the presentation space once, and then verify the arrangement relationship between the extracted aidkey expressions to ensure that only the desired Attention ID Key can be extracted. . For example, each date in the calendar on the screen shown in FIG. 22 is a candidate for the AttentionID Key, but since a series of character strings including the date does not correspond to the aidkeyexpression, it is not erroneously made into a 3D button.

In the following, aidkeyexpress is calculated using equations (1) to (18).
Define ion.

[0050]

(Equation 1)

According to equation (1), aidkeyexpression is defined as del
It consists of im0, aidkeyterm, delim2, and function. Both delim0 and delim2 are boundaries for delimiting between character strings (hereinafter, collectively referred to as "delimiter"). delim0 is used to define the head position of the aidkeyexpression, and a blank ('_') is used as shown in Expression (2). However, since blanks on the display screen include Space, Null, Attribute Character, and the like, a plurality of types of character codes correspond to blanks (hereinafter, the same applies to blanks used as delimiters). Also, delim2 is an aidkeyterm and related
It is a so-called conjunction to connect function and expression
As shown in (3), any one of '=', '-', and ':' is used in addition to the blank. Deli
A return arrow behind m2 means that delim2 may be repeated (eg, '==', ': =', etc.).

[0052]

(Equation 2)

(Equation 3)

The aidkeyterm is the character string that the user wants to call the user's attention on the screen, and is the central character string in the character string whose screen display is to be converted from a text base to a 3D button. The aidkeyterm is, according to the content of the character string, as shown in equation (4), pfkeyitem and pakeyite
m and otherkeyitem.

[0054]

(Equation 4)

The pfkeyitem corresponds to a normal function (PF) key (for example, each "PF" key in FIG. 16), and as shown in equation (5), sets the boundary with another character string. It is composed of delim1 for defining (including the case where there is no delim1 at the head of the line, etc.) and pfkeyid for specifying the type of the PF key. delim1 is used to partition between pfnumbers when a single pfkeyitem has two or more pfnumbers, such as the PF key "PF8 / 10" or "PF3 / 12" in the screen shown in FIG. Characters, "/", "
| Characters such as ",", "are used (see equation (6)).
In addition, pfkeyid further includes pfpref as shown in equation (7).
ix (including the case where pfprefix is omitted) and pfnumber. The pfprefix is a so-called prefix for indicating that the aidkeyterm is a PF key. As shown in Expression (8), any one of the character strings "PF", "FP", and "F" Used. pfnumber is a variable for specifying the number of the PF key, and depends on the machine used, etc.
As shown in (9), it is used in any range of 1 ... 24, 01 ... 09, _1 ..._ 9.

[0056]

(Equation 5)

(Equation 6)

(Equation 7)

(Equation 8)

(Equation 9)

The pakeyitem is a PA key prefixed with "PA" among function keys. The PA key is a key frequently used in a conventional host application (for example, a “PA” key exists in FIG. 27). As shown in equation (10), pakeyitem is composed of delim1 for defining a boundary with another character string, and pakeyid for specifying a PA key (d
elim1 is omitted). As shown in equation (11), pakeyid further includes a prefix “paprefix” (character string “PA”; see equation (12)) and a panumber for specifying the PA key number (see equation (13)). ).

[0058]

(Equation 10)

[Equation 11]

(Equation 12)

(Equation 13)

The function key prefix and de
The limiter function number and the like differ depending on the language and the model used, and are usually allowed to be changed by the user. This document only describes representative examples of English-based screens.

The other key items are "ENTER", "CLEAR", "E
Attentio other than function keys such as "NT", "CLR"
n ID Key, as shown in equation (14),
It is composed of otherkeyid to specify that it is an item. The otherkeyid further includes otherprefix as a prefix (see equation (16)), delim3 for defining between character strings (see equation (17)), and a suffix as shown in equation (15). Othersuffix (see equation (18)) (delim3 and o
including the case where therkeysuffix is omitted).

[0061]

[Equation 14]

(Equation 15)

(Equation 16)

[Equation 17]

(Equation 18)

The function is a character string for explaining the function of aidkeyterm. For example, in the case of FIG. 15, "Alternate PFs" connected to "PF1" or "Alternate PFs" connected to "PF2"
FileNOTE "corresponds to each function.

Usually, a plurality of aidkeyexpressions are present in 3270 screens, and are classified into “horizontal type” and “vertical type” according to the mutual positional relationship. Whether the array of aidkeyexpression is horizontal or vertical can be determined according to the following determination conditions. Note that the above
Otherkey prefix, othersuffix, delim3, etc. are different depending on the language used, so to speak, case-insensitive.

(A) Horizontal Type Determination Condition (a-1) A plurality of aidkeyexpressions are included in one line. However, the last line in the case where the horizontal type extends over a plurality of lines is not limited to this. (a-2) If a line contains multiple pfkeyitems, the pfnumbers must be arranged in left-to-right order. However, the pfnumbers need not be arranged in an arithmetic progression. A case where only one pfnumber is included in a line is also regarded as a normal order. This condition does not apply if delim1 is present. (a-3) In all of the aidkeyexpressions, the same character code is used for delim2.

(B) Vertical Type Determination Condition (b-1) A plurality of rows including only one aidkeyexpression are continuous. However, other lines are allowed. (b-2) At least one of the leftmost digit position and the rightmost digit position of pfkeyid is the same in each line. (b-3) The delim2 of each line matches. (b-4) The pfnumbers are arranged in the normal order from the upper row to the lower row. However, the pfnumbers need not necessarily be arranged in an arithmetic progression.

In the horizontal and vertical determination conditions, pf
Removing the case where the numbers are not ordered in order is
In such a case, it is based on an empirical rule that in many cases, the Attention ID Key is simply displayed in a complicated manner on the 3270 screen and does not prompt the user to input.

(2) Area to be designated by placing the cursor: 3
The second area to be made into a D button is an area to be designated by placing a cursor. For example, "TABLE OF CONT" in FIG.
This corresponds to the first input-capable field of each entry of "ENTS". The input-capable field is specified by writing a field attribute indicating permission of key input at a corresponding position in the text plane (C- In this specification, such an area is referred to as a “cursor position specification type area”. The “cursor position designation type” area may be mixed with “horizontal type” and “vertical type” in one 3270 screen as shown in FIGS.

The cursor position specification type is "cursor"&"Ente
In the first condition, it is required that a set of keywords specified in advance, such as “r”, be present in the same line or in two consecutive lines (a blank line can be inserted between them). (See FIGS. 24 to 27.) Further, the structure of the fields in the text plane (that is, the arrangement of input-capable fields and input-inhibited fields. Each field is separated by a field attribute. C-1)
The second condition is that there is a continuous line (see, for example, a blank line) that matches (see, for example), and each line includes at least one input-capable field.

(3) Each menu item in the menu bar
Character string display area: 3rd area of 3D button
Is an area for displaying a character string of each menu item in the menu bar. For example, as shown in FIG.
0 The horizontal bar at the top of the screen corresponds to this, "Books", "GoTo", "Search", "Not" in this menu bar.
A character string relating to each menu item such as e "... is a region to be converted into a 3D button. In this specification, such a region is referred to as a" menu bar type region ". “Menu bar type” includes “cursor position designation type” and “horizontal type” within the same 3270 screen. It may be mixed with "vertical type".

The condition of the menu bar type is that the uppermost line of the screen is divided into a plurality of input-capable fields, and that the line immediately below the line does not include the input-capable fields.

It should be noted that aidkeyexpress by equations (1) to (18) is used.
The definition of ion and the classification of "horizontal type", "vertical type", "cursor position designation type" and "menu bar type" are shown in FIG.
It is constructed by a heuristic method based on the contents of a large number of text-based application screens such as 3270 screens as shown in FIGS.

D-2. Screen Conversion Processing Routine FIG.
4 schematically shows a flowchart for converting base screen information and writing the converted screen information into the VRAM 8. The processing is actually performed by a 3D terminal in the 3270 terminal emulator 33.
A button subroutine and an operating system 32 running the program (eg, MS-Win)
Windows, OS / 2, AIX, etc.). The 3D button conversion subroutine converts information necessary for 3D button conversion, such as the number of lines and digits on the 3270 screen, into a format that matches the definition of the operating system 32 (that is, the 3D button conversion) based on information given as an argument. Information such as the coordinates of the starting point, width, height, etc.)
And requests the operating system to display a 3D button. A character string to be displayed on the 3D button is also passed to the operating system.

The 3270 terminal emulator 33 according to the present embodiment first scans the presentation space to be processed, extracts all the aidkeyexpressions, and converts the information necessary to convert it into a 3D button display.
It is constructed in a list format (step 100).

Next, referring to the list, ai arranged in a horizontal type (described above) in the presentation space is used.
It is determined whether or not the dkeyexpression exists, and if so, the corresponding Attention ID Key is converted into a 3D button (step 200). However, the user may be allowed to select whether or not to perform screen display conversion on the horizontal type.

Next, referring to the list, ai arranged in the vertical type (described above) in the presentation space is used.
It is determined whether or not the dkeyexpression exists, and if so, the corresponding Attention ID Key is converted into a 3D button (step 300). However, the user may be allowed to select whether or not to perform screen display conversion on the vertical type, and which range in the aidkeyexpression is to be made into a 3D button.

Next, if there is an area of the cursor position designation type in the remaining area excluding the part already converted to the 3D button in the presentation space, it is converted into a 3D button (step 400), and the menu bar type is set. If there is, a 3D button is formed (step 500). However, the user may be able to select whether or not to perform screen display conversion for the cursor position designation type and the menu bar type.

Although the flowchart for making the 3D button has been roughly described, a detailed processing procedure of each step will be described below.

(1) In the presentation space
Search for aidkeyexpression First, aidkexpression exists in the presentation space
The eyexpression is searched, which corresponds to the pre-processing for converting the display of the Attention ID Key arranged in the horizontal or vertical type. In the present embodiment, one record (hereinafter, “aid-ke
By creating a "y record"), information about the aidkeyexpression is grasped on a line-by-line basis. The aid-key record has a keyt as shown in FIG.
It is composed of six fields: ype field, keycount field, deltype field, delcount field, start field, and end field. Where ke
The ytype field contains a related to the PF key above the corresponding line.
When idkeyexpression is present, this area is used to store the type of the PF key (ie, whether pfprefix is "PF", "FP", "F", or the default). The keycount field is an area for storing the number of aidkeyexpressions existing on the corresponding line. Also, the deltype field is delim2 used in the aidkeyexpression existing on the corresponding line.
Area (that is, "_", "=", "-", ":"). Also, delcount
The field is an area for storing the number of delim2 existing on the corresponding line. The start field and end field are areas for storing the leftmost digit position (start) and the rightmost digit position (end) of pfkeyid closest to the head of the line existing on the corresponding line. Each a
The id-key record has one flag, but this flag indicates whether the corresponding row is unprocessed, and is set in the initial state and reset when the 3D button processing is performed. It has become.

Since the presentation space is composed of, for example, 24 lines on a display device used for a general PC, as shown in FIG.
Aid-key records (hereinafter "aid-key list")
Will be created. The value of each field of the aid-key record for each row is used when converting the aid-key arranged in each of the horizontal type and the vertical type into a 3D button, which will be described in detail later.

FIG. 7 shows a step 100 for searching for an aidkeyexpression in the presentation space.
2 illustrates a detailed processing procedure, that is, a processing procedure for creating an aid-key record for each row. Hereinafter, this flow will be described.

First, in step 102, the internal variables and the like are initialized, and 1 is assigned to the line pointer, so that the processing from step 104 onward is started from the first line of the presentation space.

In the closed loop formed in steps 106 to 112, a character string is sequentially extracted for each term from the leftmost digit of the line to be processed (step 1).
06), the internal state is transited and processed according to the relationship with the term taken out last time (step 11).
0), find the keytype, keycount, deltype, and delcount of the line. Then, when there is no longer a term to be taken out from the line (that is, when the processing of all the character strings in the line is completed), the process proceeds to the branch No of the decision block 108 and exits the closed loop. Next, in step 118, each value of the obtained keytype, keycount, deltype, and delcount is
Store in the corresponding field of d-key record. Then
In step 116, the leftmost and rightmost digit positions of pfkeyid closest to the beginning of the line in the line are stored in the start and end fields, respectively, and the row pointer is incremented by one. Return. Decision block 104 determines whether the line pointer is beyond the last line (eg, line 24) of the presentation space. If the row pointer does not exceed the last row, the process proceeds to branch No in block 104, and the above-described closed loop processing is repeated for the next row. On the other hand, if the line pointer is beyond the last line, it means that the processing of all the lines in the presentation space has been completed.
(Via waypoint P).

If it is determined in step 110 that the line currently being processed does not need to be made into a 3D button based on the relationship between the newly extracted term and the internal state, the internal state is set to "abort". Then, the process proceeds to Yes in the decision block 112, and in step 114, keytype = n is set in each field of the aid-key record of the row.
Store ull, keycount = 0, deltype = null, delcount = 0. Such values for each field will be
At 0,300, it is determined that the record is meaningless (described later), and as a result, it can be shown that the processing of the row has failed (abort). The reason why such failure processing is required is that the PF key on the 3270 screen does not always require the user to make a 3D button. For example, a case where a character string related to the PF key is merely quoted in a text on the screen corresponds to an abort. Further, each date of the calendar in the screen of FIG. 22 is a candidate of a PF key of the type in which pfprefix is omitted, but cannot be said to be a target of the 3D button.
If such abort processing is required, PF
The keys are arranged in a complicated manner, and the character string including the PF key does not always form the aidkeyexpression.

The “term” in the generic step 100 is a character string delimited by a delimiter (delim2 or delim0). For example, as shown in FIG. 8A, when the r-th line is composed of a character string composed of “PF1 = Help_PF2 =...”, The terms extracted from the r-th line are as shown in FIG. "PF1", "=", "Help", "P
F2 "... Between" PF1 "and" Help ".
= "And" _ "(blank) between" Help "and" PF2 "
Are both delimiters. However, since it is empirically known that a blank is a meaningless character for the 3D button processing, in the present embodiment, when the delimiter is blank, it is not taken out as a term.

FIG. 9 is a representation of the closed loop formed in steps 106 to 112 in the form of a state transition diagram. The transition between the states in the figure will be described below. Those skilled in the art will be able to fully understand the specific program configuration for obtaining the values of the variables keytype, keycount, deltype, and delcount for the row to be processed from this state transition diagram.

State 0: the first digit of the line (that is, the leftmost digit)
Does not have the previous internal state (that is, the term previously taken out), so it stands by in the neutral state (state 0). In state 0, the next term is pfke
When a character string other than yid is extracted, the state returns to state 0 (arrow α). This is because the determination of the horizontal type and the vertical type is performed based on the arrangement of the PF keys, and there is no interest in other character strings. Also, in state 0, if the character string extracted as the next term matches the definition of aidkeyterm (see equation (4)), transition to state 1 (arrow β).
In this case, the keycount is incremented by one because it is equivalent to newly finding an aidkeyexpression in the row. If the aidkeyterm is pfkeyitem (ie, PF key), the type (ie, pfprefix) is set to keyt.
While temporarily holding it as ype, its pfnumber is also held.

State 1: State 1 is an internal state when the term taken out last time is pfkeyid. In state 1,
If the character string extracted as the next term is delim1, transition is made to state 1 '(arrow γ). And one after another the term is pfn
If it is umber, it returns to state 1 again (arrow δ). In this case, the PF key of the same function is duplicated (duplicat
e) without changing the value of keytype.
ount does not increment. For example, 32 shown in FIG.
On screen 70, the PF key "PF8" followed by the delimiter "/"
This corresponds to the case where pfnumber "10" follows across "" and "12" follows "/" after "PF3". In the state 1, if the next term is the aidkeyterm, the state returns to the state 1 (arrow ε). In this case, since it is equivalent to newly finding the aidkeyexpression, the keycount is incremented by one, the previous pfnumber is discarded, and the current pfnumber is retained. However, if the aidkeyterm is pfkeyitem, the type of the PF key (that is, pfprefix) is the same as the already stored keytype, and the pfnumbe
The condition is that r is larger than the previously held pfnumber (that is, the pfnumber is in the normal order).
Also, in state 1, if the next term is delim2,
Transition to state 2 is made on condition that delim2 matches deltype (arrow ζ). However, when transitioning to state 2 for the first time in this row, transition to state 2 is made after temporarily holding the value of delim2 as deltype. Also, be sure to de
Increment lcount by one. Further, in state 1, if the next term is a character string other than aidkeyterm or delim2, the term is determined to be a function (or a part thereof), and the state transits to state 3 (arrow η). Also, in state 1, if the next term is pfkeyitem and its pfprefix is different from the previous keytype, or if its pfnumber is a value smaller than that held last time (ie, in reverse order), it passes through arrow θ. Process failure (abort).
This is because a line having such an arrangement of terms is merely a complicated arrangement of the same character string as the PF key, and is considered to be of little interest in 3D button processing. In state 1, if the next term is delim2 and does not match the previous deltype, abort processing is performed via arrow κ. This is because a line having such an arrangement of terms is simply a complicated arrangement of the same character strings as aidkeyterm and delim2, and is considered to be excluded from the 3D button conversion.

State 2: State 2 is an internal state when the term taken out last time is delim2. In state 2, if the next term is an aidkeyterm, the state transits to state 1 (arrow λ). However, if aidkeyterm is pfkeyitem, pfprefi
x is the same as the previous keytype and its pfnumb
The condition is that er is in normal order. In addition, every time the state transits to the state 1, the keycount is always incremented by one, the previous pfnumber is discarded, and the current pfnumber is retained. In the state 2, if the next term is a character string other than the aidkeyterm, the term is determined to be a function (or a part thereof), and the state transits to the state 3 (arrow μ).
Also, in state 2, if the next term is pfkeyitem and its pfprefix is different from the previous keytype or its pfnumber is in reverse order, the interest in 3D button conversion is low, and the failure (abort) ) Process (arrow ξ).

State 3: State 3 is an internal state in which the previously extracted term is a character string relating to function.
In state 3, if the next term is an aidkeyterm, the state transits to state 1 (arrow π). However, aidkeyterm is pfkeyite
In the case of m, it is a condition that the pfprefix is the same as the previous keytype and that the pfnumber is in the normal order.
In addition, every time the state transits to the state 1, the keycount is always incremented by one, the previous pfnumber is discarded, and the current pfnumber is retained. Also, in state 3, if the next term is a character string other than aidkeyterm, the term is functi
It is determined to be on (or a part thereof), and the process returns to state 3 (arrow σ). In state 3, the next term is pfkeyi
If the key is a tem and its pfprefix is different from the previous keytype or its pfnumber is in the reverse order, the interest in 3D button conversion is low, so the failure (abor
t) Transition to the state to be processed (arrow τ).

Abort: An abort is an internal state to which a transition is made when it is determined that the line being processed in states 1 to 3 is no longer a target for 3D button conversion, as described above. In this case, in the flowchart shown in FIG. 7, the process proceeds to the branch Yes of the decision block 112, exits the closed loop, and ends the processing of the line in failure. Next, at step 114, keytype = null, keycount = 0, deltype = null, de
By storing lcount = 0, subsequent generic steps 200, 300 indicate that the line is of no interest to the 3D buttoning subroutine.

The aid-keyion list (see FIG. 6B) created in this manner is physically stored in the main memory 4, and the 3D button-making subroutine is appropriately read out in the subsequent processing. Can be.

(2) Converting Horizontal Aid-Keys into 3D Buttons Next, referring to the created aid-key list, the aidkeys arranged horizontally in the presentation space
Determines whether expression exists and, if so,
The corresponding Attention ID Key is converted to a 3D button display. FIG. 10 illustrates the detailed processing procedure of the step 200. Hereinafter, this flow will be described.

When the comprehensive step 100 is completed, the process proceeds to the comprehensive step 200 via the waypoint P.

First, in decision block 202, a horizontal type
It is determined whether the user has designated the Attention ID Key as a 3D button. If the result is affirmative, the process proceeds to the next step 204. On the other hand, if the result is negative, branch No
To skip the subsequent steps and exit from the comprehensive step 100 (via-point Q). Block 202
Is provided in consideration of the fact that some users who use the 3D button subroutine do not want to convert the Attention IDKey into a 3D button in the first place (the same applies to decision blocks 302, 404, and 502 described later). ). The user's designation operation is, for example, 3270 emulation
It is performed interactively when the program is introduced to the PC.

In step 204, the aid-key list is scanned upward from the last line to find the line with the largest keycount (ie, the line containing the largest amount of aidkeyexpression). The reason for starting the search from the last line is that, as inferred from, for example, FIGS. 15 to 20 and FIGS. 23 to 27, it is empirical that "a large number of aidkeyexpressions in a horizontal arrangement exist below the 3270 screen." Because they know it. The aid-key list may be scanned only for the number of lines specified by the user for the purpose of improving the processing speed.

If a corresponding row is found in step 204, in step 206, a 3D button processing is performed on the row and the rows above and below that including the aidkeyexpression. At this time, the 3D button conversion subroutine stores information necessary for 3D button conversion, such as the number of lines and columns in the presentation space, in the operating system 3.
In addition to the conversion to a format conforming to the definition of item 2 (that is, information such as the coordinates, width, and height of the starting point of the 3D button), the operating system 32 requests the operating system 32 to display the 3D button. Then, the operating system converts the contents of the presentation space according to the request and writes the converted contents into the screen buffer 8, whereby the desired character string on the 3270 screen is switched to the 3D button. The flag of the aid-key record is reset for the line that has been subjected to the 3D button processing.

In the decision block 208, the previous step 20
In step 4, it is determined whether or not the corresponding row is actually found. If the result is positive, it is determined that there is no need to perform horizontal processing in the screen anymore, and the branch Ye
The process proceeds to s, and the process exits from the comprehensive step 204 (point Q). On the other hand, if the result is negative, the following step 2
The process proceeds to step 10, and the aid-key list is scanned by the number of lines designated by the user from the first line, and the line having the largest keycount is searched for. Next, in step 212, the 3D button processing is performed on the relevant line and the lines including pfkeytitem above and below the relevant line, and then the comprehensive step 200 is completed (via-point Q). Note that the content of the processing in step 212 is substantially the same as that in step 206, and thus the description is omitted here.

FIGS. 30, 31, and 32 show examples of a 3270 screen in which a horizontally arranged aidkeyexpression is converted to a 3D button display. In the figure, aidkeyex
Although the entire pression is made into a 3D button, it is programmable to convert the display of only one character string (for example, aidkeyterm).

(3) Converting vertical aid-keys into 3D buttons Next, referring to the created aid-key list, the aidkeys arranged vertically in the presentation space
Determines whether expression exists and, if so,
The corresponding Attention ID Key is converted to a 3D button display. FIG. 11 illustrates the detailed processing procedure of the step 300. Hereinafter, this flow will be described.

When the comprehensive step 200 is completed, the process proceeds to the comprehensive step 300 via the waypoint Q.

First, in decision block 302, a vertical type
It is determined whether the user has designated the Attention ID Key as a 3D button. If the result is negative, branch No
To exit from the comprehensive step 300 (via a route point R). On the other hand, if the result is positive, the process proceeds to the next step 304.

In step 304, the remaining aid-data except for the row already subjected to the 3D button processing in the comprehensive step 200 is output.
It is sequentially checked whether or not the key record satisfies the vertical condition, and the line number associated with the matching aid-key record is recorded in a vertical list (not shown). Whether or not each row has been subjected to the 3D button processing can be confirmed by the flag of each aid-key record. Further, as described above, the vertical type condition is as follows: (b-1) A plurality of rows containing only one aidkeyexpression are continuous. (b-2) At least one of the leftmost digit position and the rightmost digit position of pfkeyid is the same in each line. (b-3) The delim2 in each line must match. (b-4) The pfnumbers are arranged in the normal order from the upper row to the lower row. The four. As for condition (b-1), keycount is 1 and a
It can be determined by checking whether or not id-key records are continuous. The condition (b-2) can be determined by comparing the values of the start and end fields of each aid-key record. Also, the rows that violate the conditions (b-3) and (b-4) are:
Abort processing is performed at the stage of creating the aid-key record, and variables keytype... are set so as not to satisfy the condition (b-1).

Next, in step 306, each line recorded in the vertical list is examined, and only the line which is the type of the most frequently occurring PF key and coincides with the most common starting digit of the pfkeyitem is left in the vertical list. And discard other records.

Next, in a decision block 308, it is determined whether or not two or more rows still remain in the vertical list as a result of discarding the extra records in step 306. If the number of remaining records is one line or less, the condition (b-1) "... a plurality of lines are continued" is not satisfied. Exit (via point R). On the other hand, if the result is positive, the process proceeds to the next step 310.

In step 310, 3D button processing is performed for each row remaining in the vertical type list based on the user's designation. The 3D button conversion of the character string is performed by the 3D button conversion subroutine sending a request to the operating system 32 together with necessary information and the operating system 32 performing a predetermined drawing process (described above). In addition, for the row that has been subjected to the 3D button processing, the flag of the aid-key record is reset. The “user designation” here means
Start digit and end digit for 3D button conversion, pf
Character strings related to functions as well as keyitems can be specified as targets for 3D button conversion. For example, FIG. 30 shows an example of a 3270 screen in which an aidkeyexpression having a vertical arrangement is converted to a 3D button display. However, the area to be 3D button is limited to aidkeyterm, or the length of the area to be 3D button It is programmable to unify to the longest.

(4) 3D Button for Cursor Position Designation Type Area
Emissions reduction then, the remaining areas already except 3D button of rows in presentation space, if there is cursor-specifying further 3D-button. FIG. 12 illustrates a detailed processing procedure of the step 400. Hereinafter, this flow will be described.

When the comprehensive step 300 is completed, the process proceeds to the comprehensive step 400 via the route point R.

First, in step 402, one record (hereinafter, referred to as “inputtable field record”) is created for each inputtable field in the presentation space, and the presentation space is managed in inputtable field units. It can be so. As shown in FIG. 13A, the inputtable field record is
To store the start row (row: r), start column (column: c), and length (length: l) of the corresponding input-capable field, three fields are provided. FIG. 13 (b) shows input fields for one screen.
A set of records (hereinafter referred to as “inputtable field list”) is shown. Since the number of input-capable field records for one screen is not constant unlike the aid-key record created for each line, the list counts and holds the number of input-capable fields in the presentation space. It has a counter for storing. Those skilled in the art will recognize that the input space field list can be easily created by scanning the presentation space from the leftmost column of the first line. Note that the inputtable field list is also used in the next comprehensive step 500 (described later).

Next, in decision block 404, it is determined whether or not the user has designated the 3D button processing for the cursor position designation type. If the result is negative, the process proceeds to branch No, and exits from the comprehensive step 400 (passing point S). On the other hand, if the result is positive, the next step 40
Proceed to 6.

Next, in step 406, a set of keywords specified in advance is searched by scanning from the leftmost digit of the first line of the presentation space. Then, a record (keyword record) for storing the position of each found “keyword set” is created (hereinafter, a list of keyword records is referred to as a “keyword list”).
). Here, the “set of keywords specified in advance” is “cursor” as shown in FIGS.
And a combination of two or more words such as "Enter", and all the words constituting the combination exist on the same line or two consecutive lines (blank lines can be inserted). (Described above).

Next, in step 408, the inputtable field record relating to the row for which the 3D button processing has been performed is discarded from the inputtable field list. This is because such a line does not need to be converted into a 3D button again, and is considered as an extra record. The process corresponds to the r value of each inputtable field
This can be done by checking whether the flag of the aid-key record has been reset.

Next, in step 410, the "set of keywords" relating to the line for which the 3D button processing has been performed is discarded from the keyword list. The reason for discarding is the same as in step 408. This processing can be performed by checking the flag of the aid-key record corresponding to the line position of each “keyword set”.

Next, in a decision block 412, it is determined whether or not the "set of keywords" still remains in the keyword list as a result of discarding the extra records in step 410. If nothing is left, the cursor position designation type area does not exist in the 3270 screen being processed, so the process proceeds to branch No and exits from the comprehensive step 400 (via-point S). On the other hand, if the “keyword set” still remains, the process proceeds to the next step 414.

Next, in step 414, step 4
As a result of discarding the extra records at 08, it is sequentially checked whether or not the input-capable field records still remaining in the input-capable field list satisfy the condition of the cursor position designation type. The conditions are that lines having the same field structure are continuous (however, blank lines can be inserted) and that each line includes at least one input-capable field. Further, for a line satisfying the condition, it is checked whether the inputtable field does not extend over a plurality of lines and whether the field is a blank field that does not include a character string. In many cases, the user does not request the 3D button display if one input-capable field extends over a plurality of lines.
This is because it is not a target area to be made into a D button. Then, a 3D button processing is performed on the input-capable field in which all the conditions are cleared. Character strings are converted into 3D buttons.
The 3D button subroutine sends a request together with necessary information to the operating system 32, and the operating system 32 performs a predetermined drawing process (described above). In addition, for the row that has been subjected to the 3D button processing, the flag of the aid-key record is reset.

FIGS. 31 and 32 show examples of a 3270 screen in which the cursor position designation type area is converted into a 3D button display.

(5) Menu bar type area 3D button
Of then, if there is a menu bar on the top line of the presentation space, the 3D button of each menu in the menu bar. FIG. 14 illustrates a detailed processing procedure of the step 500. Hereinafter, this flow will be described.

When the comprehensive step 400 is completed, the process proceeds to the comprehensive step 500 via the waypoint S.

First, at decision block 502, it is determined whether or not the user has designated menu bar type 3D button processing. If the result is negative, the process proceeds to branch No, and the 3D button-making subroutine ends. On the other hand, if the result is positive, the process proceeds to the next step 504.

At decision block 504, a check is made as to whether there are two or more input-capable fields in the first line of the presentation space by referring to the input-capable field list. Next, decision block 5
At 06, by referring to the inputtable field list, it is determined whether or not there are 0 inputtable fields in the second line of the presentation space. A positive result of both blocks 504, 506 is a prerequisite for the presence of a menu bar type area in the presentation space. Thus, if a negative result is obtained in either block 504 or 506, proceed to branch No and skip the subsequent steps,
The 3D button subroutine ends. On the other hand, if both the results of the blocks 504 and 506 are affirmative, the process proceeds to the next step 508.

At decision block 508, the aid-ke
By referring to the flag of the y record, it is determined whether or not the first line, which is a candidate for the menu bar, is already a 3D button. If the result is affirmative, it is no longer necessary to process the first line, so the process proceeds to branch Yes and the next step 51
By skipping 0, the 3D button subroutine ends. On the other hand, if the result is negative, the process proceeds to the next step 510.

In step 510, all the fields that are not continuous with the last line ^* or the second line among the input-capable fields in the first row are converted into 3D buttons based on the input-capable field list. The 3D button conversion is performed by the 3D button conversion subroutine sending a request together with necessary information to the operating system 32 and the operating system 32 performing a predetermined drawing process (described above). At this time, the character string (the contents of the menu) to be originally displayed may be overwritten on the corresponding 3D button. FIG. 33 shows an example in which the menu bar is converted into a 3D button display. (*: According to the definition of the 3270 data stream, if there is no field allied butte at the upper left of the screen (first line, first digit), the upper right of the screen (last line, rightmost digit) This is because the attribute of the field is to be inherited.)

When the process of step 510 is completed, the process exits from the 3D button subroutine and returns to the main routine of the 3270 emulation program.

As described above, the old-fashioned two-dimensional 3270 screen is converted into a screen including a 3D button display. When the user performs a click operation on an arbitrary 3D button or the like, the operating system 32 can notify the 3270 terminal emulator 33 that the event has occurred (see section C-2).

D-3. Cancel key for screen conversion In the previous section, the processing procedure for converting the emulation screen, which is old-fashioned, to the three-button display screen has been described. However, the converted screen is not always preferable for the user. For example,
This is because the screen may become complicated and become difficult to see, or the conversion result may be different from the user's intention. For such a case, the 3270 terminal emulator 33 may have a "release key" for releasing the conversion screen or equivalent means. The user presses this key to display the original 32
The screen returns to 70 screens (that is, screens substantially the same as the contents of the presentation space). By pressing this key again, the converted screen may be displayed again.

The present invention has been described in detail with reference to the specific embodiments. However, it is obvious that those skilled in the art can modify or substitute the embodiment without departing from the spirit of the present invention. That is, the present invention has been disclosed by way of example, and should not be construed as limiting. In order to determine the gist of the present invention, the claims described at the beginning should be considered.

[0126]

As described above in detail, according to the present invention,
Text sent from the host application
The base-based and character-based screen information is converted into a GUI-like screen display (GUI-flavored hostscreen) without any modification or change of the program by the user, and the mouse-type input (Mouse-oriented operati) of the user is performed.
on) can be provided. Therefore, if the present invention is installed on a 3270 terminal emulator, the text-based 3270
Attention ID Key and the like existing in the screen can be converted into a 3D button display, and the usability of the user is greatly improved.

[Brief description of the drawings]

FIG. 1 is a diagram illustrating a personal computer used in the practice of the present invention.
1 schematically shows a hardware configuration of a computer (PC) 20.

FIG. 2 schematically shows a hierarchical configuration of software loaded on a main memory 2;

FIG. 3 is a diagram showing a 3 sent from the host system.
FIG. 3 schematically illustrates a flow for processing a 270 data stream by a 3270 terminal emulator.

FIG. 4 is a diagram schematically showing a flow for sending information input on a PC side as a 3270 data stream to a host system.

FIG. 5 shows a text-based 3270 screen as 3
It is the figure which showed in the flowchart the processing procedure for converting into the screen which displayed the D button.

FIG. 6 shows ai in a presentation space.
FIG. 4 is a diagram illustrating a data structure of a record (aid-key record) for storing information on dkeyexpression. More specifically, FIG. 6A shows a structure of an aid-key record alone (that is, each field constituting the record), and FIG. 6B shows a set of aid-key records for one screen. aid-
FIG.

FIG. 7 shows ai in a presentation space.
FIG. 9 is a diagram showing a detailed processing procedure of step 100 for searching for a dkeyexpression, that is, a processing procedure for creating an aid-key record for each row.

FIG. 8 is an illustration of one in a presentation space.
FIG. 8A is a diagram illustrating a state in which terms are sequentially extracted from a row. More specifically, FIG. 8A illustrates “PF1 = Help_PF”.
The figure which shows the r-th line comprised of the character string which consists of 2 = ... ",
FIG. 8B shows the terms “PF1”, “=”, “Help”, and “PF”.
It is a figure which shows that 2 "... is taken out from the r-th row with the information of each start digit.

FIG. 9 is a flowchart showing step 1 in the flowchart of FIG. 7;
It is the figure which expressed the closed loop formed from 06 to 112 in the form of a state transition diagram.

FIG. 10 is a diagram illustrating a processing procedure for converting the display of the 3270 screen. More specifically, FIG.
FIG. 7 is a diagram illustrating in detail a step 200 of finding an Attention ID Key arranged in a horizontal format on a presentation space by referring to a y record and performing a 3D button processing.

FIG. 11 is a diagram illustrating a processing procedure for converting the display of the 3270 screen. More specifically, FIG.
FIG. 6 is a diagram illustrating in detail a step 300 of finding an Attention ID Key arranged vertically in a presentation space by referring to a y record and performing a 3D button processing.

FIG. 12 is a diagram showing a processing procedure for converting the display of the 3270 screen. More specifically, a region arranged in a cursor position designation type on the presentation space is converted into a 3D button. FIG. 4 is a diagram illustrating step 400 in detail.

FIG. 13 is a diagram showing the structure of an input-capable field record created and used in step 400. More specifically, FIG. 13 (a) shows the structure of the record alone (that is, FIG. 13B is a diagram showing a set of input-capable field records for one screen (input-capable field list).

FIG. 14 is a diagram showing a processing procedure for converting the display of the presentation space, and more specifically, a process of converting a region arranged in a menu bar type on the presentation space into a 3D button. FIG. 5 is a diagram illustrating step 500 in detail.

FIG. 15 is a diagram illustrating an example of a 3270 screen provided by the host application. More specifically,
This is an example of a case where aidkeyexpressions are arranged horizontally. On the same screen, aidkeyterm is pfkeyitem type, p
fprefix is "PF", pfnumber is 1 ... 12, and delim2 is "_" (blank).

FIG. 16 is a diagram illustrating an example of a 3270 screen provided by the host application. More specifically,
This is an example of a case where aidkeyexpressions are arranged horizontally. On the same screen, aidkeyterm is pfkeyitem type, p
fprefix is "PF", pfnumber is 1 ... 12, and delim2 is "_" (blank).

FIG. 17 is a diagram illustrating an example of a 3270 screen provided by the host application. More specifically,
This is an example of a case where aidkeyexpressions are arranged horizontally. On the same screen, aidkeyterm is pfkeyitem type, p
fprefix is "F", pfnumber is 1 ... 12, and delim2 is "=".

FIG. 18 is a diagram illustrating an example of a 3270 screen provided by the host application. More specifically,
This is an example of a case where aidkeyexpressions are arranged horizontally. On the same screen, aidkeyterm is pfkeyitem type, p
fprefix is default, pfnumber is 1… 12, delim2 is "="
It is.

FIG. 19 is a diagram illustrating an example of a 3270 screen provided by the host application. More specifically,
It is an example of a presentation space when aidkeyexpression is arranged in a horizontal type. On the same screen,
dkeyterm is pfkeyitem type, pfprefix is default, p
fnumber is 1 ... 12 and delim2 is "-".

FIG. 20 is a diagram illustrating an example of a 3270 screen provided by the host application. More specifically,
This is an example of a case where aidkeyexpressions are arranged horizontally. On the same screen, aidkeyterm is pfkeyitem type, p
fprefix is "PF", pfnumber is 1 ... 12, delim1 is "/", delim
2 is "_" (blank).

FIG. 21 is a diagram illustrating an example of a 3270 screen provided by the host application. More specifically,
This is an example of a case where aidkeyexpressions are arranged horizontally. On the same screen, aidkeyterm is pfkeyitem type, p
fprefix is default, pfnumber is 1… 12, delim2 is "="
It is.

FIG. 22 is a diagram illustrating an example of a 3270 screen provided by the host application. More specifically,
This is an example in which horizontal and vertical aidkeyexpressions are mixed. On the same screen, the vertical type aidkeyte
rm is pfkeyitem type, pfprefix is "PF", pfnumber is 1 ...
12, delim2 is "_" (blank).

FIG. 23 is a diagram illustrating an example of a 3270 screen provided by the host application. More specifically,
This is an example of a case where a horizontal arrangement and a vertical arrangement are mixed.
On the same screen, horizontal aidkeyterm is pfkeyitem type, pfprefix is "PF", pfnumber is 1 ... 12, and delim2 is "_"
(Blank) and the vertical aidkeyterm is pfke
yitem type, pfprefix is "PF", pfnumber is 1… 12, deli
m2 is "_" (blank).

FIG. 24 is a diagram illustrating an example of a 3270 screen provided by the host application. More specifically,
This is an example of a case where a horizontal type array and a cursor position specification type array are mixed. On the same screen, horizontal aidkeyterm is pf
keyitem type, pfprefix is "PF", pfnumber is 1 ... 12, de
lim2 is "=".

FIG. 25 is a diagram illustrating an example of a 3270 screen provided by the host application. More specifically,
This is an example of a case where a horizontal type array and a cursor position specification type array are mixed. On the same screen, horizontal aidkeyterm is pf
keyitem type, pfprefix is default, pfnumber is 1 ...
12, delim2 is "=".

FIG. 26 is a diagram illustrating an example of a 3270 screen provided by the host application. More specifically,
This is an example of a case where a horizontal array and a cursor position designation type array are mixed. On the same screen, horizontal aidkeyterm is pf
keyitem type, pfprefix is default, pfnumber is 1 ...
12, delim2 is "=".

FIG. 27 is a diagram illustrating an example of a 3270 screen provided by the host application. More specifically,
This is an example of a case where a horizontal array and a cursor position designation type array are mixed. On the same screen, horizontal aidkeyterm is pf
keyitem type, pfprefix is "PF", pfnumber is 1 ... 12, de
lim2 is "=".

FIG. 28 is a diagram illustrating an example of a 3270 screen provided by the host application. More specifically,
It is an example of a menu bar type.

FIG. 29 is an example in which 3D button processing is performed on the 3270 screen shown in FIG. 22;

FIG. 30 is an example in which 3D button processing is performed on the 3270 screen shown in FIG. 23;

FIG. 31 is an example in which 3D button processing is performed on the 3270 screen shown in FIG. 24;

FIG. 32 is an example in which 3D button processing is performed on the 3270 screen shown in FIG. 27;

FIG. 33 is an example in which 3D button processing is performed on the 3270 screen shown in FIG. 28;

FIG. 34 is a diagram showing an example of a use mode of a personal computer. More specifically, FIG.
FIG. 11 is a diagram showing a state where the system is connected to a host system such as S9000 or S / 390 via a network and used as an input / output terminal (for example, a 3270 terminal) of a graphic application program running on a host mainframe. is there.

FIG. 35 shows a state in which a personal computer and a host system communicate communication data (for example, 3270 data stream) via a communication line (for example, a coaxial cable) capable of two-way communication. FIG.

FIG. 36 is a diagram illustrating an example of a screen provided by an operating system that supports bitmap display and multi-window.

[Explanation of symbols]

1 ... main CPU, 2 ... address / data bus, 3 ...
Memory bus, 4 ... Main memory, 5 ... ROM, 6 ...
HDD, 7: Video controller (VGA), 8: Screen buffer (VRAM), 10: LCD controller /
DA conversion circuit, 11 LCD, 12 CRT, 13 serial port, 14 parallel port, 15 communication adapter card.

──────────────────────────────────────────────────続 き Continuation of front page (56) References JP-A-5-289964 (JP, A) (58) Fields investigated (Int. Cl. ⁷ , DB name) G06F 3/14 370 G09G 5/00 510

Claims (8)

(57) [Claims] In a screen display conversion method for converting and displaying screen information, a character string whose display format is to be converted in the screen information (hereinafter referred to as Attention ID Key).
Key includes PFn, FPn, Fn, n, PAn and the like. However, a first stage of searching for a character string (hereinafter, referred to as an “aidkeyexpression”) that is treated as a unit including n (an integer of 1 to 24) based on a predetermined conditional expression;
A second stage of estimating a row including a plurality of aidkeyexpressions in one row as a row of a horizontal array, and PFn, FPn, F as Attention ID keys among the rows estimated as a horizontal array.
Aidkeyexpression containing n, n or PAn is included in one line.
A third step of negating the estimation for a row that includes the above and n is not arranged in the right order from left to right, and converts each Attention ID Key included in the row of the horizontal arrangement into a predetermined display format. A screen display conversion method, comprising: 2. A screen display conversion method for converting and displaying screen information, wherein a character string whose display format is to be converted in the screen information (hereinafter referred to as Attention ID Key).
The key includes PFn, FPn, Fn, n, PAn, and the like. However, a first stage of searching for a character string (hereinafter, referred to as an “aidkeyexpression”) that is treated as a unit including n (an integer of 1 to 24) based on a predetermined conditional expression;
a second step of determining whether or not a plurality of rows including only one aidkeyexpression is continuous, and estimating each continuous row as a row of a vertical array; and If there are two or more rows containing PFn, FPn, Fn or n, the third is to deny the estimation unless the positions of PFn, FPn, Fn or n from the left or right edge of the screen match in each row. If there are two or more rows that include PFn, FPn, Fn or n among the rows estimated to have the vertical type arrangement, if n of each row is not arranged from the top to the bottom of the screen in the normal order, A screen display conversion method, comprising: a fourth step of negating the estimation; and a fifth step of converting each Attention ID Key included in a row of the vertical array into a predetermined display format. 3. The method according to claim 2, wherein the predetermined conditional expression is delim0, aidkeyterm,
3. The screen display conversion method according to claim 1 , wherein the character string is composed of a character string of delim2 and function. However, delim0 is a character for defining between aidkeyexpressions, and a blank is used. Also,
The aidkeyterm is a character string itself to be converted into a screen display, and is a function key (where n is a positive integer) such as PFn, FPn, Fn, n, and PAn, and an Attention ID Key such as a Clear key and an Enter key. It consists of.
Also, delim2 is a character for linking aidkeyterm and the following function, and in addition to blanks, "=", "
-",": "May be used and may be used repeatedly. Function is a character string for explaining the function of aidkeyterm. 4. A text and a field attribute (however, a field attribute is a value for setting a field on a screen and defining each field as an input-capable field or an input-prohibited field). In a screen display conversion method for converting and displaying screen information, a first step of determining whether or not a combination of character strings specified in advance exists in one line or two consecutive lines in the screen information And if the result of the first step is affirmative, a second step of determining whether or not a plurality of consecutive rows having the same field structure formed by the field attribute are present; and a second step Converting the non-blank input-capable fields of each of the consecutive lines into a predetermined display format if the result of the above is affirmative. Conversion method. 5. The combination of character strings specified in advance is "C
5. The screen display conversion method according to claim 4 , wherein "ursor" and "Enter" (or a combination of words synonymous with these in other languages). 6. The screen display conversion according to claim 1, wherein the predetermined display format is a format in which a character string is surrounded by a frame and displayed with shading. Method. 7. A screen composed of text and field attributes (however, field attributes are values for setting fields on the screen and defining each field as an input-capable field or an input-prohibited field). In the screen display conversion method for converting and displaying information, the top row of the non-blank rows in the screen information is 2
First to determine whether or not the above input-capable fields are included
And if the result of the first step is affirmative, a second step of determining whether or not the structure of the field of the top row matches the immediately lower non-blank row; and And a third step of converting the top row to a predetermined display format if the result of the step is negative. 8. The predetermined display format is a format in which each input-capable field is surrounded by a frame and shaded, and a character string originally present on the input-capable field is displayed on the frame. The screen display conversion method according to claim 7 , wherein the format is characterized by the following.