JPH096578A - Graphic user interface - Google Patents

Abstract

PURPOSE: To increase the execution speed of a server and to relieve the burden of a client program, for the construction of a GUI. CONSTITUTION: This interface performs as the graphic user interface the control of a graphic by a callings from plural client programs 31 to 3n . Between the client programs and a server 2, plural GUI (graphic user interface) servers 61 to 6n having macros receiving the high level requests and interpreting the requests as low level requests are provided. The low level requests from these GUI servers are interpreted by the server 2 and the displays/operations on a display 5 are performed through a CPU 4 for display. The GUI servers generate/preserve the macros by the object-oriented class hierarchies for which the succession mechanism of objects of definitions and actual conditions are utilized.

Description

Detailed Description of the Invention

[0001]

FIELD OF THE INVENTION This invention relates to graphic user interfaces (GUIs) in computer software.

[0002]

2. Description of the Related Art A GUI enables various operations on a computer by designating image representations and menu items on the screen, and provides an environment for handling a direct interaction with the computer.

To implement this GUI, as shown in FIG. 7, a graphics server 2 is installed in a computer main body 1.
The client programs 3 _{1 to} 3 n make low-level calls to control all graphics.

Image display by the server 2 is performed by a display CPU.
Icons and the like are displayed on the display 5 through 4.

[0005]

Conventionally, a client-server system is adopted as a graphic interface displayed on a display, but one server is provided for many clients.

For this reason, the server does all the low-level calls, and if the number of low-level calls increases, the execution speed drops extremely.

Further, since the server has only a low-level display routine (drawing a line, setting a dot, writing a character, etc.) as a protocol, this results in a burden on the client program, and an executable file is not created. growing.

At the same time, the client program has a long compile and link time due to the large or large number of libraries.

An object of the present invention is to provide a GUI with an increased server execution speed.

Another object of the present invention is to provide a GUI that reduces the load on the client program.

[0011]

In order to solve the above-mentioned problems, the present invention provides a graphic user interface for performing graphic-related control by calling from a plurality of client programs by a client-server system, wherein each client program is A plurality of GUI servers each having a macro for accepting a high-level request from the server and interpreting the request into a low-level request;
It is characterized in that a server for interpreting a low-level request from the I server and controlling the graphics and a display CPU are provided.

Further, the GUI server is characterized in that the macro is generated and stored by an object-oriented class hierarchy utilizing an object inheritance mechanism of definition and actual condition.

[0013]

By providing a GUI server that receives a high-level request between the client program and the conventional server, the client program can make a high-level request.

By generating the definition and substance of the GUI server macro by the object-oriented class hierarchy,
Enables differential programming.

[0015]

FIG. 1 is a system configuration diagram showing an embodiment of the present invention. Portions figure differs from FIG. 7 is that in which a plurality of GUI servers 6 ₁ ~6n with a high level of processing as a macro.

The GUI servers 6 _{1 to} 6 n receive high level display / operation requests from the clients 3 ₁ to 3 n, interpret these requests as low level requests, and give them to the server 2. Conversely, return the low-level execution result from the server 2 as the processing result of the high level to the client 3 ₁ 3n.

As a result, since the GUI servers 6 _{1 to} 6 n can store high-level display / operation,
Each client 3 ₁ 3n may be prepared program by a high level, it is possible to reduce the load during GUI execution. At the same time, the compile and link time of the client routine is significantly reduced.

FIG. 2 shows a command sequence for registering macros in the GUI servers 6 ₁ to 6 n. C1 is a command for creating a window and registering a new macro for adding a label character string, a one-line edit window, etc. in the GUI server. For example, a window called "file selection" is generated.

C2 is a command for adding to the macro already registered by the command C1. For example, a new button is added to the macro "select file".

C3 is a command for assigning an operation to a part. For example, when the "select" button is pressed, the selected file name is taken out based on the ID of the list box and the button action of calling the file open function is set.

Macro registration is completed by repeating these commands C1 to C3. An example of this macro registration is shown in FIG. On the screen D1 of the figure, a case where a "filter" label is added as a label character string addition in the command C1 and one line of edit window is added by the edit window addition command is shown. Similarly, on screen D2, command C2
The case where a select button and a cancel button are added is shown. The screen D3 shows a macro completion screen displaying directories and files after the button action is set, and is registered in the GUI server.

As another macro generation method, differential programming can be performed by utilizing an object-oriented class hierarchy and utilizing an inheritance mechanism in the form of definition and actual condition.

FIG. 4 shows an example of GUI component registration using a class hierarchy. In the class hierarchy, the file selection B and the file selection C are provided in the lower class of the file selection A, and the file selection D is provided in the lower class of the file selection B. FIG. 5 illustrates the class inheritance relationship of each file selection.

While these classes become definitions, their instances become entities and instances are created based on the classes. Also, an instance object is generated by setting a specific attribute in the attribute field.

The class structure of FIG. 4 is stored in the GUI server, and the client program sends a message to the GUI server to generate an instance, and the GUI
The server internally creates a real instance object.

The macro registered in the GUI server by the above method can be converted into a text format and output to a file, and the output file can be used as an input to the GUI server.

Further, in the system configuration provided with the GUI server, as shown in FIG. 6, the GUI server, the server and the display CPU can be provided in a one-to-one relationship. in this case,
Compared with the system of FIG. 1, the load on the server 2 is reduced and higher speed processing becomes possible.

[0028]

As described above, according to the present invention, a plurality of GUI servers having macros for accepting high level requests and interpreting them as low level requests are provided between the client program and the server. effective.

(1) The GUI server can store high-level display / operation, and the client program can reduce the load at the time of execution.

(2) The high-level display / operation routine is G
Since it is stored in the UI server, the compile and link time of the client routine is greatly shortened.

(3) The high-level display / operation routine is G
Since it is stored in the UI server, the display size, position, color arrangement, etc. can be freely changed later. Also, the order of operations and the functions assigned to operations can be changed interactively. Furthermore, in order to change the display and operation, the client program is changed to eliminate the need for compilation and linking.

(4) When the GUI server uses the object-oriented class hierarchy to register macros, differential programming is possible.

(5) By saving the macro in a file in a text format, the saved file can be reused as an input without repeatedly creating the macro.

(6) When each GUI server is assigned to a multiprocessor for graphic processing, extremely high speed processing becomes possible.

[Brief description of drawings]

FIG. 1 is a system configuration diagram showing an embodiment of the present invention.

FIG. 2 is an example of a macro registration command in the embodiment.

FIG. 3 is an example of a macro registration screen in the embodiment.

FIG. 4 is an example of generating a macro by a class hierarchy according to the embodiment.

FIG. 5 is a class inheritance relationship macro in the embodiment.

FIG. 6 is a system configuration example of another embodiment.

FIG. 7 shows a conventional system configuration example.

[Explanation of symbols]

DESCRIPTION OF SYMBOLS 1 ... Computer main body 2 ... Server 3 ₁ , 3n ... Client 4 ... Display CPU 5 ... Display 6 ₁ , 6n ... GUI server

Claims (2)

[Claims] 1. A graphic user interface for performing graphic-related control by calling from a plurality of client programs by a client-server method, accepting a high-level request from each of the client programs, and converting this request into a low-level request. A graphic user interface comprising: a plurality of GUI servers having macros for interpretation; a server for interpreting a low-level request from the GUI server to control graphics; and a display CPU. 2. The graphic user interface according to claim 1, wherein the GUI server generates and saves the macro by an object-oriented class hierarchy using an object inheritance mechanism of definition and actual condition.