JPH044608B2 - - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION Technical Field of the Invention The present invention relates to a method for processing duplicate key input information of keys such as cursor keys and space keys in a computer system.

Prior Art and Problems In computer systems such as microcomputers, office computers, and word processors, when the input speed from the keyboard and the corresponding system processing speed do not match, for example, in general, the system processing speed is faster than the input speed from the keyboard. However, if there is a file access, etc., the system processing speed becomes slower, and in such cases, it is common to accumulate input from the keyboard in a buffer and then process it. .

Figure 1 is a schematic diagram of this type of system, where 1 is the keyboard (KB), 2 is the central processing unit (CPU), and 3 is the keyboard (KB).
is an external storage device such as a floppy disk (FD),
4 is a display such as a cathode ray tube (CRT).
Input from keyboard 1 is processed by CPU 2,
For example, move the cursor on the CRT4.
The cursor is moved by pressing the cursor movement key n times to move the cursor in n steps, or by pressing the key continuously and using the keyboard's key state reading function at fixed intervals to move the cursor in n steps. Although the system will not be unable to process key inputs faster than this key input speed, for example, if a file is required and the system accesses the external storage medium 3, this will cause Since it takes time, a situation may arise in which key input cannot be processed completely.
Therefore, a buffer is set up, and the key inputs that cannot be processed are stored in the buffer, and the system, which has recovered its quick processing function when file access is finished, sees the key inputs stored in the buffer and processes them quickly. make it happen.

By the way, operators tend to think that all instructions from keyboard 1 are processed instantly, so when the system is performing a time-consuming process, the result of a key input is not immediately available (it is forced to wait). ), it is easy to determine that the key was not entered correctly due to insufficient keystrokes, etc. This tendency is particularly noticeable in operations where the result of key input can be immediately confirmed on the display 4, such as the above-mentioned cursor movement. FIG. 2 is an explanatory diagram of this, and 5 indicates directions A to D perpendicular to the display 4.
A cursor that can be moved to The keyboard 1 has four cursor movement keys A to D that correspond to the movement direction of the cursor 5. For example, to move the cursor 5 one step (usually one line or one character) in the A direction, press the A key. Press the key once. At this time, if the system is executing other processing, the input of the A key is accumulated in the buffer described above. Therefore, the cursor 5 does not move at this point. The operator can see on display 4 that cursor 5 is not moving.
As recognized above, the user generally tries to move the cursor 5 by pressing the A key again. However, if the system continues other processing, the cursor 5 will not move and the A key inputs will be repeated twice.

The problem is that in the conventional method, all key inputs stored in this buffer are executed afterwards. In the above example, if the system completes the previous process after the operator presses the A key twice, the system immediately enters the process of the buffer and moves the cursor 5 to A according to the two A key inputs read from the buffer. Move two steps in the direction. However, this amount of movement is greater than the amount of movement expected by the operator (one step in this case), so the operator then presses the C key once to move cursor 5 to C.
It becomes necessary to move back one step in the direction. If the cursor is moved by a small number of steps, such as one or two steps, no particular problem may arise if the operator understands the system's mechanics, but it is a problem if the cursor is moved by a large number of steps. That is, in such cases, the operator generally presses the key as many times as necessary until the cursor moves to the target position, or presses the key continuously for automatic reading, so that when the cursor reaches the target position, there are many numbers in the buffer. Keystrokes can accumulate, causing the cursor to take several steps after the operator releases a key.

Purpose of the Invention The present invention attempts to maintain consistency between keyboard input speed and system processing time by using software to ignore some of the duplicate key inputs described above. .

Structure of the Invention The present invention executes processing corresponding to information input from a keyboard in a central processing unit and displays the result on a display, and when the processing unit is executing one process, the processing corresponding to information input from the keyboard is executed. In a method for processing duplicate key input information of a system in which key input information is sequentially accumulated in a buffer and then after the processing is completed, a process corresponding to the key input information is executed, the key input information is stored in the buffer for the latest key input information. Compare the stored key input information in order of oldest key input information, ignore the same key input information as the latest key input information, start with the different key input information, and execute the process corresponding to the different key input information, and if the key input information is the same until the end, use the latest key input information. It is characterized by executing only the processing that deals with the input information,
This will be explained in detail below with reference to the illustrated embodiments.

