Public

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

visit

Dictionary

Reactive rest calls using spring rest template

A border layout lays out a container, arranging and resizing its components to
fit in five regions: 

java.awt.BorderLayout

A generic Abstract Window Toolkit(AWT) container object is a component that can
contain other AWT co

java.awt.Container

A readable source of bytes.Most clients will use input streams that read data
from the file system (

java.io.InputStream

ArrayList is an implementation of List, backed by an array. All optional
operations including adding

java.util.ArrayList

UUID is an immutable representation of a 128-bit universally unique identifier
(UUID). There are mul

java.util.UUID

Vector is an implementation of List, backed by an array and synchronized. All
optional operations in

java.util.Vector

runOnUiThread

putExtra

requestLocationUpdates

/**
	 * 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