JPH06103145A - Application system - Google Patents

Abstract

PURPOSE:To provide an application system which can facilitate its design, change, etc. CONSTITUTION:An application process 1, an editing system 3 and a display system 4 are designed independently of each other, and a frame 6, i.e., the data structure that is conventionally held by the corresponding process and the user information 7 are separately expressed as the objects and stored in a frame server executing machine 8 which is processed by an object pointing programming operation. When a user M carries out a certain processing, the user generated an application 10, an editor 11 and a viewer 12 which are equal to the object and represent the desired application, editing system and display system respectively in an object control part 9. Then these objects are connected to each other and controlled in the part 9 via a client object 13, and the means needed for execution of an application system are connected to each other. Thus a system is constructed. The objects can be optionally added to this system.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to an application system mounted on a workstation, a computer, a network system or the like for performing various processes.

[0002]

2. Description of the Related Art With the recent development of workstations, the types of usable media such as text (document) media, graphic media, table media, etc. have become diverse, and their functions are "word processor" and "spreadsheet". , Various drawing systems such as "drawing" have been developed. Moreover, even with the same type of function, an application having each feature is created so that the related processing can be easily performed according to the processing content. Each of the application systems executes an application process that executes various predetermined processes, a data storage unit that holds data that is the contents of the medium, user information, and exchanges commands with the user to transfer the data. An input / output processing system for editing and displaying is integrally configured. That is, the above data and the like, as well as the information necessary for execution and the information generated at the time of execution, are all retained / stored in the process so that they can move autonomously.

[0003]

However, in the above-described conventional application, the "function (application process)" portion for executing various processes handles (holds) "data" as well, so that it can be handled. The type of data and the ability to describe that data have been defined in the system built into the application system, and some of the existing functions can be changed to make it easier for users to use, or they can go one step further and introduce new data. It was not easy to add functionality or add new data types such as images and videos. Therefore, the user has to consider and use the functions of the given application, and select and use the one that can be most compromised in terms of greatest common divisor, and it is not always satisfactory (suitable for the contents to be processed). It didn't become an application system.

Further, as described above, since the editing processing method, the display form, and the usable function are built in the application system and cannot be modified, even if a different application system is used, Even for processes for the same type of function (media) such as document creation (word processing function), the specific processing method (operation method) is different, and operability deteriorates.

Furthermore, it is impossible to use a plurality of application systems in combination, let alone use the data used in the application system A and the input / output processing system used in another application system B. It is not possible to build a new system for yourself by taking out the necessary (user-friendly) part of the application system, such as processing.

Furthermore, since the conventional application system is created for a single user in a single machine (processing device), a plurality of users enter into one application system (multi-user system) and data I couldn't share it. Also, if you want to share data with multiple users, you have to assume that in advance and build a computer network system, which is extremely complicated and requires a long development period. Will end up.

The present invention has been made in view of the above background, and an object of the present invention is to easily design an application system and to allow a user to appropriately modify the contents of an existing application system or to make a plurality of modifications. Integrate application systems, add new functions, unify user interfaces,
An object of the present invention is to provide an application system in which a plurality of users can easily construct a multi-user system that is combined with one application system.

[0008]

In order to achieve the above object, in the application system according to the present invention,
The input / output means, the application execution means, the data storage means, and the means for storing the user information, which are designed independently of each other, are provided, and each of the above-mentioned means is connected by means of the connection means. The means to connect and build.

[0009]

OPERATION Among the respective means designed independently of each other, the one required by the user is selected, and the respective means are connected by the means for connecting them. As a result, an application system suitable for the content (function) required by the user is constructed. By separating each means individually and connecting them arbitrarily, it is possible to connect a plurality of applications, a plurality of users, and a plurality of data storage means (a plurality of types of media). That is, for example, a multi-user system is constructed by providing a plurality of means for storing user information and connecting them to the same application, and thus to the data storage means. Further, while one application is being used, another application is further connected. Also, by connecting the same input / output means at that time, it is possible to perform processing with the same operation content when editing or the like.

[0010]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT A preferred embodiment of an application system according to the present invention will be described in detail below with reference to the accompanying drawings. First, the outline of one embodiment of the present invention will be described.
The application process, which is the built-in application execution means, data, user information, and the input / output processing system are separated. Then, as shown in FIG. 1, the application process 1 is independently designed and mounted on the application execution machine 2. Further, the input / output processing system (user interface) is composed of an editing system (editor) 3 for further finely separating and inputting, and a display system (viewer) 4 for outputting, which is also designed independently from the above. And is mounted on the user machine 5. Furthermore, the data structure (referred to as a "frame (object)" in the present example) 6 and the user information 7 that the application process conventionally has are expressed as object data and executed / processed by object-oriented programming. It is stored in the object management unit 9 in the frame server execution machine 8.

