JPH06259312A - Network type document processor using two-dimensionally defined tree structure - Google Patents

Abstract

PURPOSE:To easily process a network type document by extracting a two-dimensional tree structure from a network structure and using the two-dimensional tree structure. CONSTITUTION:This document processor consists of a document storage part 21 such as a hard disk where a document structure is stored, a document control part 22 which controls the document structure, an input part 23 such as a keyboard and a mouse for handling inputs from outside the processor, a field reference part 24 which selects a field to be displayed on the basis of the information inputted from outside the processor, a history tree control part 25 which performs control such as the generation of a tree structure consisting of history nodes and candidate nodes according to the reference, etc. In this case, a user when advancing operation along the network structure interactively generates and displays a tree structure showing the process of the reference to the nodes. Then the tree structure wherein constitution units are logical units as logical gatherings of documents and related in reference units prescribing the reference relation between the logical units.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a network type document processing apparatus for processing and outputting a network type document by using a tree structure defined secondarily.

[0002]

2. Description of the Related Art As a document structure, there is a technique called hypertext as a conventional technique relating to a document editing apparatus that handles a network structure in which logical units of a document are associated with each other by a reference relationship. Hypertext technology is described, for example, in the document “Jakob Nielsen, Hypertex.
t & Hypermedia, HBJ Publishing, 1
991 ".

(A) Prior Art Related to Reference History In the conventional art as described above, when searching for a hypertext, (1) I cannot remember how I got to that node. (2) I don't know how to go back to the node I saw a while ago. It has been pointed out that such problems will occur. These problems are collectively referred to as the lost child problem. In order to solve these problems, a device for holding a reference history and presenting it to the user has been invented. P. 27 and P
129-130, two prior art techniques are described.
These will be briefly described.

One is to display the names of the referenced nodes as a list in order of time. You can return to the previously referenced node by selecting the displayed name with your pointing device.

The second is to display the display images of the displayed nodes in time order and reduce the size of the displayed images, with reference to that point. Also in this example, by selecting the reduced display with the pointing device, it is possible to return to the node referred to before.

As described above, in the prior art, the above problems are solved by providing a means for displaying the histories arranged in time order and returning to the previously referenced node from the displayed history. However, considering why it is necessary to go back to the previously referenced node, it can be seen that the prior art is not a satisfactory solution. That is, it is often necessary to return to the previously referenced node in order to find another node candidate that has not been selected in the search path up to that point and, in some cases, to start the search again. For this purpose, if you want to go back to the previously referenced node, what you need is not the time sequence to reach the node, but what kind of candidate you have selected to reach the node. It is the progress of the work. However, the prior art shows the temporal order in which the nodes are reached, but does not show the progress of the search work. For example,
The search shown in FIGS. 4 (a) to 10 (a) provides a display of the reference order along the time as shown in FIG. 4 (c), which is useful for expressing the progress of the search work. Not a list.

(B) Prior Art Related to Allocation Processing In a document processing apparatus which handles a document structure in which logical units of a document are associated with each other, a processing called allocation processing is necessary in order to display the document on a hard copy or screen. . In the prior art, for example, by allocating the tree structure shown in FIG. 18 to the structure shown in FIG.
The allocation result shown in can be obtained. Such a tree-structured logical structure is handled by a conventional technique called a structured document. With structured documents, it is possible to obtain very high allocation results.

For example, Japanese Patent Laid-Open No. 3-147059 discloses an allocation processing technique in ODA which is an international standard for structured documents. In this prior art,
Processing is performed according to the description of a document allocation template called a common allocation structure, which is defined by ODA to control the allocation result of the entire document. The common allocation structure enables description of a very advanced template including repetition and selection.

Further, the document "Makoto Murat"
a and Koichi Hayashi, For
matter Hierarchy for Strru
ctured Documents, EP92, C
Cambridge University Pres
S, 1992 "(Japanese Patent Application No. 3-200987), a document is allocated using a partial allocation process and a partial allocation template. This prior art does not allocate the whole document using one complicated program and complicated template, which was done in the previous technology, but combines a simple small program and a simple small template hierarchically. It realizes allocation processing. This method is also ODA
It is possible to obtain an allocation result similar to the common allocation structure of.

A document having the structure shown in FIG. 18 can be expressed as shown in FIG. 20 as an example. In this figure, logical units are represented as streams indicated by arrows. A stream is a sequence of basic units such as characters, and the basic unit includes a reference unit. The name enclosed in a rectangle indicates a reference unit, and a stream, which is another logical unit, is referenced from a specific position of the stream. In this way, the tree-structured logical structure is expressed as a hierarchical stream.

The partial allocation means is a program. The one that executes this program is called a formatter. The formatter is realized in the form of a subroutine being executed, a process executing parallel execution, or an object in an object-oriented language. The formatter has the role of allocating one stream. By forming the formatter hierarchical structure shown in FIG. 21, it is possible to allocate the entire logical structure while exchanging partial allocation results.

FIG. 42 shows an outline of the above-mentioned conventional allocation algorithm. This is adopted as a part of this embodiment as described later. Figure 2
2 and FIG. 23 show one process of the allocation process.
The formatters each refer to the partial allocation template and perform allocation processing according to the rules described therein. In this example, for example, a template having the following rules is referenced. The formatter 1 (1) pours the character string of the label in a large font with the center aligned. (2) An area obtained by subtracting the top, bottom, left, and right margins from the remaining area is secured as an area into which the allocation result of the basic element or the lower formatter in the stream is poured. The formatters 2 and 3 (1) pour the label character string in a small font with left alignment. (2) An area obtained by subtracting the top, bottom, left, and right margins from the remaining area is secured as an area into which the allocation result of the basic element or the lower formatter in the stream is poured.

The document structure that can be handled on the computer is not limited to the tree structure. It can handle logical structures of more general network structures. The network structure can be expressed more freely than the tree structure, but it is more difficult to handle. FIG. 24 shows a simple example of the network structure. This structure is not a tree structure because it forms a loop. This structure is shown on the display in Figure 25.
You can refer to and edit it by displaying as.
However, since the conventional high-level allocation processing targets a tree structure, the allocation processing cannot be applied as it is.

Therefore, in searching the document structure, a method is proposed in which a subtree structure in the network structure is extracted by stopping the further search when a loop is detected, and an allocation process is performed for the structure. Came to. This method is disclosed, for example, in Japanese Patent Laid-Open Nos. 63-165968 and 4-171575. A subtree structure obtained from the network structure of FIG. 24 by this method is, for example, as shown in FIG.
This example is a result of detecting a loop depending on whether or not a search has already been performed in the depth-first search procedure. There are several types of search procedures and loop detection methods, and their modification results in different subtree structures. In any case, in the method of the conventional technique, if a node to start the search is selected, one subtree structure is extracted according to the determined mechanism.

However, since a computer arbitrarily selects one tree structure from the structure in which a plurality of tree structures may be originally extracted, the partial tree structure desired by the user is not necessarily allocated. . Further, it is not possible to apply a high-level layout process using the layout template realized in the conventional structured document. This is because the user cannot define an appropriate allocation template because it is not known in advance what kind of tree structure will be extracted.

(C) Prior Art Concerning Display of Structure In an apparatus for handling a document structure in which logical units of a document are associated with each other, means for displaying / editing the document structure and the logical unit is provided. Except for very simple cases, it is not possible to display / edit all the information that the document structure has at one time. Therefore, a means for organizing and displaying / editing information at a certain point of view and a means for displaying / editing a partial structure are used.

The former means includes, for example, a device called a browser, which organizes and displays the reference relationship in logical units (for example, Japanese Patent Laid-Open No. 40559/1992). By using this device, it becomes easy to understand the whole picture of the document structure. However, this device cannot display from which position in the content the reference is made. Also, it is difficult to display the network structure with this device.

An example of the latter means is a device using a card type interface. In this device, one window corresponds to one logical unit and displays the content and the reference unit embedded in the content. With this device, the relationship between the content and the reference unit can be clearly expressed. This device also has the advantage of being able to display the network structure. For example,
A network structure as shown in FIG. 49 (a) is shown in FIG. 49 (b).
As in (c) and (d), it is possible to freely search using a card-type interface. However, in this method, only one logical unit can be displayed in one window, and the reference relationship can express only one depth. Therefore, it is difficult for users to understand the whole picture of complicated network structure.

For this reason, there has been a need for means capable of displaying a structure at an arbitrary depth while being associated with the content.
As one of these, a device called an outline editor has been invented (Japanese Patent Laid-Open No. 3-148754).
For example, as shown in FIG. 51, the structure shown in FIG. 50A can be displayed at an arbitrary depth while being associated with the contents. In each of (a), (b), (c), and (d), the icon indicating the reference unit is selected with the pointing device, and "Open" is selected from the menu as shown in FIG. 50 (b).
An arbitrary subtree structure can be displayed by instructing "close". Furthermore, it is possible to easily display all of the substructures by instructing "open all".
Considering each rectangular area for displaying a logical unit as a window, the outline editor displays a partial structure of a document by a hierarchical structure of windows. However, since the outline editor limits the document structure to the tree structure, it cannot be applied to the network structure as it is. For example, if you have a loop, you cannot perform an "open all" operation.

[0020]

