Proceedings of Eye Tracking Research & Applications Symposium 2000, pages 15-22. ACM, 2000.
©Copyright 2000 by ACM, Inc. This copy is posted with permission of the ACM and may not be redistributed.
A definitive copy can be downloaded from the ACM Digital Library.

Text Input Methods for Eye Trackers Using Off-Screen Targets

Poika Isokoski*

University of Tampere

 

 

Abstract

Text input with eye trackers can be implemented in many ways such as on-screen keyboards or context sensitive menu-selection techniques. We propose the use of off-screen targets and various schemes for decoding target hit sequences into text. Off-screen targets help to avoid the Midas’ touch problem and conserve display area. However, the number and location of the off-screen targets is a major usability issue. We discuss the use of Morse code, our Minimal Device Independent Text Input Method (MDITIM), QuikWriting, and Cirrin-like target arrangements. Furthermore, we describe our experience with an experimental system that implements eye tracker controlled MDITIM for the Windows environment.

Categories and Subject Descriptors: H.5.5 [Information Interfaces and Presentation]: User Interfaces - Input devices and Strategies, Interaction styles

General Terms: Experimentation

Additional Keywords: eye tracker, text input, off-screen targets, MDITIM, QuikWriting, Cirrin, Morse code.

  1. INTRODUCTION
  2. In near future eye trackers may become available in a size and price range that allows them to be used as a user interface component in almost any computing device. The major issue at this time is whether eye trackers can actually improve human computer interaction. The fact that eye trackers can be used is well established now. Also, it has been demonstrated that interfaces utilizing eye tracking are efficient and favored by users at least in some special circumstances [10, 12, 13]. We have examples of systems where Gaze input is useful and some general reasoning on why this is the case [2]. However, there is still a lot of room for experimentation. We propose that the use of off-screen targets may alleviate some problems encountered in traditional eye tracker based text input methods.

    Text input with eye gaze is and most likely will never be a mainstream activity. In comparison to a keyboard, eye gaze is serial, that is, there can be only one thing happening at one time. Touch-typist can move several fingers simultaneously and thus attain much higher speeds. Furthermore in comparison to all manual methods, eye gaze text input is inferior because it ties the user’s gaze on the input task. Good manual methods allow the user to look at the resulting text or in the case of transcription typing, the original text. Thus it is clear that gaze should not be even considered for text input unless hands are for some reason unavailable. Hands may be unavailable because of a physical injury or because of a task that requires both hands to be used on something else.

    Although, the user base for gaze operated text input is narrow, text input is an integral part of many tasks that are performed with computers. Therefore, if we hope to create a user interface using only eye gaze input, text input must be implemented too. Our discussion in this paper will concentrate on the use of gaze operated text input in the context of desktop computing. This is largely due to the nature of currently available eye tracking hardware, which is not mobile. Consequently, the systems we describe are immediately useful only to those people who use gaze controlled desktop environment. In practice this includes mainly people with a severe motor disability. However, the ideas can be extended to mobile contexts where people with normal control over their limbs can find eye gaze interaction useful.

    Complete gaze controlled user interfaces need much more than just a special text input method. The whole interface and often the interaction styles need to be re-designed to facilitate gaze control [7]. Our approach does not limit these efforts in any way. Text input using off-screen targets can be compared to a keyboard in the sense that text input in both cases is external to the Graphical User Interface (GUI) seen on the computer display. The GUI can be implemented independently of the text input method.

    A straightforward and a popular way to implement text input with gaze input is to display a QWERTY keyboard on the computer screen and use dwell time as a selection technique. In a system like this a key is pressed when the gaze of the user stays on a key for a predetermined amount of time. The length of the dwell-time is a tradeoff between rapid input and erroneous input. If the dwell time is too short, the system will generate input when the user is only looking at or scanning the keyboard without the intention of pressing a key. If the dwell time is too long, the user gets frustrated because it takes so long for the system to respond when he or she is typing.

    This basic input technique can be improved in many ways. One improvement is the use of various word-completion schemes to reduce the number of key presses needed for writing. Another way to improve the interface is to get rid of the dwell time protocol by using a physical switch, such as blink of an eye, physical button, or EMG activity measured from a face muscle.

    An on-screen keyboard takes up some space on the display. This may or may not be a problem. If the display is very small, the keyboard is likely to be a problem. One way for reducing the use of screen real estate is to introduce various operating modes to the keyboard. For example the keyboard may normally show only the alphabet keys and some mode-changing keys. The user can then use the mode-changing keys to show a set of pre-programmed shortcut keys or numerical keyboard instead or in addition to the alphabet keys [8].

    Despite these improvements to the basic on-screen keyboard, the keyboard does take some space and it is still relatively slow. Thus, it is not clear that on-screen keyboards are the best method for text input using eye gaze.

    The remainder of this paper is organized as follows. First, in Section 2, we explain the rationale behind the use of off-screen targets. Section 3 gives short overviews of four text input methods that use different numbers of off-screen targets ranging from one to over 50. Section 4 will elaborate on one of these techniques and finally in Section 5 we will discuss conclusions and future directions arising from our work.

  3. OFF-SCREEN TARGETS
  4. Video-based eye trackers follow the eye by measuring how light (usually infrared light) reflects from the cornea and from the retina through the pupil. The tracking angles are limited by the visibility of the pupil and the corneal reflection. When the user turns his or her eye away from the computer display on which the eye-tracker has been calibrated, the tracker can track the eye much farther than to the edge of the screen. The accuracy may degrade, but the general direction of the gaze is known on much larger area than today’s computer displays viewed from a distance of about one meter. For example the SMI EyeLink tracker that we used in our experiments tracks in the order of 40 degrees horizontally and 34 degrees vertically according to the manufacturer’s specification [9]. From the distance of 100 cm a 40 by 40-degree box is about 70 by 70 centimeters, which is about four times the area of a typical 19-inch display (36 by 27.5cm). This means that we can place targets outside the display area and somewhat reliably detect whether the user is looking at them or not.

    Assuming that the user’s attention is focused within the display when he or she is using the computer, we can use very short dwell time on the off-screen targets without the risk of causing unintentional input. The short (<100ms) dwell time is needed if we need to determine whether the user actually stopped on the target or whether the gaze merely passed the target area on a saccade that would end somewhere else. As we will see, all text input methods do not necessarily require the point of gaze to stop on a target. On-line saccade and fixation detection algorithms could be used instead of the dwell time protocol, but we see no reason for that because target placement and a simple dwell-time measurement seem to yield good enough results. The eye tracker sample rate may limit the shortest possible dwell-time setting. The SMI EyeLink takes 250 samples each second. Consequently the sample rate did not impose any practical restrictions in our implementation.

    Off-screen targets do not consume display area, which is an improvement over on-screen keyboards. On the other hand, off-screen targets cannot be synthesized in software, like on-screen targets can. This means that they cannot give visual feedback without special hardware. Also, if we do not have special hardware to give a physical representation for the off-screen targets, the user may not be able to direct his or her gaze on the target very accurately.

    Given the limitations listed above, the use of off-screen targets seems to work best with a very static task that requires only a small number of immobile off-screen targets. Text input devices usually have a static layout. Therefore text input is well suited for off-screen targets. However, for example a regular keyboard, which is a text input device with a static layout, has a very large number of targets (i.e. keys). Therefore we may wish to use alternative methods with fewer targets. Some alternatives for doing this are discussed next.

  5. TEXT INPUT METHODS
  6. As described above, a limited number of targets outside the computer display can be used to input a limited number of different tokens into a computer using an eye tracker. In this section we describe text input methods that afford easy adaptation to off-screen target input. The descriptions are not very detailed because the purpose is only to list and shortly illustrate the features of those known text input methods that can be easily adapted to use off-screen targets. The discussion on our experimental MDITIM implementation will continue in more detail in section 4.

    1. Morse Code
    2. Morse code has been used widely for communication across very limited interfaces. Typical Morse code input devices have one, two, or three switches for input [4]. The one-switch devices require careful timing. A short contact is interpreted as a dot and a longer contact as a dash. The dots and dashes are written in groups separated by breaks. Each group is interpreted as a letter or other input entity. A two-switch device inputs a dot with one switch and dash with the other. Again the groups of dots and dashes are separated by pauses. A three-switch device can be used with no regard to timing. The third switch is used to explicitly signal the end of a character.

      Alphabet

      Morse

      alphabet

      Morse

      a

      . _

      n

      _ .

      b

      _ . . .

      o

      _ _ _

      c

      _ . _ .

      p

      . _ _ .

      d

      _ . .

      q

      _ _ . _

      e

      .

      r

      . _ .

      f

      . . _ .

      s

      . . .

      g

      _ _ .

      t

      _

      h

      . . . .

      u

      . . _

      i

      . .

      v

      . . . _

      j

      . _ _ _

      w

      . _ _

      k

      _ . _

      x

      _ . . _

      l

      . _ . .

      y

      _ . _ _

      m

      _ _

      z

      _ _ . .

      Table 1: Morse codes from A to Z.

      Any of these input devices (one, two or three switch) can be implemented with an eye tracker and off-screen targets. Given the fine rhythm required by the one and two-switch input modes the three-switch mode is likely to be the most usable for gaze controlled input.

      Table 1 shows the dot-dash sequences for Morse codes from A to Z. The longest code shown is five tokens long (assuming three switch mode). Full text input requires more characters than just the alphabet. The Morse Outreach 2000 proposal for additional Morse codes for Human Computer Interaction includes codes of up to 7 tokens in length [4].

      A simple layout for a three-switch configuration for Morse code input using an eye tracker is illustrated in Figure 1. It has three large target circles placed just outside the computer display.

      Figure 1: Off-screen targets for three switch Morse code input.

      The purpose of Figure 1 and the other figures depicting our proposals for different text input methods using off-screen targets, are not intended to be exact blueprints for the system. They are drawn merely to illustrate the concept based on our experience with an MDITIM implementation. Therefore the things like the exact proportions of the targets and their location in relation to the screen and each other may not be optimal in these illustrations.

    3. MDITIM
    4. The Minimal Device Independent Text Input Method (MDITIM) uses five tokens for input. To give the characters a two-dimensional interpretation, four of the tokens are mapped to the four principal directions: North, East, South, and West (or N, E, S, and W for brevity). Examples of the 2D interpretations of MDITIM characters are shown in Figure 2. When the characters are drawn with a pen, the stroke begins from the circle and ends at the arrowhead. The fifth token is used as a modifier to input upper-case characters and other secondary interpretations of the characters. The fifth token is usually written by pressing a key. It could also be mapped to a special sequence of the four other tokens. [1]

       

       

      Figure 2: Examples of MDITIM characters.

      MDITIM characters are prefix codes. In consequence, MDITIM characters can be extracted unambiguously from a valid MDITIM token stream. Thus, unlike the Morse code, MDITIM input imposes no timing constraints on the writer. The only constraint is that the tokens must be written in the proper order except for the modifier token, which can be written any time after the previous character and before the next character following the current one.

      For gaze input MDITIM requires five targets, which is more than is needed for Morse code. The number of tokens needed for each character varies between two and five as seen in Table 2. Thus despite the greater number different tokens, the average number of tokens per character is not much smaller than in Morse code.

      Alphabet

      MDITIM

      Alphabet

      MDITIM

      a

      NSW

      n

      WSWN

      b

      SEW

      o

      NSN

      c

      ESW

      p

      WNEN

      d

      SWE

      q

      WSES

      e

      WES

      r

      WSN

      f

      ESNE

      s

      ESE

      g

      ESNS

      t

      SNE

      h

      WSWS

      u

      SEN

      i

      WNS

      v

      WNWS

      j

      SESW

      w

      WNWN

      k

      WSWE

      x

      SWSN

      l

      SNS

      y

      SWSE

      m

      WSWN

      z

      SWSW

      Table 2: MDITIM codes from A to Z.

    5. QuikWriting
    6. QuikWriting was originally introduced as a text input method for pen-based user interfaces [5]. QuikWriting input area is divided to nine zones numbered from 1 to 9 starting from the upper left and advancing from left to right, row by row to the lower right corner. The middle zone (zone 5) is the home zone from which all strokes begin and on which they end. Two tokens are extracted from each stroke. The first token is the number of the zone to which the pen leaves from the home zone. The second token is the number of the zone from which the pen returns to the home zone. Whenever, these two tokens have been extracted, the system looks up the character that corresponds to the token pair in question. QuikWriting strokes are loops that start from the center zone, enter an outer zone, may cross several outer zones, and finally return to the center zone. The user does not need to lift the pen between strokes.

      Given the character layout shown in Figure 3, one QuikWriting input area can only be used to input 32 characters. Some of these characters may be used to set the input area into a different mode. This behavior will allow more characters, but will require more effort from the user. The triangle, square, and circle characters in the layout are used for this purpose. An approach for reducing the number of modes, which is used in the QuikWriting implementations for the Palm Pilots, is the use of two input areas that are available simultaneously. The areas are located side by side over the Graffiti input area of the Palm Pilots. The left side area is used to write upper and lower case alphabet and other characters that appear in textual information. The right side area is used to write numbers and other characters that appear in conjunction with numerical information. Both areas have more than one mode.

      Figure 3: A QuikWriting input area (adapted from [6]).

      A basic setup for QuikWriting for gaze input using off-screen targets is easy to construct with the information given above. We place eight targets around the display and the display area is the home zone. This setup is shown in Figure 4. To write a character, the user moves his or her gaze first on one target area and then on another without looking back at the display in between. The threshold value for how far from the display area the point of gaze must move in order to induce input is not shown in Figure 3. We know that it must be at least equivalent to one degree of eye displacement, which is the minimum error for eye trackers implied by the free movement of the gaze focus within the area of sharp foveal vision. However, having not implemented the system we cannot give any recommendations beyond that. Similarly, Figure 3 does not specify how far from the display the QuikWriting zones extend. An outer limit should be chosen, but we do not have enough experience to give recommendations. When the user’s gaze moves outside the outer limit, the QuikWriting recognizer should notice this and not produce input.

       

      Figure 4: QuikWriting for EyeTracker.

    7. Regular Keyboard
    8. Of course we can also place a full-featured keyboard next to the display. If we want to avoid problems with the dwell-time setting, we may want to spread the keys in one row around the display. This arrangement is similar to what is known as the Cirrin word level unistroke keyboard for pen interfaces [3]. A circular Cirrin layout is shown in Figure 5. Mankoff and Abowd report experience with circular and linear arrangement of the characters [3]. We propose using linear strips of characters arranged around the screen for gaze controlled input.

       

       

       

      Figure 5: Circular Cirrin input area (adapted from [3]).

      With a Cirrin-like arrangement, there will be many targets. This means that they must be relatively small (as can be seen by comparing figures 4 and 6), and it may be difficult for the user to find the right character. This may re-introduce the need for visual searching and thus necessitate longer dwell times. However, because this arrangement requires only one fixation per character, the speed may be even better than what can be expected from the systems described above.

      Figure 6: A target scheme somewhat similar to Cirrin for eye tracker use.

    9. Summary

    An interrelated bundle of tradeoffs must be considered when choosing a text input method from the ones listed above. One of these tradeoffs is between the number of targets and the number of target activations per character. Having fewer target activations means faster writing.

    Table 2 gives the average number of fixations needed for writing text consisting of the 26 lower case characters in the alphabet used in English and the space character. The numbers were computed by weighting the activation count of each individual character by its relative frequency in a representative sample of English texts. The character frequencies were taken from [11].

     

    Morse

    MDITIM

    QuikWriting

    Cirrin

    activations

    3.84

    3.06

    1.41

    1

    with middle

    3.84

    3.06

    2.41

    2


    Table 3: Average numbers of target activations per character.

    The reason for giving two different figures for QuikWriting and Cirrin is that with these methods the user must fixate on the screen once for each character. For QuikWriting this behavior is copied from the pen based original version. With the dwell-time protocol the need for this extra fixation in QuikWriting can be eliminated. User testing is needed to determine which is the better solution. Cirrin does not force the user to change targets via the middle area, but this behavior is most likely to ensue because if we are using very short dwell times, the user cannot move his or her point of gaze over any irrelevant targets without risking unwanted input. Most Cirrin targets can be reached without moving over any others, but the ones in the same row cannot. It is not clear whether users will learn to optimize their behavior and fixate on the middle area between characters only if it is necessary. With Morse and MDITIM the user can move directly from an off-screen target to another because the gaze does not pass over any other targets in between.

    The numbers in Table 3 will change slightly to the favor of MDITIM if we re-compute them for average text instead of lower case text without punctuation. Isolated upper case characters are relatively cheap in MDITIM because they require only one more fixation (the modifier target). In Morse code the shift-character must be written. The cost of the shift character in three switch mode is 6 fixations. In QuikWriting the cost of the shift-character is 2 (or 3 with center fixation) and in Cirrin the cost is 1 (or 2). However, upper-case characters and punctuation are rare enough to change the numbers given in Table 3 only marginally. Also, the numbers for Morse code are computed assuming that the end of a character is signaled explicitly using the third target. If a one-target or two-target scheme is used, we must subtract 1 from the number of activations for Morse code. This would yield a relatively good figure of 2.84. However, it is questionable whether the careful timing needed for inputting Morse code without the character end signal is possible with an eye tracker.

    If we have many targets, they will be relatively small by necessity. A system with many targets give a good speed potential due to the relatively small number of target activations needed per character. On the other hand, smaller targets are harder to hit with the gaze and require careful calibration between the eye-tracker and the physical off-screen fixation targets. Furthermore, if we have many targets, learning to hit them rapidly with one’s eyes is likely to take more time.

    Speed potential is only one part of the usability of an interface and the preceding analysis on the minimal number of target activations needed by each writing method is only one of the components that determine the speed of a writing method. Things like how the writing method integrates with the rest of the interface and how well practiced the user is often outweigh simplistic predictions based on the assumption of a perfect user.

  7. MDITIM IMPLEMENTATION
  8. To gain some experience in using off-screen targets, we implemented one of the text input methods described above. MDITIM was chosen because we could transfer most of the code from our earlier projects.

    We used the SMI EyeLink eye tracker. It consists of head-mounted camera assembly, display-mounted IR-emitters for head motion tracking, a tracker PC, which processes the data from the sensors in real time, and a subject PC which can connect to the tracker PC through Ethernet. The tracking system operates with a very small delay of typically less than 12 milliseconds between the eye motion and the time that the data describing it is available on the subject PC. The tracker can recognize saccades, fixations, blinks, and some other events, but we used only the raw gaze position data.

    The placement of the targets was straightforward except for the fifth "modifier" target. We chose to place it on the upper left corner of the display. We expect that the user is less likely to look over the display than under it. The reason for this is that the user will probably change his or her attention (and point of gaze) between the desktop and the display more often than between the display and the wall behind the display. Thus, if we place the fifth target along the upper edge, we will get fewer unintentional activations of the target. The choice between the left and the right corner was arbitrary. Proper placement of the fifth target will depend on the location and habits of the user and should probably be user-configurable. The target placement we used in our experiment is shown in Figure 7.

    Figure 7: The target placement.

    The targets shown in figure 7 are approximately the same size in relation to the display as the targets we used in our prototype. We observed a tradeoff in the choice target size. Making the targets larger will make hitting them easier. This enables the use of the system with poorly calibrated or inaccurate eye trackers. However, when the accuracy of the tracker degrades, the targets will have to be placed further away from the display to avoid unintentional activation. This forces the user to use larger eye-movements, which may not be desirable.

    The shape of the targets could be chosen differently. Instead of circles, we could have divided the whole area around the display into five slices in a way similar to what was done above in our proposal for using QuikWriting with an eye tracker. We chose to use circles because it is mathematically very simple and makes it possible for the user to look outside the display without causing input as long as the point of gaze stays out of the target circles.

    Our experimental software has a small window on the display in which it shows information on the state of the MDITIM recognition algorithm and the gaze cursor (see Figure 8). Obviously the gaze cursor data is not useful to the user, because he or she cannot fixate on a target outside the display and look at the status display at the same time. However for an observer the gaze cursor is very informative. The gaze cursor can be seen as a small black rectangle in Figure 8.

    The large black rectangle in Figure 8 depicts the physical display. The large white ovals are the targets. The targets are not perfectly circular in Figure 8 because we chose to translate the actual gaze coordinates into a different coordinate system within our software. In this system the screen occupies a square region instead of the actual 3:4 proportions. The image is always rendered to fill the entire status window and in this case the shape of the window causes slight distortion to both the target circles and the screen. We should also point out that the target circles are circular only in the internal coordinate system of our software. In our experiment, the real-world target areas were horizontally elongated. The practical consequences of this small imprecision were not important in our prototype.

    Figure 8: The status window.

    The status of the recognition algorithm is shown in the center of the status window using a two dimensional interpretation of the MDITIM characters. Currently the user seems to be working on a "y". The display shows S, E, and S. The last token (W) is still missing.

    A small status window does not need as much space as a full-featured keyboard, but it does need some space. This is somewhat contradictory to what we said earlier on using off-screen targets to save screen real estate. We argue that once the user has learned to write with the system, the status window will not be needed.

    In addition to maintaining the user interface components, our system has to actually deliver the input to the application programs that the user is operating. This happens as follows: When the gaze input has been translated into characters, the characters are again translated into keyboard events. These keyboard events are then given to the operating system to deliver to the user applications according to the keyboard focus mechanism. Thus, our system can be used as a keyboard replacement in all Windows compatible applications with normal keyboard message handling.

    The partly non-conscious mechanism that controls our eyes tends to direct them towards visible features [2]. Therefore it is very difficult to focus our gaze on a point in space especially if there are visible objects next to it. We found it unnecessarily difficult to look at a point on the side of the display that is not actually visible. To make the targets visible, we used strips of paper that had big black dots printed on them. The strips were taped to the side of the display at the approximate location of the target as seen in Figure 9. We did not need to be very careful with the placement of the physical targets, because our targets were so large. When using more and smaller targets, calibrating the tracker coordinates with the physical targets may become an issue.

    Adding the dots to the sides of the display made writing much easier. However, it was still possible to unintentionally miss a target especially when trying to write very fast. These errors were not easily detectable to the user except by stopping and reviewing the written text and the state of the recognition algorithm shown in the status window. To alleviate this problem we introduced auditory feedback. A "click" sound was played whenever the point of gaze entered or left a target circle. A writer quickly gets accustomed to the rattling that writing causes and can notice missed targets by missing clicks. These two improvements, the visible targets and auditory feedback, improved the initial user experience greatly. However, in order to determine their exact contribution to the accuracy and speed of writing we need to conduct more formal tests.

      

    Figure 9: User writing with MDITIM using an SMI EyeLink tracker.

     

  9. CONCLUSIONS AND FUTURE WORK