When the user (user) M actually tries to execute an application system, an application object (AP) 10 representing a necessary application process and an editor representing an editing system and a display system. An object (E) 11 and a viewer object (V) 12 are generated in the object management unit 9 and necessary objects are combined in the object management unit 9 so that an application required to execute the application system is created. Process 1, editing system 3, display system 4, frame (data) 6
And the user 7 are connected to form one system.

Further, in this example, the connection relationship between the user 7 and the application process 1 (application object 10) separated as described above is defined, and the frame 6 used by the application 10 is defined.
Editing system 3 (editor 1) according to (media type, etc.)
1) A client object (cl) 13 as a connecting means for managing the display system 4 (viewer 12) is arranged.

That is, the application process 1, the editing system 3 and the display system 4 and the objects 10, 11 and 12 representing each of them are connected via the system control unit 14 in the frame server execution machine 8. , Knowing the location of the other party to each other, for example, when the user issues a data change command via the editing system 3, the editing system 3 notifies the editor object 11 representing itself that A change order will be sent. Then, the object 11 that received the change command
Is connected to the frame 6 to execute the change instruction.
A change command is issued to predetermined object data in the.

Further, when a display command (for example, display correction) comes to the viewer object 12 as a result of executing a certain command, the viewer object 12 knows the location of the display system 4 of the connection destination. Therefore, the contents of the received display command are transmitted to the display system 4, the display system 4 in the user machine 5 performs predetermined processing according to the command, and displays the predetermined contents on a display unit such as a CRT (not shown). Will be displayed.

As described above, various processes are executed by communication between objects in the object management unit 9,
The result is sent to various actual machines 2 and 5 arranged outside the object management unit 9 to execute the application system.

Then, as described above, each machine 2, 5
Knows only the existence of objects that represent itself, and can operate the system by connecting objects and communicating between objects without knowing the specific existence of other parts that make up the application. it can.

As a result, by connecting an object represented by itself to an arbitrary object, a predetermined application process is connected to a user, and data handled by the application process is also freely connected by connecting to a predetermined frame. can do. In addition, by connecting a plurality of users to one application system, and further by using an editing system that is easy for the user to use, the combination can be changed as appropriate to perform multi-user, multimedia, and unified user interfaces. be able to.

In this example, the editing process 3 and the display process 4 mounted on the user machine 5 basically send the command given from the editing process 3 to the frame server execution machine 8 side. , After the prescribed processing,
A control signal based on the processing result is sent to the display system process 4 to perform a predetermined display process. But,
For example, in the case of a process that does not affect the frame (data structure) in the frame server execution machine 8, such as a dragged display of a graphic or a display of a mouse cursor, it is necessary to perform high-speed processing. And the display system process 4 are connected to each other so that they can be processed as a feedback command for direct data communication between both processes.

Although the application machine 1, the user machine 5 and the frame server execution machine 8 are shown as independent machines in the above embodiment and FIG. 1, the present invention is not limited to this. Any machine can be integrated. That is, for example, usually, the application machine 2 and the frame server execution machine 8 are often configured on the same machine (the application process 1 and each object are mounted on the same machine), and further, a user machine is You may have all the objects and, if necessary, the application process. In such a case, as described later, when a plurality of users share an application or an object (data), when the object is changed, another user machine connected via the network If the same contents are changed for a certain object, the frame server execution machine can be eliminated.

Further, in the above-mentioned modification, it is premised that each machine is connected by a computer network using wired / wireless as a communication means in order to enable multi-user. All the system configurations may be installed on one machine. In this case, the communication means is, for example, a keyboard,
All means for performing communication between a mouse and the like, the computer main body (CPU), a bus inside the computer, and communication performed on software (means for transmitting / receiving data inside a normal computer etc.) ).

Next, details of the frame server execution machine 8 shown in FIG. 1 for executing the above-mentioned functions and actions will be described. This machine 8 is operated by an object-oriented language written in C ++, and more specifically,
Necessary objects are made to operate by a prototype instance type object system in which they are generated by inheritance from other original (parent) objects.

First, the system control unit 14 issues a command from the outside (application process 1, editing system 3, display system 4) to the correct object, or issues a command to each of the above-mentioned representative objects to the related external device. The system control unit 14 and each external means are connected by interprocess communication.

The frame 6 is configured as an object (the same applies hereinafter) in an object-oriented language, and as shown in FIG. 3, a Create interface 6a, an Attach interface 6b, a Detach interface 6c, and the like. A new object (data) generation command, an addition command, a deletion command, and the like are sent to predetermined processing units via various interfaces.

That is, the create interface 6a
A new object duplication command is sent via the object duplication unit 6d together with the prototype name which is the duplication source.
Is given to the new object connection unit 6e via the attach interface 6b, and a pointer to the object to be deleted (disconnected) via the detach interface 6c is added to the object release unit 6f. To be given to.

