JPH0666066B2 - Document processor with furigana addition function - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION The present invention relates to a document processing apparatus with a furigana addition function, which is preferably implemented to add furigana to a name written in Chinese characters, for example.

In the prior art, in the case of horizontal writing, the furigana is entered in advance, and the corresponding kanji is entered in the line below it. Therefore, the operation is complicated. In particular, in a document processing device having a function of inputting a kana character and converting it into a corresponding kanji or kanji mixed sentence, the kana character is input to input a kanji character, and the same kana character is continuously input to add a kana character again. The input is complicated and the operation is troublesome.

An object of the present invention is to provide a document processing device with a function of adding a pseudonym with improved operability.

FIG. 1 is an overall block diagram of an embodiment of the present invention.
The keyboard device 1 includes a kana key 11 arranged in the order of Japanese syllabary as shown in FIG. 2, and a conversion key 12 for instructing conversion of the input kana character into kanji or kanji mixed sentence.
And a ruby key 13 for setting a mode in which a kana is added to the kanji read by this conversion, that is, a kana instructing means, and a text buffer for editing and storing the input text.
A print key 14 for instructing to print the sentence 41 and a cursor key 15 for moving a cursor mark indicating an input position on the display screen are included. The keyboard 1 outputs a character code, a control code, or a coded signal related to these, corresponding to the operated key. The processing circuit 2 performs the operation described below according to the editing program stored in the area 31 of the read-only memory 3 in advance. Other areas of this read-only memory 3 32
The character size is smaller than the general character code that is input and stored in, for example, 1/2
A conversion table for converting the code of the ruby character of the degree is stored. The size of a general character here is
For example, it is 10.5 points, and the ruby character is half this size as described above. The random access memory 4 which is a buffer means stores the data of the input sentence, that is, the sentence buffer 41 and the kana key 11 which store the edited sentence data converted from the kana sentence into kanji or kanji magic sentence according to the input order. The input buffer 42 that stores the input kana sentence, the kana sentence that is input from the kana key 11 in the ruby mode temporarily is stored, and the ruby buffer 43 that is stored after being converted into the ruby character code and the input line of the sentence It stores the text data for one line, and uses the line A buffer 44 for editing control in this and the line A buffer used when printing the kana.
Row B buffer 45 and row A buffer with similar configurations to 44
A pointer 46 indicating one character position of 44, a pointer 47 indicating one character position of the line B buffer, a character counter 48 used for counting the number of characters, and an area 49 forming various other flag buffers. Including. At the beginning of each line of the text buffer 41, flag data indicating that it is a ruby line is stored.

The kana-kanji conversion circuit 5, which is kana-kanji conversion means, is provided with a dictionary for converting the input kana into kanji or kanji mixed sentences of the same reading kana, in which the output buffer is included.
51 are equipped. In the kana-kanji conversion circuit 5 buffer 51, the converted kanji or kanji magic sentence, that is, the conversion sentence is read and stored as a character code string, and the total number of characters of this conversion sentence and the number of reading kana for each kanji character are read. Remembered. In this way, the kana-kanji conversion circuit 5 is configured so that the kana or kanji magic sentence of the same phoneme can be read with the kana character string as an entry word in association with the number of characters of the conversion sentence and the number of reading kana of each kanji. To be done.

The print control circuit 6 is for controlling the printer 7, and is a character generator 61 that receives a character code and outputs a corresponding character pattern, and develops and prints each line of characters into a dot pattern. It has a buffer 62 and a buffer 63 for storing the pitch amount between characters. The display control circuit 8 is a display device 9 which may be a cathode ray tube display device or the like.
And includes a display memory 81 for storing display data, a cursor buffer 82 for storing the position of the cursor mark, and a character generator for outputting a character pattern from a character code. The cursor buffer 82 has a storage area for each character area of the screen of the display device 9, and by storing data in this storage area, a cursor mark is displayed in the corresponding screen area.

The operation when inputting a normal sentence, that is, when inputting without adding furigana to kanji will be described. When the operator operates the kana key 11 to input a kana character, the operations after step 110 in FIG. 3 are performed. The process proceeds from step 111 to steps 113 and 114, and the kana character entered at the position indicated by the pointer 46 of the input buffer 42 and the line A buffer 44 is stored. 116
In step 117, the data of the row A buffer 44 is updated to the corresponding row area of the display memory 81, that is, the row where the cursor mark is located.
In, it is rewritten with the display data before writing. The kana character input in this way is displayed on the display device 9, and the cursor mark indicates the next input position.
This operation is repeated each time a kana character is input, and the kana sentence is stored in the input buffer 42 and the line A buffer 44.