Conventionally, a simple structure has been secondarily generated from a network structure to simplify the handling of the network structure. Since the structure itself, the structure generation method, or the structure management method was too simple, it was difficult to express necessary information, allocate the data, and display the windows in a proper hierarchy. In order to solve this problem, an object of the present invention is to provide a network-type document processing device that appropriately generates and manages a tree structure as a secondary structure.

It is another object of the present invention to provide a network type document processing apparatus which can display a secondary tree structure in a user-friendly manner so that the user can easily operate a network type document. To do.

In order to solve the above-mentioned problem of the prior art relating to the reference history, it is important to clarify the progress of the search operation as to what kind of candidate was selected to reach the node. However, the prior art shows the temporal order in which the nodes are reached, but does not show the progress of the search work. An object of the present invention is to solve the above problems and to obtain a document processing apparatus that can express the progress of a search operation. According to the present invention, this is achieved by managing the reference history as a tree structure that indicates the reference order in the depth direction and the node candidates in the width direction, and presents it to the user.

In the conventional allocation processing technique for the network structure, as described above, since the computer arbitrarily selects one tree structure from the structure in which a plurality of tree structures may be originally extracted, it is not always necessary. The subtree structure desired by the user is not allocated, and the advanced allocation processing using the allocation template realized in the conventional structured document cannot be applied. SUMMARY OF THE INVENTION It is an object of the present invention to solve such a problem and to obtain a document processing apparatus capable of selecting a necessary part of a network structure and performing allocation processing. According to the present invention, this is achieved by providing means for generating a tree structure from the components of the network structure according to an instruction from the user and applying the allocation process to the generated tree structure.

The hierarchical structure of the window is one of the secondary structures that reflect the partial structure of the data and enable the operation using the structure. However, the conventional method of generating a hierarchical structure of windows is for displaying a tree structure and is not suitable for a network structure. The present invention creates a window hierarchy for displaying an arbitrary subtree structure in a network structure.
An object is to obtain a network-type document processing device that can be managed.

It is another object of the present invention to provide a network type document processing apparatus capable of clearly associating a plurality of secondary tree structures, expressing all the structures in a unified manner, and displaying them simultaneously.

[0026]

The network type document processing apparatus of the present invention defines a tree structure as a secondary structure from the network structure, and performs processing using the tree structure. Conventionally, it has been performed to generate a secondary simple structure from a network structure to simplify the handling of the network structure, but since the structure itself, or its generation method, or its management method is too simple,
It was difficult to express the necessary information, perform the allocation process, and display the appropriate hierarchy of windows. The present invention can solve these problems.

A network type document processing apparatus according to the present invention (claim 1) comprises a document management means (11 in FIG. 1 and 22 in FIG. 2) for managing a document structure and a logical unit reference means (FIG. 1-12, 24) of FIG. 2, and a history tree structure management for managing a reference history of the logical unit as a tree structure in which the referred logical unit and the reference unit that is another candidate at the time of the reference are associated with each other. Means (13 in FIG. 1, 25 in FIG. 2)
Is equipped with. The document structure is configured by associating predetermined constituent units. The structural unit of the document structure is a logical unit that is a logical unit of the document, and the relationship between the structural units is performed by the reference unit that defines the reference relationship between the logical units. The logical unit reference means specifies a reference unit in the logical unit according to a user's instruction and selects a logical unit to be referred to (241 in FIG. 2), and a logical unit for displaying the selected logical unit. Unit display means (24 in FIG. 2)
2) consists of In the present specification, the reference unit is an element of a logical unit that serves as an index for referencing another logical unit from a logical unit, and the logical unit is a logical unit in a document such as a chapter or paragraph in a document. It represents a group of people.

The conventional history list is also one of the secondary structures, but since the structure is too simple, it is not possible to express all the information necessary for history management. In the present invention, the history is represented by a tree structure, so that the history of work progress can be represented.

A network-type document processing apparatus according to the present invention (claim 2) is an apparatus for processing a document structure formed by associating predetermined structural units with each other, and the structural units are logical units of a logical unit of a document. A document management unit (151 in FIG. 15 and 162 in FIG. 16) that manages a document structure in which logical units are associated with each other by reference units that define the reference relationship between the logical units, and an allocation process target in the document structure. Allocation target tree structure management means for managing the allocation target tree structure configured by the following logical units or reference units (see FIG. 15).
153, and 165 in FIG. 16). The allocation target tree structure management means generates an allocation target tree structure from the components of the network structure by a simple instruction from the user. The tree structure to be allocated is a secondary tree structure, but in the conventional technique, the generation method was too simple, and therefore the user could not obtain the necessary structure. In the prior art, a tree structure for allocation is generated by starting a search starting from a node selected by a user and stopping by detecting a leaf or a loop, but it is possible to specify an allocation target required by the user. could not. According to the present invention, the user can interactively generate the tree structure of the allocation target, and the allocation process using it can be facilitated.

According to the network type document processing apparatus of the present invention (Claim 3), in the invention (Claim 2), a tree structure allocating means for allocating a tree structure to be allocated (152 in FIG. 15, 166 in FIG. 16). It is equipped with. The tree structure allocating means can collectively apply the allocation process to the tree structure. No complicated work is required unlike the prior art (for example, Japanese Laid-Open Patent Publication No. 1-134561) in which a node to be allocated must be sequentially selected during the allocation process.

A network-type document processing apparatus according to the present invention (claim 4) is an apparatus for processing a document structure formed by associating predetermined constituent units with each other, and the constituent units are logical units of a logical unit of a document. Therefore, a document management unit (441 in FIG. 44, 452 in FIG. 45) for managing the document structure in which the logical units are associated with each other by the reference unit that defines the reference relationship between the logical units, and a part or the whole of the document structure are displayed Is a display target tree structure represented by a hierarchical structure, and the display target tree structure managing unit (442 in FIG. 44, 442 in FIG. 44, which manages the display target tree structure in association with the structure in the displayed document structure).
45 of FIG. 45). The display target tree structure is a secondary tree structure, but in the prior art, it was managed only as temporary information. Therefore, in order to get the same display as the previous time when editing is interrupted and restarted,
It was necessary to repeat the work for tracing the hierarchy. Since the display target tree structure management means of the present invention manages the display target tree structure and the structure in the displayed document structure in association with each other, when the editing is interrupted and restarted, the tree structure up to the last time is edited. The structure of the display can be retained and the display before the interruption can be obtained in one step.

According to the network type document processing apparatus of the present invention (Claim 5), in the invention (Claim 4), the logical unit indicates display information (FIG. 46 (a)).
(B) 463, 468), and the display target tree structure management means generates or changes the display target tree structure from an instruction from the user and display information. There is a window tree as the display target tree structure (claim 6). The display information is, for example, that the logical unit is displayed or is displayed in a single window, or is displayed or is displayed in the logical unit display window that is hierarchically combined. Information such as whether there is. Since the display target tree structure management means manages the display target tree structure so as to reflect it in the data in the document structure, when the editing is resumed, the hierarchical combination of the windows which is the display target tree structure at the end of editing is displayed. Can be restored.

A network-type document processing apparatus according to the present invention (claim 7) is an apparatus for processing a document structure formed by associating predetermined structural units with each other, and the structural units are logical units of a logical unit of a document. Therefore, the document management means (601 in FIG. 60, 612 in FIG. 61) for managing the document structure in which the logical units are associated with each other by the reference unit that defines the reference relationship between the logical units is defined secondarily from the document structure. Secondary tree structure management means (60 in FIG. 60) for managing the closed tree structure.
3, 615 in FIG. 61) and a secondary tree structure display means (602 in FIG. 60, 616 in FIG. 61) for displaying the secondary tree structure in association with the document structure or another secondary tree structure. It is equipped with. According to the present invention, since the secondary tree structure is managed and displayed in association with the document structure and other secondary tree structures, the state of each tree structure can be grasped in a unified manner.

According to the network type document processing apparatus of the present invention (Claim 11), in the invention (Claim 10), a combination of states relating to a plurality of secondary tree structures is used as a display rule of a logical unit or a reference relation. Correspondence and secondary tree structure display means apply a display rule in displaying the document structure to display the plurality of secondary tree structures in association with each other. The secondary tree structure includes an allocation target tree structure (formatter tree), a display target tree structure (window tree), a history tree structure (history tree), or any combination thereof (claim 12). .

[0036]

【Example】

(First Embodiment) FIG. 2 shows the configuration of a network type document processing apparatus according to the first embodiment. The present embodiment interactively creates and displays a tree structure representing the progress (history) of reference of a node when a user proceeds with work in a network type document. A tree structure representing the history is called a history tree. The history tree is composed of history nodes. In order to generate a secondary tree structure from the data structure of a network-type document, in the present embodiment, a reference that defines a reference relationship between logical units is a logical unit that is a logical unit of a document. A document structure in which logical units are associated with each other is used. The logical unit is called a field, and the reference unit is called an anchor. Further, a basic unit such as a character that constitutes a logical unit is called a primitive. The primitive also includes an anchor. It should be noted that the data representation by this field and anchor is not essential in the present invention. Data representation by nodes and links is also acceptable.

As shown in FIG. 2, the network-type document editing apparatus of this embodiment includes a document storage unit 21 such as a hard disk for storing the document structure, a document management unit 22 for managing the document structure, and an external device. An input unit 23 such as a keyboard and a mouse that handles input, a field reference unit 24 that selects a field to be displayed based on information input from outside the device, and a history of field reference is expressed as a history tree. A history tree management unit 25 that performs management such as generation of a tree structure using history nodes and candidate nodes, a history tree display generation unit 26 that generates a window displaying the history tree structure, and a display unit 27 such as a display device that performs display. It has and.