Embodiment of the Invention FIG. 3 is an explanatory diagram showing an embodiment of the present invention, and FIG. 4 is a flowchart thereof. Figure 3 a is
Look-ahead buffer in CPU2 (the buffer mentioned above)
Key inputs A, A, B, C are accumulated in 6,
This is a case where the key (designated key) for the latest execution was the A key. In this case, the system skips the key A that is the same as the specified key that has been stored in the buffer 6 for a long time, and processes it by determining that the system receives a different input from the next B key, which is different from the A key. That is, the CPU 2 ignores the first two A and A, and processes only the subsequent B, C, and A as if they were input in this order. Figure b shows a case in which all keys in the buffer 6 are A keys, and in this case, the previous four keys A are skipped and processing is performed assuming that only the last (latest) key A has been input.

If you enable the same key only once among the keys (key inputs) accumulated in the buffer in this way, when you try to move cursor 5 by one step in the A direction as in the previous example, No matter how many times you press the A key, the result will be the same (provided that all the keys are pressed). In other words, CPU2
When the previous process is completed, the operator moves one step in the A direction as desired by the operator. This type of skip processing is performed by continuously pressing the same key, and the input of that key is executed at a certain time interval (for example, 20 seconds).
This is particularly effective when typing a key input that is recognized as having been repeatedly performed in ms). In this case, the situation should be as shown in FIG. 3b, and the operator is not aware of how many times he has pressed the A key.
Of course, there may be cases where the operator wanted to move 2 steps in the direction of A, but in that case, the
By pressing the key once, the cursor, which has moved 5 steps in the A direction according to the buffer content, can be moved to C.
It is easier to operate than going back three steps in the direction.
However, since different types of keys (for example, B and C) specify completely different processes, they are not skipped.

FIG. 4 is a flowchart of the process described above. Information about the latest execution key is obtained from the display control unit, etc., and this is used as the designated key. In this example, this is A. The step determines whether a key input (A here) is valid (or exists), and if N (no), the process waits for a key. If the answer is Y (yes), it is determined in this step whether the first block of the buffer is valid (contains data). If a key input is accumulated in that block, it is determined whether it is the same as the A that was just input (step). If they are the same, add 1 to the step buffer pointer (pt) and look at the contents of the next second block. If there is a difference, the content, for example the B code, is processed. In this way, you can look at all the blocks in the buffer and find that they are all A.
If so (if the last one is also A) then process A for the first time. This is the step.

Effects of the Invention As described above, according to the present invention, duplicate key inputs that occur during system processing are ignored, thereby ensuring consistency between keyboard input and system processing time. You can have it. In the example, the cursor movement key was mentioned, but
The present invention can also effectively utilize space keys used to set intervals, and previous page and next page keys used to open a desired page by flipping a file forward or backward.

[Brief explanation of drawings]

FIG. 1 is a schematic configuration diagram of a general computer system, FIG. 2 is an explanatory diagram of a cursor on a display, and FIG. 3 is an explanatory diagram showing an embodiment of the present invention.
Figure 4 is a flowchart. In the figure, 1 is the keyboard, 2 is the central processing unit, 3
is an external storage device, 4 is a display, and 6 is a buffer.

Claims (1)

[Claims] 1. A central processing unit executes a process corresponding to information input from a keyboard and displays the result on a display, and when the processing unit is executing one process, information input from the keyboard is executed. In a method for processing duplicate key input information of a system in which key input information is sequentially accumulated in a buffer and then after the processing is completed, a process corresponding to the key input information is executed, the key input information is stored in the buffer for the latest key input information. Compare the stored key input information in order of oldest key input information, ignore the same key input information as the latest key input information, start with the different key input information, and execute the process corresponding to the different key input information, and if the key input information is the same until the end, use the latest key input information. A method for processing duplicate key input information, characterized in that only processing corresponding to the input information is executed.