Each of the processing units 6d to 6f is connected to the object list 6g, stores pointers of newly created and added objects in the object list 6g together with their object names, and also provides information about objects to be released. It is designed to be deleted from the list 6g. Furthermore, the object duplication unit 6d
In addition, the new object connection unit 6e is also connected to the prototype list 6h so that the pointer to the object (prototype) stored in the list 6h can be read.

Here, in the prototype list 6h, a primitive object that is concrete data that can be handled in this frame, that is, if this frame or a graphic medium is used, primitive data such as "circle" or "triangle". Or Rilcompo (R) for connecting frames and primitive data
An object serving as a prototype of the elCompo) object 6i (specifically, a pointer to the object) is stored. In the prototype stored in the prototype list 6h, all prototypes managed by the frame are determined and registered at the same time when the prototype of the frame object is generated in this example, but additions and changes are made after the generation. You may do it.

It should be noted that the lil compo object 6i has substantially the same function as the client object 13, that is, in this example, the frame object 6 does not directly connect to the primitive object 6j, but the primitive It has a role of entering between the object 6j and the frame object 6 itself and setting (connecting) both. Therefore, the internal data structure of the relevant lil compo object 6i is a pointer to the connected upper object (frame object 6 in this example),
A pointer to a connected lower object (primitive object 6j in this example) and various data of XY coordinates, which is the position of the lower object on the frame, are stored. That is, the created specific data (object 6j) is stored in this rilcompo object 6i.

On the other hand, the object list 6g manages new objects created in accordance with the object creation command. Specifically, the primitive objects created at the same time when the new object 6j is duplicated are managed. A pointer to the fill component object 6i that manages is stored.