Further, the document management unit 22 is composed of an anchor management unit 221 for managing an anchor and a field management unit 222 for managing a field.

The anchor management unit 221 manages the information of the anchor such as storing, retrieving, and updating the document storage unit 21. The anchor has a data structure as shown in FIG. 14B, and includes an anchor identifier 144 for identifying the anchor, a label 145 for displaying the anchor, and a pointer 146 to a field referred to by the anchor. ing. Field management unit 222
Stores field information in the document storage unit 21,
Management such as taking out and updating. The field has a data structure as shown in FIG. 14A, and a field identifier 14 for identifying the field
1, a field type 142 representing the kind of collective relation defined by the field, and a list 143 of primitives contained in the field. When the primitive in the list is an anchor, it is a pointer to the anchor and a list of basic elements of content data. A field can represent a character string or a sequence of chapters, for example, by maintaining an order relation between primitives. At this time, the field type is stream, which matches the stream used in the prior art. In addition to the order, the fields can hold a two-dimensional positional relationship, for example.

The field reference unit 24 selects the anchor or the field referred to by the anchor according to the instruction from the input unit 23.
And a field display generation unit 242 that generates a window displaying the selected field.

FIG. 3 shows a data structure of a tree structure generated secondarily in this embodiment. (A) shows a history node, and (b) shows a reference relationship between a history node and an anchor. ing. The data structure of the history node is shown in Figure 3.
As shown in (a), the history node identifier 31 for identifying the history node, the corresponding anchor 32 that is a pointer to the corresponding anchor, and the anchor in the field referred to by the corresponding anchor A child history node 33 that is a list of pointers to history nodes corresponding to the referenced ones, and a candidate that is a list of pointers to anchors in the field referenced by the corresponding anchors that have not been referenced in the past. Anchor 3
It consists of four. The anchor and field data structures are the same as in FIG. 14 (b) described above.

This embodiment is shown in FIGS. 4 (a), 5 (a), 6 (a), 7 (a), 8 (a), 9 (a), and 10 (a). A document processing apparatus characterized in that it manages a history in a network-type document search operation using a card-type interface, which is exemplified in [hereinafter, abbreviated as FIG. 4 (a) to FIG. 10 (a)]. is there. In the present embodiment, the reference history is represented as a tree structure, and the history of FIG.
It is displayed as shown in FIG.

FIGS. 4 (a) to 10 (a) show how data is searched for in the window displayed in the display. That is, open the window of the node named "Description of the invention" and select the "Claims" icon (Fig. 4).
(A)), the window is opened (FIG. 5 (a)). Select the "Claim 2" icon (Fig. 5
(A)), the window is opened (FIG. 6 (a)). The "Claims" and "Claims 2" windows are closed, and the "Explanation of invention" window is returned to (Fig. 7 (a)). Select the "Example" icon (Fig. 7 (a)),
Open the window (Fig. 8 (a)). Fig. 15 Select the icon of "Example 2" (Fig. 8
(A)), a window is opened (FIG. 9 (a)). Select the "Claim 2" icon (Fig. 9
(A)), a window is opened (FIG. 10 (a)).

As an example of displaying history information corresponding to each operation in FIGS. 4A to 10A, FIGS.
In FIG. 4C, a list of reference histories, which is a conventional technique, is shown in FIG.
10B to 10B show display examples of the history tree in this embodiment. In the display example of the history tree according to the present embodiment of FIGS. 4B to 10B, the rectangle corresponding to the referenced field and the line segment indicating the reference relationship are drawn with thick lines. The thin lines are the other candidates presented at the time the reference was made. On the other hand, FIG.
In the prior arts of (c) to (c) of FIG. 10, only a list of reference histories is shown, and nothing else is shown about other candidates that were presented when the reference was made. in this way,
In this embodiment, it is possible to understand the progress of the work, which could not be expressed by the conventional display. In the present embodiment, the actually-referenced one is displayed at a higher position, but the upper and lower sides may be determined in the order within the field.

Next, the operation of this embodiment will be described with reference to the flow charts shown in FIGS. In this example, in the window displaying the fields,
Move your mouse cursor over the icon that represents the anchor,
Refer to the corresponding field by clicking. For example, in FIG. 4A, by clicking the icon “Claim” 42 indicating an anchor in the window 41 displaying the field with the mouse, the window 51 displaying the corresponding field (see FIG. ))open. In this way, a field composed of 52, 53, and 54 anchors is referred to corresponding to 42 anchors.

When there is no anchor icon corresponding to the clicked position (for example, FIG. 10A), a "close" menu (not shown) can be selected. In addition, clicking outside the window allows you to select the "Exit" menu. Makes the field displayed in the window containing the cursor the current field.
Note that you cannot select the first anchor from the window. It is specified by the user when the program is started.

FIG. 11 shows a flow of the field reference algorithm showing the contents of the processing of the field reference unit 24.

(Start) (Step S1110) The user moves the cursor through the input unit 23 to indicate one anchor icon. For example, in FIG. 4, the anchor icon 42 is clicked. Then, the anchor field selection unit 2
41 identifies the clicked anchor from the anchors managed by the anchor management unit 221 in the document management unit 22 based on the click signal and the position information.

(Step S1111) The field display generation unit 242 acquires the data of the field corresponding to the specified anchor from the field management unit 222, generates a window for displaying the field, and displays it through the display unit 27. To display.

(Step S1112) The history tree generation algorithm (A) (FIG. 12) is called. As will be described later, the field referred to by the history tree management unit 25 is managed in the form of a history tree and displayed by the history tree display algorithm (FIG. 13).

(Step S1113) Step S111
1. Move the cursor into the window displaying the field generated in 1.

(Step S1114) If the cursor position is
Check if the field is inside or outside the window that displayed it.

[In case where the field is displayed in the window] When the cursor is in the window where the field is displayed, a mouse click input is awaited, and the following process related to anchor selection is performed. (Step S1115) The field displayed in the window with the cursor is set as the current field.

(Step S1116) Whether or not the mouse has been clicked is determined. If the mouse has not been clicked, the process proceeds to step S1114, and if it has been clicked, the process proceeds to step S1117.

(Step S1117) The anchor field selection unit 241 performs an anchor selection process corresponding to the click. (Step S1118) It is determined whether the anchor selection has failed.

(Step S1119) When the selection of the anchor does not fail, that is, when the click is made on the anchor icon, it is determined whether or not the field corresponding to the anchor is already displayed.
If the field is not displayed, step S111 is performed to display the field and register it in the history tree.
Move to 1.

(Step S1120) When the field is displayed, the cursor is moved into the window in which the field is displayed, and the process proceeds to step S1114.

(Step S1130) Step S111
If it is determined in step 8 that the selection of the anchor has failed, that is, if the click is made when the cursor is located at a position other than the anchor icon, is the click selecting "close" in the menu? Determine whether or not. If the result of the determination is that "close" has not been selected in the menu, the process moves to step S1114 to wait for the next click input.

(Step S1131) If "close" is selected as a result of the determination, the window is closed.

[Outside the window displaying the field] (steps S1140 and S1141) step S111
When the cursor is at a position outside the window displaying the judgment result field of 4, the mouse click is monitored, and if there is a click, it is judged whether or not it is a menu end selection, and an end selection is made. If so, the field reference process ends. Otherwise, the process moves to step S1114.

FIG. 12 shows a flow of the history tree algorithm showing the contents of processing of the history tree management unit 25. When a new field is displayed, it is added to the history tree. (Start of A) (Step S120) The history tree is searched by the anchor corresponding to the field displayed in step S1111 of FIG. 11 to check whether or not there is a history node corresponding to the anchor. If you have a history node,
Since the field has already been added to the history tree, the flow returns to the original processing flow of FIG. If there is no history node, create and display the following history node.

(Step S121) A history node corresponding to the anchor is newly generated. The history node has the data structure shown in FIG. On the other hand, the data structure of the target network-type document is as shown in FIG. 14A for the field and FIG. 14B for the anchor in this embodiment. A pointer to the selected anchor is stored in the “corresponding anchor” column 32 of the newly created history node. The list of anchors in the field of the network-type document indicated by the reference field of the anchor is stored as the list 34 of candidate anchors in the history node. For example, the state in which FIG. 4 (a) is displayed is represented as in FIG. 3 (b). In this state, the anchor icon "Claims" 42 is selected,
As shown in FIG. 5A, when a window 51 for displaying a field referred to by the “claim” is newly created, a history node is created and the state shown in FIG. 3C is obtained. In the newly created history node H002, the anchor "claim" A00 is entered in the corresponding anchor 32 column.
Another anchor that stores a pointer to 2 and is in the newly displayed field in window 51 "Claim 1"
A005, "Claim 2" A006, "Claim 3" A00
7 is stored in the candidate anchor list 34.

(Step S122) A history node corresponding to the current field is selected.

(Step S123) It is determined whether or not the selection has failed, and if the selection has failed, the process returns to the flow of FIG.

(Steps S124 and S125) The corresponding anchor is deleted from the candidate anchors of the selected history node. Add the newly created history node to the child history node list. Thereby, for example, the anchor A002 is removed from the candidate anchors of the history node H001 of FIG. 3B, and the newly created history node H002 is added to the child history node (FIG. 3C).

