Automatic, look-and-feel independent dialog creation for graphical user interfaces

Jade is a new interactive tool that automatically creates graphical input dialogs such as dialog boxes and menus. Application programmers write a textual specification of a dialog’s contents. This specification contains absolutely no graphical information and thus is look-and-feel inde-pendent. The graphic artist uses a direct manipulation graphical editor to define the rules, graphical objects, in-teraction techniques, and decorations that will govern the dialog’s look-and-feel, and stores the results in a look and feel database. Jade combines the application programmer’s specification with the look-and-feel database to automatically generate a graphical dialog. If necessary, the graphic artist can then edit the resulting dialog using a graphical editor and these edits will be remembered by Jade, even if the original textual specification is modified. By eliminating all graphical references from the dialog’s content specification, Jade requires only the absolutely minimum specification from the application programmer. This also allows a dialog box or menu’s look and feel to be rapidly and effortlessly changed by simply switching look and feel databases. Finally, Jade permits complex inter-field relationships to be specified in a simple manner

An Incremental Algorithm for Satisfying Hierarchies of Multi-way, Dataflow Constraints

One-way dataflow constraints have gained popularity in many types of interactive systems because of their simplicity, efficiency, and manageability. Although it is widely acknowledged that multi-way dataflow constraints could make it easier to specify certain relationships in these applications, concerns about their predictability and efficiency have impeded their acceptance. Constraint hierarchies have been developed to address the predictability problem and incremental algorithms have been developed to address the efficiency problem. However, existing incremental algorithms for satisfying constraint hierarchies encounter two difficulties: (1) they are incapable of guaranteeing an acyclic solution if a constraint hierarchy has one or more cyclic solutions, and (2) they require worst-case exponential time to satisfy systems of multi-output constraints. This paper surmounts these difficulties by presenting an 2 incremental algorithm called QuickPlan that satisfies in worst case O(N ) ..

The Lapidary Graphical Interface Design Tool

The Lapidary interface design tool allows the graphics and run-time behaviors that go inside an application window, as well as the graphics and behaviors that go around the application window, such as menus and scroll bars, to be specified pictorially. In particular, Lapidary allows the designer to draw pictures of application-specific graphical objects that the end user will manipulate (such as boxes and arrows, or elements of a list), the feedback that shows which objects are selected (such as small boxes on the sides and corners of an object), and the dynamic feedback objects (such as hair-line boxes to show where an object is being dragged). The run-time behavior of all these objects can be specified in a straightforward way using constraints and dialog boxes that allow the designer to provide abstract descriptions of the interactive response to the input devices. Lapidary also generalizes from the specific example pictures to allow the graphics and behaviors to be specified by demonstration. Finally, Lapidary supports the construction and use of "widgets" (sometimes called interaction techniques or gadgets) such as menus, scroll bars, buttons and icons. Thus Lapidary allows all pictorial aspects of an application to be specified graphically

Integrating pointer variables into one-way constraint models

Pointer variables have long been considered useful for constructing and manipulating data structures in traditional programming languages. This article discusses how pointer variables can be integrated into one-way constraint models and indicates how these constraints can be usefully employed in user interfaces. Pointer variables allow constraints to model a wide array of dynamic application behavior, simplify the implementation of structured objects and demonstrational systems, and improve the storage and effkiency of constraint-based applications. This article presents two incremental algorithms—one lazy and one eager—for solving constraints with pointer variables. Both algorithms arecapable ofhandling (l)arbitrary systems ofone-way constraints, including constraints that involve cycles, and(2) editing models that allow multiple changes between calls to the constraint solver. These algorithms are fault tolerant in that they can handle and recover gracefully from formulas that crash due to programmer error. Constraints that use pointer variables have been implemented in a comprehensive user interface toolkit, Garnet, and our experience with applications written in Garnet have proven the usefulness of pointer variable constraints. Many large-scale applications have been implemente

Declarative programming in a prototype-instance system: object-oriented programming without writing methods

Most programming in the Garnet system uses a Over the last three years of using the Garnet system to declarative style that eliminates the need to write new create dozens of large-scale user interfaces, we have methods. One implication is that the interface to ob