As described above, the frame object 6 in this example is a set (aggregate) of predetermined primitive data objects, and is not a direct connection management of such objects, but a relation object that is a relation object. Since the connection is made via the component object 6i, the frame side only knows the existence position of each object on the frame, and does not care about the specific contents of the primitive data. Furthermore, since the frame itself is also an object, it is necessary to fit a frame object that handles another medium (for example, a graphic) into a predetermined position of a frame object that handles a medium (for example, a document) using the related object (nested structure ( It can be easily done). In other words, since the basic frame object only knows the pointer to the Lil compo object, etc., handle it in the same way even if the actual connection destination is a primitive data object or the frame object. You can

The specific functions of the above processing units will be described. First, the object duplication unit 6d
As shown in FIG. 3, a primitive object that matches the given prototype name is read from the prototype list 6h, and it is inherited as a parent to duplicate a new object 6j. Then, based on the data stored in the prototype list, the rally compo object 6i is duplicated, and the ruri compo object 6i is
The generated primitive object 6j and the main frame object 6 itself are set, and the frame 6 and the object 6j are connected. After setting, the pointer to the lil compo object 6i is set in the object list 6g.

That is, to explain with a concrete example, assuming that this frame is for graphic media and a "circle" is to be drawn, first, the editing system 3 for graphic media is used.
A create command is issued from the (editor object 11) to the frame object 6, and at that time, the name "Elli" of the prototype object of "Yen" is used as an argument.
pse ”is passed. Then, the frame 6 finds an object with the name "Ellipse" in the prototype list 6h, duplicates the object, and further duplicates the Lil compo object,
Then, the pointer of this frame and the pointer of the object duplicated by Ellipse are set (registered), and then the pointer of the duplicate of the lil compo is registered in the object list 6g of the frame.

Further, the concrete function of the new object connecting unit 6e is to judge whether or not the object to be added indicated by the given pointer is stored in the prototype list 6h as shown in FIG. However, if it does not exist, an error will occur because the object cannot be handled by this frame object. On the other hand, in some cases, the rilcompo object is duplicated, the input object and the frame itself are set in the duplicated rilcompo object, and after the setting, the rilcompo object is set in the object list. .

Further, as shown in FIG. 5, the concrete function of the object releasing unit 6f is to judge whether or not the given object is stored in the object list. In some cases, the setting of the frame for the Lil compo object corresponding to the object is invalidated, and the object stored in the object list is deleted.

The user object 7 has a set name interface 7a, a set password interface 7b, a check password interface 7c, and a set cut buffer interface 7 as shown in FIG.
d, the name of the user who joins the new application system, the password and the setting of the cut buffer, the collation command, and the like are sent to a predetermined processing unit through various interfaces such as d and the get cut buffer interface 7e.

That is, the set name interface 7
The user name is given to the user name setting unit 7f via a,
Here, the process shown in FIG. 7 is performed, and a new user name is registered in the connected user name holding unit 7g.

Also, the set password interface 7
The password name to be set via b is given to the password setting unit 7h, the process shown in FIG. 8A is performed here, and the password of the user who uses this user object is connected to the password holding unit 7i. Is set. Then, in the case of subsequent use, the password is given to the password collating unit 7j via the check password interface 7c. In this collating unit 7j, the password given based on the process shown in FIG. Judgment whether or not it matches the one stored in the holding unit 7i and outputs the result (reply)
It is supposed to do.

Further, the frame to be set is given to the cut buffer registration unit 7k via the set cut buffer interface 7b, and here, the frame is set as shown in FIG. 9 (A).
The process shown in (1) is performed, and a new frame is registered in the connected cut buffer 7l. By providing the cut buffer 7l, even if a plurality of users connect to the same application and process the same data, each user can change the data stored in the cut buffer 7l. Will be processed.

Also, during various processing, a necessary frame is given to the cut buffer reading unit 7m via the get cut buffer interface 7e, and the cut buffer 7 is processed based on the processing shown in FIG.
The frame pointer stored in l is returned as a return value.

On the other hand, the application object 10
As shown in FIG. 10, a request join (RequestJoin) interface 10a or the like is provided as an interface, and a pointer to a user object is stored in the user interface via this interface 10a.
It is given to the application combination processing unit 10b.

Then, the user / application connection processing unit 10b requests the existing predetermined client object 13 to copy a new client object for managing the connection between the user and this application according to the flowchart shown in FIG. To do. When receiving a pointer to a new client object that has been duplicated in the client object, the application itself and the given user object are set in the new client object and registered in the client table 10c.

On the other hand, the editor object 11 is shown in FIG.
2, various event commands for editing are given to the internal event dispatcher 11b via the DoMenuItem interface 11a, the contents of the given event command are judged, and predetermined processing units 11c, d, e Is sent to the object (data), and various kinds of modification processing and the like are performed on the object (data).

That is, the system installed in the editing system 3 (for example, the X window system, the ET ++ system, etc.) does the DoMen for the editor object 11.
Issue uItem. In this issue, if the figure processing system is used, the thickness of the line used for drawing is set using the menu (a small window is opened at that location by clicking the mouse and displayed in that window). This is done when changing, and more specifically, when the line thickness "medium" is selected in the menu, the X window is the mouse button of the mouse (connected to the editing system 3) that is the input device. Knowing that the object has been released, examine the operation target (object), and edit the object 1
The ID of the target object and the processing content are passed as an argument to 1 (issue of DoMenuItem). Then, the event dispatcher 11b starts a predetermined function based on the given argument. Note that the specific processing function in each processing unit is as shown in FIG.
As shown in (B) and (C), and although not shown in the other drawings, such respective processes are implemented.

Further, as shown in FIG. 14, in the viewer object 12, a predetermined message from the object group side is changed (Changed) interface 1.
Data relating to an object to be displayed, a redisplay command, and the like are sent to a predetermined processing unit via various interfaces such as 2a and the update interface 12b.

That is, the change interface 12a
The address (pointer) of the object to be displayed is sent to the change table registration unit 12c via the, and the pointer is registered in the change table 12d therein as shown in FIG. 15 (A). Further, when a display (redisplay) command is given to the update processing unit 12e via the update interface 12b after the registration, the processing target in the change table 12d is shown therein as shown in FIG. It is determined whether or not the object is registered, and if there is (not empty), a predetermined calculation process is performed based on the data registered in the table 12d to process the data, and then the display data is displayed on the screen. The table 12d is cleared while being sent to the control unit 20. The screen control unit 20 redisplays the display screen according to the given display data. Then, the screen control unit 20 displays X
It is created using a window, ET ++, and is installed in the display system 4 and the editing system 3 which are user interfaces.

On the other hand, the client object 13 is
Set as shown in FIG. 16 (SetApplUser)
Interface 13a, Add Entry (AddEnt
ry) interface 13b, get entry (Get)
Entry interfaces 13c and the like are sent to a predetermined processing unit, for example, application user names and entry commands relating to the frame / editing system / displaying system correlation that are coupled (combined) with each other.

That is, management is performed by this client object 13 via the set interface 13a,
Data (pointers) relating to the user object 7 and the application object 10 to be combined are given to the internal application / user setting unit 13d, and in accordance therewith the flow of FIG. 17, the pointers are changed to the application holding unit 13e and the user holding unit. Set to 13f. As a result, the application object 10 and the user object 7 are linked.

The media used by the application object 10 (pointer 6 to the frame object), the editing system (pointer to the editor object 11) and the display system (to the viewer object 12) for processing the frame. A table (entry) made up of three sets of (pointer) is given to the adding unit 13g via the add entry interface 13b, where the processing of FIG. 18 (A) is performed and stored in the entry table 13h. Further, an entry consisting of the above-mentioned predetermined combination is given to the reading unit 13i via the get entry interface 13c together with the read command, where the processing of FIG. 9B is performed, and the predetermined value stored in the entry table 13h. The entry is sent back.

By the way, although not specifically shown in FIG. 1, in the object management unit 9, a system object 21 which is an application for a user (user) to log in, and the user (user) concerned. Until the actual login, the public object 22 that is a user object paired with the system object 21 exists.

More specifically, as shown in FIG. 19, the system object 21 is configured such that a login command is given to the login processing section 21b from the user machine 5 via the request joint interface 21a. Then, in the login processing unit 21b, as shown in FIG.
The process shown in 0 is performed. That is, the password input from the user machine is verified by referring to the user / password correspondence table 21c held by the user.
If it is correct, a duplication command is issued to the user object 7, a new user object 7 is generated, and then a client object (which will be described later in detail) between the system object 21 and the public object 22 (details will be described later). , The client between them becomes a prototype for all clients,
(The default edit system / display system for all frame types is stored), and a new user object created by logging in to the newly created client object and this system object 21 itself. Is set, and the pointer to the generated client object is stored in the client table 21c of the system object 21.

On the other hand, as for the public object 22, as shown in FIG. 21, an application generation command is given to the public initialization unit 22b via the public interface 22a, and a predetermined process is performed there according to the flow shown in FIG. Is done. That is, a connection command is issued to the system object 21 to connect to the public object 22 itself. Then, the new application object 10 obtained by copying from the application object 10 is connected to the public object 22 itself, and then the entry table (table of correspondence between frames / editing system / display system) is initialized and Prepare the parent (prototype) of that entry and finish initialization.

Next, an outline of an example of starting the system will be described. When a user (user) logs in to the system from the user machine 5, the user is represented in the object management unit 9 of the frame server execution machine 8. The user object 7 is generated. Then, when the application process 1 is activated on the application machine 2, it is sent to the object management unit 9 and the application object 10 is generated. When the user wants to use the application process 1, the user object 7 is connected to the application object 10. At this time, the client object 13 is generated, and the two objects 7 and 10 are connected via the client object 13.

When the data in the frame 6 is edited by the application process 1, the application process 1 issues a connection command, the command is transmitted to the application object 10 via the system control unit 7, and the application object which received the command. 10 connects to the frame 6. Then, the client object 13 generates the editor object 11 and the viewer object 12 according to the type of the frame 6. When the editor object 11 and the viewer object 12 are generated, the system control unit 7
Activates the corresponding editing process 3 and display process 4 on the user machine 5.

More specifically, when the system is started up, first, the prototype objects of the respective objects are (1) client object, (2) application object, (3) system object, (4) user object, (5 ) Generated in the order of public objects. At this time, it is only created as a prototype, and the connection between each object is not made.

When the fifth public object is generated, a generation command is given to the public object 22 in accordance with the inter-object message flow shown in FIG. 23. A connection request is made to the system object according to the flow shown in. Then, the system object 21 that has received the connection request
Issues a duplication command to the client object (prototype) and sets the system object 21 and public object 22 in the newly created client object A.

Next, the system object 21 processes according to the flow shown in FIG. 20, that is, issues a prompt from the console screen, and the user (user)
Request login. Then, when the user inputs the correct user name and password, the system object 21 duplicates the above user object (prototype) and generates the user object 7 corresponding to the logged-in user. In this way, when the corresponding user object 7 is created, the client and the object A are parented to the client and a new client object B is created, and the user object 7 and the system object 21 are set therein. Then, a predetermined entry table is set in the client object B.

Similarly, in accordance with the inter-object message flow shown in FIG. 24, a connection request is made from the public object to the application object, and based on this, the client C is duplicated with the client A as the parent, and the client C Application object 10 and public object 2
2 is set, and a predetermined entry table is set in the client object C. Then, through such processing, a connection structure as shown in FIG.

From this state, further processing is performed in accordance with the inter-object message flow shown in FIG. 26, and the client object D newly obtained by copying the client object B as a parent
The application object 10 and the user object 7 are set, and as a result, as shown in FIG.
A connection structure of objects as shown in (B) is obtained,
A user (user) is connected to an application object 10 (application process connected to it) via a user object 7 representing it,
The application is a client object D
The user interface (editor object (editing system) / viewer object (display system)) registered in can be used and processed.

Furthermore, after each object is generated as described above, the object data can be modified. Therefore, for example, by rewriting the definition of the editor object 117 viewer object 12, the input / output system or the like desired by the user or the input / output system suitable for the application can be obtained.

Now, the connection between the application object and the frame object that occurs during the generation and connection of the above objects will be described with reference to FIG.
From the state as shown in (A) (connection in which the application object and the frame object are not connected),
By performing processing according to the inter-object message flow shown in FIG. 8, the connection structure of objects as shown in FIG. 27B, that is, the application object 10 and the frame object 6 are connected, and further the frame object 6 is The viewer object 12 and the editor object 11 are sequentially connected.

Note that, on the upper side of the frame object 13, a lil frame (RelFrame) object 23 and a top frame (TopFrame) object 24 are sequentially connected, and the lil frame object 23 is the same as the above-mentioned lil compo object. Similarly, the upper top frame object 24
For connecting the frame object 6 and the subordinate frame object 6 and having pointers to both objects 24 and 6, and pointers to the editor object 11 and the viewer object 12 connected to the frame object 6. . It should be noted that the top frame object 24 is the only object that exists in the present system, and is sequentially connected in tree form from the top frame object to the subordinate objects.

By appropriately connecting the objects of the application object frame as described above between predetermined objects, as shown in FIG.
Different applications (1) and (2) can be connected to the same frame (A) 6A and used (data sharing). Although an example of the entry table 13h which is a part of the internal structure of the client object 13 is shown in the figure, the frame A0, the editing system A0 and the display system A0 in the table have the same type as the frame object A. Each prototype is an actual process for the frame object A, and is performed based on an entry consisting of the frame A, the editing system A, and the display system A.

By the way, although the client object connected to the application (2) 10B is not shown in FIG. 29, for the frame A, the entry (frame) for the frame A stored in the client object (D) 13D. A / Edit system A / Display system A) is duplicated and stored in the entry table in the client object connected to the application B.