The operator operates the conversion key 12 to convert a kana sentence into a kanji or kanji mixed sentence. When this conversion key 12 is operated, the operations after step 120 are executed. Pointer 4
6 indicates the next input position of the line A buffer 44, which is corrected at step 121 to the start address of the kana part. Further, the kana sentence of the input buffer 42 is given to the kana-kanji conversion circuit 5, and the converted sentence and the character number data corresponding to the output buffer 51 are read out in step 122 and stored as described above. From step 123 to step 124, the conversion sentence of the output buffer 51 is incremented by sequentially increasing the pointer 46 from the position indicated by the pointer 46 of the line A buffer 44.
It is written in 124, and by this, it is rewritten into a kana character kana conversion sentence. Subsequently, the total number of characters in the converted sentence and the number of characters in the kana sentence are compared in step 125, and the difference in the number of characters is calculated. In step 126, the cursor buffer 82 is corrected by this difference, and step 12
At step 7, the remaining kana characters in the kana part of the line A buffer 44 are deleted at step 127.

In general, the number of characters in a kanji or kanji mixed sentence, that is, a converted sentence is equal to or less than the number of characters in a kana sentence. At step 128, the row A buffer 44 is written in the corresponding row area of the display memory 81 and can be rewritten as the previous display data. Step 12
At 9, the input buffer 42 is initialized. By such an operation, the converted sentence is displayed on the display screen, and the cursor mark is displayed at the next input position. Similarly, the pointer 46 also indicates the next input position.

The operation of adding furigana to kanji will be described. When the input position is at the input position of the kanji for adding kana, the operator operates the ruby key 13 to move from step 100 to step 101 and the ruby mode is set. When the kana reading kana is entered from the kana key 11, step 110 is executed and step 111 is moved to step 112, and the input character is stored in ruby buffer 43. Below, step 113
Or step 117 is performed as before. The operator operates the conversion key 12 after the kana character is input.
As a result, the process moves from step 120 to step 121, and the data of the input buffer 42 is given to the kana-kanji conversion circuit 5,
Output the converted text and character data to the buffer 51
Read at. The process moves from step 123 to step 140 shown in FIG. 4, and the kana kana start code indicating the beginning of the kanji for adding kana to the position corresponding to the pointer 46 indicating the input position of the line A buffer 44 is stored. The furigana start code is indicated by FS. At step 141, the content of pointer 46 is incremented by +1. Step 14
In step 2, the conversion sentence of the output buffer 51 is stored by replacing the pointer 46 with the pointer 46 of the line A buffer 44 by one, and performing the writing operation to replace the kana character. Further, subsequently, in step 143, a furigana end code indicating the end of the kanji to which furigana is added is stored, and in step 144, the pointer 46 is incremented by one. The furigana end code is indicated by reference numeral FE. By this operation, consecutive kanji characters sandwiched by the kana kana start code and kana kana end code are stored at the kanji character with kana kana position in the line A buffer 44. The furigana start code FS and furigana end code FE are used to associate each kanji with the ruby character of that furigana at the time of printing in FIG. 6 described later. At step 145, row A buffer 44
The number of characters from the beginning to the kana start code is counted by the counter 48 and held in step 145.
Therefore, in step 146, the difference in the number of characters between the kana sentence and the converted sentence is obtained in the same manner as described above, and in step 147, the kana portion remaining in the line A buffer 44 is deleted and the step is performed.
At 148, the cursor buffer 82 is modified.

Line feed data is stored in the line A buffer 44, that is, when a line feed key (not shown) is operated or when the number of input characters reaches a predetermined number. It is determined in step 149 whether or not there is this line feed data. If there is no line feed data, the process moves to step 150 and the line feed data is written in the position corresponding to the pointer 46 of the line A buffer 44.

The line A buffer 44 is stored in the corresponding line area of the sentence buffer 41 and the display memory 81 at steps 152 and 153,
In step 154, line A buffer 44 and pointer 4
Initialize 6.

