Background 
The Chordic Graphic User Interface (CGUI) works in a totally different manner than other computer interfaces. For example, using a mouse you move a pointer to a button and click. Very simple and intuitive, but what if you were trying to do it whilst walking? Then it's much harder because body movement reduces your accuracy. The pointer is actually an extension of your hand, it's as if you are reaching into the computer to control it, the object in the pixel world of the screen reflects all the movements you make in the real physical world, it's direct manipulation. Imagine trying to do that whilst swimming!

That's the problem scientists at the Australian Institute of Marine Science (AIMS) faced when they tried to develop a computer for collecting data underwater. The AIMS divers wanted to control complex interfaces but do it swiftly and easily with one (either) hand. Initial experiments soon showed that normal interfaces were impractical, swimming and controlling a pointer required a lot of attention and was extremely difficult. They needed a simple interface, immediate, a push-button environment.

That was the impetus for the invention of the CGUI. Unlike a mouse pointer, nothing moves in the CGUI, there is no pointer, instead there is virtual manipulation. It's somewhat similar to shortcut keys, for example pressing Control C on the keyboard to copy something, but it's far more powerful. Firstly, you learn shortcut keys they are mostly "hidden". Where in the MS-Windows interface does it show you that pressing Alt Tab will switch between open windows? Secondly, each combination of keys is dedicated to one function, limiting the total number of things you can do.


How it works 
Imagine you are holding a special keypad in your hand, under each finger there is a button. By pressing combinations of your fingers you can form chords (similar to a piano chord), each chord can have a different function, but how do you know what to press?

This is where the CGUI comes in, at its simplest the computer screen has finger symbols showing what to press for a particular function. Let's create a simple set of text glyphs to illustrate this. A finger symbol (glyph) like this \|||| means press all your fingers (and thumb). A glyph like this _|... means press your first finger, \|... means press your thumb and index finger.

These glyphs are "literal", meaning they look like the finger combinations you are supposed to press. So we could put "SAVE" and \.|.. on a button and you can see that it means press thumb and middle finger to activate the save button. That's it! In a nutshell the concept is what you see is what you press. In other words you don't have to learn chord combinations to use the interface just look at the screen to see which fingers to press for any function.


Advanced ideas 
Your hand (usually!) has five digits, this gives you 31 possible chords (2 raised to the power 5 minus 1), some of these chords are quite hard to do, try \.|.| so in practical terms there are about 25 usable chords. That doesn't limit the scope of the interface however, as it is possible to press two or more chords in sequence for a function, called a couplet. Using our practical 25 chords yields over 600 couplets, going to a triplet gives us over 15,000 combinations, so the interface has plenty of bandwidth. Literal glyphs are not the only way of representing indications onscreen.

Another technique is proportional representation, this takes a little bit more understanding but is just as easy to use. Rather than putting what is essentially a drawing of the hand on the button we use the actual width of the button to show what to press. Imagine your right hand placed over the adjacent diagram, your thumb would rest on the button labelled"A". Now divide the total width of the two buttons into fifths and imagine where your fingers would fall. Button A would be activated by your thumb and first finger, whilst button B would be the remaining three fingers. Notice that button A is two fifths of the total width of both buttons whilst button B is three fifths of the total width. That's it! You just look at the relative widths of the buttons to determine which fingers to use.

Of course unlike the literal glyphs the buttons have to be in groups for you to be able to determine their relative widths. Also you can't show some chords proportionally, for example \...| just can't be displayed proportionally because it has a a gap or "void" in it, only solid chords can be used. The advantage of proportional representation is the reduction in screen real estate.


Practical examples 
Enough theory, lets look at some screenshots of real CGUI interfaces and how they work. In the screenshot below a diver is using a program to collect data about the bottom type. Each proportional data field is activated by a chord so if they wanted to activate the "Particle size" field they would press their little finger.

In this screenshot they have activated the "Bottom material description field" by pressing all fingers (and thumb) except the little finger, out pops a data entry panel specific to that field (the light brown box), the relevant field has turned white to show that it is active. The data entry panel now has the chord focus, in other words all chords pressed are sent to it and not to the data fields. If the diver wanted to clear the data field they would press all fingers except the thumb, similarly if they wanted to enter "Sand" they press the middle finger. To close the data panel they press OK by pressing all but the little finger. The divers soon become very rapid at using these tools as muscle memory allows them to control the interface with little visual concentration. Apart from voice recognition no other interface gives this amount of eyes-free control.


Another example 
The screen-shot below shows a data entry program designed for use by the Australian Army Special Forces. Imagine a hostage situation, the hostages and their captors are being held in a building under observation by Special Forces Operatives. An observer has crept into an adjacent room and is monitoring the situation through a fibre-optic scope in the wall. He has a data link back to the command post and is sending back reports. The observer can't use a radio (because of the noise) and he doesn't want to take his eye from the scope to type messages. The SendWord interface allows him to use muscle memory to construct simple situation reports chordically. As he enters each word it is read back to him through his earpiece, when he wants to send the message he presses Send.




Conclusions 
This tutorial has shown you how the interface works and some of its features. The CGUI has numerous advantages over conventional interfaces, it is easy to learn and use and can be operated very rapidly under difficult conditions, with a small amount of practice it can be controlled eyes-free. We have only touched on some of the major features, have a look at the online demonstrations to try it out for real.