Therefore, even if different applications are used, the same frame (media data type) is used.
Can be done using the same user interface. Since the content of the entry can be modified after the client object is generated as described above, the same user interface may be used for the same frame as described above in consideration of the ease of processing, or The user application may be appropriately configured according to the application process, and any system configuration can be adopted.

As shown in the figure, the application object (1) is connected to two frame objects (A) and (B). It is conceivable to connect the frame object (B). In such a case, a new frame is generated and an entry is added to the new frame according to the flowchart shown in FIG.

As long as the user interface is shared as described above, the user object 7 and the client object 13 do not necessarily have to be separately arranged as in the above-described configuration, and both objects may be integrated. . That is, the same effect can be achieved by separating both of these integrally configured objects and the application object (separating the frame object) and appropriately copying and connecting each object. Although not specifically shown, such a configuration is also included.

On the other hand, as described above, each object formed separately is appropriately duplicated and generated, and
By connecting predetermined objects, a new application system as shown below can be constructed.

That is, as an example, as shown in FIG. 31, one application process (application object 10), that is, the application object 10 includes a plurality of users (user objects (A), (B) 7A, 7B) and the data in the frame object 6 connected to the application object 10 can be shared by a plurality of such users, and a multi-user system can be constructed.

A concrete forming procedure will be described. When an application object (1) 10A, a client object (B) 13B and a user object (1) 7A are set, a new user connection will be made. Then, the user object (1) 7A is duplicated to generate the user object (2) 7B, and the client object (B) 13B is duplicated to create a new client object (F) 13
Generate F. Then, by setting the application object (1) 10A and the user object (2) 7B in the new client object (F) 13F, the system configuration shown in the drawing is obtained.