The continuum of text input methods from Morse code to Cirrin illustrates the various approaches to using off-screen targets for text input in gaze controlled user interfaces. At one extreme, Morse code requires only one target, but forces the user to time his or her eye movements very carefully. Also, the number of target selections needed for one character of input is rather large. At the other extreme, Cirrin requires only between one and three target selections per character, but introduces a great number of targets.

The lack of visual feedback outside the display is a major constraint in using off-screen targets. Static off-screen targets are well suited for text input because the alphabet does not change often. Furthermore, text input is typically practiced to the level of automation. This means that it is not unreasonable to expect that the users will spend some time memorizing the target locations.

However, there is a way to use off-screen targets in a way that is integrated to what is happening on the display. This is a commonly used technique in devices with small screens. Mobile phones and automatic teller machines often have an array of buttons organized around the display. A menu is shown on the display and the user makes his or her selection using the button right next to the menu item. Using off-screen eye gaze targets in a similar manner may remove some accuracy problems in the use of eye-gaze on extremely small displays such as seen in mobile telephones today. The integration with the text input methods described above and indeed the whole concept needs to be investigated in more detail.

If off-screen targets are placed on different sides of the display, as is the case in our proposals, the eyes will be forced to make many very long saccadic jumps. The long-term effects of this activity need to be evaluated. It is possible that extended use of these techniques cause tiring of eye-muscles or even more serious physical conditions comparable to the various Repetitive Strain Injury conditions caused by keyboard and mouse usage.

