JPH0764972A - Structural document editing system - Google Patents

Abstract

PURPOSE:To permit a user to grasp document structure at a glance. CONSTITUTION:When an editor reads an SGML document, DTD(document-type definition), at first, an input is analyzed by an SGML parser 2. An SGML parser 2 generates a finite automaton (DFA) 5 in accordance with DTD as an analyzed result and stores it in DTD holding part 3. DFA 5 expresses the possible arrayal of low-order node in respective tags. DFA 5 is generated every tag which is defined by DTD. In a succeeding processing, it is utilized so as to continue analyzing the SGML document. Tree structure corresponding to document structure is generated in an internal part as the result of the analysis of the SGML document itself. Generated tree structure is stored in a document storing part 4.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a structured document editing method, and more specifically, displaying a document instance based on a document type definition in an indented tree structure so that the document structure can be grasped at a glance. This relates to a structured document editing method.

[0002]

The SGML standard is a standard for standardizing the exchange of structured documents. The structure of a document is defined by a document type definition (DTD). When creating a document according to the document structure specified by DTD, it is necessary to input the tag as plain text at the same time as the content and process the SGML document by batch processing, or use a structured document editor with a dedicated edit function. There is. In a conventional structured document editor, a method of expressing a start tag and an end tag on the screen at the same time as the list of the writer of the document is used as the expression of the tag.
This method has drawbacks such as the range of tags is difficult to understand at a glance, the hierarchical relationship of tags is difficult to understand at a glance, and editing operations in structural units are difficult.

[0003]

[Purpose] The present invention has been made in view of the above situation, and a document instance based on a document type definition is expressed by an indented tree structure, and a tag is expressed as a node. The purpose of the invention is to provide a structured document editing method that allows a document to be expressed without any information.

[0004]

In order to achieve the above object, the present invention provides (1)
Input means for inputting an SGML document, analysis means for analyzing the SGML document input by the input means, creation means for creating a finite automaton corresponding to the document type definition as the analysis result of the analysis means, and the creation Storage means for holding a finite state automaton created by the means, and the SG
The ML document itself includes a tree structure creating unit that creates a tree structure corresponding to the document structure as a result of the analysis, and a document holding unit that stores the tree structure created by the tree structure creating unit. Displaying document instances based on the definition in an indented tree structure, and
(2) When a substructure is automatically inserted based on the document type definition at the time of creating a new tag, if the substructure has ambiguity based on the document type definition, a new tag creation having a mechanism for selecting it Having means, and further,
(3) When a new tag is created, it has a new tag creating means for automatically inserting a node having no ambiguity in a lower structure based on the document type definition, and (4) based on the document type definition. When displaying a document instance, if the substructure of a certain tag does not satisfy the document type definition, the node whose substructure is incompatible is shown to the user by highlighting, and further, (5) the document type definition When displaying a document instance based on, a display means for hiding a lower structure of a certain tag is provided, and (6) when displaying a document instance based on the document type definition, a certain tag including a lower structure is included. (7) When displaying a document instance based on the document type definition, a certain tag including a substructure is stored in the Yank buffer, Having an insertion means for insertion into any position on the document instance, furthermore, when displaying a document instance based on the document type definition (8),
In the means for moving / inserting a certain tag, the moving destination is limited according to the document type definition. Hereinafter, description will be given based on examples of the present invention.

FIG. 1 is a block diagram for explaining an embodiment of a structured document editing system according to the present invention, in which 1 is an SGM.
L document, 2 is SGML parser, 3 is DTD (Document T
ypeDefinition: document type definition) storage unit, 4 document storage unit, 5 DFA (finite automaton), 6 edit processing unit, 7 document tree structure, 8 Yank Buffer, and 9 display input unit.

The input of the editor is the SGML document 1.
In the SGML document 1, the DTD designation or the DTD itself is described. The editor receives the SGML document 1 as an input and stores the edited result as an output in the SGML document format. In the case of a new document, the user is asked to specify the DTD and only the DTD is read. Editor is SGM
When reading an L document / DTD, the input is SGML first.
Analyze with parser 2. The SGML parser 2 creates a finite state automaton (DFA) 5 as shown in FIG. 2 corresponding to the DTD as the analysis result, and stores it in the DTD holding unit 3. DFA5 represents a possible sequence of nodes under each tag. Figure 2 shows D for one tag "kaigi"
FA. A DFA 5 is created for each tag defined by DTD. In the subsequent processing, it is used to continue the parsing of the SGML document. As a result of the analysis of the SGML document itself, a tree structure corresponding to the document structure is created inside, as shown in FIG. The created tree structure is stored in the document holding unit. In other words, by expressing the document in a tree structure and expressing the tags as nodes, the document is expressed without the start and end tags (claim 1).