(Step S126) In order to apply the history tree display algorithm (B) to the root history node, the process is transferred to the history tree display generation unit 26.

FIG. 13 shows a flow of a history tree display algorithm showing the contents of processing of the history tree display generation unit 26. Display the history tree updated after a new history node is created. (Start of B) (Step S131) First, the history node of the route is displayed.

(Step S132) The display algorithm (B) is applied to all child history nodes of the history node. Display all history nodes by recursive call. In FIGS. 7B to 10B, the thick line portion is the display corresponding to the history node.

(Step S133) Candidate anchors held by the history node are displayed. 7 (b) to 10 (b)
In, the thin line portion is the display corresponding to the candidate anchor. After performing this display, the flow returns to the process flow (step 12) in FIG.

The conventional history list is also one of the secondary structures, but since the structure is too simple, it is not possible to express all the information necessary for history management. According to the present embodiment, the history of work progress can be expressed in an easy-to-understand manner by expressing the history with a tree structure secondarily generated from the network structure.

(Second Embodiment) FIG. 16 shows the arrangement of a network type document processing apparatus according to the second embodiment. In the present embodiment, in the network type document, a tree structure is generated from the constituent elements of the network structure according to a user's instruction, and the allocation process is applied to the generated tree structure so that a necessary part of the network structure is obtained. Is selected so that allocation processing can be performed. In this embodiment, data is expressed by fields and anchors. This data representation is not essential to the invention. Data representation by nodes and links is also acceptable.
In the present embodiment, the overall allocation process is performed by hierarchically executing the partial allocation process using the hierarchical structure of the formatter described in the prior art. The formatter is a process for performing partial allocation processing. In this embodiment, the formatter hierarchical structure is called a formatter tree.

The network type document processing apparatus of the present embodiment, as shown in FIG. 16, includes a document storage unit 161 such as a hard disk for storing the document structure, a document management unit 162 for managing the document structure, and an external device. Input unit 1 that handles input
63, an anchor field selection unit 164 that selects an anchor or a field referred to by the anchor according to an instruction from the input unit 163, and an allocation target tree structure designated by the anchor field selection unit as a formatter tree. Fomatta tree management unit 1 to express and manage
65, a formatter tree display generation unit 166 that generates a window that displays a formatter tree, a formatter execution control unit 167 that executes the formatter, generates an allocation result, and sends the allocation result to the display unit 168 or the printing unit 169.
A display unit 168 such as a display device for displaying and a printing unit 169 for outputting the allocation result to a hard copy. The document storage unit 161, the document management unit 16
2, input unit 163, anchor field selection unit 16
4, the display unit 168 and the like are common to the first embodiment.

FIG. 17 shows the data structure of this embodiment. (A) is a formatter, (b) is an anchor,
(C) shows the reference relationship between the formatter and the anchor. As shown in FIG. 17A, the formatter data structure includes a formatter identifier 171 for identifying allocation nodes, a corresponding anchor 172 that is a pointer to a corresponding anchor, and a list 173 of pointers to child formatters. ing.

The data structure of the anchor is, as shown in FIG. 17B, anchor identifier 1 for identifying the anchor.
74, the anchor that is the label when displaying the anchor
A label 175, a corresponding formatter 176 which is a pointer to a corresponding formatter, and a reference field 177 which is a pointer to a field referred to by the anchor.

Next, the operation of the apparatus of this embodiment constructed as described above will be explained. 27A to 27C show a state in which a tree structure is designated from the network structure shown in FIG. On the interface displaying the tree structure as shown in (a) to (c) of FIG. 27, the user selects the anchor icon to be allocated with the mouse,
By clicking, the menu shown in FIG. 29A is displayed. By selecting "create formatter" in this menu display, a formatter for allocating the field referred to by the corresponding anchor is created and displayed as an icon surrounded by a thick line. The rectangular area indicated by a thin line is an anchor in a state in which there is no corresponding formatter, but indicates a selection candidate for generating a formatter. If you select "Discard formatter" from the selection menu, the formatter that was running is discarded. When the user clicks the anchor icon without selecting it, the selection menu shown in FIG. 29B is displayed. By selecting "print" from the selection menu, each formatter tree is formed. Allocation processing is performed by the formatter and output.

The formatter tree generated as a result of selecting the tree structure shown in FIG. 30 is as shown in FIG. FIG. 32 shows the result of performing the entire allocation process using this formatter tree. In FIG. 33 and FIG. 34, FIG.
It shows an example in which a formatter tree different from 0 is generated.

The structure to be allocated is not limited to the partial structure of the network structure. 35, 36,
FIG. 37 shows a state in which the designations of FIGS. 30 and 33 are made at the same time. In this case, it is not a partial structure accurately because there are overlapping parts.

Next, description will be made with reference to the flow charts shown in FIGS. FIG. 41 shows the formatter tree management unit 16
5 shows a flow of a formatter tree management algorithm representing the processing content of No. 5. It is assumed that the structure of the network-type document to be processed is displayed as shown in FIG. 27, for example.

(Start) (Steps S4110, S4111) The mouse click input is monitored. If there is a click, the anchor field selection unit 164 performs processing to select the anchor at the cursor position. For example, if the user moves the cursor by the input unit 163 to select the anchor icon 272 (FIG. 27B) to be allocated and clicks it, the anchor field selection unit 164 displays the cursor position at the cursor position. The formatter tree management unit 165 is notified of information about the anchor.

(Step S4112) If the selection of the anchor is successful, that is, if there is no anchor icon at the cursor position, the process proceeds to step S4113 if the anchor selection succeeds, or to step S4114 if the anchor selection fails.

(Step S4113) After the anchor is selected, the menu shown in FIG. 29A is displayed, and the user "create formatter" or "discard formatter".
Select. If "formatter activation generation" is selected, the process proceeds to step S4120, and if "formatter discard" is selected, the process proceeds to step S90.

[Activation of Formatter] (Step S4120) It is checked whether or not there is a formatter corresponding to the selected anchor. If there is already a formatter, it is not necessary to generate it. If not returned to S4110, the process proceeds to step S4114.

(Step S4121) A formatter corresponding to the anchor is newly generated. The formatter is shown in Figure 1.
It has a data structure shown in 7 (a). On the other hand, the data structure of the target network-type document is as shown in FIG. 14A for the field and FIG. 17B for the anchor in this embodiment. The pointer to the selected anchor is stored in the “corresponding anchor” column 172 of the newly created formatter.

(Step S4122) The newly generated formatter is arranged below the formatter corresponding to the upper anchor. That is, the pointer to the newly generated formatter is added to the list 173 of the child formatters of the formatter corresponding to the upper anchor.

(Step S4123) The display algorithm (B) is applied to the root formatter, and the control is transferred to the formatter tree display generation unit 166 in order to display again.

[Stop Formatter] (Steps S4130, S4131, S4123) FIG.
When "discard formatter" is selected by the user in the menu shown in FIG. 9A, it is checked whether or not there is a formatter corresponding to the anchor, and if there is, the corresponding formatter and its subordinate formatters are all deleted. Then, in step S4123, the formatter tree is displayed again. If not, the process returns to step S4110.

(Steps S4114, S4140, S4
147) In the determination of step S4112, if there is no anchor icon at the cursor position, FIG.
The menu of (b) is displayed, the selection of the user is waited, and when the "print" of the menu is selected, the formatter execution control unit 167 performs the allocation process by the formatter tree, and the allocation result is passed to the printing unit 169. Print out. When "end" is selected in the menu, the process ends.

FIG. 42 is a flow chart showing the partial allocation processing algorithm in the processing of the formatter execution control unit 167. By executing this algorithm from the root formatter, the allocation processing by the all formatter tree is performed. Also, this algorithm is the same as that used in the conventional allocation processing technique. In this embodiment, the logical unit corresponds to the field, the reference unit corresponds to the anchor, and the basic unit corresponds to the primitive. (Step S4200) It is determined whether all basic units included in the logical unit have been allocated.

(Step S4201) If allocation of all basic units has not been completed, the first element not allocated is taken out.

(Step S4202) It is determined whether the basic unit is a reference unit.

(Step S4203) If the basic unit is the reference unit, partial allocation processing is executed for the logical unit referred to by the reference unit (recursive call), and the allocation result is received.

(Step S4204) The allocation result is poured into the rectangular area.

(Step S4205) When the basic unit is not the reference unit, since the basic unit is a character or the like, they are poured into the rectangular area.

(Step S4206) When the allocation of all the basic units is completed, the allocated result is passed to the upper formatter.

FIG. 43 shows the formatter tree display generation unit 166.
7 is a flow chart of a formatter tree display algorithm representing the processing content of FIG.

(Step S4300) The label of the corresponding anchor is displayed in the graphic indicating that the formatter is activated.

(Steps S4301, S4302) It is checked whether all the anchors in the referenced field are displayed, and if there is an anchor that is not displayed, the first anchor that is not displayed is selected. When all the anchors in the referenced field are displayed, the process returns to step S4123 in FIG.

(Steps S4303, S4304, S4
305) Check whether the formatter corresponding to the selected anchor has been activated. If activated, the display algorithm is applied (recursively called) to the corresponding formatter. If not activated, the formatter has not activated. Display the label of the anchor in the graphic that indicates that.