With such a configuration, the multi-user system is provided as described above, and in this example, each user, application, etc. are individually generated,
At the time of this design, it is possible to design assuming a single user without considering the number of connected users and the number of applications, etc., so the system design is simple, so it is relatively easy to build a multi-user system. can do. Since each object is independent, each user object can be dynamically combined and separated from all application objects.

Further, when a plurality of (two) users are already connected to one application as shown in FIG. 31 and an attempt is made to connect another frame to the application, the flow is the same as that shown in FIG. It can be easily connected through the process of. That is, regardless of the number of users connected, frames can be added by the same process, and this addition process can be performed by only one user, and the frame after addition can be used by other users. Therefore, operability and processability are improved.

As another example, as shown in FIG. 32, one user object 7 may be connected to a plurality of application objects (1) and (2).
That is, since the connection between the application object and the user object is processed according to the flow shown in FIG. 29, the client object (D) 13D of the application object (1) 10A generated from the system 21, for example, is ) 13B is connected to the user object 7 that is generated as a prototype, while the client object (E) 13E of the application (2) 10B that is also generated has the prototype of the client object (B) 13B. That is, when a new application is started, it is obtained by duplicating the client object (B) 13B between the system and the user, so that it is stored in each of the generated client objects (B) and (E). The entry table for frame / editing system / display system is also a prototype, that is,
In this example, the three clients are the same. Therefore, the same user interface is guaranteed for different applications and the operability is improved.

In the above example, the prototype instance type object-oriented language using C ++ is used, but a class instance type object-oriented language may also be used, and the language used is C ++.
It is not limited to +.

Next, an actual application (use) example will be described. That is, using a graphical window system such as X window, a text frame for creating a sentence as a medium and a draw (Dra) for drawing an image.
w) It is assumed that a frame and a table frame for creating a table are prepared.

That is, the user starts the application A after logging in, and then connects the text frame to the application A. Then, according to the entry in the entry table in the client, the editing system (text editor) and display system (text viewer) corresponding to the text frame are automatically generated and connected, and the user opens a new window and Now you can create sentences.

Next, the user selects a menu in the text editor to connect the table frame as one object in the text frame, and adds an editing system (table Editor) and display system (table viewer) are connected. As a result, due to the function of the table viewer, the table frame TF is displayed at the place where the user clicked the mouse in the window displaying the text viewer (see FIG. 34). That is, the frame A shown in FIG. 29 corresponds to a text frame, and the frame B corresponds to a table frame.