[0007] Each node of the tree structure holds information for each type. Tag: Tag name, attribute data: Character string data processing instruction: Character string data In addition, information common to nodes is also stored. Possible state: Whether the node should be displayed on the screen Highlight: Should it be highlighted on the screen Node pointer: Parent, child, sibling pointer information to each node

How to use these pieces of information will be described later. Figure 4
2 shows a part of the DTD of the SGML document corresponding to FIGS. Further, FIG. 5 shows a part of an example of a document using the DTD of FIG. The editor displays the indented tree structure on the display unit corresponding to the tree structure of FIG. Figure 6
The screen of the embodiment using X11R5 and Motif1.2 is shown in FIG.
In the embodiment, the indented tree structure on the screen is Widge
It is expressed by t. Widget is an X11 object on the screen. Events such as mouse and key input are W
It is processed by the callback function registered in idget.

In FIG. 7, the new creation is selected from the menu.
It is a processing flowchart of the callback called in the case
It Hereinafter, each step will be described in order.step1 : First, generate the top tag specified by DTD
Then, the tag is set to x. step2 : Next, it is determined whether x is absent. without x
If it ends.step3 : If there is x in step 2, then x
The DFA corresponding to is taken out.step4 : Next, when the DFA node pointer is p,
Put p in the DFA start state.step5 : Next, it is determined whether p is in the end state.

Step 6 : In step 5, if p is in the end state, the node generated as a child of x is repeated as x. step7: In the step6, p is if the end condition, then p determines whether ambiguous. If p is ambiguous, go to step 10 described later. step8 : In step 7, if p is not ambiguous, then p is advanced to the next transition destination. step9 : Next, if the position of p is a tag, the tag is generated as a child of x, and the process returns to step5. step10 : If p is ambiguous in step 7, then it is determined whether or not the mode is the interactive mode. Exit if not in interactive mode. step11 : In the step 10, if in the interactive mode, a dialog is displayed, a transition destination is selected, and p is advanced to the selected transition destination.

That is, in the case of new creation, the DTD is created inside by allowing the user to specify the DTD and analyzing the DTD with the parser. In the past, only the top node indicated by DTD was generated. In this method, lower nodes are further created using DTD DFA. At this time, transition the DFA state,
Corresponding nodes are created, but if there are multiple transition destinations, that is, there are multiple arcs, it is ambiguous. In the procedure, there is a flag indicating whether it is in interactive mode,
When this flag is true, a dialog is displayed, the user is presented with a candidate for a transition destination, and selection is made to proceed the processing. When it is false, the processing is terminated (claims 2 and 3).

Such a node can be generated not only at the time of creating a new document but also at the time of creating individual nodes in the editing process, by simultaneously generating the lower nodes. That is, when a document having a document structure represented by DTD is created, it is conventionally created by specifying each tag. In order to make this work more efficient, it is possible to automatically insert the substructure according to the document type definition. In this case, there is a possibility that the lower document structure may not be uniquely determined, but as a method, a method of generating a partial sequence that is uniquely determined and a method of selecting a possible generation sequence can be considered.

FIGS. 8A and 8B are flowcharts showing the display procedure of the nodes. Hereinafter, each step will be described in order. In FIG. 10A, first, the root of the tree structure of the document holding unit is substituted for the variable x (step 1), and sub is called (step 2). In the figure (b), first, a Widget corresponding to x is generated at a position indented with respect to the parent (ste
p1). Next, node check processing is performed (step 2),
It is determined whether the highlight flag is true (step 3).
If the highlight flag is true, the Widget is highlighted (step 4). If the highlight flag is not true, then it is determined whether the visible state is true (step 5). If the visible state is true, the process is terminated. If the visible state is not true, it is judged whether or not there is a child next (step 6). If there is no child, the process is terminated, and if there is a child, the next Substituting the child into x for each child and calling sub, and the process ends.

That is, when displaying a tree-structured node,
Check the visible state of the node and the highlighted state of the node and reflect them on the display. In the example,
The objects on the display are realized as Widget. A callback function is activated for each Widget in response to a mouse keyboard event.

In the process of such editing operation, SGML is used.
There is a possibility that the structure does not conform to the document structure of. In the conventional editor, SG or
This is dealt with by performing the ML parsing in batches or by restricting only compatible structures to be created in the editing process. According to this method, the nodes whose substructures are incompatible are shown to the user by displaying highlights or the like, thereby allowing the incompatibility in the editing process and facilitating the creation of a document conforming to the document structure (claim 4). ). When editing a huge document, there are times when you want to see the structure of its tags at a rough level. In such a case, by hiding the structure below the tag, the structure of the tag can be easily grasped (claim 5).

