All Classes and Interfaces

Class
Description
This class is the superclass of all parsers.
This class provides an implementation of the PathHandler that initializes a Shape from the value of a path's 'd' attribute.
This class produces a polygon shape from a reader.
This class produces a polyline shape from a reader.
This interface defines constants for CSS.
This class provides a default implementation of ErrorHandler.
This interface must be implemented and then registred as the error handler in order to be notified of parsing errors.
The ExtendedGeneralPath class represents a geometric path constructed from straight lines, quadratic and cubic (Bezier) curves and elliptical arc.
The ExtendedPathIterator class represents a geometric path constructed from straight lines, quadratic and cubic (Bezier) curves and elliptical arcs.
 
Implements a collection of utility methods abstracting the graph structure taking into account graph properties such as visible/non-visible traversal
Baseclass for all timer-based animations.
 
A very fast and memory efficient class to encode and decode to and from BASE64 in full accordance with RFC 2045.

On Windows XP sp1 with 1.4.2_04 and later ;), this encoder and decoder is about 10 times faster on small arrays (10 - 1000 bytes) and 2-3 times as fast on larger arrays (10000 - 1000000 bytes) compared to sun.misc.Encoder()/Decoder().

On byte arrays the encoder is about 20% faster than Jakarta Commons Base64 Codec for encode and about 50% faster for decoding large arrays.
 
 
Cells are the elements of the graph model.
Codec for mxCells.
To control this editor, use mxGraph.invokesStopCellEditing, mxGraph.
 
Implements a mouse tracker that marks cells under the mouse.
 
Implements a mechanism for temporary cell Ids.
 
 
Represents the current state of a cell in a given graph view.
Represents the current state of a cell in a given graph view.
Event handler that highlights cells.
Codec for mxChildChanges.
 
 
XML codec for Java object graphs.
Singleton class that acts as a global registry for codecs.
 
 
 
 
Defines an object that contains the constraints about how to connect one side of an edge to its terminal.
Connection handler creates new connections between cells.
 
Connection handler creates new connections between cells.
Implements a cost function for a constant cost per traversed cell.
Contains all global constants.
 
Sets the horizontal locations of node and edge dummy nodes on each layer.
 
 
Draws the edge label along a curve derived from the curve describing the edge's path
 
 
 
Implements a cost function for the Euclidean length of an edge.
public static void main(String[] args) { try { String filename = Test.class.getResource( "/com/mxgraph/online/exported.xml").getPath(); String xml = mxUtils.readFile(filename); System.out.println("xml=" + xml); Document doc = mxUtils.parseXml(xml); Element root = doc.getDocumentElement(); int width = Integer.parseInt(root.getAttribute("width")); int height = Integer.parseInt(root.getAttribute("height")); System.out.println("width=" + width + " height=" + height); BufferedImage img = mxUtils.createBufferedImage(width, height, Color.WHITE); Graphics2D g2 = img.createGraphics(); mxUtils.setAntiAlias(g2, true, true); mxDomOutputParser reader = new mxDomOutputParser( new mxGraphicsExportCanvas(g2)); reader.read((Element) root.getFirstChild().getNextSibling()); ImageIO.write(img, "PNG", new File( "C:\\Users\\Gaudenz\\Desktop\\test.png")); } catch (Exception e) { e.printStackTrace(); } } // ------------- Document doc = mxUtils.parseXml(xml); Element root = doc.getDocumentElement(); mxDomOutputParser reader = new mxDomOutputParser(canvas); reader.read(root.getFirstChild());
 
Contains various DOM API helper methods for use with mxGraph.
 
 
A cost function that assumes that edge value is of type "double" or "String" and returns that value.
 
 
Provides various edge styles to be used as the values for mxConstants.STYLE_EDGE in a cell style.
Defines the requirements for an edge style function.
 
 
Contains all global constants.
Base class for objects that dispatch named events.
Base class for objects that dispatch named events.
Defines the requirements for an object that listens to an event source.
Fast organic layout algorithm.
This class implements a priority queue.
Implements a node of the Fibonacci heap.
Parses a GD .txt file and imports it in the given graph.
This class depends from the classes contained in com.mxgraph.io.gd.
Represents the different states in the parse of a file.
 
 
 
 
Codec for mxChildChanges.
Represents the geometry of a cell.
Implements a graph object that allows to create diagrams from a graph model and stylesheet.
 
An abstraction of an internal hierarchy node or edge
 
 
 
 
 
 
 
 
 
 
 
 
A singleton class that provides algorithms for graphs.
For setting the preferred size of the viewport for scrolling, use mxGraph.setMinimumGraphSize.
 
 
 