By the way, the user activates another application B to perform another job, and connects the draw frame to the application B. Then, similarly to the above, according to the entry in the entry table, a predetermined draw editor and draw viewer are generated and connected to the draw frame, and the window for drawing is displayed by the action of the draw viewer. Then, the user can connect the table frame in this application B as well as the above, and thereby the drawing (figure) and the table as shown in FIG. 351 are displayed. Then, according to the principle shown in FIG. 32, the text data in the application B can be used and processed by the same editing method and the same display format as those of the text data of the application A.

Next, if another user (2) connects to the above-mentioned application (A) 10A from another machine via a computer network, the application A will already have the text by the original user (1) as described above. The frame 6a and the table frame 6b are connected, and the data used there (obtained as a result of processing by the original user (1)) is stored.

Therefore, when another newly connected user (2) connects to the application A, the text frame is referred to by referring to the entry in the entry table of the client created for that user (1). 6
An editing system and a display system are connected to A and the table frame 6B, respectively. Then, the contents of the frames 6A and 6B connected to the application A are automatically displayed in the window W2 by the action of the text viewer object 11A and the table viewer object 11B of the new user (2) (see FIG. 36). .

At this time, the same contents are displayed in the same form in the windows W1 and W2 of the new user (2) and the original user (1). Then, one of the users receives the frame 6
When the contents of A and 6B are changed, other users are also connected to the same frame 6A and 6B, and therefore the same contents as the changed contents are displayed. However, if the viewer editor is modified after connection as described above, the contents of data are the same although the display form is different.

[0080]

As described above, in the application system according to the present invention, each means constituting the system is designed independently of each other, so that each design amount is small and the relationship with other is important. Because it is designed without
It is relatively easy and easy to create. An application system suitable for the contents required by the user is selected from the means thus designed, and the means for connecting the means are selected by the user. Can be built. Further, since each means is individually separated and can be arbitrarily connected, for example, if a plurality of means for storing user information are provided and connected to the same application and data storage means, a plurality of users share the same data. It will be. Further, even if another application is further connected while using one application, if the same input / output means is connected at that time, the user interface (operability such as editing) is different even if the application is different. Unity is guaranteed. Furthermore, by connecting another data storage means in which another type of media is newly stored to a data storage means in which one medium used by an application is stored, addition of usable media, that is,
The user can easily upgrade the system version.

[Brief description of drawings]

FIG. 1 is a block diagram showing a preferred embodiment of an application system according to the present invention.

FIG. 2 is a block diagram showing an internal structure of a frame object.

FIG. 3 is a flowchart showing a part of the function thereof.

FIG. 4 is a flowchart showing a part of the function.

FIG. 5 is a flowchart showing a part of the function.

FIG. 6 is a block diagram showing an internal configuration of a user object.

FIG. 7 is a flowchart showing a part of the function.

FIG. 8 is a flowchart showing a part of the function.

FIG. 9 is a flowchart showing a part of the function.

FIG. 10 is a block diagram showing an internal configuration of an application object.

FIG. 11 is a flowchart showing a part of the function.

FIG. 12 is a block diagram showing an internal structure of an editor object.

FIG. 13 is a flowchart showing a part of the function.

FIG. 14 is a block diagram showing an internal structure of a viewer object.

FIG. 15 is a flowchart showing a part of the function.

FIG. 16 is a block diagram showing an internal configuration of a client object.

FIG. 17 is a flowchart showing a part of the function thereof.

FIG. 18 is a flowchart showing a part of the function.

FIG. 19 is a block diagram showing an internal configuration of a system object.

FIG. 20 is a flowchart showing a part of the function.

FIG. 21 is a block diagram showing the internal structure of a public object.

FIG. 22 is a flowchart showing a part of the function.

FIG. 23 is a diagram showing a part of an inter-object message flow for explaining an operation at startup of the application system according to the exemplary embodiment of the present invention.

FIG. 24 is a diagram showing a part of an inter-object message flow for explaining an operation at startup of the application system according to the exemplary embodiment of the present invention.

FIG. 25 is a diagram showing an example of a connection structure of an application system of the present invention.

FIG. 26 is a diagram showing a part of an inter-object message flow for explaining an operation at startup of the application system according to the exemplary embodiment of the present invention.

FIG. 27 is a diagram showing an example of a connection structure of an application system of the present invention.

FIG. 28 is a diagram showing a part of an inter-object message flow for explaining an operation at startup of the application system according to the exemplary embodiment of the present invention.

FIG. 29 is a diagram showing an example of a connection structure of an application system of the present invention.

FIG. 30 is a flow chart diagram for explaining the operation.

FIG. 31 is a diagram showing an example of a connection structure of an application system of the present invention.

FIG. 32 is a diagram showing an example of a connection structure of an application system of the present invention.

FIG. 33 is a flow chart diagram for explaining the operation.