FIG. 9 is a flowchart of the node check process of step 2 in FIG. 8 (b). Hereinafter, each step will be described in order. step1 : First, it is checked whether the node x is a tag node. step2 : Pointer p to the start position of DFA corresponding to the tag
Put. step3 : Next, it is determined whether the pointer p is in the end state. step4: in the step3, if p is the end state,
The highlight is false.

[0017] step5: In the step3, if not p is the end state, then it is determined whether or not the child does not exist. If there are no children, go to step 9 described below and set the highlight to true. step6 : If there is a child in step 5, the child of the node is set to y. step7 : Next, the transition of p is searched for corresponding to y. step8 : Next, it is determined whether the transition cannot be made. Step 9 : If the transition cannot be made in Step 8 , the highlight is set to true. step10 : In step 8, if the transition can be made, the transition destination is p
Then, go to step 3 above.

FIG. 10 is a diagram showing a screen example of the result of node movement. The movement on the screen is realized as a callback function when dragging is performed on the Widget indicating the node. In FIG. 10, when the node is moved by the drag operation, the tree structure is changed accordingly, and then the callback function is set to perform the display operation of FIG. The name tag will be duplicated in sakusei due to the move, and it will be highlighted because it does not conform to DTD. Also,
Since shusai has no name, it no longer matches and is highlighted. In editing a structural document, it is convenient to be able to edit in a certain partial structure (tag including substructure) as a unit. When a tag like this method is a tree-structured node, it is conceivable to implement a mechanism for moving a partial structure by dragging the node with a mouse (claim 6).

FIG. 11 is a diagram showing a flow chart of node migration. Hereinafter, each step will be described in order. First, the root of the tree structure is the destination node (step 1),
Let the node of interest be y (step 2). Next, it is determined whether y is a tag node (step 3), and if y is not a tag node, the process ends. If y is a tag node, the child of y is transited to the finite state automaton of the content model of y (step 4). Next, it is determined whether the same node as x can come during the transition (step 5). If no, go to step 7 described later, and if yes, add to the destination list (step 6). Next, the child of y is recursively repeated as a node of interest (step 7).

FIGS. 12 (a) and 12 (b) are flowcharts of the mouse movement / release processing. Figure (a)
Is a mouse movement callback, and FIG. 9B is a flowchart of mouse release callback. Hereinafter, each step will be described in order. In FIG. 10A, first, the node closest to the mouse position is taken out from the move destination list (step 1), and the node is dragged to the move destination position (step 2). In FIG. 6B, first, the dragged node is moved to the drag destination node position (step 1), and the node check procedure is called for the parent node of the drag source and the drag destination (step 2).

That is, in this processing, first, the W
Called when dragged as a callback function of idget, the process of searching for a moveable place is performed. Get a list of places you can go to by searching the destination. The callback function of the drag process on the screen is as follows. There are two callback processes, one is the movement on the screen, and the other is the process when the mouse button is released at that position. When the mouse button is released, it moves the node that was moving along with its child node. After the move, call the node check procedure and highlight the parent node if the move does not match the node order to the content model of the parent node.

In editing the structural unit, cut the structure &
It would be convenient if there was a pasting mechanism. In the conventional editor, there is no cut and paste of the structural unit that the tag makes. Therefore, a buffer for holding the partial structure is required (claim 7). In addition, when pasting or moving a structural unit, it is often inserted at a position according to the document type definition. Therefore, by restricting the insertion position with respect to the tag, it is possible to move and paste without fail (claim 8).

FIGS. 13A and 13B are flow charts of the cut / paste processing. FIG. 7A is a flow chart of the cutting process, and FIG. 6B is a flow chart of the paste process. Hereinafter, each step will be described in order. In the figure (a), first, the node of interest is set to Ya
Move to the nk buffer (step 1), and call the node check procedure for the parent node at the place where the target node was (step 2). In FIG. 6B, first, it is determined whether or not a node exists in the Yank buffer (step 1), and if it exists, the move destination list creation procedure is called (step 2), and the position of the move destination list closest to the edit target position is determined. At Yank buff
Insert the contents of er (step 3).

[0024]