By the above operation, the line data including the kana with kana stored in the line A buffer 44 is stored in the sentence buffer 41, and in step 160, the flag data to be stored at the beginning position of the sentence data of the line before the above line is changed. Then, in step 161, it is determined whether or not it is a ruby flag, that is, whether or not a ruby character has been previously input in this line. If it is not a ruby line, a ruby flag is added to the beginning of the line A buffer 44. Is set in step 152, and if it is a ruby line, the data of that line is transferred to the line A buffer 44 on the assumption that another kana character is present in the same line in step 163. At this time, the text data transferred to the line A buffer 44 in the text buffer 41 is deleted. In step 164, if it is determined in step 161 that it is not the ruby line, the pointer 46 is incremented by 1 in the line A buffer 44 to indicate the next writing position until the number of characters stored in the counter 46 is equal to that in step 145. . If the text data is transferred from the text buffer 41 to the line A buffer 44 in step 163, the character is moved to the position indicated by the pointer 46 of the line A buffer while updating the pointer 46 until the number of characters of the counter 48 becomes equal. If not, write a space character, if there is a character, only update pointer 46,
Increment 46 to indicate the next write position. That is, the space character is inserted so that the kana stored in the next line is output to the line above the position of the kanji to which the kana is to be added. In step 165, the kana character of the ruby buffer 43 is converted into the ruby character by the kana ruby conversion table 32 of the read-only memory 3, and the step 165 is performed.
Remember in. Next, the character number data stored in the output buffer is read at step 166 by the kana-kanji conversion described above, and the delimiter data is inserted for each reading number of each kanji character of the ruby buffer 43.

FIG. 5 shows a state displayed by the display device 9.
As shown in FIG. 5 (1), assuming that a kana character is added to the kanji character "Tokyo", the kana characters "to", "kiyo" and "to" are divided into units,
Separation data will be inserted between them.

At step 167, the ruby start code is stored at the position indicated by the pointer 46 of the row A buffer 44, that is, at the position to be input. The ruby start code is indicated by the reference symbol SRB. At step 168, the pointer 46 is incremented by 1,
In step 169, the ruby character data of the ruby buffer 43 in which the delimiter data is inserted in the number of readings for each kanji in the previous step 166 is updated by the pointer 46 from the position indicated by the pointer (PA) 46 of the line A buffer 44. While writing in order,
At step 170, the ruby end code is stored in row A buffer 44. The ruby exit code is indicated by the reference symbol ERB. By this operation, the ruby start code (SR) is added to the position of the kana in line A buffer 44 corresponding to the above kanji with kana.
B) and the ruby end code (ERB) sandwiched between consecutive ruby character data are stored. This ruby start data (SR
B) and the ruby end code (ERB) are used in associating each kanji with the ruby character of its kana when printing FIG. 6 described later. In step 171, the pointer 46 is incremented by 1. In step 172, it is judged whether or not the line A buffer 44 has a line feed code.
The line feed code is written in 44 at step 173. In step 174, the data in row A buffer 44 is displayed in the display memory 8
Written in the corresponding row area of 1. In Step 175,
The data of line A buffer 44 is inserted into the corresponding line area of sentence buffer 41. That is, it is judged whether or not there is line feed data in the line A buffer 44, and if there is no line feed data, the line feed data is stored and the text of the ruby line is completed in the line A buffer 44. The data of the line A buffer 44 is stored in the corresponding area of the display memory 81, inserted into the corresponding line area of the sentence buffer, and the line A buffer 44 and the pointer 46 are stepped.
It is initialized in 176, and the ruby mode is released in step 177. In step 178, the text data of the next line is transferred to the line A buffer 44 again. When a kanji is input to add a kana to a desired line by such a series of operations, the ruby character that becomes a kana in the line immediately above the kanji is divided according to the number of readings of this kanji, Rows are formed and stored. At this time, the cursor mark is located next to the previous kanji, and you can continue to input new text. Such an operation is repeated.

The printing operation of the character thus edited by the printer 7 will be described. When the operator inputs one page of characters,
Operate the print key 14.

When the print key 14 is operated, the step shown in FIG.
From 200 to step 201 shown in FIG. Step
The head of the printed page of the text buffer 41 is selected by 201. In step 202, the selected sentence buffer 41
From the first line to the line A buffer 44 and stored at the beginning of the line. Read the flag indicating the ruby line
At 203, the ruby line is determined, and if it is the ruby line, the same data is stored in the line B buffer 45 at step 204. The position indicated by the pointer 46 of the line A buffer 44 initially indicates the first character at the beginning. The data at the position indicated by the pointer 46 is read in step 205, and it is determined in step 206, 207, 208 whether this data is a line feed data SRB code or a kana start code, and if it is not any data, it means that it is character data. This data is provided to the charactor generator 61 at step 209. In step 210, the character generator 61 outputs the corresponding character pattern and prints it.
The data is stored in 62 in order from the beginning. Further, in step 211, the pointer 46 is incremented by 1 to give an instruction to read the next data. In this way, the character data stored in the line A buffer 44 is successively developed into a pattern, and the print buffer is printed.
It is stored in 62.

