TRANSLUCENT HISTORY
TRANSLUCENT HISTORY
Andreas Genau,
Axel Kramer
GMD(German National Research Center for Computer
Science)
PO. Box 1316, 53731 Sankt Augustin, Germany
genau@gmd.de
axel@well.com
© ACM
Abstract
This paper presents an approach that visualizes object history by using
translucent presentations. It extends the typical sequential presentation of
an object history by a concurrent presentation of the object contents through
time.
Our goal is to enable the fluid refinement and animation of graphically
presented ideas while exposing the changes to objects as a whole and not just
in discrete steps.
Translucency, as a mechanism, works particulary well if the object content is
sufficiently spatially distributed.
Keywords:
versioning, history-mechanism, translucency, interface metaphor, pen-based
interface
Introduction
In systems that use translucency, one can simulate history through stacking of
translucent surfaces with progressive content [7], using an architects
yellowpaper metaphor. There, marks in subsequent surfaces have no relationship
with each other. Instead, our approach moves the notion of time to the surface
itself, resulting in a consistent and very fluid manipulation of changes on
that surface over time and opportunities to present those changes in various
ways.
To illustrate the purpose of the idea we take a brief look at an
architects meeting with a customer. The architect makes some changes to the
plan of a house, using his large Architects Electronic-Sketchboard.
After some work and some discussion, the customer is not quite happy about the
location of the door. The architect turns on the translucent history of the
plan, and its former states become visible as increasingly dimmed layers below
the present state. The customer can now view the previous and current location
of the door in direct comparison. They decide to change the wall instead of
relocating the door again. The previous location of the wall can still be seen
as part of the lower layers of the plan.
They decide to integrate the previously deleted walk-in-closet, that is dimmly
visible, by fetching it from a lower layer and moving it to the newly created
space at the wall.
Related
work
Quite some work has been done on versioning objects, and thus being able to
access the history of changes to an object. Simple one-level, undo/redo
mechanisms evolved into linear and non-linear representation of state-changes
objects pass through. Approaches for this problem vastly differ, spanning:
command-objects [1, 5], textual differences [6], semantic-deltas in
transactions [4], Contracts, Sagas [2].
The presentation of objects through time is usually restricted to a sequential
presentation of states an object has gone through. The user typically sees the
object in one particular state, while having access to a linear, or tree-like
representation of the object history that can be used to change the view on the
object.
TRANSLUCENT
PRESENTATION
The approach presented here extends translucent patches [3] by a notion of
time. Translucent patches are non-rectangular patches that serve as a
substitute for rectangular opaque windows. The underlying metaphor is closer
to a mix between the architects yellow paper and the usage of white boards,
than to rectangular opaque paper in piles and folders on a desktop.
Translucent patches provide a base from which the tight connection between
windows, their content, and applications can be dissolved. It forms one aspect
of on-going work to support design activities that involve the written medium,
like paper and white boards, with computers. The central idea of that research
is to allow the user to associate structure and meaning dynamically and
smoothly to marks on a display surface.
Patches
with History
Translucent patches as described in [3] are essentially time-less, rendering
their content in the present moment. Instead, we now look at a rendered patch
as a presentation of its content at a particular point in time, which the user
can move through.
Screenshot 1. Handles on translucent patches
While the user interacts with the patch, semantic operations are recorded. Via
handles on the patch border, the user can undo those operations, or mark that
an interesting state has been reached, at which point the system groups those
operations together in one transaction.
Except the additional handles, patches look visually still the same. The
interaction is still fluid. Simple button operations on the patch are used to
undo operations in sequence, commit transactions, move within the transaction
sequence, or animate it much like a flipbook.
In a sketching system this transacted recording of history is especially useful
for animating and thus visualizing the dynamic properties of an idea, something
as static a medium as paper or whiteboard can not provide.
Translucent
History
With a gesture the user can switch to another presentation of a patch that
visualizes the sequence of its changes by using translucency. Taking the
current transaction the user is looking at as the top, and layering older
transactions successively below, original locations and already deleted objects
will appear dimmed, proportionally to the age of the transaction they are in.
Screenshot 2. Dimmed History
Editing in the top layer is done as usual, determined by the interpretation
that is associated with the patch [3]. Changing spatial properties of objects,
or deleting objects might make their previous state visible in a dimmed form,
if it was already contained in a layer below.
Moving information contained in historic layers to the top is done using
gestures, much like objects can be moved through non-historic patches. This
operation corresponds to selective undo/redo operations in other history
mechanisms [1], and is facilitated by keeping the object identity through time.
IMPLEMENTATION
The new ideas presented in this paper are implemented as extensions to the
implementation of the translucent patches system.
Our object model is similar to the one used in the Thangka toolset [4]:
semantic operations on objects (patches, ink, and interpretation objects) are
recorded in time and grouped into transactions that describe consistent changes
to a set of objects. This is used to compute the state of an object at a
particular point in time.
When showing the history of a patch with translucency, the sequence of
transactions making up that history are put into virtual patches that share the
same outline. The translucency of this virtual stack of patches is adjusted so
that the content of other intersecting patches is shown with an appropriate
lucency value. To optimize rendering, objects that are contained in older
transactions are not drawn unless their spatial-visual properties change in
newer transactions.
CONCLUSIONS
The system presented in this paper visualizes the state changes objects have
gone through by making use of translucency, an approach particulary well suited
for sufficiently spatially distributed information. This concurrent
presentation of the object history is fluidly combined with the typical
sequential presentation of history. Preserving object identity over time
allows the concurrent presentation to be derived from the sequential
presentation, and allows to map some of the more complicated notions of history
mechanisms, e.g. selective undo/redo, to simple user interactions. We believe
that this approach enables in particular the fluid refinement and animation of
graphically presented ideas.
Visualizing object history with translucency opens interesting avenues for
further explorations of object history mechanisms, as well as interactions with
and visualizations of object histories, e.g. (1) nested translucent patches may
provide a natural representation for configuring and embedding versioned
objects, (2) different kinds of rendering algorithms might be used to emphasize
different aspects of an objects' history, (3) different interaction mechanisms
can support the tracing workstyle typical for architects, as well as a direct
object manipulation workstyle, (4) using translucent patches as a mechanism to
visualize object history on the one hand and to structure disparate things on
the other, creates an interesting tension that needs more exploration.
Acknowledgments
Many thanks to Jeff Close for a stimulating discussion about aspects of this
topic at UIST 94.
BIBLIOGRAPHY
[1] Berlage, T., Genau, A., A Framework for Shared Applications with
Replicated Architecture, UIST'93, Atlanta, Georgia, 1993
[2] Gray, J., Reuter, A., Transaction Processing Systems, Concepts and
Techniques, Morgan Kaufman Publishers, 1991
[3] Kramer, A., Translucent Patches - Dissolving Windows, UIST 94,
Marina del Rey, 1994
[4] Kramer, A., Makkuni, R., Tools for Constructing the Electronic
Sketchbook of Thangka Paintings, TOOLS 89, Paris, 1989
[5] Schmucker, K.J., Object Oriented Programming for the Macintosh,
Hayden, New Jersey, 1986
[6] Tichy, W., RCS: A Revision Control System, Software - Practice and
Experience, vol 15 no 7, 1985
[7] Wong, Y.Y, Layer Tool: Support for Progressive Design, InterCHI 93
Adjunct Proceedings, 1993