While we have not yet validated our ideas in reliable controlled experiments, our experience gives us confidence, that text input may indeed be good use for the previously unused area around the display in gaze controlled user interfaces.

Acknowledgments

This work was supported by Tampere Graduate School in Information Science and Engineering (TISE) and by the Academy of Finland (project 163356).

References

  1. P. Isokoski, and R. Raisamo. Device Independent Text Input: A Rationale and an Example, Proceedings of AVI 2000 Conference on Advanced Visual Interfaces, pages 76 – 83, ACM, New York, 2000.
  2. R. J. K. Jacob. Eye Movement-Based Human-computer Interaction Techniques: Toward Non-Command Interfaces, in H. R. Hartson and D. Hix, editors, Advances in Human-Computer Interaction, pages 151 – 190, Ablex Publishing Co.,: Norwood, N.J., 1993.
  3. J. Mankoff, and G. D. Abowd. Cirrin: a word-level unistroke keyboard for pen input. Proceedings of UIST’98 ACM Symposium on User Interface Software and Technology, pages 213-214, ACM, New York, 1998.
  4. Morse Code Input System for the Windows 2000 Operating System (Proposal draft), MORSE 2000 Outreach, http://www.uwec.edu/academic/hss-or/Morse2000 /MorseSpecification.doc.
  5. K. Perlin. Quikwriting: continuous stylus-based text entry. Proceedings UIST’98 ACM Symposium on User Interface Software and Technology, pages 215-216, ACM, New York, 1998.
  6. QuikWriting 2.1 release notes, http://www.mrl.nyu.edu /perlin/demos/quikwriting2_1-rel-notes.html, 2000.
  7. D. D. Salvucci, and J. R. Anderson. Intelligent Gaze-Added Interfaces, Proceedings of the CHI 2000, pages 273-280 ACM,New York, 2000.
  8. SensoMotoric Insturments, Adaptative visual keyboard, http://www.smi.de/em/index.html
  9. SensoMotoric Instuments, EyeLink Gaze Tracking, http://www.smi.de/el/index.html
  10. L. E. Sibert, and R. J. K. Jacob. Evaluation of Eye Gaze Interaction, Proceedings of the CHI 2000, pages 281-288, ACM, New York, 2000.
  11. R. W. Soukoreff, and I. S. MacKenzie, Theoretical upper and lower bounds on typing speed using a stylus and soft keyboard, Behaviour & Information Technology, 14(6), 370-379, Taylor & Francis ltd., London, 1995.
  12. V. Tanriverdi, and R. J. K. Jacob, Interacting with eye movements in virtual environments, Proceedings of the CHI 2000, pages 265-272, ACM, New York, 2000.
  13. S. Zhai, C. Morimoto, and S. Ihde. Manual And Gaze Input Cascaded (MAGIC) Pointing, Proceedings of the CHI 99, pages 246-253, ACM, New York, 1999.