An abstraction of a hierarchical edge for the hierarchy layout
Internal model of a hierarchical graph.
Defines the interface that visitors use to perform operations upon the graph information during depth first search (dfs) or other tree-traversal strategies implemented by subclassers.
An abstraction of an internal node in the hierarchy layout
An abstraction of a rank in the hierarchy layout.
An implementation of a canvas that uses Graphics2D for painting.
Used for exporting images.
Abstract bass class for layouts
Extends mxEventSource to implement a graph model.
 
 
 
 
 
 
 
 
 
An outline view for a specific graph component.
Constants for graph structure properties
 
Implements the selection model for a graph.
 
 
 
 
Implements a view for the graph.
Action to change the current root in a view.
A converter that renders display XML data onto a graphics canvas.
An abstract converter that renders display XML data onto a canvas.
 
The top level compound layout of the hierarchical layout.
The specific layout interface for hierarchical layouts.
An implementation of a canvas that uses HTML for painting.
Contains various helper methods for use with mxGraph.
To set global CSS for all HTML labels, use the following code:
Defines the requirements for a canvas that paints the vertices and edges of a graph.
Requirements for implementing technologies: - Path rendering (move, line, quad, curve, arc) - Images, flip v/h, aspect, alpha (PNG, JPG, GIF) - Linear gradients (in all four directions) - Transparency, fill and stroke - Rotation, flip v/h - Font rendering - Dash patterns - Clipping by path (not just rectangle) - Alpha gradients (for glass effect) - Encode result as image (PNG, JPG)
Defines the requirements for a cell that can be used in an mxGraphModel.
 
 
The cost function takes a cell and returns it's cost as a double.
Defines the requirements for an object that implements a graph layout.
Defines the requirements for a graph model to be used with mxGraph.
Defines the interface for an atomic change of the graph model.
Implements a 2-dimensional point with double precision coordinates.
Maps from keys to base64 encoded images or file locations.
An implementation of a canvas that uses Graphics2D for painting.
A rectangular shape that contains a single image.
 
 
 
 
 
 
 
Implements a layout manager that updates the layout for a given transaction.
 
Implements a line with double precision coordinates.
 
 
Performs a vertex ordering within ranks as described by Gansner et al 1993
An implementation of the first stage of the Sugiyama layout.
Codec for mxGraphModels.
Provides animation effects.
 
Connection handler creates new connections between cells.
 
Generic codec for Java objects.
An implementation of a simulated annealing layout, based on "Drawing Graphs Nicely Using Simulated Annealing" by Davidson and Harel (1996).
 
A custom graph model
 
 
 
Provides various perimeter functions to be used in a style as the value of mxConstants.STYLE_PERIMETER.
Defines the requirements for a perimeter function.
An instance of ImageEncodeParam for encoding images in the PNG format.
 
 
 
An ImageEncoder for the PNG file format.
A class representing the fields of a PNG suggested palette entry.
Utility class to extract the compression text portion of a PNG
Implements a 2-dimensional point with double precision coordinates.
 
 
Implements a 2-dimensional rectangle with double precision coordinates.
 
 
 
Codec for mxChildChanges.
Basic example of implementing a handler for rotation.
Implements a rubberband selection.
XMLReader reader = SAXParserFactory.newInstance().newSAXParser() .getXMLReader(); reader.setContentHandler(new mxSaxExportHandler( new mxGraphicsExportCanvas(g2))); reader.parse(new InputSource(new StringReader(xml)));
 
 
 
 
One dimension of a spline curve
 
Implements a stencil for the given XML definition.
 
Stencil shape drawing that takes an XML definition of the shape and renders it.
Singleton class that acts as a global converter from string to object values in a style.
Defines the appearance of the cells in a graph.
Codec for mxStylesheets.
Contains various style helper methods for use with mxGraph.
An implementation of a canvas that uses SVG for painting.
Manager for swimlanes and nested swimlanes that sets the size of newly added swimlanes to that of their siblings, and propagates changes to the size of a swimlane to its siblings, if siblings is true, and its ancestors, if bubbling is true.
 
 
 
Codec for mxChildChanges.
Implements a collection of utility methods for traversing the graph structure.
 
Implements a 2-dimensional rectangle with double precision coordinates.
Defines the requirements for an undoable change.
Implements an undo history.
Implements a union find structure that uses union by rank and path compression.
Contains various helper methods for use with mxGraph.
 
An implementation of a canvas that uses VML for painting.
Contains various XML helper methods for use with mxGraph.
This class represents a reader which normalizes the line break: \n, \r, \r\n are replaced by \n.
This class represents a parser with support for numbers.
This class encapsulates a general parse error or warning.
This interface represents a parser.
This interface must be implemented and then registred as the handler of a PathParser instance in order to be notified of parsing events.
This class implements an event-based parser for the SVG path's d attribute values.
This interface must be implemented and then registred as the handler of a PointsParser instance in order to be notified of parsing events.
This class implements an event-based parser for the SVG points attribute values (used with polyline and polygon elements).
This interface represents objects which creates Shape objects.
This class represents a NormalizingReader which handles Strings.