Browse Prior Art Database

A compaction algorithm to reduce the width of tree diagrams Disclosure Number: IPCOM000010103D
Original Publication Date: 2002-Oct-23
Included in the Prior Art Database: 2002-Oct-23
Document File: 5 page(s) / 138K

Publishing Venue



Disclosed is a compaction algorithm for reducing the width of tree diagrams. The algorithm is advantageously implemented using extensions to standard Java classes that layout components in a user interface. The implementation is thus available to other Java programs that want to layout components in their user interface in the same way.

This text was extracted from a PDF file.
At least one non-text object (such as an image or picture) has been suppressed.
This is the abbreviated version, containing approximately 32% of the total text.

Page 1 of 5

A compaction algorithm to reduce the width of tree diagrams

A program is disclosed that minimises the width of hierarchical tree diagrams. Such diagrams have a variety of uses, one of which is to represent task models.

     Task modelling is an established method from ergonomics and human-computer interaction for describing, analyzing, and optimizing human activity. Task modelling is *widely used to support the design of efficient, intuitive user interfaces within IBM and the software industry. Task models are often represented as an HTA (Hierarchical Task Analysis) to decompose tasks into subtasks described by plans. Each separate task is drawn in a box. An example of a HTA is shown below:

     HTA's are created by decomposing a task into a series of subtasks, which are horizontally drawn below the parent task they represent. The amount of decomposition depends on the nature of the task and the judgement of analysts. However resulting diagrams typically have a landscape orientation and contain horizontal gaps, which means diagrams are typically wider than they need to be with the result that less tasks can be viewed simultaneously. Consequently, analysts find it less easy to input and analyse complex diagrams.

     An algorithm has been developed to reduce the width of these diagrams. This is achieved by removing the maximum number of gaps between tasks whilst maintaining the diagrams structure.

     This has the benefit of increasing the number of tasks concurrently visible in a limited amount of horizontal space, without the need to reduce the size of the task boxes, with a consequent loss of diagram readability. With more tasks visible, users will have a clearer idea of the diagrams overall structure, allowing them to analyse and update the diagram more effectively.

     **An implementation of the algorithm involves using Java's LayoutManager architecture by creating an implementation of the java.awt.LayoutManager interface. Using Java's standard layout architecture allows this layout to be plugged into other Java programs, allowing other programs to layout their components in a similar way. Other applications, such as organisation chart builders, could reuse this implementation if they adopt a Java component based interface.

     In an implementation that uses Swing components to render the diagram. Each task box is drawn in a separate JComponent component, and each component is large

[This page contains 1 picture or other non-text object]

Page 2 of 5

enough to completely contain all its child components. This is shown below.

     This use of nested components allows the layout to be controlled using Java's LayoutManager architecture. Therefore, the creation of different diagram representations is handled by separate Java classes that implement the LayoutManager interface.

The compact algorithm has two broad steps:

     Firstly, it creates a uniform diagram (as in the above example), using the uniform layout class to create a diagram with a similar layout to the ab...