According to this embodiment, a tree structure is generated from the components of the network structure according to the instruction from the user,
By applying the allocation process to the generated tree structure, a necessary part of the network structure can be selected and allocated. In addition, the present embodiment uses the formatter tree structure as a secondary structure to enable control of the allocation process of the network structure, which the user could not control conventionally. Also,
Since the user selects the tree structure to be allocated, an appropriate allocation template can be defined and the allocation process can be applied to the structured document.

(Modification of Second Embodiment) The tree structure is a restricted network structure. Therefore, the present invention can be applied to a tree structure. FIG. 38 shows an apparatus for displaying the entire logical structure of the tree structure shown in FIG. The user can define a subtree structure by defining a rectangular area on this display device. By using the formatter tree of FIG. 40 corresponding to this subtree structure, the allocation result of FIG. 39 can be obtained.

The allocation result is not only a hard copy,
It can also be displayed on the display. Conventionally, there has been a WYSIWYG system in which printing on a hard copy and display on a display are matched with each other, but this function is limited to output of the entire document. By matching the partial allocation result with the printout on the hard copy and the display on the display, it becomes possible to confirm on the display only the necessary part of the document to be printed. The necessary part is, for example, a peripheral part of the changed part when the change is made.

(Third Embodiment) FIG. 45 shows the arrangement of a network type document processing apparatus according to the third embodiment. The present embodiment is an apparatus capable of presenting an arbitrary subtree structure in a network type document to a user by combining windows and interactively changing the display state.
The display state is managed as a window tree in association with the data structure and can be restored after the work is interrupted.
In this embodiment, the data representation is performed by the field and the anchor, but this data representation is not essential in the present invention. Data representation by nodes and links may be adopted. The network-type document editing device of this embodiment is
As shown in FIG. 45, a document storage unit 451 such as a hard disk for storing a document structure, a document management unit 452 including an anchor management unit 4521 and a field management unit 4522 for managing the document structure, and an input from outside the device are handled. An input unit 453 such as a keyboard and a mouse, and an input unit 453
An anchor / field selector 45 for selecting an anchor or a field referred to by an anchor by an instruction from
4, a window tree management unit 455 that manages the hierarchical structure of windows as a window tree, and a window display generation unit 456 that generates a window for displaying fields.
And a display unit 457 such as a display device for displaying. The document storage unit 451 and the document management unit 45
2, input unit 453, anchor field selection unit 45
4 and the display unit 457 are common to the corresponding parts of the first or second embodiment.

FIG. 46 shows the data structure of this embodiment. (A) shows the window data structure and (b) shows the anchor data structure. In this embodiment, the window that is the root of the window tree is called the top window, and the other windows are called subwindows. As shown in FIG. 46A, the data structure of the window is a window identifier 46 for identifying the window.
1, a corresponding anchor 462 that is a pointer to the corresponding anchor, a display state 463 indicating the state of the window whether it is a top window or a subwindow, a display area 464 indicating the area in which the window is displayed, and a child window. It consists of a list 465 of pointers to. "TOP" in the display state indicates that it is a top window, and "SUB" indicates that it is a subwindow.

The data structure of the anchor is, as shown in FIG. 46 (b), an anchor identifier 4 for identifying the anchor.
66, the anchor that is the label when displaying the anchor
It includes a label 467, display information 468 which is information regarding display of a field referred to by the anchor, and a reference field 469 which is a pointer to a field referred to by the anchor. "TOP" in the display information indicates that the field referred to by the anchor is being displayed in the top window or was being displayed as the top window before the work was interrupted. "SUB" indicates that the field referred to by the anchor is displayed in the subwindow or was displayed as the subwindow before the work was interrupted. "OFF" indicates that the field referenced by the anchor is not displayed, and is not displayed even before the work is interrupted.

FIG. 47 shows the reference relationship between the window tree and the anchor. This corresponds to a part of FIG. Since the anchor of "claim 1" is not displayed, the display state is OFF. FIG. 48 shows the relationship between the values in the display area of the window shown in FIG. 47 and the display in FIG. 63 (a).

The present embodiment is an outline editor having a function of restoring the window tree at the end of editing when the editing is resumed by reflecting the window tree structure on the data in the document structure. When the display shown in FIG. 53A is being performed, the window tree is shown in FIG.
It becomes like (b). This state is as shown in FIG.
It is reflected in the data structure as display information (TOP, SUB, OFF). Those that do not indicate the state are OFF.

By selecting the icon corresponding to the anchor in the window with the mouse and clicking, the icon shown in FIG.
Open the menu of (c). In this menu, select "Open" to open sub windows.
Select "Close" to close the sub-window. By these operations, TOP, SUB, OFF
The state of changes. By selecting the top window and clicking "Close", all windows will be closed and the program will end. At this time, all display states are OF
Become F. If you select "Stop", TOP, SUB, O
The program ends without changing the state of the FF.

By referring to the display information in the data structure when editing is resumed, the state of the window tree at the time of interruption of editing can be restored. When opening the top window or subwindow, if there is an anchor in the state of "SUB" at the lower level, the subwindow for displaying the field referred to by the anchor is subsequently opened.

In this embodiment, there is one window tree to manage. Also, since each anchor has only one display state, it is not possible to represent the state of sharing the same anchor or field. If a function of sharing a plurality of window trees or fields is required, the state may be held for each display as shown in FIG. 54 (a). In this case, FIG.
The display shown in FIG. 54B can be expressed together with the display shown in FIG.

Even if the TOP information is not written out,
Partial window hierarchy restoration is possible. FIG. 55
When only SUB information is described as shown in (a), accessing "Explanation of the invention" will always include the "Claims" and "Examples" in which the SUB is described in the lower window. A window tree displaying the corresponding fields is generated. In the example of FIG. 55 (a), the display of FIG. 55 (b) is obtained.

Further, this mechanism can be applied to other than the outline editor as long as it displays a subtree structure by a hierarchical structure of windows. For example, in FIG.
The display by the subwindow freely arranged in the window as shown in (c) can also be realized by adding a simple modification to the configuration shown in the embodiment. The necessary modification in this case is to add window area information to the display information.

Next, description will be made with reference to the flowcharts shown in FIGS. FIG. 56 shows the window tree management unit 455.
5 is a flow chart of a window tree management algorithm representing the processing content of FIG.

(Step S5611) When the processing is started, first, the anchor whose state is TOP is selected.

(Step S5612) A top window is generated.

(Step S5613) In the generated top window, the field display algorithm (A) of FIG. 57 is applied to the field referred to by the selected anchor to display the field.

(Step S5614) When the user selects a window by clicking the mouse, the window shown in FIG.
The menu shown in (c) is displayed.

(Step S5615) According to the item selected by the menu, if the selected menu item is "open", go to step S5630, if "close", go to step S5640, and if "interrupt", The process advances to step S5650 to perform each process.

(Step S5630) If "Open" is selected from the menu, it is checked whether or not the anchor is selected. If no anchor has been selected, the process returns to step S5615.

(Step S5631) When the anchor is selected, the anchor state (display information 468)
To SUB.

(Step S5632) In the selection window, the process of the field display algorithm (A) is called for the field corresponding to the selected anchor and is re-displayed. Then, the process returns to step S5615 to perform the next selection process.

(Step S5640) When "Close" is selected from the menu, the states of the anchors corresponding to the selected window and all windows below it are turned off.

(Step S5641) The selected window and all subwindows below it are discarded.

(Step S5642) It is determined whether or not the window is the top window, and if it is the top window, all the windows have already been discarded, and the processing is terminated. If it is not the top window, step S5632
Go to and redisplay.

(Step S5650) If the selected menu is "interrupt", the selected window and all subwindows below it are discarded and the process is terminated.

FIG. 57 shows the flow of the field display algorithm (A) showing the processing contents of the field display generation unit 456. This algorithm takes care of displaying a field in a window, given the window and the field. (Step S570) It is determined whether or not all the primitives in the given field have been processed. If all the processings have been completed, the process returns to the original routine. If the primitive to be processed remains, the processing is performed by the following steps.

(Step and 571) The first primitive which has not been processed is selected.

(Step S572) It is checked whether or not the primitive is an anchor, and if it is an anchor, step S573.
If not, move to step S578.

(Step S573) Display status 4 of the anchor state in the anchor data structure of FIG. 46 (b).
68.

(Step S574) When the content of the display information is "SUB", a subwindow is generated and placed in the given window.

(Step S575) The display algorithm (A) is applied and displayed in the field referred to by the anchor in the generated subwindow (recursive call).

(Step S576) If the display information 468 of the anchor is OFF in the determination of step S573, an icon corresponding to the anchor is generated.

(Step S577) Place an icon in the given subwindow. (Step S578) If it is determined in step S573 that the primitive is not the anchor, the primitive is placed in the given subwindow.

According to this embodiment, the window tree management unit 4
Since 55 manages the display target tree structure so as to reflect it in the data in the document structure, the window tree at the end of editing can be restored when editing is resumed.

(Fourth Embodiment) In general, a network structure can be expressed freely, but it is much more difficult to handle than a simpler structure such as a tree structure. Therefore, it is effective to generate a secondary structure that is easy to handle from the network structure and use the structure to facilitate the operation of the network structure. The present invention includes a history tree structure (history tree), a tree structure to be displayed (window tree), a tree structure to be allocated (formatter tree),
The present invention utilizes a secondary structure such as, and the respective examples have been described in detail with reference to the first to third embodiments. Since these are all tree structures, they are collectively referred to as a secondary tree structure in this specification. Although these secondary tree structures are related to each other, they are different structures.

