Zoomable Graphical Sketchpad
We are also using Pad++ as a substrate for building user-definable animated objects such as complex interface widgets. We have recently applied the same techniques to create animated human-like actors [28]. Although the widgets are much simpler, we employ the same mechanisms that allow us to control human-like movements and gestures to simulate personality and intentionality. The ultimate goal is to support an informational physics in which objects animate naturally. Using these tools, the Pad++ application designer can always convey to the user a clearly structured animated narrative instead of merely an assortment of disjoint temporal events.
We approach this goal by providing a mechanism for the definition of moveable graphical objects. In addition, we define high-level hierarchical control mechanisms for the movements. We are starting to define simple widgets such as buttons and sliders at a behavioral level that makes it easier for application developers to easily change the look and feel of an application. While the widget definitions we supply have a traditional Motif-like look and feel, a designer can easily change their visual style or interaction mechanism.
In addition, we are exploring novel widgets that take advantage of the Pad++ zooming environment. We used our extension mechanisms to implement a choice widget that provides an alternative to the traditional pop-up menu. Figure 14 shows two views of the same widget. The view on the left shows a zoomed out view. Here the widget just shows its current value. On the right we have zoomed into the widget and now the available choices become visible for user selection.
Figure 14: A prototype zoomable choice widget.
These widgets are implemented with our KPL rendering language. This language was designed to allow very fast run-time recompilation, compact representation, and efficient execution (roughly 100 times faster execution time than TCL). It is a post-fix stack language whose simple structure allows execution times roughly 10 faster than other interpreted or byte-compiled languages. KPL's speed allows us to execute scripts during each render. Without this efficient mechanism, we would only be able to render items pre-defined in the C++ substrate.
The next step uses KPL to create complex animations by the definition of simple repetitive motions of objects based on stochastic processes along with a built-in mechanism to automatically transition between different motions. The stochastic processes are defined by rotation axes, periods, and magnitudes with some coherent noise [27] applied to give more natural behavior. The mechanism to change between motions gives the hierarchical control described above.
By changing the parameters of the stochastic movement in response to the environment and chaining sequences of motions together with the transitioning mechanism, we are able to build complex animated behavior in the user interface.
We handle transitions between two actions having different tempos via a morphing approach. At the start of the transition, we use the tempo of the first action, and at the end, we use the tempo of the second action. During the time of the transition, we continuously vary the speed of the master clock from the first to the second tempo. In this way, any phase dependent synchronization of the two actions is always preserved during transitions. We may also define new actions as extended transitions between two or more other actions. On a Pad++ surface with multiple actors, each actor maintains its own individual tempo.
A related notion that we are exploring is peripheral attention. How does an actor convey that a process is proceeding normally or abnormally, without distracting the user from his/her current tasks? This is especially important in a zoomable environment where the ability to provide peripheral awareness of processes is an important attribute of the paradigm.
We are also studying the semantics of the discrete state transitions that visually represent shifts in attention. In this way an actor on the Pad++ surface can quickly convey to users which other actors and users it is interacting with. We are also interested in determining to what extent we can encode the texture of interactions in order to convey the visual impression of complex activities going on at different scales without requiring all the detail to be specified. We suspect that some of the same techniques used in character animation might be effective here too.
Copyright Computer Science Department, The University of New Mexico