FIG. 34 is a diagram showing an example of an operation situation.

FIG. 35 is a diagram showing an example of an operation situation.

FIG. 36 is a diagram showing another example of the system configuration according to the present invention.

[Explanation of symbols]

DESCRIPTION OF SYMBOLS 1 Application process (application execution means) 2 Application execution machine 3 Editing system (input / output means) 4 Display system (input / output means) 5 User machine 6 Frame object (data) 7 User object (user information) 8 Frame server execution machine 9 Object management unit 10 Application object (application executing means) 11 Editor object (input / output means) 12 Viewer object (input / output means) 13 Client object (joining means)

─────────────────────────────────────────────────── ───

[Procedure amendment]

[Submission date] January 18, 1993

[Procedure Amendment 1]

[Document name to be amended] Statement

[Name of item to be corrected] 0023

[Correction method] Change

[Correction content]

The frame 6 is constructed as an object in an object-oriented language (hereinafter the same).
As shown in FIG. 2 , a new object (data) generation command, an addition command, a deletion command, etc. are respectively generated through various interfaces such as a Create interface 6a, an Attach interface 6b, and a Detach interface 6c. Are sent to a predetermined processing unit.

[Procedure Amendment 2]

[Document name to be amended] Statement

[Correction target item name] 0055

[Correction method] Change

[Correction content]

Next, the system object 21 processes according to the flow shown in FIG. 20, that is, issues a prompt from the console screen, and the user (user)
Request login. Then, when the user inputs the correct user name and password, the system object 21 duplicates the above user object (prototype) and generates the user object 7 corresponding to the logged-in user. In this way, if the corresponding user object 7 is generated, the client <br/> down the door object A and inheritance as parents to generate new client object B, user object 7 and the system object transfected 21 And are set, and a predetermined entry table is set in the client object B.

[Procedure 3]

[Document name to be amended] Statement

[Name of item to be corrected] 0058

[Correction method] Change

[Correction content]

Furthermore, after each object is generated as described above, the object data can be modified. Therefore, for example, by rewriting the definitions of the editor object 11 and the viewer object 12, it is possible to make the input / output system of the user's liking, or the input / output system of which the application is good.

[Procedure amendment 4]

[Document name to be amended] Statement

[Correction target item name] 0078

[Correction method] Change

[Correction content]

Therefore, when another newly connected user (2) connects to the application A, the text frame is referred to by referring to the entry in the entry table of the client created for that user ( 2 ). 6
An editing system and a display system are connected to A and the table frame 6B, respectively. Then, the contents of the frames 6A and 6B connected to the application A are automatically displayed in the window W2 by the action of the text viewer object 11A and the table viewer object 11B of the new user (2) (see FIG. 36). .

 ─────────────────────────────────────────────────── ─── Continuation of the front page (72) Inventor Takashi Suzuki 47 Yotsuzuka-cho, Minami-ku, Kyoto-shi, Kyoto Sanvoa Kyoto 405

Claims (9)

[Claims] 1. An input / output unit, an application executing unit, a data storing unit, which are designed independently of each other,
An application system having means for storing user information, and constructed by connecting the respective means by a connecting means storing association information of the respective means. 2. An independently designed input / output unit, an application execution unit, and a data storage unit, and each unit is connected by a connecting unit that stores association information of each unit. An application system that is constructed by storing user information in the connecting means. 3. By changing the information stored in the connecting means, the connection of the predetermined means connected is eliminated, or another means of the same kind as the predetermined means among the respective means is connected. The application system according to claim 1, which is constructed by additionally connecting. 4. A plurality of means for storing the user information are provided, and the means for storing the plurality of user information are connected to the same application execution means and the same data storage means, and mutually connected to the data storage means. The application system according to any one of claims 1 to 3, wherein various processes such as a change can be performed on the stored data. 5. The input / output unit is configured to be separated into an editing system for inputting and a display system for outputting, and various types of application executing unit, data storing unit, etc. are provided between the editing system and the display system. The application system according to any one of claims 1 to 4, comprising a path for transmitting a command signal via a means, and a path for directly communicating between the editing system and the display system. 6. An application execution means, a data storage means, and a means for storing user information, which has a plurality of at least one kind and is sharably connected to other means. The application system according to any one of 1. 7. The means for connecting to the data storage means, and the means for storing the user information as necessary, are each configured by an object, and an object representing the input / output means and the application execution means is defined. 7. The structure according to claim 1, wherein the object is constructed and constructed by appropriately connecting the respective objects.
The application system described in the section. 8. The objects are managed on a server machine, and the server machine, the machine on which the input / output unit is mounted, and the machine on which the application executing unit is mounted are connected via various communication units. The application system according to any one of claims 1 to 7, which is connected. 9. The server machine according to claim 8, a machine including an input / output unit, and a machine including an application executing unit, wherein a plurality of predetermined machines are the same machine. Item 8. The application system according to item 8.