Increasingly, graphical input and output techniques
are being combined in order to construct
powerful, interactive user interfaces.
In the program being demonstrated,
the operator's using a number of techniques
in order to design a flow chart.
The example shows how both hands and various devices
can be combined to make use of the operator's full operating
potential.
Such interfaces are hard to construct, however.
In this tape we will demonstrate two tools developed
at the University of Toronto in order to facilitate this task.
The first is a runtime support package
that handles user interaction.
It is a table-driven package that
handles all input, event detection, screen updates,
and procedure implication.
Even on its own, such a package has several benefits.
It frees applications programmers
from low-level detail.
It facilitates software maintenance
by enforcing a common programming methodology
for user interfaces.
And finally, it facilitates portability
of application software, since all interaction
is via a standard software package.
This next example is a simple chemistry simulation
on titration.
Adding acid brings a solution to equivalence.
Acid is added by pushing the tablet selection button
while pointing at the burette.
Equivalence is indicated by a color change in the beaker--
[SOUND EFFECT]
--and a sound effect.
Let's reconstruct this simple program
as a means of illustrating our second main tool, Menula.
Menula is a program for interactively designing
the user interface for menu-driven software.
It is a preprocessor whose output
is automatically translated into high-level source code.
Menula generated itself, so all interactions used
in working through our example are available candidates
for our titration experiment.
Our first step is to draw the objects which
are to appear in the display.
Here, a simple sketch editor is being used to draw the burette.
Our next step is to design the layout for our display.
First we select and position the graphical elements
to be employed.
We use our hand-drawn objects, all of which
are immediately available through the picture library
at the bottom of the screen.
We then add the necessary text by positioning the tracking
symbol and typing on the keyboard.
We then assign colors to the objects.
Since we are using a monochrome terminal,
colors appear as words.
They will, however, be properly displayed
when shown on the final device.
Next, we will specify the semantics of the experiment.
We do this by typing the names of the procedures
to be associated with each active object.
The procedures must be pre- or post-defined
by the applications programmer or defined
on the spot within Menula.
Nearing the end, we will now do the final scaling
and positioning of objects.
Note that in positioning objects,
we can make use of a grid for increased accuracy.
Having finished our specification,
we now save our work.
We are ready to invoke the process that
will translate our specification into C-code,
compile the result, and link it with our runtime support
package.
In doing so, all options are selectable by the menu.
We now exit Menula and are ready to run our simulation.