Public

The method within which the visitor will perform operations upon the graph model

visit

Dictionary

Start an intent from android

The Color class is used encapsulate colors in the default sRGB color space or
colors in arbitrary co

java.awt.Color

A buffer for bytes. A byte buffer can be created in either one of the following
ways: *  #allocate(i

java.nio.ByteBuffer

The abstract base class for all number formats. This class provides the
interface for formatting and

java.text.NumberFormat

 Collection is the root of the collection hierarchy. It defines operations on
data collections and t

java.util.Collection

javax.swing.JLabel

The LoggerFactory is a utility class producing Loggers for various logging APIs,
most notably for lo

org.slf4j.LoggerFactory

onCreateOptionsMenu

Sets the general request property. If a property with the key already exists,
overwrite its value wi

setRequestProperty

getExternalFilesDir

/**
	 * Performs a depth first search on the internal hierarchy model
	 * 
	 * @param parent
	 *            the parent internal node of the current internal node
	 * @param root
	 *            the current internal node
	 * @param connectingEdge
	 *            the internal edge connecting the internal node and the parent
	 *            internal node, if any
	 * @param visitor
	 *            the visitor pattern to be called for each node
	 * @param seen
	 *            a set of all nodes seen by this dfs a set of all of the
	 *            ancestor node of the current node
	 * @param layer
	 *            the layer on the dfs tree ( not the same as the model ranks )
	 */

// Copy the connects as source list so that visitors

// can change the original for edge direction inversions

// Use the int field to indicate this node has been seen

/**
 * Internal model of a hierarchical graph. This model stores nodes and edges
 * equivalent to the real graph nodes and edges, but also stores the rank of the
 * cells, the order within the ranks and the new candidate locations of cells.
 * The internal model also reverses edge direction were appropriate , ignores
 * self-loop and groups parallels together under one edge object.
 */

/**
	 * Stores the largest rank number allocated
	 */

/**
	 * Map from graph vertices to internal model nodes
	 */

/**
	 * Map from graph edges to internal model edges
	 */

/**
	 * Mapping from rank number to actual rank
	 */

/**
	 * Store of roots of this hierarchy model, these are real graph cells, not
	 * internal cells
	 */

/**
	 * The parent cell whose children are being laid out
	 */

/**
	 * Count of the number of times the ancestor dfs has been used
	 */

/** High value to start source layering scan rank value from */

/**
	 * Creates an internal ordered graph model using the vertices passed in. If
	 * there are any, leftward edge need to be inverted in the internal model
	 * 
	 * @param layout
	 *            the enclosing layout object
	 * @param vertices
	 *            the vertices for this hierarchy
	 */

// map of cells to internal cell needed for second run through

// to setup the sink of edges correctly. Guess size by number

// of edges is roughly same as number of vertices.

// Go through edges set their sink values. Also check the

// ordering if and invert edges if necessary

// Only need to process the first real edge, since

// all the edges connect to the same other vertex

// The real edge is reversed relative to the internal edge

// Use the temp variable in the internal nodes to mark this

// internal vertex as having been visited.

/**
	 * Creates all edges in the internal model
	 * 
	 * @param layout
	 *            reference to the layout algorithm
	 * @param vertices
	 *            the vertices whom are to have an internal representation
	 *            created
	 * @param internalVertices
	 *            the blank internal vertices to have their information filled
	 *            in using the real vertices
	 */

// If the layout is deterministic, order the cells

// Create internal edges, but don't do any rank assignment yet

// First use the information from the greedy cycle remover to

// We process all edge between this source and its targets

// If there are edges going both ways, we need to collect

// them all into one internal edges to avoid looping problems

// later. We assume this direction (source -> target) is the 

// natural direction if at least half the edges are going in

// The check below for edgeMapper.get(edges[0]) == null is

// in case we've processed this the other way around

// (target -> source) and the number of edges in each direction

// are the same. All the graph edges will have been assigned to

// an internal edge going the other way, so we don't want to 

// Resets all point on the edge and disables the edge style

// without deleting it from the cell style

How to usemxGraphHierarchyModel$CellVisitor in com.mxgraph.layout.hierarchical.model

Best Java code snippets using com.mxgraph.layout.hierarchical.model.mxGraphHierarchyModel$CellVisitor (Showing top 4 results out of 315)

How to use
mxGraphHierarchyModel$CellVisitor
in
com.mxgraph.layout.hierarchical.model