For example, referring to the document structure shown in FIG. 28 in the following procedure, the result is as shown in FIG. 58 (a). (1) Open a window that displays "Explanation of the invention". (2) Open a sub-window displaying "Claims" in the "Explanation of Invention" window. (3) Open a sub-window displaying "Example" in the "Explanation of Invention" window. (4) Open a sub-window displaying "Claims 1" in the "Claims" sub-window. (5) Open a window displaying "Claim 2". (6) Open a window displaying "Prior Art". Further, the result of FIG. 58B is obtained by the following procedure. (7) Close the sub-window of "Example"

At this time, the history tree, the window tree,
The formatter tree is shown in FIG. 59 (a), (b),
It shows in (c). The history tree is for expressing the part of the network-type document that the user has referred to. The history tree holds a history of references made by users in a tree structure. By displaying this tree structure as shown in FIG. 59 (a), it is possible to show the user the history of the work in the network structure performed up to that point.

The window tree is for designating a portion of the network document to be displayed. A part of the network type document structure is presented to the user as a synthetic window represented by a window tree. The user edits the network structure through this composition window. By displaying the window trees as shown in FIG. 59 (b), necessary windows can be accessed even when they are arranged in a stack.

The formatter tree is for designating a portion of the network type document structure which is an allocation target. By specifying the tree structure of the allocation target using the formatter hierarchy, advanced allocation processing using the template can be performed. The formatter tree shown in FIG. 59 (c) is specified regardless of the above-mentioned reference procedure. A device for associating and displaying the data structure and the formatter tree is required for the designation.

By combining the functions for these secondary tree structures, it is possible to realize more advanced functions. For example, it is conceivable to use them in combination as follows. (1) ... By using a combination of the history tree and the window tree, operations such as selectively deleting a window related to a specific work from a large number of windows opened on the screen are performed. This is because the history tree can show the progress of work. (2) ... By using the window tree and the formatter tree in combination, the information displayed by the window opened on the screen is allocated and output. (3) By using the history tree and the formatter tree in combination, the information referred to by the user is allocated and output.

The fourth embodiment is an example in which the respective secondary tree structures shown in the first to third embodiments are combined. A simple combination of the respective technologies is not sufficient to realize the above-described composite function. By simply combining the techniques of the first to third embodiments, in addition to the window shown in FIG. 58, a browser that displays a window tree, a browser that displays a history tree,
The browser that displays the formatter tree will open on the same screen. In some cases, a browser is also opened that displays the data structure. Moreover, the structure displayed in each browser is closely related to each other. For example, in the "open" operation of the above steps,
Both the window tree and the history tree are updated. on the other hand,
The "close" operation only updates the window tree.

As described above, in the simple combination of the respective technologies, (1) the relation between the structures is not arranged. (2) The relationship between the structures cannot be presented to the user. (3) Display similar structures in separate windows. Therefore, it is very difficult for a user to associate and use a plurality of secondary tree structures.

Therefore, in the fourth embodiment, a plurality of secondary tree structures are clearly associated with each other, all the structures are expressed in a unified manner, and displayed simultaneously. Since a plurality of secondary tree structures are presented to the user as one structure, confusion of the user can be avoided. Furthermore, by extracting each structure from the unified expression, the function using each structure,
Alternatively, it becomes easy to obtain a combined function. Also,
The procedure for updating a plurality of structures at the same time becomes easy, and the processing efficiency can be improved.

In the fourth embodiment, data is expressed by fields and anchors. This data representation is not essential to the invention. Data representation by nodes and links is also acceptable.

Further, in this embodiment, the formatter is realized as a process for executing the allocation process. This processing method is not essential in the present invention. The allocation target portion may be held in a tree-structured data structure, and another means may perform the allocation process while referring to the data structure. In this case, the data structure indicating the allocation target portion corresponds to the formatter tree.

The structure of the fourth embodiment is shown in FIG. As shown in FIG. 61, the network-type document editing apparatus of this embodiment manages a document structure including a document storage unit 611 such as a hard disk for storing the document structure, an anchor management unit 6121, and a field management unit 6122. An input unit 612, an input unit 613 such as a keyboard and a mouse that handles input from outside the apparatus, an anchor field selection unit 614 that selects an anchor or a field referred to by the anchor by an instruction from the input unit 613, and an anchor field.
A formatter tree management unit 615 that manages the allocation target tree structure designated by the field selection unit as a formatter tree, a document display generation unit 616 that generates a window that displays a part or the whole of the document, and a display device that performs display. For example, the display unit 167 executes the formatter, generates the allocation result, and outputs the allocation result to the hard copy by the formatter execution control unit 618 which sends the allocation result to the display unit 617 or the printing unit 619 via the document display generation unit 616. It comprises a printing unit 169. The document storage unit 611, the document management unit 612, the input unit 613, the anchor / field selection unit 614, the display unit 617, etc. are the first
The formatter tree management unit 615, the formatter execution control unit 618, and the printing unit 619 are common to those of the second embodiment.

The document display generation section 616 further comprises a document structure display generation section 6161 and a field display generation section 6162. The document structure display generation unit 6161 is for generating a window for displaying the structure of a document, and corresponds to a browser in the related art. In this embodiment, by displaying the anchor icon, a plurality of secondary tree structures are displayed in association with the document structure. The field display generation unit 6162
It creates a window that displays the fields. In this embodiment, a formatter managed by the formatter management unit 615 is used to generate a window and display a field.

FIG. 62 shows the data structure of this embodiment. (A) is a formatter, (b) is a window,
(C) is an anchor and (d) is a field structure.

The data structure of the formatter is shown in FIG. 62 (a).
, A list of formatter identifiers 62a1 for identifying allocation nodes, corresponding anchors 62a2 that are pointers to corresponding anchors, corresponding windows 62a3 that are pointers to corresponding windows, and pointers to child formatters. 62a4.

As shown in FIG. 62B, the data structure of the window is a window identifier 62b1 for identifying the window, a display area 62b2 for displaying the window, and a pointer 62b3 for the upper window.
And a list 62b4 of pointers to child windows.

The data structure of the anchor is, as shown in FIG. 62 (c), an anchor identifier 6 for identifying the anchor.
2c1, an anchor label 62c2 which is a label for displaying an anchor, and a reference field 62c3 which is a pointer to a field referred to by the anchor.

The data structure of the field is, as shown in FIG. 62 (d), a field identifier 62d1 for identifying the field, a field type 62d2 representing the kind of collective relationship defined by the field, and a pointer to the corresponding formatter. The corresponding formatter 62d3, which is, and a list 62d of the primitives included in the field.
It consists of four.

FIG. 63 shows the reference relationship among formatters, anchors, fields and windows. This reference relationship corresponds to a part of the states shown in FIGS. 64 and 65. In FIG. 65, it is shown that the window 652 displaying the field referred to by the “claim” anchor is open in the window 651 displaying the field referred to by the “description of the invention” anchor.

As described above, this embodiment is an apparatus for centrally managing and displaying the entire tree structure in order to simplify the operations on the history tree, window tree and formatter tree. FIG. 64 shows a display example according to this embodiment when the operation shown in FIG. 58 (b) is performed. This display simultaneously shows a part of the document structure, a history tree, a window tree, and a formatter tree. Each secondary tree structure is presented according to the type of icon indicating the anchor. Prior to the explanation of this display, a unified management method of the tree structure in the present embodiment will be explained.

In this embodiment, the formatter tree is associated with the window tree and the history tree by adding a new role. In the second embodiment, the formatter tree is for identifying a subtree structure to be output, allocating it, and outputting it. The role of each formatter in the formatter tree is to perform a partial allocation process for output. In this embodiment, as the role of the formatter, allocation processing for displaying in the window is added. That is, the formatter has two kinds of allocation algorithms for displaying windows and for outputting. Since the formatter performs the allocation process of the window display, the corresponding formatter is always generated when the window is displayed.

When the formatter defined as described above is used, when the window is opened, the formatter is generated and the allocation process for displaying the window is executed. When the windows are hierarchically structured, formatters are also hierarchically generated to execute the allocation process. From this, the window tree can be represented as a formatter tree.

The formatter does not disappear when the window is closed. That is, the formatter tree remains even if there is no corresponding window tree. By doing so, the history of window display, that is, the history tree that is the history of references can be expressed as a formatter tree.

In order to further associate the history tree, the window tree, and the formatter tree, which are associated with each other as described above, with the data structure, the combinations of the window and formatter states corresponding to the anchors are arranged. In this embodiment, a plurality of secondary tree structures are displayed by displaying each state on the anchor icon.

The combination of formatter and window states corresponding to anchors, SLEEP and RE shown in FIG.
The states of ADY, SUB and TOP are defined. E to this
A state in which the state of LSWHERE is added is called an anchor state. (1) SLEEP state indicates that there is no formatter corresponding to the anchor. (2) The READY state indicates that the formatter corresponding to the anchor exists, but the field referred to by the anchor is not displayed in the window. (3) The TOP state indicates that the field referred to by the anchor is displayed in the top window. (4) The SUB state indicates that the field referred to by the anchor is displayed in the sub window. (5) ELSEWHERE: In the state, the formatter corresponding to the field referred to by the anchor is generated from another anchor.

In this embodiment, the anchor state is indicated by changing the display of the anchor icon. FIG. 67 shows a list of anchor icons corresponding to anchor states.

