The dynamic query filter is generated by a set of user interface components which produce values that can
be compared to a field in a data record. For example, when forming a query which involves price, a range
slider (a slider with two thumbs which generates a range as a value) may be used to quickly adjust the range
of prices the user is interested in. As the user adjusts the slider's position (value), different records in the
data set pass through the dynamic query filter, and thus different display points are lit up or turned off in the
starfield display. Each query component produces a Boolean value when compared against some (fixed)
field in the data record; a record is defined to pass through the filter if and only if all the query components
result in a positive outcome. A query interface is a collection of components which can form a dynamic
query filter over some data set and whose output is a starfield display.
From this specification, the system generates the display shown in Figure 1: Starfield Display Of An Event
Trace Log. The main window shows the starfield display with a sample screen dump as a backdrop to
provide context. The smaller window near the bottom provides the query component controls. In this case,
the query indicates that "Press" and "Key" events within the given time interval
should be displayed. The distance query is currently not enabled, and hence does not affect the result. In
general, the checkbox at the left of each query component indicates if it is to be enabled (used) or disabled
(ignored), while the sliders and buttons to the right specify the actual query.
Using this display one can quickly move the slider to see how different regions of the interface under study
are used over time -- whether there are clusters of activity and how spread out actions are over various
intervals of time. If specific screen areas are of interest, the distance query can be used to limit the range of
results.
StarGen currently allows four types of specifiers:
As an example of the type of one-way constraints generated by the StarGen compiler, consider in our
example above which allows the Time field to range from 0 to 941,100. The generated constraint is:
An interesting observation about the StarGen system is that due to its underlying constraint system, it would
be very easy to adapt to "live" data; data which was dynamically varying at run-time. We are
considering augmenting the input language to StarGen slightly to allow the user to specify that their data
may be dynamic.
Abstract
In this paper we present an constraint-based approach to the automatic generation of starfield displays for
use with dynamic query filters. This approach automatically transforms a specification of the data to be
displayed into a dynamic query filter interface whose results are shown to the user in a starfield display.
This transformation is accomplished by translating the data specification into a specification for a one-way
constraint system and accompanying user interface objects. Both of these are compiled into fast, executable
code to create a final program.
Keywords:
Starfield Displays, Visualization Techniques, Constraints, Graphical User Interfaces, Dynamic Query
Filters, Automatic Generation.Introduction
Previous work by Ahlberg and Schneiderman has shown starfield displays to be an effective tool for
displaying the results of highly interactive queries, often called dynamic query filters [1]. A dynamic query
filter is a filter which is applied to a set of data records and whose results are immediately visible. The
starfield display shows the results of these queries by displaying an icon at an x,y location for each data
record which passed "through" the filter. 
EXAMPLE
An example StarGen input description is shown below:
type input_event icon = "star2.xbm" {
kind "Kinds of Events:" :
enumset("Press", "Release", "Key");
value "Time":
range(0,941100);
dist "Distance From:":
distance("marker2.xbm", 1000);
}; backdrop = "screen.xbm";
The data corresponding to this description comes from an event log trace captured during an interactive
session with a popular drawing tool. As can be seen from this example, this description consists primarily of
a relatively standard data record description with a few extra annotations providing human readable titles
and an appropriate background image. In this case, each record indicates (in addition to required x and y
values) what kind of event occurred (either "Press", "Release", or
"Key") and the time that the event was recorded. In addition, a distance query is specified
allowing selection of objects within various distances away from a movable marker.
APPROACH
Our approach to the automatic generation of starfield displays can basically be described in three stages.
The user describes the format of the data to be queried and the StarGen compiler constructs a set of one-
way constraints which can be used to query the data. Then the Eval/Vite constraint compiler [2] is used to
translate these constraints to C++ code which is finally compiled into an efficient executable program.Input To StarGen
StarGen accepts as input a set of specifiers which express the format of the data over which the dynamic
query filter will be run, as well as control the nature of the final query components.
Compiling Specifiers
The StarGen compiler reads in the specification of the data records and user interface components (detailed
above) and outputs an Eval/Vite specification for the user interface and its semantics. This specification
chiefly consists of a set of one-way constraints which when evaluated will result in the desired display.
These one-way constraints compute a Boolean value which determines whether or not to display the icon
corresponding to the data record. This visibility constraint is applied to each of the records that are read in
by the final program at run-time. The StarGen output also specifies that the icon (if visible) should be
displayed at the x,y location associated with the each particular record in the dataset, yielding a starfield
display.
star_is_visible::= IF q.enabled THEN
(v<=q.slider.upper && v>q.slider.lower)
ELSE 0;
The value v here is the value of the time field in the current record, q is the query component, and q.slider is
the range slider within that query component. This is compiled into optimized C++, which allows the
system to (for example) automatically avoid computations associated with disabled query components.
PLANNED FUTURE WORK
Future work on StarGen includes the addition of new specifier types in the StarGen input specification.
Some of the additions we have been considering are a string matcher (which would display a editable text
field) and a minimum/maximum specifier which would compute the maximum or minimum value present in
a data field and return a positive outcome for records which have values within some offset from the
minimum or maximum.
References
1 Ahlberg C., Schneiderman B. Visual Information
Seeking: Tight Coupling of Dynamic Query Filters
with Starfield Display. In Proceedings Of CHI `94.
p. 313-317.
2 Hudson S., Smith I. Practical System For Compiling
One-Way Constraints Into C++ Objects. Georgia
Tech Graphics Visualization And Usability Center
Technical Report, 1994.