When the line feed data is read, step 206 to step 2
The process proceeds to 10,220 and the print pattern for one line stored in the print buffer 62 is given to the printer 7 to perform printing. 1
If the page has not been printed, step 22
In step 3, the next line is selected, pointers 46 and 47 are initialized in step 224, and the operation is performed again in step 202. In this way, one page is finally printed.

Printing of ruby lines will be described. When the ruby line is detected in step 203, the same sentence data is stored in line A buffer 44 and line B buffer 45 in step 204. While reading each data in the row A buffer 44, the SRB code indicating the start of ruby should be read soon. At this time, the step moves from step 207 to step 230, the pointer 46 is incremented by 1, and the pointer 46 indicating the head of the ruby character in the line A buffer 44 is displayed.
The number of ruby characters from the position of
At 1 it is counted by the counter 48. This count value is n. Then, in step 232, the comparison of N × n ≧ M (1) is performed. Here, M represents the size of one kanji character, and N represents the size of one ruby character. In this example
10.5 points. The size N of the ruby characters is M / 2. According to the first expression, the necessary size of the entire ruby character for one kanji character is compared. If the kana kana tow is assigned to the Chinese character “east” shown in FIG. 5 (1), then N × n = m (2) That is, if there are two or more ruby characters, the process proceeds to step 233. After step 233, the ruby character pitch is given priority, and the ruby character "to" at the position of the pointer 46 on the line A buffer 44 is given to the character generator 61, and the pattern is transferred to the print buffer 62 at step 234. . In step 235, the position is added to the pointer 46, and it is determined whether the data indicated by the pointer 46 is delimited data or EBR indicating the end of ruby.
When the determination is made at 36 and 237, respectively, and when neither is the case, the process returns to step 233, and the pattern of the pseudonym “U” is stored in the print buffer 62. Similarly, the same applies to the kana "Kyou". When the delimiter data is read, the above operation is repeated again, and when the EBR code is read, the process proceeds to step 211 and the ruby printing is completed.

As shown in FIG. 5 (1), in the case of "Koto", which is one kana for one kanji, step 232 is followed by step 240. In this step 240, Is calculated and the value P is stored in the buffer 63. However,
P uses its absolute value. That is, the difference between the ruby character pitch and the kanji character pitch is calculated, and the width value is calculated by halving the difference. The value represented by the third equation is stored in the buffer 63 so that the amount of space for feeding between the ruby characters is arranged on both sides of the ruby character. At step 241, the value of the buffer 63 is stored in the print buffer 62. The print buffer 62 stores the space in the dot row corresponding to the value of the buffer 63. In Step 245, in Step 2
The same operation as 33 to 237 is performed (in step 245 in FIG. 6, it is expressed as steps 233, 234, 235, 236, 237), and the pattern of the single plate name “TO” in this embodiment is stored in the print buffer 62 and again. Step 24
The value P of the buffer 63 of 1 is stored in the printing buffer 62 at step 246. If the next data is the SRB code, the process proceeds to step 230, and if the next data is the ERB code, the process proceeds to step 211.

By such an operation, the kana characters are stored as shown in FIG. 5 (1), and when the number is smaller than the Chinese character pitch, P1 indicating the character spacing is inserted and the character is identified as the Chinese character pitch.

The operation when printing a line of kanji to which a furigana is added will be described. At this time, a line of Chinese characters is stored in the line A buffer 44, and the ruby line printed on the line is stored in the line B buffer 45 by the step 204. When data is being read for printing the line A buffer 44, the kana start code will be read as described above. This moves from step 208 to step 260 in FIG. In this step 260, when the data is sequentially read out according to the contents of the pointer 47 and the ruby start code is read out, the step moves from the step 261 to the step 263. When the ruby start code is not read, the pointer 47 is incremented by 1 in step 262, and the process returns to step 260.
At step 263, the contents of Poita 47 are incremented by one.
The content of the pointer 47 indicates the ruby character start position. The number of ruby characters stored in line B buffer 45 is counted by counter 48 and in step 264. In step 265, N × n ≦ M (4) is compared, and one kanji or one ruby character or two ruby characters are compared.
If it is a character, move to step 266. This is the case, for example, for the Chinese characters “east” and “tou” in FIG. 5 (1).

