JP3590974B2 - Network-type document processing apparatus and method using tree structure defined secondary - Google Patents

Description

[0001]
[Industrial applications]
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. And document processing method using the same About.
[0002]
[Prior art]
2. Description of the Related Art As a document structure, there is a technology called hypertext as a conventional technology relating to a document editing apparatus that handles a network structure in which logical units of a document are related by a reference relationship.
Hypertext technology, for example,
Reference "Jakob Nielsen, Hypertext & Hypermedia, HBJ Publishing Bureau, 1991"
Is shown in
[0003]
(A) Conventional technology related to reference history
In the conventional techniques as described above, when searching for a hypertext, (1) it is not possible to remember how to reach the node.
(2) I do not know how to return to the node I saw a while ago.
It has been pointed out that such problems may occur. These problems are collectively called the lost child problem.
In order to solve these problems, a device for retaining a reference history and presenting it to a user has been invented. P. 27 and P129-130 describe two prior arts. These will be described briefly.
[0004]
One is to list the names of referenced nodes in chronological order and display them. By selecting the displayed name with the pointing device, one can return to the previously referenced node.
[0005]
The second method is to reduce the size of the displayed images of the displayed nodes by arranging them in chronological order with reference to them. Also in this example, by selecting the reduced display with the pointing device, it is possible to return to the previously referred node.
[0006]
As described above, in the related art, the above-described problem is solved by displaying the histories in chronological order and providing a means for returning to the previously referred node from the display.
However, considering why it is necessary to return to the previously referenced node, it can be seen that the prior art is not a satisfactory solution. In other words, it is often necessary to return to the previously referenced node in order to search for another node that has not been selected in the search path up to that point and to repeat the search in some cases. If you want to return to a previously referenced node for this purpose, what you need is not a chronological order to reach the node, but a search of what candidates have been selected and reached the node. This is the progress of work.
However, in the prior art, the time sequence of arriving at the node is indicated, but the progress of the search operation is not indicated. For example, the search shown in FIGS. 4 (a) to 10 (a) can provide a display of the reference order along time as shown in FIG. 4 (c), but in order to express the progress of the search operation, Not a useful list.
[0007]
(B) Conventional technology related to allocation processing
2. Description of the Related Art In a document processing apparatus that handles a document structure in which logical units of a document are associated with each other, a process called an assignment process is required to display the document on a hard copy or on a screen. In the prior art, for example, by performing an allocation process on the tree structure type structure shown in FIG. 18, the allocation result shown in FIG. 19 can be obtained. Such a tree-structured logical structure is handled by a conventional technique called a structured document. In a structured document, very high allocation results can be obtained.
[0008]
For example, Japanese Patent Laying-Open No. 3-147059 discloses an allocation processing technique in ODA which is an international standard for structured documents. In this conventional technique, processing is performed in accordance with the description of a document layout template called a common layout structure, which is defined by ODA in order to control the layout result of the entire document. The common allocation structure allows a very advanced template description including repetition and selection.
[0009]
In addition, the document "Makoto Murata and Koichi Hayashi, Formatter Hierarchy for Structured Documents, EP92, Cambridge University Press, 1992, which is described in Japanese Patent Application No. 3-98, which is incorporated by reference in Japanese Patent Application No. 3-98, is incorporated herein by reference. And assign documents. In this prior art, rather than allocating the entire document using a single complicated program and a complex template, which was performed in the prior art, a simple small program and a simple small template are hierarchically combined. This implements the allocation process. Even with this method, an allocation result similar to the common allocation structure of ODA can be obtained.
[0010]
A document having the structure of FIG. 18 can be represented as an example in FIG. In this figure, the logical unit is represented as a stream indicated by an arrow. A stream is a sequence of basic units such as characters, and the basic units include reference units. The name enclosed in a rectangle indicates a reference unit, and refers to a stream which is another logical unit from a specific position of the stream. In this way, the tree-structured logical structure is represented as a hierarchical stream.
[0011]
The partial allocation means is a program. A program that executes this program is called a formatter. The formatter is realized as a form of a subroutine being executed, a process of executing in parallel, or an object in an object-oriented language.
The formatter is responsible for allocating one stream. By forming the formatter hierarchical structure shown in FIG. 21, the entire logical structure can be allocated while exchanging partial allocation results.
[0012]
FIG. 42 shows an outline of the conventional allocation algorithm. This is adopted as a part in this embodiment as described later. FIG. 22 and FIG. 23 show one process of the allocation processing. Each formatter refers to the partial allocation template and performs allocation processing according to the rules described therein.
In this example, for example, a template having the following rules is referenced.
Formatter 1
(1) The character string of the label is poured in a large font and centered.
(2) An area obtained by subtracting the upper, lower, 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 flows.
Formatters 2 and 3 are
(1) The character string of the label is poured in a small font and left-aligned.
(2) An area obtained by subtracting the upper, lower, 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 flows.
[0013]
The structure of a document that can be handled on a computer is not limited to a tree structure. It can handle the logical structure of a more general network structure. 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 displayed on the display as shown in FIG. 25, and can be referenced and edited. However, since the conventional advanced allocation processing targets a tree structure, the allocation processing cannot be applied as it is.
[0014]
Therefore, in the search of the document structure, a method of extracting a subtree structure in the network structure by halting the search further when a loop is detected, and allocating the structure to the structure has been devised. . This method is disclosed in, for example, JP-A-63-165968 and JP-A-4-171575. The subtree structure obtained from the network structure in FIG. 24 by this method is as shown in FIG. 26, for example. This example is a result of detecting a loop based on whether or not a search has already been performed in a depth-first search procedure. There are several types of search procedures and loop detection methods, and these changes result in different subtree structures. In any case, in the method of the related art, if a node to start a search is selected, one subtree structure is extracted according to a determined mechanism.
[0015]
However, in order for a computer to select one tree structure from a structure from which a plurality of tree structures may be extracted, a partial tree structure desired by a user is not necessarily allocated.
Further, it is not possible to apply advanced layout processing using a layout template realized in a conventional structured document. This is because the user cannot define an appropriate layout template because the user does not know in advance what kind of tree structure is to be extracted.
[0016]
(C) Conventional technology related to structure display
In an apparatus for handling a document structure in which logical units of a document are associated with each other, means for displaying and editing the document structure and the logical unit are provided. Except in very simple cases, it is not possible to display and edit all information of the document structure at once. Therefore, means for organizing and displaying / editing information at a certain point of view and means for displaying / editing a partial structure are used.
[0017]
The former means includes, for example, a device called a browser, which sorts and displays the reference relations of logical units (for example, Japanese Patent Application Laid-Open No. H4-40559). The use of this device makes it easier to understand the whole picture of the document structure. However, in this device, it is not possible to indicate from which position in the content the reference is being made. Also, it is difficult to display the network structure with this device.
[0018]
The latter means includes, for example, a device using a card type interface. In this device, one window corresponds to one logical unit, and displays contents and reference units embedded in the contents. In this device, the relationship between the content and the reference unit can be clearly expressed. This device also has the advantage that the network structure can be displayed. For example, a network structure as shown in FIG. 49 (a) can be freely searched using a card type interface as shown in FIGS. 49 (b), (c) and (d). However, in this method, only one logical unit can be displayed in one window, and a reference relationship can be expressed only at a depth of one. For this reason, it is difficult for a user to understand the whole picture of a complicated network structure.
[0019]
For this reason, there has been a need for a 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), an icon indicating a reference unit is selected by a pointing device, and "open" and "close" are designated from a menu as shown in FIG. 50 (b). , Any subtree structure can be displayed. Further, it is possible to easily display all of the lower-level structures by instructing "open all". When each rectangular area for displaying a logical unit is considered to be a window, the outline editor displays a partial structure of the document by a hierarchical structure of windows.
However, since the outline editor limits the document structure to a tree structure, it cannot be applied to the network structure as it is. For example, if there is a loop, the "open all" operation cannot be performed.
[0020]
[Problems to be solved by the invention]
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 method of generating the structure, or the method of managing the structure was too simple, it was difficult to represent necessary information, perform allocation processing, and appropriately display windows in a hierarchical manner.
An object of the present invention is to provide a network-type document processing apparatus that appropriately generates and manages a tree structure as a secondary structure in order to solve this problem.
[0021]
It is another object of the present invention to provide a network-type document processing apparatus capable of displaying a secondary tree structure in a manner that is easy for a user to understand, so that the user can easily operate a network-type document.
[0022]
In order to solve the above-described problem of the related art regarding the reference history, it is important to clarify the progress of the search operation as to which candidate has been selected and reached the node. However, in the prior art, the time sequence of arriving at the node is indicated, but the progress of the search operation is not indicated.
An object of the present invention is to solve such a problem and to obtain a document processing device capable of expressing the progress of a search operation. According to the present invention, this is achieved by managing the reference history as a tree structure indicating the reference order in the depth direction and indicating the node candidates in the width direction, and presenting it to the user.
[0023]
In the conventional allocation processing technology for a network structure, as described above, the user does not necessarily select one tree structure from a structure from which a plurality of tree structures may be extracted. A desired subtree structure cannot be allocated, and a high-level layout process using a layout template realized in a 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 in accordance with an instruction from the user, and applying an allocation process to the generated tree structure.
[0024]
The hierarchical structure of the window is a secondary structure that reflects a partial structure of the data and enables operations using the structure. However, the conventional method of generating a hierarchical structure of windows is for displaying a tree structure, and is not appropriate for a network structure.
SUMMARY OF THE INVENTION It is an object of the present invention to provide a network type document processing apparatus capable of generating and managing a window hierarchy for displaying an arbitrary subtree structure in a network structure.
[0025]
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 simultaneously displaying them.
[0026]
Means and action for solving the problem
The network type document processing apparatus of the present invention defines a tree structure as a secondary structure from a network structure, and performs processing using the tree structure. Conventionally, a simple structure was generated secondarily from the network structure to simplify the handling of the network structure. However, the structure itself, its generation method, or its management method was too simple. It was difficult to express necessary information, to perform allocation processing, and to appropriately display windows in a hierarchy. The present invention can solve these problems.
[0027]
The network-type document processing apparatus according to the present invention (claim 1) includes a document management unit (11 in FIG. 1, 22 in FIG. 2) for managing a document structure and a logical unit reference unit (12 in FIG. 1) for referring to a logical unit. And 24) in FIG. 2 and a history tree structure managing means (FIG. 2) for managing the reference history of the logical unit as a tree structure in which the referenced logical unit and the reference unit which was another candidate at the time of the reference are associated with each other. 13 of FIG. 1 and 25) of FIG. 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 structural units are related by a reference unit that defines a reference relationship between the logical units. The logical unit reference means specifies a reference unit in the logical unit in accordance with a user's instruction, and selects a logical unit to be referred to (241 in FIG. 2), and a logic for displaying the selected logical unit. It comprises unit display means (242 in FIG. 2).
In this specification, a reference unit is an element of a logical unit serving as an index for referring to another logical unit from a logical unit. For example, a logical unit is a logical unit in a document such as a chapter or a paragraph in the document. It represents a unity.
[0029]
The conventional history list is one of the secondary structures, but the structure is too simple to express all the information necessary for managing the history. In the present invention, it is possible to express the history of the work by expressing the history in a tree structure.
[0034]
The present invention ( Claim 2 The network-type document processing device of the first embodiment is a device for processing a document structure formed by associating predetermined structural units, wherein the structural unit is a logical unit that is a logical unit of a document, and a reference relationship between the logical units. Document management means (601 in FIG. 60, 612 in FIG. 61) for managing a document structure in which logical units are associated with each other by a reference unit which defines a tree structure, and a secondary for managing a tree structure secondary defined from the document structure. A tree structure management means (603 in FIG. 60, 615 in FIG. 61) and a secondary tree structure display means (FIG. 60) for displaying a secondary tree structure in association with a document structure or another secondary tree structure. 602 and 616 in FIG. 61). 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.
[0035]
The present invention ( Claim 3 The network-type document processing device according to Claim 2 )), Associating a plurality of combinations of states relating to the secondary tree structure with a display rule of a logical unit or a reference relation, and the secondary tree structure display means applying the display rule in displaying the document structure. Displays a plurality of secondary tree structures and document structures in association with each other. Note that 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 4 ).
[0036]
【Example】
(First embodiment)
FIG. 2 shows the configuration of the 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 node reference when a user proceeds with a work along a network structure in a network-type document. The 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 the network-type document, in the present embodiment, the constituent unit is a logical unit that is a logical unit of the document, and a reference that defines a reference relationship between the logical units. Use a document structure in which logical units are associated with each other. The logical unit is called a field, and the reference unit is called an anchor. Further, basic units such as characters constituting logical units are called primitives. Primitives also include anchors. Note that the data expression using the field and the anchor is not essential in the present invention. Data representation using nodes and links may be used.
[0037]
As shown in FIG. 2, the network-type document editing apparatus according to the present embodiment handles a document storage unit 21 such as a hard disk for storing a document structure, a document management unit 22 for managing a document structure, and inputs from outside the apparatus. An input unit 23 such as a keyboard and a mouse, a field reference unit 24 for selecting a field to be displayed based on information input from outside the device, and a history node according to the reference in order to express the history of the field reference as a history tree. A history tree management unit 25 that performs management such as generation of a tree structure using 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. ing.
[0038]
Further, the document management unit 22 includes an anchor management unit 221 for managing anchors and a field management unit 222 for managing fields.
[0039]
The anchor management unit 221 performs management such as storing, retrieving and updating anchor information in 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.
The field management unit 222 performs management such as storing, extracting, and updating field information in the document storage unit 21. The field has a data structure as shown in FIG. 14A, and is included in a field identifier 141 for identifying the field, a field type 142 indicating the kind of collective relation defined by the field, and the field. It consists of a list 143 of primitives. If the primitive in the list is an anchor, it is a pointer to the anchor and a list of basic elements of the content data. The field can express a sequence of character strings or chapters, for example, by maintaining an order relationship between primitives. At this time, the field type is a stream, which matches the stream used in the related art. The fields can hold, for example, a two-dimensional positional relationship in addition to the order.
[0040]
The field reference unit 24 includes an anchor / field selection unit 241 for selecting an anchor or a field referred to by the anchor in response to an instruction from the input unit 23, and a field display generation unit 242 for generating a window displaying the selected field. Consists of
[0041]
3A and 3B show a data structure of a tree structure which is generated secondarily according to the present embodiment. FIG. 3A shows a history node, and FIG. 3B shows a reference relationship between a history node and an anchor.
As shown in FIG. 3A, the data structure of the history node is referred to by the history node identifier 31 for identifying the history node, the corresponding anchor 32 which is a pointer to the corresponding anchor, and the corresponding anchor. Of the anchors in the field, the child history node 33 which is a list of the pointers to the history nodes corresponding to the ones referenced in the past, and the anchors in the field referenced by the corresponding anchors that have not been referenced in the past It consists of a candidate anchor 34, which is a list of pointers to things.
The data structure of the anchor and the field is the same as that of FIG.
[0042]
In the present embodiment, FIGS. 4 (a), 5 (a), 6 (a), 7 (a), 8 (a), 9 (a), and 10 (a) [hereinafter, 4 (a) to 10 (a)]. The document processing apparatus is characterized in that it manages a history in a network-type document search operation using a card-type interface exemplified in FIG. In the present embodiment, the reference history is expressed as a tree structure, and displayed as shown in FIGS. 4B to 10B.
[0043]
FIGS. 4A to 10A show a state in which data is searched for in a window displayed in the display. That is,
(1) Open the window of the node named "Description of the invention", select the icon of "Claim" (FIG. 4 (a)), and open the window (FIG. 5 (a)).
{Circle around (2)} The icon of “Claim 2” is selected (FIG. 5A), and its window is opened (FIG. 6A).
{Circle around (3)} Close the "claims" and "claims 2" windows and return to the "explanation of invention" window (FIG. 7 (a)).
{Circle around (4)} The icon of “Example” is selected (FIG. 7A), and a window is opened (FIG. 8A).
{Circle around (5)} FIG. 15 The icon of “Example 2” is selected (FIG. 8A), and a window is opened (FIG. 9A).
{Circle around (6)} The icon of “Claim 2” is selected (FIG. 9A), and a window is opened (FIG. 10A).
[0044]
As examples of display of history information corresponding to each operation of FIGS. 4A to 10A, FIGS. 4C to 10C show a list of reference histories according to the related art, and FIGS. FIGS. 10A to 10B show display examples of the history tree in the present embodiment.
In the display example of the history tree according to the present embodiment illustrated in FIGS. 4B to 10B, a rectangle corresponding to the referenced field and a line segment indicating the reference relationship are drawn with thick lines. The thin lines are other candidates that were presented at the time the reference was made.
On the other hand, in the related art of FIGS. 4C to 10C, only a reference history list is shown, and nothing is displayed for other candidates presented at the time of reference. Absent.
As described above, in this embodiment, it is possible to understand the progress of the operation, which cannot be expressed by the conventional display. Note that, in the present embodiment, what is actually referred to is displayed at a higher position, but the upper and lower positions may be determined in the order within the field.
[0045]
Next, the operation of the present embodiment will be described with reference to the flowcharts shown in FIGS.
In the present embodiment, the mouse cursor is moved to the icon indicating the anchor in the window displaying the field, and the corresponding field is referenced by clicking. For example, in FIG. 4 (a), by clicking on the icon “Claim” 42 indicating an anchor in the window 41 displaying the field with a mouse, a window 51 (FIG. ))open. In this way, the fields consisting of 52, 53 and 54 anchors are referenced corresponding to the 42 anchors.
[0046]
When there is no anchor icon corresponding to the clicked location (for example, FIG. 10A), a “close” menu (not shown) can be selected.
Furthermore, clicking outside the window will allow you to select the "Exit" menu.
The field displayed in the window where the cursor is located is the current field.
Note that you cannot select the first anchor from the window. Specified by the user when starting the program.
[0047]
FIG. 11 shows the flow of the field reference algorithm representing the contents of the processing of the field reference unit 24.
[0048]
(start)
(Step S1110)
The user moves the cursor using the input unit 23 to specify one anchor icon. For example, in FIG. 4, the anchor icon 42 is clicked. Then, the anchor / field selection unit 241 specifies 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.
[0049]
(Step S1111)
The field display generation unit 242 obtains 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 the window via the display unit 27.
[0050]
(Step S1112)
The history tree generation algorithm (A) (FIG. 12) is called. As will be described later, the fields referred to by the history tree management unit 25 are managed in the form of a history tree, and displayed by a history tree display algorithm (FIG. 13).
[0051]
(Step S1113)
The cursor is moved into the window displaying the field generated in step S1111.
[0052]
(Step S1114)
Determines whether the cursor is in or outside the window that displayed the field.
[0053]
[When in the window that displays the field]
If the cursor is in the window displaying the field, the process waits for a mouse click input and performs the following process for anchor selection.
(Step S1115)
The field displayed in the window where the cursor is located is the current field.
[0054]
(Step S1116)
It is determined whether or not the mouse has been clicked. If the mouse has not been clicked, the process proceeds to step S1114, and if the mouse has been clicked, the process proceeds to step S1117.
[0055]
(Step S1117)
The anchor / field selector 241 performs an anchor selection process corresponding to the click.
(Step S1118)
It is determined whether or not the anchor selection has failed.
[0056]
(Step S1119)
When the selection of the anchor has not failed, 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 has not been displayed, the process moves to step S1111 in order to display the field and register it in the history tree.
[0057]
(Step S1120)
If a field has been displayed, the cursor is moved to the window in which the field is displayed, and the process proceeds to step S1114.
[0058]
(Step S1130)
If it is determined in step S1118 that the selection of the anchor has failed, that is, if a click is made when the cursor is located at a position other than the anchor icon, the click selects "close" in the menu. It is determined whether or not.
If the result of the determination is that the selection is not "close" in the menu, the flow moves to step S1114 to wait for the next click input.
[0059]
(Step S1131)
If “close” is selected as a result of the determination, a process of closing the window is performed.
[0060]
[Outside window displaying fields]
(Steps S1140, S1141)
When the cursor is located outside the window displaying the field as a result of the determination in step S1114, the mouse is monitored for clicks. When the mouse is clicked, it is determined whether or not it is a menu end selection. If it is selected, the field reference processing ends. Otherwise, the process proceeds to step S1114.
[0061]
FIG. 12 shows a flow of a history tree algorithm representing the contents of the 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, and it is determined whether or not there is a history node corresponding to the anchor. If there is 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, the following history node is created and displayed.
[0062]
(Step S121)
Create a new history node corresponding to the anchor. The history node has a data structure shown in FIG. On the other hand, in the present embodiment, the data structure of the target network type document is such that the fields are as shown in FIG. 14A and the anchors are as shown in FIG. 14B. The 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 a list 34 of candidate anchors in the history node.
For example, the state in which FIG. 4A is displayed is represented as in FIG. In this state, when the anchor icon “Claim” 42 is selected and a window 51 displaying a field referred to by the “Claim” is newly generated as shown in FIG. 5A, a history node is created. 3 (c). In the newly created history node H002, a pointer to the anchor “Claim” A002 is stored in the column of the corresponding anchor 32, and the other anchor “Claim 1” A005 in the window 51 is displayed in the newly displayed field. “Claim 2” A006 and “Claim 3” A007 are stored in the candidate anchor list 34.
[0063]
(Step S122)
Select the history node corresponding to the current field.
[0064]
(Step S123)
It is determined whether or not the selection has failed, and if the selection has failed, the process returns to the processing flow of FIG.
[0065]
(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 anchor of the history node H001 in FIG. 3B, and the newly generated history node H002 is added to the child history node (FIG. 3C).
[0066]
(Step S126)
In order to apply the history tree display algorithm (B) to the root history node, the processing is shifted to the history tree display generation unit 26.
[0067]
FIG. 13 shows a flow of a history tree display algorithm representing the contents of the processing of the history tree display generation unit 26. Display processing of a history tree updated after a new history node is generated.
(Start of B)
(Step S131)
First, the history node of the root is displayed.
[0068]
(Step S132)
The display algorithm (B) is applied to all the child history nodes of the history node. Display all history nodes by recursive call. 7 (b) to 10 (b), the thick line indicates the display corresponding to the history node.
[0069]
(Step S133)
Display the candidate anchors of the history node. In FIG. 7B to FIG. 10B, a thin line portion is a display corresponding to the candidate anchor.
After this display, the process returns to the processing flow (step 12) in FIG.
[0070]
The conventional history list is one of the secondary structures, but the structure is too simple to express all the information necessary for managing the history. According to the present embodiment, the history of the work can be represented in an easy-to-understand manner by expressing the history with a tree structure secondary generated from the network structure.
[0071]
(Explanation of the secondary tree structure to be assigned)
FIG. 16 shows a configuration example of a network-type document processing apparatus using a tree structure to be allocated which is defined secondarily. This device generates a tree structure from the components of the network structure according to the instruction from the user in the network type document, and applies the allocation processing to the generated tree structure, so that the necessary part of the network structure is It is possible to select and perform allocation processing. In this device, data expression is performed using fields and anchors. This data representation is not essential in the present invention. Data representation using nodes and links may be used. In this embodiment, the entire allocation processing is performed by executing the partial allocation processing hierarchically using the hierarchical structure of the formatter described in the above-mentioned prior art. The formatter is a process for performing a partial allocation process. In this example, the hierarchical structure of the formatter is called a formatter tree.
[0072]
As shown in FIG. 16, a network-type document processing apparatus based on a tree structure to be allocated which is secondarily defined includes a document storage unit 161 such as a hard disk for storing a document structure, a document management unit 162 for managing the document structure, and the like. , An input unit 163 for handling input from outside the device, an anchor field selection unit 164 for selecting an anchor or a field referred to by the anchor, and an instruction from the anchor field selection unit. A formatter tree management unit 165 that expresses and manages a tree structure to be allocated as a formatter tree, a formatter tree display generation unit 166 that generates a window that displays the formatter tree, and executes a formatter to generate an allocation result. A display unit 168 or a formatter execution control unit 167 to be sent to the printing unit 169; A display unit 168 such as a display device for performing display, has an allocation result from the printing unit 169 for outputting a hard copy. Note that the document storage unit 161, the document management unit 162, the input unit 163, the anchor / field selection unit 164, the display unit 168, and the like are common to the first embodiment.
[0073]
FIGS. 17A and 17B show the data structure of the present example. FIG. 17A shows a formatter, FIG. 17B shows an anchor, and FIG. 17C shows a reference relationship between the formatter and the anchor. As shown in FIG. 17A, the data structure of the formatter includes a formatter identifier 171 for identifying an allocation node, a corresponding anchor 172 that is a pointer to a corresponding anchor, and a list 173 of pointers to child formatters. ing.
[0074]
The data structure of the anchor is, as shown in FIG. 17B, an anchor identifier 174 for identifying the anchor, an anchor label 175 which is a label for displaying the anchor, and a corresponding formatter 176 which is a pointer to a corresponding formatter. , A reference field 177 which is a pointer to the field referenced by the anchor.
[0075]
Next, the operation of the present apparatus configured as described above will be described. FIGS. 27A to 27C show how a tree structure is designated from the network structure shown in FIG. When the user selects and clicks on the anchor icon to be assigned with the mouse on the interface for displaying the tree structure as shown in FIGS. A menu is displayed. By selecting "Generate Formatter" in this menu display, a formatter for allocating the field referenced by the corresponding anchor is generated and displayed as an icon surrounded by a thick line. The rectangular area indicated by a thin line is an anchor without a corresponding formatter, but indicates a candidate for selection to generate a formatter. When "Formatter Discard" is selected from the selection menu, the activated formatter is discarded. When the user clicks the anchor icon without selecting it, a selection menu shown in FIG. 29B is displayed, and by selecting “print” in the selection menu, each of the items forming the formatter tree is displayed. Assignment processing is performed by the formatter and output.
[0076]
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 processing using this formatter tree. FIGS. 33 and 34 show examples in which a formatter tree different from that in FIG. 30 is generated.
[0077]
The structure to be allocated is not limited to a partial structure of the network structure. FIGS. 35, 36, and 37 show the states when the designations in FIGS. 30 and 33 are performed simultaneously. In this case, since there is an overlapping portion, the structure is not exactly a partial structure.
[0078]
Next, a description will be given with reference to flowcharts shown in FIGS.
FIG. 41 shows the flow of the formatter tree management algorithm representing the processing contents of the formatter tree management unit 165.
It is assumed that the structure of the network type document to be processed is displayed, for example, as shown in FIG.
[0079]
(start)
(Steps S4110, S4111)
Monitor mouse clicks. If there is a click, the anchor / field selector 164 performs a process of selecting an anchor at the cursor position. For example, if the user moves the cursor by using the input unit 163 to select and click the anchor icon 272 (FIG. 27B) to be assigned, the anchor / field selection unit 164 determines the position of the cursor. The information about the anchor is notified to the formatter tree management unit 165.
[0080]
(Step S4112)
Depending on whether or not the anchor selection has failed, that is, whether or not there is an anchor icon at the cursor position, the flow proceeds to step S4113 if the anchor selection has succeeded, or to step S4114 if the anchor selection has failed.
[0081]
(Step S4113)
After the anchor is selected, a menu shown in FIG. 29A is displayed, and the user selects “Generate Formatter” or “Discard Formatter”. When “formatter activation generation” is selected, the process proceeds to step S4120, and when “formatter discard” is selected, the process proceeds to step S90.
[0082]
[Start 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 one. Therefore, the flow returns to step S4110 to wait for the selection of the next anchor;
[0083]
(Step S4121)
Generate a new formatter corresponding to the anchor. The formatter has a data structure shown in FIG. On the other hand, in the present embodiment, 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 the present embodiment. The pointer to the selected anchor is stored in the “corresponding anchor” column 172 of the newly created formatter.
[0084]
(Step S4122)
The newly generated formatter is placed 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.
[0085]
(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.
[0086]
[Stop Formatter]
(Steps S4130, S4311, S4123)
In the menu shown in FIG. 29A, when "discard formatter" is selected by the user, it is checked whether or not there is a formatter corresponding to the anchor, and if so, the corresponding formatter and all lower formatters are deleted. . Then, in step S4123, the formatter tree is displayed again. If not, the process returns to step S4110.
[0087]
(Steps S4114, S4140, S4147)
If it is determined in step S4112 that there is no anchor icon at the cursor position, the menu shown in FIG. 29B is displayed, and the user waits for selection. When "print" in the menu is selected, the formatter is executed. The control unit 167 performs an allocation process using a formatter tree, passes the allocation result to the printing unit 169, and prints out. When "end" is selected in the menu, the process ends.
[0088]
FIG. 42 is a flowchart showing a partial allocation processing algorithm in the processing of the formatter execution control unit 167. By executing this algorithm from the root formatter, allocation processing is performed using all formatter trees. 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.
[0089]
(Step S4201)
If the assignment of all basic units has not been completed, the first unassigned element is extracted.
[0090]
(Step S4202)
It is determined whether the basic unit is a reference unit.
[0091]
(Step S4203)
When the basic unit is a reference unit, a partial allocation process is executed for the logical unit referred to by the reference unit (recursive call), and the allocation result is received.
[0092]
(Step S4204)
Pour the allocation result into the rectangular area.
[0093]
(Step S4205)
When the basic unit is not a reference unit, since the basic unit is a character or the like, they are poured into a rectangular area.
[0094]
(Step S4206)
When all the basic units have been assigned, the assignment result is passed to the upper formatter.
[0095]
FIG. 43 shows the flow of the formatter tree display algorithm representing the processing contents of the formatter tree display generation unit 166.
[0096]
(Step S4300)
Display the label of the corresponding anchor in the figure indicating that the formatter is running.
[0097]
(Steps S4301 and S4302)
Check that all anchors in the referenced field have been displayed, and if there are any anchors that are not displayed, select the first anchor that is not displayed. When all the anchors in the referenced field have been displayed, the flow returns to step S4123 in FIG.
[0098]
(Steps S4303, S4304, S4305)
Checks whether the formatter corresponding to the selected anchor has been activated, and if so, applies the display algorithm for the corresponding formatter (recursive call); otherwise, confirms that the formatter has not been activated Display the label of the anchor in the shape shown.
[0099]
According to the present apparatus, a tree structure is generated from the components of the network structure according to an instruction from the user, and a necessary part of the network structure is selected by applying an allocation process to the generated tree structure. Assignment processing can be performed. Further, in the present embodiment, the use of the formatter tree structure as the secondary structure enables the control of the network structure allocation processing which could not be conventionally controlled by the user. Further, since the user selects a tree structure to be laid out, an appropriate layout template can be defined, and the layout processing in the structured document can be applied.
[0100]
Note that 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. A user can define a partial tree structure on this display device by defining a rectangular area. By using the formatter tree of FIG. 40 corresponding to this partial tree structure, the allocation result of FIG. 39 can be obtained.
[0101]
The allocation result can be displayed on a display as well as a hard copy. Conventionally, there has been a WYSIWYG system for matching a print on a hard copy with a display on a display, but this function has been limited to the output of the entire document. By matching the partial layout result with the print on the hard copy and the display on the display, it becomes possible to confirm only a necessary part of the document to be printed on the display. The necessary part is, for example, a part around the changed part when the change is made.
[0102]
(Explanation of the display target tree structure that is defined secondarily)
FIG. 45 shows the configuration of a network-type document processing apparatus based on a display target tree structure defined secondarily. The present embodiment is an apparatus which can present an arbitrary subtree structure to a user by a combination of windows in a network type document and interactively change the display state thereof. 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 the present embodiment, data is expressed by fields and anchors, but this data expression is not essential in the present invention. Data representation by nodes and links may be adopted. As shown in FIG. 45, the network-type document editing apparatus according to the present embodiment includes a document storage unit 451 such as a hard disk for storing a document structure, and an anchor management unit 4521 and a field management unit 4522 for managing the document structure. An input unit 453 such as a keyboard and a mouse for handling input from outside the apparatus; an anchor / field selecting unit 454 for selecting an anchor or a field referred to by the anchor by an instruction from the input unit 453; A window tree management unit 455 that manages the hierarchical structure as a window tree, a window display generation unit 456 that generates a window that displays fields, and a display unit 457 such as a display device that performs display are provided. Note that the document storage unit 451, the document management unit 452, the input unit 453, the anchor / field selection unit 454, and the display unit 457 are common to corresponding parts in FIG. 2 or FIG.
[0103]
FIGS. 46A and 46B show the data structure of this example. FIG. 46A shows the data structure of a window, and FIG. 46B shows the data structure of an anchor. In this embodiment, the window that is the root of the window tree is called a top window, and the other windows are called subwindows. As shown in FIG. 46A, the data structure of the window is a window identifier 461 for identifying the window, a corresponding anchor 462 which is a pointer to the corresponding anchor, and a window indicating whether the window is a top window or a subwindow. , A display area 464 indicating an area where a window is displayed, and a list 465 of pointers to child windows. “TOP” in the display state indicates a top window, and “SUB” indicates a subwindow.
[0104]
As shown in FIG. 46B, the data structure of the anchor is an anchor identifier 466 for identifying the anchor, an anchor label 467 which is a label for displaying the anchor, and information on display of a field referred to by the anchor. The display information 468 includes 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 displayed as the top window before the work was interrupted. "SUB" indicates that the field referred to by the anchor is being displayed in the sub-window or was displayed as a sub-window before the work was interrupted. “OFF” indicates that the field referred to by the anchor is not displayed, and is not displayed before the work is interrupted.
[0105]
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 value of the display area of the window shown in FIG. 47 and the display of FIG.
[0106]
This embodiment is an outline editor having a function of restoring a window tree at the end of editing when the editing is restarted by reflecting the tree structure of the window on data in the document structure.
When the display shown in FIG. 53 (a) is being performed, the window tree is as shown in FIG. 53 (b). This state is reflected in the data structure as display information (TOP, SUB, OFF) as shown in FIG. Those with no state indicate OFF.
[0106]
An icon corresponding to the anchor in the window is selected with the mouse and clicked to open the menu in FIG. 53 (c). By selecting "Open" in this menu, a sub-window is opened. Select "Close" to close the subwindow. By these operations, the states of TOP, SUB, and OFF change. By selecting the top window and performing "close", all windows are closed and the program is terminated. At this time, all display states are turned off. When "interrupt" is selected, the program ends without changing the state of TOP, SUB, and OFF.
[0107]
By referring to the display information in the data structure when editing is resumed, it is possible to restore the state of the window tree at the time of editing interruption.
When the top window or the subwindow is opened, if there is an anchor of “SUB” in the lower level, the subwindow displaying the field referred to by the anchor is opened.
[0108]
In this example, one window tree is managed. Further, since each anchor has only one display state, a state where the same anchor or field is shared cannot be expressed. If a function of sharing a plurality of window trees and fields is required, the state may be maintained for each display as shown in FIG. In this case, the display shown in FIG. 54B can be expressed together with the display shown in FIG.
[0109]
Note that it is possible to partially restore the window hierarchy without writing the TOP information. When only the SUB information is described as shown in FIG. 55 (a), accessing the “Description of the Invention” always includes the “claim” and “embodiment” in which the SUB is described in the lower window. Is generated. A window tree displaying a field corresponding to "" is generated. In the example of FIG. 55A, the display is as shown in FIG.
[0110]
This mechanism can be applied to other than the outline editor as long as the subtree structure is displayed by the hierarchical structure of windows. For example, display by a sub-window freely arranged in a window as shown in FIG. 55C can be realized by adding a simple modification to the configuration shown in the embodiment. A necessary modification in this case is to add the area information of the window to the display information.
[0111]
Next, a description will be given with reference to flowcharts shown in FIGS.
FIG. 56 shows the flow of the window tree management algorithm representing the processing contents of the window tree management unit 455.
[0112]
(Step S5611)
When the process starts, first, the anchor whose state is TOP is selected.
[0113]
(Step S5612)
Create a top window.
[0114]
(Step S5613)
In the generated top window, the field display algorithm (A) of FIG. 57 is applied to the field referenced by the selected anchor to display the field.
[0115]
(Step S5614)
When the user selects a window by clicking the mouse, a menu shown in FIG. 53C is displayed.
[0116]
(Step S5615)
If the selected menu item is “open” according to the item selected by the menu, the process proceeds to step S5630, if “close”, the process proceeds to step S5640, and if “interrupted”, the process proceeds to step S5650 to perform each process. I do.
[0117]
(Step S5630)
If "Open" in the menu is selected, it is checked whether an anchor is selected. If an anchor has not been selected, the process returns to step S5615.
[0118]
(Step S5631)
When the anchor has been selected, the state of the anchor (display information 468) is set to SUB.
[0119]
(Step S5632)
In the selection window, the processing of the field display algorithm (A) is called for the field corresponding to the selected anchor, and is displayed again. Then, the process returns to step S5615 to perform the next selection process.
[0120]
(Step S5640)
When "close" is selected from the menu, the state of the anchor corresponding to the selected window and all the windows under the selected window is turned off.
[0121]
(Step S5641)
Destroys the selected window and all its subwindows.
[0122]
(Step S5642)
It is determined whether or not the window is the top window. If the window is the top window, the process ends because all windows have already been discarded.
If it is not the top window, go to step S5632 and display again.
[0123]
(Step S5650)
If the selected menu is "interrupt", the selected window and all sub-windows below it are discarded, and the process ends.
[0124]
FIG. 57 shows the flow of the field display algorithm (A) representing the processing contents of the field display generation unit 456. This algorithm performs a process of displaying a field in a window, given a window and a field.
(Step S570)
It is determined whether all the primitives of the given field have been processed. If all the processing has been completed, the process returns to the original routine. If there are primitives to be processed, the processing is performed by the following steps.
[0125]
(Steps and 571)
Select the first primitive that has not been processed.
[0126]
(Step S572)
It is checked whether the primitive is an anchor. If it is an anchor, the process proceeds to step S573, and if not, to step S578.
[0127]
(Step S573)
The state of the anchor is checked by the display information 468 in the data structure of the anchor shown in FIG.
[0128]
(Step S574)
When the content of the display information is "SUB", a subwindow is generated and arranged in a given window.
[0129]
(Step S575)
The display algorithm (A) is applied and displayed on the field referred to by the anchor in the generated subwindow (recursive call).
[0130]
(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.
[0131]
(Step S577)
Places 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 arranged in the given sub-window.
[0132]
According to the present apparatus, the window tree management unit 455 manages the display target tree structure so that it is reflected in the data in the document structure. Therefore, when editing is resumed, the window tree at the end of editing can be restored. .
[0133]
(Second embodiment)
In general, a network structure can be freely expressed, but is much more difficult to handle than a simpler structure, for example, a tree structure. Therefore, it is effective to generate an easy-to-handle secondary structure from the network structure and use the structure to facilitate the operation of the network structure. The present invention is an invention that uses secondary structures such as a tree structure of history (history tree), a tree structure to be displayed (window tree), and a tree structure to be allocated (formatter tree). Was described in detail. In addition, since these have a tree structure, they are collectively referred to as a secondary tree structure in this specification. These secondary tree structures are interconnected but different.
[0134]
For example, referring to the document structure shown in FIG. 28 in the following procedure, the result is as shown in FIG.
(1) Open a window displaying "Description of the invention".
(2) Open a sub-window displaying "claims" in the "Description of Invention" window.
(3) Open a sub-window displaying “Example” in the “Description of the Invention” window.
(4) Open a sub-window displaying “Claim 1” in the “Claim” sub-window.
(5) Open a window displaying “Claim 2”.
(6) Open a window displaying “conventional technology”.
Further, the result of FIG. 58B is obtained by the following procedure.
(7) Close the "Example" subwindow
[0135]
The history tree, window tree and formatter tree at this time are shown in FIGS. 59 (a), (b) and (c), respectively.
The history tree is for expressing a part referred to by the user in the network type document. The history tree holds a history of references by the user 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 work performed in the network structure up to that time.
[0136]
The window tree is for specifying a portion to be displayed in the network type document. A part of the network-type document structure is presented to the user as a composite window represented by a window tree. The user edits the network structure via the synthesis window. By displaying the window tree as shown in FIG. 59 (b), it is possible to access necessary windows even when they are arranged in an overlapping manner.
[0137]
The formatter tree is for specifying a portion to be allocated in the network-type document structure. By specifying the tree structure to be allocated using the formatter hierarchy, it is possible to perform advanced allocation processing using a template. The formatter tree shown in FIG. 59C is specified irrespective of the above-mentioned reference procedure. For the specification, a device for displaying the data structure and the formatter tree in association with each other is required.
[0138]
By combining the functions for these secondary tree structures, more advanced functions can be realized. For example, it is conceivable to use a composite as follows.
(1) By using a history tree and a window tree in combination, an operation such as selectively deleting a window related to a specific work from a number of windows opened on the screen is performed. This is because the history tree can indicate the progress of work.
(2) By using a combination of a window tree and a formatter tree, information displayed by a 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.
[0139]
The fourth embodiment is an example in which the respective secondary tree structures shown in the first to third embodiments as described above are combined. In order to realize the above-described composite functions, it is not enough to simply combine the respective technologies.
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, and a browser that displays a formatter tree They will open on the same screen. In some cases, a browser that opens the data structure is opened. Moreover, the structures displayed in each browser are 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, in the “close” operation, only the window tree is updated.
[0139]
Thus, with a simple combination of each technology,
(1) Relationships between structures are not organized.
(2) The relationship between 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.
[0140]
Therefore, in the second embodiment, a plurality of secondary tree structures are clearly associated with each other, all the structures are unified and displayed simultaneously. Since a plurality of secondary tree structures are presented to the user as one structure, confusion for the user can be avoided. Further, by extracting each structure from the unified expression, it becomes easy to obtain a function using each structure or a combined function. In addition, the procedure for updating a plurality of structures at the same time becomes easier, and the efficiency of processing can be improved.
[0141]
In the second embodiment, data is represented by fields and anchors. This data representation is not essential in the present invention. Data representation using nodes and links may be used.
[0142]
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 portion to be allocated 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 portion to be allocated corresponds to the formatter tree.
[0143]
FIG. 61 shows the configuration of the second embodiment. As shown in FIG. 61, the network-type document editing apparatus according to this embodiment includes a document storage unit 611 such as a hard disk that stores a document structure, and a document management unit that manages a document structure including an anchor management unit 6121 and a field management unit 6122. An input unit 613 such as a keyboard and a mouse for handling input from outside the device; an anchor field selection unit 614 for selecting an anchor or a field referred to by the anchor according to an instruction from the input unit 613; A formatter tree management unit 615 that manages a tree structure to be allocated specified by the selection unit as a formatter tree, a document display generation unit 616 that generates a window that displays a part or the whole of a document, a display device that performs display, etc. Display part 167, execute formatter and assign It generates a result, a formatter execution control unit 618 to send to the display unit 617 or printing unit 619, via the document display generation unit 616 consists of a printing unit 169 for outputting the assignment result to the hard copy. The document storage unit 611, the document management unit 612, the input unit 613, the anchor / field selection unit 614, the display unit 617, and the like are common to the examples in FIGS. 2, 16, and 45, and the formatter tree management unit 615 The formatter execution control unit 618 and the printing unit 619 are common to the example of FIG.
[0144]
The document display generation unit 616 further includes a document structure display generation unit 6161 and a field display generation unit 6162.
The document structure display generation unit 6161 generates a window that displays the structure of a document, and corresponds to a browser in the related art. In this embodiment, a plurality of secondary tree structures are displayed in association with the document structure by displaying the anchor icons.
The field display generation unit 6162 generates a window for displaying a field. In this embodiment, a window is generated and a field is displayed using a formatter managed by the formatter management unit 615.
[0145]
FIG. 62 shows the data structure of the present embodiment, in which (a) shows a formatter, (b) shows a window, (c) shows an anchor, and (d) shows a field structure.
[0146]
The data structure of the formatter is, as shown in FIG. 62A, a formatter identifier 62a1 for identifying an allocation node, a corresponding anchor 62a2 which is a pointer to a corresponding anchor, and a corresponding window which is a pointer to a corresponding window. 62a3 and a list 62a4 of pointers to the child formatters.
[0147]
As shown in FIG. 62 (b), the data structure of the window is a window identifier 62b1 for identifying the window, a display area 62b2 representing an area where the window is displayed, a pointer 62b3 to the upper window, and a pointer to the child window. Consists of a list 62b4.
[0148]
As shown in FIG. 62 (c), the data structure of the anchor is an anchor identifier 62c1 for identifying the anchor, an anchor label 62c2 which is a label for displaying the anchor, and a pointer to a field referred to by the anchor. It consists of a reference field 62c3.
[0149]
As shown in FIG. 62 (d), 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 type of collective relation defined by the field, and a pointer to a corresponding formatter It consists of a formatter 62d3 and a list 62d4 of primitives included in the field.
[0150]
FIG. 63 shows a reference relationship among formatters, anchors, fields, and windows.
This reference relationship corresponds to a part of the states shown in FIGS. FIG. 65 shows that a window 652 displaying a field referred to by a “claims” anchor is opened in a window 651 displaying a field referred to by a “description of the invention” anchor.
[0151]
As described above, this embodiment is an apparatus for centrally managing and displaying the entire tree structure in order to simplify operations on a history tree, a window tree, and a formatter tree. FIG. 64 shows a display example according to this embodiment when the operation shown in FIG. 58B is performed. This display simultaneously displays 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 the icon indicating the anchor. Prior to the description of the display, a unified management method of a tree structure in the present embodiment will be described.
[0152]
In the present embodiment, the window tree and the history tree are related by adding a new role to the formatter tree.
In the second embodiment, the formatter tree specifies a subtree structure to be output, allocates the subtree structure, and outputs it. The role of each formatter in the formatter tree is to perform a partial allocation process for output. In the present embodiment, as a role of the formatter, an allocation process for display in a window is added. That is, the formatter is provided with two types of allocation algorithms for window display and output. Since the formatter performs window display allocation processing, a corresponding formatter is always generated when a window is displayed.
[0153]
When the formatter defined as described above is used, when a window is opened, a formatter is generated, and the allocation processing for window display is executed. When the windows are configured hierarchically, the formatters are also generated hierarchically and execute the allocation processing. From this, the window tree can be represented as a formatter tree.
[0154]
The formatter will not disappear when the window is closed. That is, the formatter tree remains even if the corresponding window tree disappears. In this way, the history of window display, that is, the history tree that is the history of reference, can be expressed as a formatter tree.
[0155]
In order to further associate the history tree, window tree, and formatter tree, which are associated with each other as described above, with a data structure, the combinations of 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 an anchor icon.
[0156]
The state of SLEEP, READY, SUB, and TOP shown in FIG. 66 is defined by the combination of the state of the formatter and the window corresponding to the anchor. The state obtained by adding the state of ELSEWHERE to this is called an anchor state.
(1) The 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 subwindow.
(5) ELSEWHERE: In the state, the formatter corresponding to the field referenced by the anchor has been generated from another anchor.
[0157]
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 the anchor state.
[0158]
This embodiment allows a plurality of anchors to refer to the same field. On the other hand, a formatter is constructed by selecting an anchor icon and opening a window. For this reason, a plurality of formatters corresponding to the same field may be defined. In the present embodiment, for the sake of simplicity, a limitation is provided that the number of formatters corresponding to a field is one. For this reason, it is necessary to display the ELSEWHERE state. Although the configuration is somewhat complicated, it is not difficult to make a plurality of formatters correspond to one field.
[0159]
As shown in FIG. 68, a formatter tree, a history tree, and a window tree are obtained by selecting a specific state from the five state anchors as shown in FIG.
[0160]
FIG. 64 shows a display example according to this embodiment when the operation shown in FIG. 58B is performed.
The window tree has a structure based on TOP and SUB anchors.
The formatter tree has a structure in which a READY anchor is further added.
The history tree has a structure in which SLEEP and ELSEWHERE anchors are further added. These anchors will indicate candidate references.
As shown in FIG. 65, by using an anchor icon in a window for displaying a field, it is also possible to clarify the relationship with each displayed tree structure.
[0162]
In the present embodiment, a plurality of tree structures are displayed to the user in an easily understandable form. In addition to this function, a required tree structure is extracted from the conditions in FIG. 68, and the extracted tree structure is used together with the inventions (first to third embodiments) using the respective features.
That is,
(1) The history of references to the document structure can be stored and displayed as a tree structure (first embodiment).
(2) For the formatter tree used for window generation, by changing the allocation processing to that for output, the referenced portion can be output (second embodiment).
(3) By saving the anchor state, the display can be restored even if the editing is temporarily suspended (third embodiment).
[0163]
Next, the operation of the document display generation unit 616 for displaying the secondary tree structure in the present embodiment will be described. The operation of the other parts is as described in any of the first to third embodiments.
[0164]
In order to display the document structure, processing is performed in accordance with the anchor state. Therefore, determination processing for that is necessary. FIG. 69 shows an anchor state determination algorithm.
[0165]
(Step S690)
Anchor information is acquired from the anchor management unit 612 and is set as a current anchor.
[0166]
(Step S691)
Checks whether the field referenced by the current anchor has a corresponding formatter. This is performed by examining the corresponding formatter 62d3 (FIG. 62 (c)) of the field shown in the reference field 62c3 (FIG. 62 (c)) of the current anchor.
If there is no formatter, it is determined to be SLEEP.
[0167]
(Step S692)
For the formatter obtained in step S691, it is checked whether or not the corresponding anchor 62a2 (FIG. 62 (a)) matches the current anchor. If it does not match the current anchor, it is determined to be ELSEWHERE.
[0168]
(Step S693)
For the formatter obtained in step S691, it is checked whether there is a corresponding window by using the corresponding window 62a3 (FIG. 62 (a)), and if there is no corresponding window, it is determined to be READY.
[0169]
(Step S694)
The window is checked whether it is the top window by the upper window 62b3 (FIG. 62 (b)). If a higher-level window is specified, it is a subwindow; otherwise, it is a top window. If it is not the top window, it is determined that it is SUB, and if it is the top window, it is determined that it is TOP.
[0170]
FIG. 70 is a structure display algorithm showing the processing of the document structure display generation unit 6161.
[0171]
[start]
(Step S700)
The partial structure display algorithm (B) is applied to the root anchor. [End]
[0172]
FIG. 71 shows a partial structure display algorithm.
(Step S711)
The anchor state is determined by the anchor state determination algorithm (A) of FIG. 69. If the state is ELSEWHERE or SLEEP, the process proceeds to step S712. If the state is READY, TOP, or SUB, the process proceeds to step S713.
[0173]
(Step S712)
If the result of the above determination is that the anchor state is ELSEWHERE or SLEEP, the corresponding anchor icon is displayed.
[0174]
(Step S713)
If the anchor status is READY, TOP, or SUB as a result of the determination, the corresponding icon is displayed.
[0175]
(Step S714)
It is checked whether or not there is an anchor in the field referred to by the anchor. If there is, go to the next step S715, otherwise return to the original routine.
[0176]
(Step S715)
Apply the substructure display algorithm (B) to all anchors in the field (recursive call).
[0177]
(Step S716)
A field display generation unit 6162 generates a graphic representing a field, and displays it on the display unit 617.
[0178]
According to the present embodiment, a plurality of secondary tree structures, that is, a history tree, a window tree, a formatter tree, and the like are clearly associated with each other, and as shown in FIG. be able to.
[0179]
【The invention's effect】
Conventionally, a simple secondary structure was generated from the network structure to simplify the handling of the network structure. However, the structure itself, its generation method, or its management method was simple. Because of this, it was difficult to express necessary information, perform allocation processing, and appropriately display windows in a hierarchical manner. According to the present invention, these problems can be solved.
[00180]
That is, according to the present invention, a network-type document can be easily processed by extracting a secondary tree structure from a network structure and using the secondary tree structure. By displaying the secondary tree structure to the user, the operation of the network type document by the user can be simplified.
[0181]
Further, according to the present invention, the reference history is managed as a tree structure having node candidates in the width direction and the reference order in the depth direction, and is presented to the user. And a document processing apparatus that can perform the processing.
In other words, the conventional history list is one of the secondary structures, but the structure is too simple to express all the information necessary for history management. According to the present invention, the history of the work progress can be expressed in an easy-to-understand manner by expressing the history with a tree structure generated secondarily from the network structure.
[0182]
According to the present invention, a tree structure to be allocated is generated from components of a network structure according to a simple instruction from a user. The tree structure to be assigned is a secondary tree structure. However, in the related art, the generation method was too simple, so that the user could not obtain a necessary structure. In the prior art, a tree structure to be allocated is generated by starting a search from a node selected by a user as a starting point and stopping by detecting a leaf or a loop, but the user can specify a required allocation target. could not. According to the present invention, a user can interactively generate a tree structure to be allocated as a secondary tree structure by presenting a structure that has been extracted by an arbitrary interpretation by a computer. The used allocation process becomes easy. That is, a means for generating a tree structure from the components of the network structure in accordance with an instruction from the user is provided, and by applying an allocation process to the generated tree structure, a necessary portion of the network structure is selected and allocated. A document processing device capable of processing can be obtained.
[0183]
Further, according to the present invention, it is possible to generate and manage a window hierarchy for displaying an arbitrary subtree structure in a network structure. Therefore, it becomes possible to use the outline editor, which has been conventionally used only for editing the tree structure, for editing the network structure.
[0184]
Further, according to the present invention, it is possible to obtain 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 simultaneously displaying them. As a result, in addition to the functions provided by the respective secondary tree structures, it is possible to provide the user with a further advanced operation of the network structure by combining them.
[Brief description of the drawings]
FIG. 1 is a diagram showing a configuration corresponding to the invention of claim 1;
FIG. 2 is a block diagram showing a configuration of a first embodiment.
FIGS. 3A and 3B show the data structure of tree-structured data generated secondarily according to the first embodiment. FIG. 3A shows a history node, and FIGS. 3B and 3C show a history node and an anchor. Diagram showing reference relationships
4A and 4B are diagrams 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 a display, and FIGS. FIG. 10A shows a series of processes for searching for data, FIG. 10B shows a display example of a history tree according to the present embodiment corresponding to the window of FIG. 10A, and FIG. It is a display example.
5A is an example of a window displayed in the display, FIG. 5B is a display example of a history tree according to the present embodiment corresponding to the window of FIG. 5A, and FIG. Display example of history list by example
6A is an example of a window displayed in the display, FIG. 6B is an example of a history tree display according to the present embodiment corresponding to the window of FIG. 4A, and FIG. Display example of history list by example
7A is an example of a window displayed in the display, FIG. 7B is a display example of a history tree according to the present embodiment corresponding to the window of FIG. Display example of history list by example
8A is an example of a window displayed in the display, FIG. 8B is an example of a history tree display according to the present embodiment corresponding to the window of FIG. Display example of history list by example
9A is an example of a window displayed in the display, FIG. 9B is an example of a history tree display according to the present embodiment corresponding to the window of FIG. Display example of history list by example
FIG. 10A is an example of a window displayed in the display, FIG. 10B is an example of a history tree display according to the present embodiment corresponding to the window of FIG. Display example of history list by example
FIG. 11 is a flowchart of a field reference algorithm representing the content of processing of a field reference unit 24;
FIG. 12 is a flowchart of a history tree algorithm representing the contents of processing of a history tree management unit 25;
FIG. 13 is a flowchart of a history tree display algorithm representing the contents of processing of a history tree display generation unit 26;
14A and 14B are diagrams illustrating an example of a data structure of a network-type document used in the first embodiment. FIG. 14A illustrates a data structure of a field, FIG. 14B illustrates a data structure of an anchor, and FIG. Diagram showing reference relationships
FIG. Outline of a network-type document processing device using a tree structure to be allocated Diagram showing configuration
FIG. Use the tree structure to be allocated FIG. 2 is a block diagram illustrating a configuration of a network type document processing apparatus
FIG. ( a) is a formatter, (b) is an anchor, and (c) is a diagram showing a reference relationship between the formatter and the anchor.
FIG. 18 is a diagram illustrating an example of a tree structure expressing a document.
19 is a diagram showing a result of performing an allocation process on the tree structure of FIG. 18 according to the related art.
FIG. 20 is a view showing an example of expressing a document having the structure of FIG. 18;
FIG. 21 is a diagram showing a hierarchical structure of a formatter.
FIG. 22 is a diagram showing a hierarchical structure of a formatter and illustrating a process of an allocation process together with FIG. 23;
FIG. 23 is a diagram showing a hierarchical configuration of an area allocated by the formatter, and together with FIG. 22 is used to explain the process of allocation processing;
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 shown in 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.
FIGS. 27A to 27C show how a tree structure is designated from the network structure shown in FIG. 28; Figure .
FIG. 28 is a diagram illustrating an example of a network structure for explaining the embodiment;
FIGS. 29A and 29B are diagrams showing examples of a selection menu used in the allocation processing.
FIG. 30 is a diagram showing an example of referring to a tree structure displayed on a display (a thick line indicates a selected portion)
FIG. 31 is a diagram showing a formatter tree generated by selecting the tree structure shown in FIG. 30;
FIG. 32 is a diagram showing a result of performing the entire allocation processing using the formatter tree of FIG. 31;
FIG. 33 is a diagram showing another reference example of a tree structure;
FIG. 34 is a view showing the allocation result of FIG. 33;
FIG. 35 is a diagram showing a reference example in which the designations of FIG. 30 and FIG. 33 are performed at the same time;
FIG. 36 is a diagram showing a result of the assignment of FIG. 35;
FIG. 37 is a diagram showing a formatter tree generated by selecting the tree structure shown in FIG. 35;
38 is a diagram illustrating an example in which the entire logical structure of the tree structure illustrated in FIG. 18 is displayed, and a user specifies a rectangular area to define a partial tree structure.
FIG. 39 is a diagram showing a result of allocating the selected subtree structure of FIG. 38;
40 shows 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 processing contents 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 illustrating a flow of a formatter tree display algorithm representing processing contents of the formatter tree display generation unit 166.
FIG. 44 Outline of network type document processing device using tree structure to be displayed Diagram showing configuration
FIG. 45 is a diagram illustrating a configuration of a network-type document processing apparatus that performs display by combining windows.
FIG. 46 ( a) is the data structure of the window, and (b) is the data structure of the anchor.
FIG. 47 is a diagram showing a reference relationship between a window tree and an anchor.
FIG. 48 is a diagram showing an example of a window display area.
FIG. 49 is a diagram for explaining a conventional window, in which (a) shows an example of a network structure, and (b) to (c) show card-type windows.
FIG. 50 is a diagram for explaining a conventional hierarchical window, where (a) is an example of a network structure and (b) is a menu for selecting a node;
FIG. 51 is a diagram showing a state in which the window of the document having the network structure shown in FIG.
FIG. 52 is a view showing a network structure including display information (TOP, SUB, OFF);
53A shows a window obtained from the display information and its structure in FIG. 52, FIG. 53B shows a corresponding window tree, and FIG. 53C shows a menu
54A and 54B are diagrams showing a case where a plurality of window trees and fields are shared, in which FIG. 54A shows that a state is maintained for each display, and FIG.
FIG. 55 (a) shows an example of a network structure in which only SUB information is described, FIG. 55 (b) shows an example of a window display in which a display area is designated by adding area information, and FIG. Illustration
FIG. 56 is a diagram showing the flow of a window tree management algorithm representing the processing contents of the window tree management unit 455.
FIG. 57 is a diagram showing a flow of a field display algorithm (A) representing processing contents of the field display generation unit 456.
FIGS. 58A and 58B 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, (a) showing a history tree, (b) showing a window tree, and (c) showing a formatter tree.
FIG. 60 2 Showing a configuration corresponding to the invention of FIG.
FIG. 61 2 Block diagram showing the configuration of the embodiment of FIG.
FIG. 62 2 6A and 6B show a data structure of the embodiment, in which FIG. 7A shows a formatter, FIG. 7B shows a window, FIG. 7C shows an anchor, and FIG.
FIG. 63 is a diagram showing a reference relationship among a formatter, an anchor, and a window.
FIG. 64 is a view 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 relationship with the display of a structure.
FIG. 66 is a diagram showing a definition of an anchor state based on a combination of a formatter and a window state;
FIG. 67 is a diagram showing an anchor icon corresponding to 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 a flow of a structure display process in a document structure display generation unit 6161.
FIG. 71 is a diagram showing a flow of a partial structure display process in a document structure display generation unit 6161.
[Explanation of symbols]
11, 151, 441, 601: document management means, 12: logical unit reference means, 13: history tree structure management means, 151: tree structure allocation means, 153: allocation target tree structure management means, 442: display target tree structure management Means, 602: secondary tree structure display means, 603: secondary tree structure management means,
21, 161, 611: Document storage unit, 22, 162, 612: Document management unit, 221, 1621, 4521, 6121, ... Anchor management unit, 222, 1322, 4522, 6122 ... Field management unit, 23, 163, 454 , 613 ... input unit, 24 ... field reference unit, 241, 164, 454, 614 ... anchor field selection unit, 242 ... field display generation unit, 25 ... history tree management unit, 26 ... history tree display generation unit, 27, 168, 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, 6 9 ... the printing unit.

Claims (5)

In an apparatus for processing a document structure configured by associating predetermined constituent units,
Document management means for managing a document structure in which a constituent unit is a logical unit that is a logical unit of a document, and the logical unit is related by a reference unit that defines a reference relationship between the logical units;
A reference unit in a logical unit is specified in accordance with a user's instruction, and a logical unit including a logical unit selecting unit for selecting the logical unit to be referred to and a logical unit display unit for displaying the selected logical unit is referred to. Logical unit reference means;
A network type management unit for managing a reference history of a logical unit as a tree structure that associates a referenced logical unit with a reference unit that has been another candidate at the time of the reference. Document processing device. In an apparatus for processing a document structure configured by associating predetermined constituent units,
Document management means for managing a document structure in which a constituent unit is a logical unit that is a logical unit of a document, and the logical unit is related by a reference unit that defines a reference relationship between the logical units;
Secondary tree structure management means for managing a tree structure defined secondary from a document structure, and a secondary tree for displaying the secondary tree structure in association with a document structure or another secondary tree structure A network type document processing apparatus comprising: a structure display unit. Associating a combination of states relating to a plurality of secondary tree structures with a display rule of a logical unit or a reference relation,
The secondary tree structure display means applies display rules in displaying the document structure,
3. The network-type document processing apparatus according to claim 2, wherein a plurality of secondary tree structures and a document structure are displayed in association with each other. 4. The document structure processing apparatus according to claim 3, wherein the secondary tree structure is an allocation target tree structure, a display target tree structure, a history tree structure, or any combination thereof. A document management unit that manages a document structure in which a constituent unit is a logical unit of a document as a logical unit and associates the logical unit with a reference unit that defines a reference relationship between the logical units, and a logical unit according to a user instruction. A logical unit selecting means for specifying a reference unit in the unit, a logical unit selecting means for selecting a logical unit to be referred to, and a logical unit displaying means for displaying the selected logical unit; A document by a network-type document processing apparatus including a history tree structure management unit that manages a history of referencing a logical unit as a tree structure that associates a referenced logical unit with a reference unit that was another candidate at the time of reference. A processing method, wherein a reference unit in a logical unit is specified according to a user's instruction, and a logical unit to be referred to is selected (S1110);
Displaying the selected logical unit (S1111);
Search the history tree by the reference unit, check whether there is a corresponding history node, and when there is no history node, newly generate a history node corresponding to the reference unit, in the column of the corresponding reference unit of the history node Storing a pointer to the selected reference unit and storing a list of reference units in a logical unit referred to by the reference unit as a list of candidate reference units in the history node (S120, S121);
Selecting a history node corresponding to the current logical unit being referred to and deleting the corresponding reference unit from the candidate reference units of the selected history node (S123, S124);
Adding the newly generated history node to the child history node list of the history node (S125).

Images