In this embodiment, a plurality of anchors are allowed to refer to the same field. On the other hand, the formatter is constructed by selecting the anchor icon and opening the window. Therefore, multiple formatters corresponding to the same field may be defined. In the present embodiment, for the sake of simplicity, there is a limit that there is only one formatter corresponding to the field. For this reason ELSE
It became necessary to display the WHERE status. Although the configuration becomes a little complicated, it is not difficult to make a plurality of formatters correspond to one field.

By selecting an anchor in a specific state from the anchors in the above five states, as shown in FIG. 68,
You get a formatter tree, a history tree, and a window tree.

FIG. 64 shows a display example according to this embodiment when the operation shown in FIG. 58 (b) is performed. The window tree is a structure with TOP and SUB anchors. The formatter tree has a structure in which a READY anchor is further added. The history tree is SLEEP
This is a structure in which the anchor of ELSEWHERE is added.
These anchors will indicate candidates for reference.

As shown in FIG. 65, the anchor icon can also be used in a window displaying a field to clarify the relationship with each displayed tree structure.

The present embodiment is an apparatus for displaying a plurality of tree structures in a form that is easy for the user to understand. In addition to this function,
Inventions in which necessary tree structures are extracted from the conditions of FIG. 68 and respective features are used for the extracted tree structures (first to third)
Examples) are used together. That is, (1) the history of references to the document structure can be held and displayed as a tree structure (first embodiment). (2) With respect to the formatter tree used for window generation, by changing the allocation process to that for output, it is possible to output the referred portion (second embodiment). (3) By saving the anchor state, the display can be restored even if editing is temporarily stopped (third embodiment).

Next, the operation of the document display generation unit 616 for displaying the secondary tree structure in this embodiment will be described.
The operation of the other parts is as already described in any of the first to third embodiments.

Since the processing is performed according to the anchor state in order to display the document structure, the determination processing for that is necessary. FIG. 69 shows an anchor state determination algorithm.

(Step S690) Anchor information is acquired from the anchor management unit 612 and set as the current anchor.

(Step S691) It is checked whether the field referenced by the current anchor has a corresponding formatter. This is done by looking up the corresponding formatter 62d3 (FIG. 62 (c)) of the field shown in the reference field 62c3 (FIG. 62 (c)) of the current anchor. SLEE without formatter
It is determined to be P.

(Step S692) The anchor 62 corresponding to the formatter obtained in step S691.
It is checked whether or not a2 (FIG. 62 (a)) matches the current anchor. E if there is no match with the current anchor
It is determined to be LSWHERE.

(Step S693) Whether or not there is a corresponding window for the formatter obtained in step S691 is determined by the corresponding window 62a3 (FIG. 62 (a)).
If there is no corresponding window, it is determined to be READY.

(Step S694) Whether the window is the top window or not is determined by the upper window 62b3 (see FIG. 62).
(B)). If the upper window is specified, it is the sub window, and if it is not specified, it is the top window. If it is not the top window, it is determined to be SUB, and if it is the top window, it is determined to be TOP.

FIG. 70 is a structure display algorithm showing the processing of the document structure display generation unit 6161.

[Start] (Step S700) The partial structure display algorithm (B) is applied to the anchor serving as the root. [End]

FIG. 71 shows a partial structure display algorithm. (Step S711) The anchor state is determined by the anchor state determination algorithm (A) in FIG.
If it is SEWHERE or SLEEP, the process proceeds to step S712, and if it is READY, TOP, or SUB, the process proceeds to step S713.

(Step S712) When the anchor state is ELSEWHERE or SLEEP as a result of the above determination, the corresponding anchor icon is displayed.

(Step S713) If the result of the determination is that the anchor status is READY, TOP, or SUB, then the corresponding icon is displayed.

(Step S714) It is checked whether or not there is an anchor in the field referred to by the anchor. If there is an anchor, the process proceeds to the next step S715, and if not, the process returns to the original routine.

(Step S715) Partial structure display algorithm (B) for all anchors in the field
Is applied (recursive call).

(Step S716) The field display generation unit 6162 generates a graphic representing the field and displays it on the display unit 617.

According to this embodiment, a plurality of secondary tree structures,
That is, history trees, window trees, formatter trees, etc. are clearly associated, and as shown in FIG. 64, all structures can be expressed in a unified manner and displayed simultaneously.

[0179]

In the past, a simple secondary structure was secondarily generated from a network structure to simplify the handling of the network structure. However, the structure itself, the generation method thereof, or Because the management method was too simple, the necessary information expression, allocation process,
It was difficult to display the proper hierarchy of windows. According to the present invention, these problems can be solved.

That is, according to the present invention, by extracting a secondary tree structure from the network structure and using the secondary tree structure, it is possible to easily process the network type document, and By displaying the defined secondary tree structure to the user, the user can easily operate the network document.

Further, according to the present invention, the reference history is managed as a tree structure having a reference order in the depth direction and a node candidate in the width direction, and is presented to the user. It is possible to obtain a document processing device capable of expressing the progress. That is, the conventional history list is also one of the secondary structures, but the structure is too simple to represent all the information necessary for history management.
According to the present invention, the history of work progress can be expressed in an easy-to-understand manner by expressing the history with a tree structure secondarily generated from the network structure.

According to the present invention, the tree structure to be allocated is generated from the components of the network structure by a simple instruction from the user. The tree structure to be allocated is a secondary tree structure, but in the conventional technique, the generation method was too simple, and therefore the user could not obtain the necessary structure. In the conventional technique, a tree structure to be allocated is generated by starting a search starting from a node selected by a user and stopping by detecting a leaf or a loop.
The allocation target required by the user could not be specified. According to the present invention, a user can interactively generate a tree structure to be allocated as a secondary tree structure by presenting the structure extracted by a computer's arbitrary interpretation, and The allocation process used becomes easy. That is, by providing a means for generating a tree structure from the components of the network structure according to an instruction from the user and applying an allocation process to the generated tree structure, a necessary part of the network structure is selected and allocated. A document processing device capable of processing can be obtained.

Further, according to the present invention, it is possible to generate and manage a window hierarchy for displaying an arbitrary subtree structure in the network structure. Therefore, it is possible to use an outline editor, which has been conventionally used only for editing a tree structure, for editing a network structure.

Further, according to the present invention, a plurality of secondary tree structures are clearly associated with each other, and all structures are expressed in a unified manner.
It is possible to obtain a network type document processing device which can be displayed at the same time. As a result, in addition to the functions provided by the secondary tree structures described above, they can be combined to provide the user with an operation of a higher level network structure.

[Brief description of drawings]

FIG. 1 is a diagram showing a configuration corresponding to the invention of claim 1;

FIG. 2 is a block diagram showing the configuration of the first embodiment.

FIG. 3 shows a data structure of tree structure data that is secondarily generated in the first embodiment. (A) is a history node, (b) and (c) are history nodes and anchors. Diagram showing reference relationships

FIG. 4 is a diagram for explaining history management in a network-type document search function using a card-type interface. FIG. 4A is an example of a window displayed on the display. 10A shows a series of processes for searching data, FIG. 10B shows a display example of the history tree corresponding to the window of FIG. 10A, and FIG. 10C shows a history list according to the conventional example. Is a display example of.

5A is an example of a window displayed in the display, FIG. 5B is a display example of a history tree corresponding to the window of FIG.
(C) is a display example of the history list according to the conventional example

FIG. 6A is an example of a window displayed in the display, and FIG. 6B is a display example of a history tree according to the present embodiment corresponding to the window of FIG.
(C) is a display example of the history list according to the conventional example

FIG. 7A is an example of a window displayed in the display, and FIG. 7B is a display example of a history tree according to the present embodiment corresponding to the window of FIG.
(C) is a display example of the history list according to the conventional example

8A is an example of a window displayed in the display, and FIG. 8B is a display example of a history tree corresponding to the window of FIG.
(C) is a display example of the history list according to the conventional example

9A is an example of a window displayed in the display, and FIG. 9B is a display example of a history tree according to the present embodiment corresponding to the window of FIG. 9A.
(C) is a display example of the history list according to the conventional example

10A is an example of a window displayed in the display, and FIG. 10B is a display example of a history tree according to the present embodiment corresponding to the window of FIG.
(C) is a display example of the history list according to the conventional example

FIG. 11 is a flow chart of a field reference algorithm showing the contents of processing of the field reference unit 24.

FIG. 12 is a flow chart of a history tree algorithm showing the contents of processing of the history tree management unit 25.

FIG. 13 is a flow chart of a history tree display algorithm representing the contents of processing of the history tree display generation unit 26.

FIG. 14 is a diagram showing an example of a data structure of a network-type document used in the first embodiment. (A) is a field data structure, (b) is an anchor data structure, and (c) is a field and anchor data structure. Diagram showing reference relationships

FIG. 15 is a diagram showing a configuration corresponding to claim 2;

FIG. 16 is a block diagram showing a configuration of a network type document processing apparatus according to a second embodiment.

FIG. 17 shows a data structure of the second embodiment,
(A) is a formatter, (b) is an anchor, (c) is a diagram showing the reference relationship between the formatter and the anchor

FIG. 18 is a diagram showing an example of a tree structure expressing a document.

FIG. 19 is a diagram showing a result of performing allocation processing on the tree structure of FIG. 18 by a conventional technique.

20 is a diagram showing an example of representation of a document having the structure of FIG.