The character data indicated by the pointer 46 of the row A buffer 44 is given to the character generator 61 at step 266, and the corresponding pattern is stored in the print buffer 62. Step
At 268, the content of the pointer 46 is incremented by one character, and it is instructed to read the next data. In step 269, it is judged whether or not it is a kana ending code, and if not, the process returns to step 263.

When the kana ending code is read, the process moves to step 211 in FIG. 6 again and general character printing processing is performed.

If the fourth formula is not satisfied in step 265, that is, if the kanji "Kyo" shown in Fig. 5 (1) and "mayu" shown in Fig. 5 (2), go to step 280 and the fifth formula Is calculated.

The absolute value of this value P. Will be stored at Buffer 63. Thereafter, as in the above description, the amount of space to be stored in the buffer 63 is arranged on both sides of the character pattern and written in the print buffer at steps 281 and 282. In step 282, the operations of steps 266, 267 and 281 are performed. In this way, the feed amounts P2 and P3 are arranged on both sides of one Kanji character as shown in FIGS. 5 (1) and 5 (2).

By such an operation, the furigana character for one kanji character is automatically arranged corresponding to the line immediately above the kanji character. Although the explanation is omitted, when printing the ruby line, the space character is stored up to the first kanji to which the kana is added by the previous editing, and the entire ruby character is one of the corresponding kanji groups.
Positioned one above.

The furigana may be either kana or slab name.
Also, the present invention can be implemented not only in horizontal writing but also in vertical writing.

As described above, according to the present invention, a kana can be added to a kanji by a simple operation.

According to the present invention, the number of furigana characters for each kanji is calculated,
Since the correspondence between Chinese characters and furigana characters is adjusted and arranged, it is possible to display furigana that is easy to read.

[Brief description of drawings]

FIG. 1 is an overall block diagram of an embodiment of the present invention, FIG. 2 is a plan view of the keyboard device 1, and FIGS. 3 and 4 are for explaining the operation of the embodiment shown in FIG. FIG. 5 is a flow chart showing the state displayed by the display device 9, and FIGS. 6 and 7 are flow charts for explaining the operation of giving a kana kana kana. 1 ... Keyboard device, 2 ... Processing circuit, 3 ... Read-only memory, 4 ... Random access memory, 5 ...
Kana-Kanji conversion circuit, 7 ... Printer, 9 ... Display device

 ─────────────────────────────────────────────────── ─── Continuation of the front page (56) References JP-A-55-124836 (JP, A) JP-A-56-80729 (JP, A) JP-A-57-81643 (JP, A) JP-A-53- 99723 (JP, A)

Claims (1)

[Claims] Claim: What is claimed is: 1. In a document processing device for converting kana or kanji mixed sentences by inputting kana characters, a cursor means for specifying a kana input position, a kana kana instructing means for inputting a kana, and a kana kanji conversion A first buffer means for storing the kana characters input for that purpose, a conversion instructing means for instructing kana-kanji conversion, a second buffer means for storing kanji or kanji spelled sentences corresponding to the kana characters, and the furigana instruction. When the means is not operated, the kana character stored in the first buffer means is stored in the line where the cursor is located, and the kanji or kanji stored in the second buffer means is stored based on the subsequent conversion instruction. In a state in which a magic sentence is stored by replacing the kana character with the kana character indicating means being operated,
The kana character stored in the first buffer means is stored in the line where the cursor is located, and the kanji or kanji spelling sentence stored in the second buffer means is replaced with the kana character and stored based on the subsequent conversion instruction. In addition, a text buffer that stores the kana or kana-kanji mixed sentences in which the kana characters stored in the first buffer means are converted into ruby characters is stored in a line before the stored kanji or kanji kanji characters, and the printing of the contents of the text buffer is instructed. And a print instruction means for reading and reading the kanji and its kana characters stored in the sentence buffer in accordance with the operation of the print instruction means, comparing the print widths, and a width corresponding to the difference. Calculating means for calculating a value, and a control means for inserting and outputting the calculated width value in the side having a smaller print width when printing the kanji and its kana kana characters, Phonetic additional function document processing apparatus characterized by comprising.