prefuse

The top-level Visualization and Display classes, as well as Constants used throughout the toolkit.

A library of reusable and composable modules for performing data processing or assigning visual attributes.

Action modules for constructing animations. Most Animator actions require an interpolated data fields--such that a backing data table has three columns, one each for start values, current values, and ending values. See {@link prefuse.data.Schema#addInterpolatedColumn(String, Class)} for more.

Action modules for assigning visual properties such as colors, sizes, and fonts.

Actions modules which distort the presentation space to support enhanced navigation and browsing. Most distortion techniques magnify a "focal" region of space, allocating more screen space and showing items in higher detail. Non-focal space is compressed/demagnified, but remains visible to keep everything in context.

Action modules for visually filtering items by controlling their visibility.

Action modules providing layout algorithms for use by prefuse visualizations. All provided layouts descend from the abstract {@link prefuse.action.layout.Layout} class, allowing the layout bounds and anchor point to be customized on a per-Action basis. Layouts specifically for graph or tree structured data are available in the {@link prefuse.action.layout.graph} package.

Action modules for computing the layout of graph or tree structured data. All tree layouts can be used on non-tree Graphs; a spanning tree of the graph will be requested using the {@link prefuse.data.Graph#getSpanningTree()} method.

General classes for scheduling and running activities with specified starting times and durations. Used by all {@link prefuse.action.Action} implementations, these activities can be used to perform scheduled data processing and animation. Pacers can be used to control the rate of animation, for example, providing slow-in slow-out animated transitions.

Control modules for incorporating interaction in prefuse Displays. Examples include clicking a node to make it the new focus, dragging nodes to change their position, and performing pan and zoom operations. To add one of these controls to a visualization, create a new instance of the desired control and register it using the {@link prefuse.Display#addControlListener(Control)} method of the {@link prefuse.Display} class. Custom Controls can easily be constructed by implementing the {@link prefuse.controls.Control} interface, or, more conveniently, by subclassing the {@link prefuse.controls.ControlAdapter} class.

Table, Graph, and Tree data structures for organizing data. {@link prefuse.data.Table} instances store any number of type data in a row and column format. Each column of data is separately represented in a {@link prefuse.data.column.Column} instance. Row data can be accessed directly by the row index, or can be accessed in an object-oriented manner using the {@link prefuse.data.Tuple} interface. The {@link prefuse.data.CascadedTable} class provides filtered views over backing Table instances. Table {@link prefuse.data.Schema Schemas} are used to represent the names, data type, and default values of table columns, and can be used to instantiate tables of the desired type.

{@link prefuse.data.Graph} and {@link prefuse.data.Tree} instances also use a tabular representation, using separate data tables to store node and edge data. At the cost of a little complexity, this allows for a very flexible system. For example, the same data table can be used as the node table for multiple graphs, supporting efficient memory use and allowing easy propagation of data changes. Similar to tables, graphs and trees can be accessed using the row indices of the respective tables, or through object-oriented Tuple proxies. The {@link prefuse.data.Node} and {@link prefuse.data.Edge} interfaces provide a more typical object-oriented API to the graph structure and data.

Data columns for storing typed data within a data table. In most cases, these classes should not be instantiated directly. Instead use the setColumn() methods of the {@link prefuse.data.Table} class, which will call the appropriate {@link prefuse.data.column.ColumnFactory} method for you.

Listener interfaces for monitoring prefuse data structures and expressions.

Classes implementing an SQL-like expression language for filtering and manipulating data. The base type of the language, {@link prefuse.data.expression.Expression}, represents a calculation over a single tuple at a time. Expressions can be created programatically by instantiating the desired classes of this package, or can be compiled from a textual language with a SQL-like syntax by the {@link prefuse.data.expression.parser.ExpressionParser} class.

Parser/compiler for the prefuse expression language. The parser is implemented using the JavaCC package.

The file "ExpressionParser.jj" in the source distrubtion contains the JavaCC source. This file is meta-compiled by JavaCC into the classes contained within this package.

Input/output classes for reading and writing data from formatted files.

Input libraries for loading data from SQL databases. One can use the {@link prefuse.data.io.sql.ConnectionFactory} class to obtain an active {@link prefuse.data.io.sql.DatabaseDataSource} that can issue and process database queries both synchronously and asynchronously. Translation of database types into Java data types within prefuse data tables is handled by implementations of the {@link prefuse.data.io.sql.SQLDataHandler} interface.

Text parsers for different data types and machinery for automatically inferring data types.

Dynamic query bindings and data range models for creating dynamic queries. A dynamic query binding takes a particular data column and creates a binding between a filtering predicate over the data and user interface widgets for controlling the parameters of the predicate. This includes queries over a range of data ({@link prefuse.data.query.RangeQueryBinding}), selecting between different categories of data ({@link prefuse.data.query.ListQueryBinding}), and text search ({@link prefuse.data.query.SearchQueryBinding}).

Text search support for prefix, keyword, and regular expression searches. Each search engine type subclasses {@link prefuse.data.search.SearchTupleSet}, an implementation of the {@link prefuse.data.tuple.TupleSet} interface. Classes derived from SearchTupleSet (e.g., {@link prefuse.data.search.PrefixSearchTupleSet}, {@link prefuse.data.search.KeywordSearchTupleSet}, and {@link prefuse.data.search.RegexSearchTupleSet}) can be instantiated and used directly or in conjunction with a {@link prefuse.data.query.SearchQueryBinding}.

Implementing classes for data tuples, object proxies to a row of table data. Prefuse data tables can be accessed and manipulated directly, indexed by row numbers, but that is not always the most convenient. The {@link prefuse.data.Tuple} interface provides an object-relational mapping, providing an object-oriented interface to a row of table data. Furthermore, tuples provide enhanced safety, as a deleted row will result in an invalidated tuple, while a row index provides no such guarantees.

Groups of tuples can be collected and monitored using the {@link prefuse.data.tuple.TupleSet} interface, which {@link prefuse.data.Table}, {@link prefuse.data.Graph}, and {@link prefuse.data.Tree} all implement. Other TupleSet instances can be used to collect Tuples from any number of backing tables ({@link prefuse.data.tuple.DefaultTupleSet}) or aggregate multiple TupleSets ({@link prefuse.data.tuple.CompositeTupleSet}).

Graph nodes and edges are also represented as Tuples, with additional methods for accessing the underlying graph structure. Any methods that reference a tree structure will first request a spanning tree from the backing graph.

Tuples are created and stored by {@link prefuse.data.tuple.TupleManager} instances. To customize tuple creation, one needs to register the appropriate concrete Tuple type with an enclosing data table. This is done using the {@link prefuse.data.Table#Table(int,int,Class)} constructor.

Utility classes for supporting prefuse data structures, including indexes, iterators, filters, and column projections.

Indexes ({@link prefuse.data.util.Index}) support efficient access to table rows organized by the data values of a particular column.

Filtered Iterators support selecting subsets of data from data tables. This includes optimized queries over table rows (using availabled indexes). Currently all query planning is performed by the {@link prefuse.data.util.FilterIteratorFactory} class.

Column Projections filter out unwanted table columns, controlling what data fields are inherited by a {@link prefuse.data.CascadedTable}.

Interfaces and modules for rendering VisualItems into a graphics context. {@link prefuse.render.Renderer} instances are responsible for drawing items, computing item bounds, and determining if a point lies within or without an item. {@link prefuse.render.RendererFactory} instances, on the other hand, are used to determine which Renderer should be used for a given VisualItem.

Utility classes for use by both the toolkit and applications, including color and font support.

Utility classes providing useful data structures not present in the Java Collections framework. This package includes Map implementations for various primitive types, a copy-on-write array list, and iterators supporting primitive types.

Utility classes specific to the Display class.

Utility classes providing a physical force simulation for layout and animation. Force simulations consist of a series of force functions that calculate forces acting on data elements, and an integrator that determines how these calculated forces effect the position and velocity of these elements over time. The {@link prefuse.util.force.ForceSimulator} class keeps track of which elements should be included in the simulation, as well as which {@link prefuse.util.force.Force} functions and {@link prefuse.util.force.Integrator} are used.

To create your own custom simulations, create a new ForceSimulator instance and add the desired force functions. Custom force functions can be introduced by subclassing {@link prefuse.util.force.AbstractForce} or implementing the {@link prefuse.util.force.Force} interface. Additionally, the {@link prefuse.util.ui.JForcePanel} user interface component can be used during development to explore different parameterizations of the various force functions until a desired behavior is found.

Utility classes pertaining to input and output.

Utility classes facilitating the generation and composition of user interface components. This package contains both custom user interface widgets and convenience wrappers for existing Swing widgets.

Classes for representing and storing VisualItems. In addition to the top level {@link prefuse.visual.VisualItem} interface, {@link prefuse.visual.NodeItem} and {@link prefuse.visual.EdgeItem} provide access to an underlying graph structure, {@link prefuse.visual.DecoratorItem} represents a VisualItem "attached to" or "decorating" another VisualItem, and {@link prefuse.visual.AggregateItem} represents an aggregated collection of VisualItems.

VisualItems descend from the {@link prefuse.data.Tuple} interface, and as such are actually object proxies for a row of a data table. This package includes the corresponding table and graph implementations, which have been tuned to the needs of the visual abstraction. More implementational machinery for these types is in the {@link prefuse.visual.tuple} package.

Expressions in the prefuse expression language that are specific to VisualItems. These expression instances can be instantiated directly and used, or are accessible as functions in the prefuse expression language.

ItemSorter instances for determining the rendering order of VisualItems. Each {@link prefuse.Display} instance can have a unique item sorter for controlling the order in which items are drawn to the screen.

Implementations of VisualItem types and backing TupleManager instances.