FIG. 21 is a diagram showing a hierarchical structure of a formatter.

22 is a diagram showing the hierarchical structure of the formatter and for explaining the process of the allocation process together with FIG. 23.

FIG. 23 is a diagram showing a hierarchical structure of areas allocated by the formatter, for explaining the process of allocation processing together with FIG. 22.

FIG. 24 is a diagram showing a simple example of a network structure.

FIG. 25 is a diagram showing an example in which a part of the network structure of FIG. 24 is displayed on a display.

FIG. 26 is a diagram showing an example of a subtree structure obtained from the network structure of FIG. 24 by a conventional technique.

27 (a) to 27 (c) are diagrams showing how a tree structure is specified from the network structure shown in FIG.
The menu shown in FIG. 29A is displayed.

FIG. 28 is a diagram showing an example of a network structure for explaining the present embodiment.

29 (a) and 29 (b) are views showing examples of selection menus used in allocation processing.

FIG. 30 is a diagram showing an example of reference of a tree structure displayed on the display (thick line part is a selection part)

FIG. 31 is a diagram showing a formatter tree generated by selecting the tree structure shown in FIG. 30.

32 is a diagram showing a result of performing the entire allocation process by the formatter tree of FIG. 31.

FIG. 33 is a diagram showing another reference example of the tree structure.

34 is a diagram showing the allocation result of FIG. 33.

FIG. 35 is a diagram showing a reference example in which the designations of FIGS. 30 and 33 are made simultaneously.

FIG. 36 is a diagram showing a result of performing the allocation shown in FIG. 35.

FIG. 37 is a diagram showing a formatter tree generated by selecting the tree structure shown in FIG. 35.

FIG. 38 is a diagram showing an example in which the entire logical structure of the tree structure shown in FIG. 18 is displayed, and the user defines a sub-tree structure by designating a rectangular area.

39 is a diagram showing the result of allocating the selected subtree structure of FIG. 38. FIG.

FIG. 40 is a diagram showing a formatter tree generated from the tree structure of the selected rectangular area in FIG. 38.

FIG. 41 is a diagram showing a flow of a formatter tree management algorithm representing the processing content of the formatter tree management unit 165.

FIG. 42 is a diagram showing a flow of a partial allocation processing algorithm in the processing of the formatter execution control unit 167.

FIG. 43 is a diagram showing the flow of a formatter tree display algorithm representing the processing contents of the formatter tree display generation unit 166.

FIG. 44 is a diagram showing a configuration corresponding to the invention of claim 4;

[FIG. 45] Third display by combining windows
Of the network type document processing apparatus according to the embodiment of the present invention

FIG. 46 is a diagram showing the data structure of the present embodiment.
Is a window, (b) is an anchor data structure

FIG. 47 is a diagram showing a reference relationship between a window tree and anchors.

FIG. 48 is a diagram showing an example of a display area of a window.

FIG. 49 is a diagram for explaining a conventional window,
(A) shows an example of network structure, (b)-(c) shows a card type window.

[Fig. 50] Fig. 50 is a diagram for explaining a conventional hierarchical window, (a) is an example of a network structure, and (b) is a menu for selecting a node.

FIG. 51 is a diagram showing how the window of the document having the network structure shown in FIG. 50A is displayed hierarchically.

FIG. 52 is a diagram showing a network structure including display information (TOP, SUB, OFF).

53A shows a window obtained from the display information and its structure shown in FIG. 52, FIG. 53B shows a corresponding window tree, and FIG. 53C shows a menu.

FIG. 54 is a diagram showing a case where a plurality of window trees and fields are shared, where (a) shows that each display holds a state, and (b) shows a window display example.

55 (a) is a network structure in which only SUB information is described, (b) is its window display, (c).
Shows an example of a window display in which the display area is specified by adding the area information

FIG. 56 is a diagram showing the flow of a window tree management algorithm representing the processing content of the window tree management unit 455.

FIG. 57 is a diagram showing the flow of a field display algorithm (A) showing the processing content of the field display generation unit 456.

FIGS. 58 (a) and 58 (b) are diagrams showing examples of results when the document structure shown in FIG. 28 is referred to in a certain procedure.

FIG. 59 is a diagram showing each tree structure when the display of FIG. 58 (a) is obtained, where (a) is a history tree and (b) is
Is a window tree and (c) is a formatter tree.

FIG. 60 is a diagram showing a configuration corresponding to the invention of claim 7;

FIG. 61 is a block diagram showing the configuration of the fourth embodiment.

FIG. 62 shows a data structure of the fourth embodiment,
(A) is a formatter, (b) is a window, (c) is an anchor, and (d) is a diagram showing the structure of a field.

FIG. 63 is a diagram showing a reference relationship among formatters, anchors and windows.

FIG. 64 is a diagram showing a display example according to the fourth embodiment when the operation shown in FIG. 58 (b) is performed.

FIG. 65 is a diagram showing a display example in which an anchor icon is also used in a window for displaying a field to clarify the relation with the display of the structure.

FIG. 66 is a diagram showing definition of an anchor state by a combination of formatter and window states.

FIG. 67 is a view showing an anchor icon for an anchor state.

FIG. 68 is a diagram defining a relationship between an anchor state and each tree structure extracted and displayed by the selection.

FIG. 69 is a diagram showing a flow of processing for determining an anchor state.

FIG. 70 is a diagram showing the flow of structure display processing in the document structure display generation unit 6161.

71 is a diagram showing a flow of partial structure display processing in the document structure display generation unit 6161. FIG.

[Explanation of symbols]

11, 151, 441, 601 ... Document management means, 12 ...
Logical unit reference means, 13 ... History tree structure management means, 151
... Tree structure allocating means, 153 ... Allocation target tree structure managing means, 442 ... Display target tree structure managing means, 602 ... Secondary tree structure displaying means, 603 ... Secondary tree structure managing means,
21, 161, 611 ... Document storage unit, 22, 162, 6
12 ... Document management unit, 221, 1621, 4521, 61
21, ... Anchor management unit, 222, 1322, 452
2, 6122 ... Field management unit, 23, 163, 45
4, 613 ... Input part, 24 ... Field reference part, 24
1, 164, 454, 614 ... Anchor / field selection unit, 242 ... Field display generation unit, 25 ... History tree management unit, 26 ... History tree display generation unit, 27, 16
8, 457, 617 ... Display unit, 165, 615 ... Formatter tree management unit, 166 ... Formatter tree display generation unit,
455 ... Window tree management unit, 616 ... Document display generation unit, 6161 ... Document structure display generation unit, 456, 6162
... field display generation unit, 167, 618 ... formatter execution control unit, 169, 619 ... printing unit.

Claims (9)

[Claims] 1. A device for processing a document structure configured by associating predetermined constituent units, wherein the constituent unit is a logical unit that is a logical unit of a document, and a reference defining a reference relationship between the logical units. A document management unit that manages the document structure in which logical units are associated with each other, and a reference unit in the logical unit is specified according to the user's instruction.
Refer to a logical unit reference unit for referring to a logical unit, which includes a logical unit selection unit for selecting the logical unit to be referred to and a logical unit display unit for displaying the selected logical unit, and a reference history of the logical unit. A network-type document processing device, comprising: a history tree structure management unit that manages a history tree structure management unit that manages the created logical unit and a reference unit that is another candidate at the time of the reference. 2. In a device for processing a document structure formed by associating predetermined constituent units, a constituent unit is a logical unit that is a logical unit of a document, and a reference defining a reference relationship between the logical units. A document management unit that manages a document structure in which logical units are associated with each other by a unit, and an allocation target tree structure management unit that manages an allocation target tree structure that is composed of logical units or reference units in the document structure A network-type document processing device comprising: 3. The network type document processing apparatus according to claim 2, further comprising a tree structure allocating means for allocating an allocation target tree structure. 4. A device for processing a document structure, which is configured by associating predetermined constituent units, wherein the constituent unit is a logical unit that is a logical unit of a document, and a reference defining a reference relationship between the logical units. A document management unit that manages a document structure in which logical units are associated with each other, and a display target tree structure that represents a part or the whole of the document structure in a hierarchical structure, and the display target tree structure and the displayed document A network-type document processing device, comprising: a display tree target structure management means for managing structures in a structure in association with each other. 5. The logical unit holds display information indicating its display state, and the display target tree structure management means generates or changes a display target tree structure from an instruction from a user and display information. The network-type document processing device according to claim 4. 6. The network-type document processing device according to claim 4, wherein the display target tree structure is a hierarchical structure of windows. 7. In a device for processing a document structure configured by associating predetermined constituent units, the constituent unit is a logical unit that is a logical unit of a document, and a reference defining a reference relationship between the logical units. A document management unit that manages a document structure in which logical units are associated with each other by a unit, a secondary tree structure management unit that manages a tree structure secondary defined from the document structure, and a secondary tree structure And a secondary tree structure display means for displaying the secondary tree structure in association with another secondary tree structure. 8. A combination of a plurality of states relating to a secondary tree structure is associated with a display rule of a logical unit or a reference relation, and the secondary tree structure display means applies the display rule when displaying a document structure. 8. The network-type document processing device according to claim 7, wherein the plurality of secondary tree structures and the document structure are displayed in association with each other. 9. The secondary tree structure is an allocation target tree structure,
9. The document structure processing apparatus according to claim 8, which has a display target tree structure, a history tree structure, or any combination thereof.