We present the Auckland Layout Model (ALM), a constraint-based technique for specifying 2D layout as it is used for arranging the controls in a graphical user interface (GUI). Most GUI frameworks offer layout managers that are basically adjustable tables; often adjacent table cells can be merged. In the ALM, the focus switches from the table cells to vertical and horizontal tabulators between the cells. On the lowest level of abstraction, the model applies linear constraints, and an optimal layout is calculated using linear programming. However, bare linear programming makes layout specification cumbersome and unintuitive, especially for GUI domain experts who are often not used to such mathematical formalisms. In order to improve the usability of the model, ALM offers several other layers of abstraction that make it possible to define common GUI layout more easily. In the domain of user interfaces it is important that specifications are not overconstrained, therefore ALM introduces soft constraints, which are automatically translated to appropriate hard linear constraints and terms in the objective function. GUIs are usually composed of rectangular areas containing controls, therefore ALM offers an abstraction for such areas. Dynamic resizing behavior is very important for GUIs, hence areas have domain-specific parameters specifying their minimum, maximum and preferred sizes. From such definitions, hard and soft constraints are automatically derived. A third level of abstraction allows designers to arrange GUIs in a tabular fashion, using abstractions for columns and rows, which offer additional parameters for ordering and alignment. Row and column definitions are used to automatically generate definitions from lower levels of abstraction, such as hard and soft constraints and areas. Specifications from all levels of abstraction can be consistently combined, offering GUI developers a rich set of tools that is much closer to their needs than pure linear constraints. Incremental computation of solutions makes constraint solving fast enough for near real-time use.

No abstract

Strongly sequential constructor systems admit a very efficient algorithm to compute normal forms. Thatte found a transformation that allows us to simulate any orthogonal system with a constructor system. Unfortunately, this transformation does not generally preserve strong sequentiality. On the other hand, the class of forward-branching systems contains the class of strongly sequential constructor systems. Moreover, it admits a reduction algorithm similar to the reduction algorithm of the strongly sequential constructor class, but less efficient on the entire class of forward-branching systems.In this article, we present a new transformation which transforms any forward-branching system into a strongly sequential constructor system. The size of the system increases only modestly over that of the original one in many practical situations. We give an algorithm for this transformation and we prove its correctness and completeness. The new system is then proved to be equivalent to the input system, with respect to the behavior and the semantics. We then give a new transformation algorithm which increases the size of the system only linearly.