As is apparent from the above description, the present invention has the following effects. (1) Effect corresponding to claim 1: Since the document instance based on the document type definition is displayed by the indented tree structure, the user can grasp the structure of the document at a glance. (2) Effect corresponding to claim 2: When a substructure is automatically inserted based on the document type definition when creating a new tag, if the substructure is ambiguous based on the document type definition, select it Since it has a new tag creation mechanism having a mechanism for allowing the user to do so, the user can save time and effort for inserting a fixed tag. (3) Effect corresponding to claim 3: When a new tag is created, a new tag creation mechanism characterized by automatically inserting a node with no ambiguity in the substructure based on the document type definition is provided. , Since it is automatically inserted interactively, the user can save the trouble of inserting a fixed tag. (4) Effect corresponding to claim 4: When a document instance based on a document type definition is displayed, if the lower mechanism of a certain tag does not satisfy the document type definition, it is shown to the user by highlighting it. Since the node that violates the DTD is visible on the display, the user can clearly see the points to be corrected. (5) Effect corresponding to claim 5: When the document instance based on the document type definition is displayed, since the display mechanism for hiding the substructure of a certain tag is provided, the portion which the user thinks is unnecessary on the display is displayed. Since it can be hidden, it becomes easier to understand the tree structure. (6) Effect corresponding to claim 6: When displaying a document instance based on the document type definition, since it has a mechanism for moving a certain tag including a substructure, it is possible to move a partial structure of a tree structure and edit it. , You can easily change the tree structure. (7) Effect corresponding to claim 7: A mechanism that, when displaying a document instance based on a document type definition, stores a certain tag including a substructure in a Yank buffer and inserts it at an arbitrary position on the document instance. Since it has, the partial structure of the tree structure can be easily copied and deleted, and the tree structure can be easily changed at the time of editing. (8) Effect corresponding to claim 8: When displaying a document instance based on a document type definition, in a mechanism for moving / inserting a certain tag, the moving destination is restricted according to the document type definition, so a document structure conforming to DTD. Can be made.

[Brief description of drawings]

FIG. 1 is a configuration diagram for explaining an embodiment of a structured document editing method according to the present invention.

FIG. 2 is a finite state automaton (DFA) according to the present invention.
FIG.

FIG. 3 is a diagram showing a machine structure of a document holding unit according to the present invention.

FIG. 4 is a diagram showing an example of a document type definition (DTD) in the present invention.

FIG. 5 is a diagram showing an example of an SGML document according to the present invention.

FIG. 6 is a diagram showing an example of a screen according to the present invention.

FIG. 7 is a flowchart showing a processing procedure of a newly created callback according to the present invention.

FIG. 8 is a flowchart showing a display processing means in the present invention.

FIG. 9 is a flowchart showing a node check procedure according to the present invention.

FIG. 10 is a diagram showing a screen example of a node movement result according to the present invention.

FIG. 11 is a flowchart showing a procedure for creating a destination list in the present invention.

FIG. 12 is a flowchart of mouse movement / release processing according to the present invention.

FIG. 13 is a flowchart of cut / paste processing according to the present invention.

[Explanation of symbols]

1 ... SGML document, 2 ... SGML parser, 3 ... DTD
(Document Type Definition) holding unit, 4
... Document storage, 5 ... DFA (finite automaton), 6 ...
Edit processing part, 7 ... Document tree structure, 8 ... Yank Buffer, 9 ...
Display input section.

─────────────────────────────────────────────────── ─── Continuation of the front page (51) Int.Cl. ⁶ Identification code Office reference number FI Technical display location 7315-5L G06F 15/20 550 E 7315-5L 554 H

Claims (8)

[Claims] 1. An input unit for inputting an SGML document, an analysis unit for analyzing the SGML document input by the input unit, and a creation for creating a finite automaton corresponding to a document type definition as an analysis result of the analysis unit. Means, storage means for holding the finite state automaton created by the creating means, tree structure creating means for creating a tree structure corresponding to the document structure inside as a result of analysis of the SGML document itself, and the tree structure creating And a document holding means for storing the tree structure created by the means, wherein the document instance based on the document type definition is displayed in an indented tree structure. 2. When creating a new tag, when a substructure is automatically inserted based on the document type definition, and if the substructure has ambiguity based on the document type definition, it has a mechanism for selecting it. The structural document editing method according to claim 1, further comprising a tag creating unit. 3. The structure document according to claim 1, further comprising a new tag creating means for automatically inserting a node having no ambiguity in a lower structure based on the document type definition when creating a new tag. Editing method. 4. When displaying a document instance based on the document type definition, if the substructure of a certain tag does not satisfy the document type definition, the node whose substructure is incompatible is shown to the user by highlighting or the like. The structural document editing method according to claim 1, wherein 5. The structured document editing method according to claim 1, further comprising display means for hiding a lower structure of a certain tag when displaying a document instance based on the document type definition. 6. The structured document editing method according to claim 1, further comprising a moving unit that moves a certain tag including a lower structure when displaying a document instance based on the document type definition. 7. When displaying a document instance based on the document type definition, a tag including a substructure is stored in a Yank buffer, and an insertion unit that can insert the tag at an arbitrary position on the document instance is provided. The structural document editing method according to claim 1, characterized in that 8. The structured document editing according to claim 1, wherein when displaying a document instance based on the document type definition, the moving destination of the certain tag is restricted according to the document type definition in the means for moving / inserting a certain tag. method.