|
Search this API | ||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||
DataProvider key for attaching an AbortHandler instance to a graph
Only instances of AbortHandler should be assigned to this DataProvider, otherwise a
ClassCastException will occur.
AbortHandler instance.
GenericNodeRealizer instances.AbstractCustomHotspotPainter that
paints all 8 possible hot spots.
AbstractCustomHotspotPainter using a
bit mask to determine which of the 8 possible hotspots to use.
YLabel.Painter implementations.GenericNodeRealizer instances.DataAcceptor-based implementation of InputHandler.AbstractDataAcceptorInputHandler class.
AbstractDataAcceptorInputHandler class.
AbstractOutputHandler class
that uses an DataProvider to retrieve the values to output for each item.AbstractDataProviderOutputHandler class
DeserializationEventhierarchic layout algorithm.AbstractDrawer with default settings.
AbstractEdgeLayoutSerializer instance.
EdgeRealizerSerializer.InputHandler interface.AbstractInputHandler class.
AbstractInputHandler class.
ItemEditor classes can be
derived.AbstractLabelingAlgorithm instance with default settings.
LayoutStage that handles the management of the core layout algorithm.LayoutStage instance without a specific core layout algorithm.
LayoutStage instance using the given core layout algorithm.
MouseInputEditor that
provides convenient support for the necessary listener implementation.AbstractNodeLayoutSerializer instance.
NodePlacer interface.AbstractNodePlacer.
NodeRealizerSerializer.OutputHandler interface.AbstractOutputHandler class.
AbstractOutputHandler class
PortConstraintOptimizer interface that minimizes the effort
required to modify the port assignment after the sequencing phase of hierarchic layout algorithm.AbstractPortConstraintOptimizer instance with default settings.
AbstractPortConstraintOptimizer.AbstractPortConstraintOptimizer.SameLayerData instance.
NodePort data attributes in GraphML.NodePlacers that support rotations of the subtrees.AbstractRotatableNodePlacer whose direction is specified by the given
modification matrix.
AbstractRotatableNodePlacer.AbstractRotatableNodePlacer.RootAlignment describes how a local root node is arranged in relation to its children.AbstractSegmentInfo.
AbstractSegmentInfo using a line segment to describe the edge segment.
SerializationHandlerMoveSnapContext and HotSpotSnapContext
that stores the context and manages the snapping related data for ViewMode implementations
and the like.Graph2DView.
NodePort data attributes in GraphML.XmlWriter.true iff the specified File does not
represent a directory and its filename extension matches this
SuffixFileFilter's accepting suffix or the accepting suffix'
length is 0.
Object should be accepted (or
rejected) by this filter implementation.
true, iff the specified graph element's visibility
matches this filter's current visibility setting for the corresponding
element type and false otherwise.
true if the specified bend should be deleted or false otherwise.
true if the specified edge should be deleted or
false otherwise.
true if the specified edge label should be deleted or false otherwise.
true, iff a representative of the specified model
node should be inserted into an associated view graph; false
otherwise.
true, iff a representative of the specified model
edge should be inserted into an associated view graph; false
otherwise.
yfiles.type has the value portconstraints.
yfiles.type="edgegraphics".
yfiles.type="nodegraphics".
true if the specified node should be deleted or false otherwise.
true if the specified node label should be deleted or false otherwise.
true if the specified node port should be deleted or
false otherwise.
true, iff a representative of the specified model
node should be removed from an associated view graph; false
otherwise.
true, iff a representative of the specified model
edge should be removed from an associated view graph; false
otherwise.
true, iff a representative of the specified model
node should be retained in an associated view graph; false
otherwise.
true, iff a representative of the specified model
edge should be retained in an associated view graph; false
otherwise.
(x,y)
starting from node source.
(x,y)
starting from node source.
(x,y)
starting from the specified node port of the specified node.
true if the specified table column should be deleted or false otherwise.
true if the specified table row should be deleted or false otherwise.
(x,y)
by connecting to node target.
(x,y)
by connecting to the specified node port of the specified node.
moduleSelected in the
PackageMenuListener for the selected module.
delete for the view returned by
getView.
Graph2DViewActions.DuplicateAction.duplicate(Graph2DView) for the view returned by
getView(e).
editLabel for the view returned by
getView.
select for the view returned by
getView.
ViewMode.ACTIVE_PROPERTY as the property name.
ViewMode.ACTIVE_PROPERTY as the property name.
PropertyChangeEvent.getPropertyName().
PropertyChangeEvent.getPropertyName().
null if there is none.
null if there is none.
ShortestPaths.acyclic(Graph, Node, double[], double[]) but, additionally, this method
yields the path edges of each calculated shortest path.
ShortestPaths.acyclic(Graph, Node, double[], double[]) but uses NodeMaps and
DataProviders instead of arrays.
YList.addLast(Object).
Node to this Layer instance.
PortCandidate with capacity 1 to this PortCandidateSet.
PortCandidate with the given capacity to this PortCandidateSet.
EnumOptionItem.add(Object, Object) with item
as both of the arguments.
Drawable to this manager's list
of graph objects.
EdgeRealizer to this manager's list
of graph objects.
NodeRealizer to this manager's list
of graph objects.
Graph2DViewActions.getAddPredecessorsAction().
Graph2DViewActions.getAddSuccessorsAction().
EnterIntervalCalculators.
EnumOptionItem.add(Object, Object) method.
0 and 2*Pi.
0 and 2*Pi.
AnimationObject to the composite.
AnimationListener to the AnimationObject.
GMLEncoder.addAttribute(String, Object)
for each entry in items.
GenericTreeLayouter.SubtreeShape instance by the given rectangle.
ResourceBundle to the list of bundles that are checked
for localized strings.
ResourceBundle to the list of bundles that are checked
for localized strings.
MouseInputEditor.isEditing() state of this instance changes.
PropertyChangeListener to receive
all PropertyChange events from all
PropertyChangeReporter children of this
reporter.
PropertyChangeListener to receive
specific PropertyChange events from all
PropertyChangeReporter children of this
reporter.
VetoableChangeListener to receive
all VetoableChange events from all
VetoableChangeReporter children of this
reporter.
VetoableChangeListener to receive
specific VetoableChange events from all
VetoableChangeReporter children of this
reporter.
column to the PartitionGrid instance.
container at the specified position and updates the sizes of
it's new ancestors accordingly.
DeserializationEvents.
DeserializationEvents.
OptionHandler.addDouble(String,double,double,double).
Node to this AbstractPortConstraintOptimizer.SameLayerData
instance and associates it with the given original (same-layer) Edge.
DynamicDecomposition.Listener that will be notified of dynamic decomposition events to the Partition.
dynamic decomposition listener to receive
PartitionCell subdivision and creation events from this decomposition.
GraphPartition.
EdgeRealizerSerializer
GenericTreeLayouter.SubtreeShape instance.
CompoundEditor.
el so that it will receive notifications
when an editor is added or removed.
el so that it will receive notifications
when an editor is added or removed.
HotSpotSnapContext.getFixedSnapLines(java.util.Collection) that
collects SnapLine instances for a given fixed node.
SnapLine methods to the result
Collection for the given NodeRealizer.
SnapLines that are induced by a given node.
Bend as a confirmed hit for this
HitInfo.
Edge as a confirmed hit for this
HitInfo.
EdgeLabel as a confirmed hit for this
HitInfo.
Node as a confirmed hit for this
HitInfo.
NodeLabel as a confirmed hit for this
HitInfo.
NodePort as a confirmed hit for this
HitInfo.
Port as a confirmed hit for this
HitInfo.
Image instance directly.
URL instance that describes an image resource.
DataAcceptor instance for
use as an input data target.
DataAcceptor instance for
use as an input data target.
DataAcceptor instance for
use as an input data target
for the actual deserialization.
DataAcceptor instance for
use as an input data target
for the actual deserialization.
DataAcceptor instance for
use as an input data target
for the actual deserialization.
DataAcceptor instance for
use as an input data target.
Future instance that wraps an DataMap for
use as an input data target.
Future instance that wraps an DataMap for
use as an input data target.
Future instance that wraps an DataMap for
use as an input data target.
InputHandler instance for the current QueryInputHandlersEvent.getKeyDefinition().
QueryInputHandlersEvents.
QueryInputHandlersEvents.
EdgeLabelLayout to the given edge.
GenericTreeLayouter.SubtreeShape instance by the given segment.
MouseInputMode.findMouseInputEditor(Graph2DView, double, double, HitInfo) for editors when this mode receives
mouse events.
MultiplexingNodeEditor instance.
NodeRealizerSerializer
OptionHandler.
DataProvider instance for
use as an output data source
This methods creates and configures the necessary handler
itself.
DataProvider instance for
use as an output data source
This methods creates and configures the necessary handler
itself.
DataProvider instance for
use as an output data source.
DataProvider instance for
use as an output data source.
QueryOutputHandlersEvents.
QueryOutputHandlersEvents.
ParseEventListener.
ParseEventListener.
PathSearchExtensions.
Node or Edge with id after to lie
after the Node or Edge with id reference.
Node or Edge at the start of the sequence.
Node or Edge at the end of the sequence.
Node or Edge with id before to lie
before the Node or Edge with id reference.
aboveId to lie above the node referenceId.
aboveId to lie at least minDistance layers above
the node with ID referenceId.
aboveId to lie at least minDistance layers above
the node with ID referenceId with a given weight penalty for larger layer differences.
Node with ID aboveId to lie above the
Node with ID referenceId.
Node with ID aboveId to lie at least
minDistance layers above the Node with ID referenceId.
Node with ID aboveId to lie at least
minDistance layers above the Node with ID referenceId with a given
weight penalty for larger layer differences.
SequenceConstraintFactory.addPlaceAfterConstraint(Object, Object) instead.
Node on the bottom layer.
SequenceConstraintFactory.addPlaceAtHeadConstraint(Object) instead.
SequenceConstraintFactory.addPlaceAtTailConstraint(Object) instead.
Node on the topmost layer.
SequenceConstraintFactory.addPlaceBeforeConstraint(Object, Object) instead.
Node with ID belowId to lie below the Node
with ID referenceId.
Node with ID belowId to lie at least
minDistance layers below the Node with ID referenceId.
belowId to lie at least minDistance layers below
the node with ID referenceId with a given weight penalty for larger layer differences.
Node with ID belowId to lie below the Node
with ID referenceId.
Node with ID belowId to lie at least
minDistance layers below the Node with ID referenceId.
Node with ID belowId to lie at least
minDistance layers below the Node with ID referenceId with a given weight
penalty for larger layer differences.
sameLayerId to lie in the same-layer as the node with ID
referenceId.
Node with ID sameLayerId to lie in the same layer
as the Node with ID referenceId.
PropertyChangeListener to receive
all PropertyChange events from this reporter.
PropertyChangeListener to receive
specific PropertyChange events from this reporter.
PropertyChangeListener to the list of registered listeners.
PropertyChangeListener for the given property
to the list of registered listeners.
DataProvider instance that has been registered on the underlying graph instance
as source for the given GraphML attribute.
DataProvider instance that has been registered on the underlying graph instance
as source for the given GraphML attribute.
DataProvider instance that has been registered on the underlying graph instance
as source for the given GraphML attribute.
row to the PartitionGrid instance.
container at the specified position and updates the sizes of
it's new ancestors accordingly.
Edge to this Layer instance.
p1 and p2
to the set of elements that should be routed within the channel.
segment info to the channel.
MoveSnapContext.adjustMouseCoordinates(y.geom.YPoint)
This method can be used to provide this class with segments that cannot be easily obtained from the graph structure.
MoveSnapContext.MovingInfos.
segment group to this channel.
Graph2DSelectionListener to the creator's
model graph that creates a local view on selection changes.
SerializationEvents.
SerializationEvents.
SnapResult to this instance that will be honored during calls to
AbstractSnapContext.processSnapResults(java.util.List,y.geom.YPoint)
current edge if it is not already contained in
the list of source cells.
MoveSnapContext.addNodeSnapLines(y.base.Node, NodeRealizer, java.util.Collection, java.util.Collection)
that will be used if the realizer of the node is a TableGroupNodeRealizer.
current edge if it is not already contained in the
list of target cells.
VetoableChangeListener to receive
all VetoableChange events from this reporter.
VetoableChangeListener to receive
specific VetoableChange events from this reporter.
Graph to the list of views handled by this
manager.
Graph to the list of views handled by this
manager.
WriteEventListener.
WriteEventListener.
initialized.
LabelSnapContext.initializeEdgeLabelMove(y.geom.YPoint, EdgeLabel) or
LabelSnapContext.initializeNodeLabelMove(y.geom.YPoint, NodeLabel) has been and
before LabelSnapContext.cleanUp() is called.
LabelSnapContext.initializeEdgeLabelMove(y.geom.YPoint, EdgeLabel) or
LabelSnapContext.initializeNodeLabelMove(y.geom.YPoint, NodeLabel) has been
and before LabelSnapContext.cleanUp() is called.
initialization
and before MoveSnapContext.cleanUp() that will snap the coordinates and update the Drawables.
segment info in the channel considering
the preferred alignment of the segment.
Editor.commitValue() instead.
adoptItemValue() of all contained editors.
OrientedRectangle to this instance.
LayerSequencer to this sequencer.
TaskExecutorFactory that creates TaskExecutors that
execute tasks in parallel, i.e., multi-threaded.
DataProvider key for marking the edges that should be routed.
DataProvider key for determining which edges are routed.
DataProvider key for determining which edges are distributed.
DataProvider key for determining which nodes should be placed by this stage.
AlgorithmAbortedException with the specified detail message.
AlgorithmAbortedException with no detail message.
Graph2DViewActions.getAlignHorizontallyAction()
Graph2DViewActions.getAlignVerticallyAction().
HierarchicLayouter
such that they are aligned according to the user's specifications.AlignmentDrawer instance using the given Drawer instance as the actual drawer.
DataProvider that will make all nodes bottom-aligned (in top-to-bottom layouts) when registered.AlignmentDrawer.BottomAlignmentDataProvider instance.
DataProvider that will make all nodes left-aligned (in left-to-right layouts) when registered.AlignmentDrawer.LeftAlignmentDataProvider instance.
DataProvider that will make all nodes right-aligned (in left-to-right layouts) when registered.AlignmentDrawer.RightAlignmentDataProvider instance.
DataProvider that will make all nodes top-aligned (in top-to-bottom layouts) when registered.AlignmentDrawer.TopAlignmentDataProvider instance.
all.
AbstractRotatableNodePlacer.RootAlignments.
null) image values can be selected through the editor.
MouseInputMode.
TableGroupNodeRealizer.
TableGroupNodeRealizer.
TableGroupNodeRealizer.
TableGroupNodeRealizer.
DataProvider key for associating alternative paths for edges connecting to groups, group content or folder nodes.
DataProvider key for associating an alternative bounds with the collapsed/expanded group.
180 degrees
should be added to the angle.
AnimationObject and informs the
AnimationListener whenever changes in the animation scene should be
displayed.
Graph2DLayoutExecutor.setMode(byte) and Graph2DLayoutExecutor.getMode() that tells the executor to
run a buffered layout and then morph
the current graph to the newly calculated layout.
Graph2DLayoutExecutor.setMode(byte) and Graph2DLayoutExecutor.getMode() that tells the executor to
run a buffered layout and then morph
the current graph to the newly calculated layout.
AnimationEvent has been fired.
update for the appropriate events.
NodeLabel.FREE.
x to the rear of this queue.
(x,y) to the list
of bends.
partition cell of the current CellEntrance to the neighboring
cell.
layout algorithm to the end of the chain.
layout algorithms to the end of the chain.
LayoutStage to the layout pipeline.
LayoutStage to the previously added LayoutStages.
LayoutStage to the previously added LayoutStages.
entrances for the path search of the current edge to the given
list of all previously generated entrances.
EdgeLayout instance.
GraphLayout to the LayoutGraph.
Graph2DLayoutExecutor in
Graph2DLayoutExecutor.BUFFERED mode to calculate a layout for the currently given
graph using the provided layouter instance.
Graph2DLayoutExecutor in
Graph2DLayoutExecutor.ANIMATED mode to calculate a layout for the currently given
graph using the provided layouter instance and applying the new layout in an animated fashion.
Bend.setLocation(double, double) according to the movement constraints.
Port.setOffsets(double, double) according to the movement constraints.
ArcEdgeRealizer.NodePlacer places the subtrees such that the overall aspect ratio of the arranged subtree will
be close to a preferred aspect ratio.ARNodePlacer with default settings.
ARNodePlacer with given settings.
ListCellRenderer and TableCellRenderer
implementation that renders objects of type Arrow nicely.ARTreeLayouter arranges tree graphs in a compact fashion.ARTreeLayouter instance with default settings.
YLabel.Painter instance to support
automatic flipping of label content according to rotation angle.
AsIsLayerer assigns nodes to layers by analyzing already existing node coordinates.AsIsLayerer with default settings.
AsIsSequencer instance.
Layerer implementation that delegates the actual layering to a
delegate Layerer object.AspectRatioComponentLayerer using the given delegate Layerer instance.
Layers instance.
Layers instance.
Layers instance.
Layers instance.
Layers instance.
Layers instance based on the given
aspect ratio.
Layers instance based on relative and
absolute layering constraints defined by the given layering constraints.
Layers instance.
Layers instance.
Layers instance.
DataProvider registered with the graph using key
GivenLayersLayerer.LAYER_ID_KEY.
WeightedLayerer.assignNodeLayer(y.layout.LayoutGraph, y.base.NodeMap, y.base.EdgeList, y.base.DataProvider)
instead.
This method does not support graphs that have several disjoint graph components nor the edge weight based cycle removal heuristic.
node compaction is enabled.
port assignment mode.
port assignment mode.
NodeMap which assigns a profit value to each node in the conflict graph.
NodeMap which assigns a profit value to each node in the conflict graph.
GenericTreeLayouter.SubtreeShape instance to the given shape applying a modification matrix.
DataProvider key for marking which nodes are placed as assistants
AssistantPlacer places nodes that are marked as assistants left and right of their parents and all other
nodes below the assistant nodes.AssistantPlacer instance with default settings.
AssistantPlacer instance that uses the transformation defined by the given matrix.
YInsets insets representing the specified data.
"attr.name" attribute.
"attr.type" attribute.
"yfiles:attr.uri" attribute.
Boolean.TRUE,
the editor is initialized to be in autoAdopt mode.
Boolean.TRUE,
the editor is initialized to be in autoCommit state.
String id tag.
handlername.sectionname.
handlername.
Object id tag usable as a
key in a Map.
ObjectStringConverter to be
used by editors.
TableEditorFactory.EditorLocation.RELATIVE_TO_REFERENCE_COMPONENT.
JFileChooser to be used by editors.
JFileChooser to be used by editors.
Collection
of OptionGroup instance that the item belongs to.
ItemListener.
ListCellRenderer.
Boolean.TRUE,
text-based editors should select their text content when they receive
focus due to a focus traversal event (i.e. receiving the focus due to
mouse clicks should not trigger the content selection).
TableEditorFactory.getDefaultEditor(OptionItem).
TableEditorFactory.getDefaultRenderer(OptionItem).
String.
String to be displayed in the
title bar of dialogs created by the showEditor methods.
String to be displayed in the title bar of dialogs created
by the showEditor methods.
OptionItem should be used as its tool tip text if no
explicit tip text has been specified.
Graph2DView.(upY > 0).
EdgeLabelModel implementation used specifically for labels
that are being rotated automatically according to the path of the edge.AutoRotationSliderEdgeLabelModel and its parameters.Graph2DView.AbstractCustomNodePainter.restoreGraphics(Graphics2D)
This implementation stores and restores the color, the stroke, and the paint
of the graphics context.
Graph2D.backupRealizers(y.base.EdgeCursor) call.
Graph2D.backupRealizers(y.base.NodeCursor) call.
Graph2D.BackupRealizersHandler implementation.
Graph2D.BackupRealizersHandler implementation.
OptionItem
subclasses that want to support Editor.resetValue().true iff it is possible to retrieve
a command by calling CommandStream.backward().
BadVersionException is thrown upon deserializing graphs from
YGF format for elements whose associated serialization
version is not supported by the corresponding
read(ObjectInputStream) method.BadVersionException with detail message.
BadVersionException without detail message.
BadVersionException without detail message.
BadVersionException with the specified detail message.
BalloonLayouter instance with default settings.
BalloonLayouter.ShortestPaths.bellmanFord(Graph, Node, boolean, double[], double[]) but, additionally, this method
yields the path edges of each calculated shortest path.
ShortestPaths.bellmanFord(Graph, Node, boolean, double[], double[], Edge[])
but uses NodeMaps and DataProviders instead of arrays.
EdgeRealizer.bendChanged(Bend, double, double)
EditMode.mouseReleasedLeft(double,double) and
EditMode.mouseShiftReleasedLeft(double,double) when a Bend has been
clicked.
BendConverter replaces edge bends with dummy nodes for the core layout algorithm.BendConverter instance with default settings.
BendConverter with the given core layout algorithm.
BendConverter instance with the given size as
the width and height for the dummy nodes.
EditMode.mouseDraggedLeft(double,double) when a
Bend is being dragged.
GenericNodeRealizer.Painter that draws a rounded
rectangle with a bevel border and an optional simple drop shadow in a shiny fashion.BezierEdgeRealizer.BezierPathCalculator instance.
BezierPathCalculator instance.
BFSLayerer uses a breadth first search for assigning layers to the nodes.BFSLayerer.
AnimationObject that lets the node represented
by the specified NodeRealizer blink (once).
AnimationObject that applies a blurring
fade-in effect to the specified Drawable.
AnimationObject that applies a blurring
fade-in effect to the specified NodeRealizer.
AnimationObject that applies a blurring
fade-in effect to the specified EdgeRealizer.
AnimationObject that applies a blurring
fade-out effect to the specified Drawable.
AnimationObject that applies a blurring
fade-out effect to the specified NodeRealizer.
AnimationObject that applies a blurring
fade-out effect to the specified EdgeRealizer.
boolean.
NodeHalo size at the bottom side of the node.
NodeLabel.INTERNAL.
snap type.
Graph2DViewActions.getBottomAlignAction().
NodeLabel.INTERNAL.
NodeLabel.INTERNAL.
GenericNodeRealizer.BoundsChangedHandler implementation to
delegate the actual work to.
LabelCandidates to the corresponding nodes in the MISLabelingAlgorithm.conflictGraph.
PathIterators.ListCellRenderer and TableCellRenderer implementation that renders objects of type BridgeCalculator nicely.BridgeCalculatorCellRenderer.STYLE_ALL
D.bug(Object), but omits newline.
D.bug(Object, Object), but does not append a newline to the
output.
D.bug(int, String), but uses no line-feed.
Graph2DLayoutExecutor.setMode(byte) and Graph2DLayoutExecutor.getMode() that tells the executor to
run a buffered layout and then apply
the calculated results to the graph.
BufferedLayouter is a hull algorithm that invokes its core layout algorithm on a
copy of the input graph.BufferedLayouter instance without a core layout algorithm.
BufferedLayouter instance using the given core layout algorithm.
System.out if
the given debug level if bigger than
DEBUG_LEVEL.
System.err unconditionally.
System.err if the fully qualified
class name of the given source object is encoded
in the system property y.debug and
if the given debug level if bigger than
DEBUG_LEVEL.
System.err if the fully qualified
class name of the given source object is encoded
in the system property y.debug.
BusDescriptor for the specified bus ID which is marked as not fixed and uses
the default edge group IDs.
BusDescriptor for the specified parameters and marks it as not fixed.
BusDescriptor for the specified parameters and default group IDs.
BusDescriptor for the specified parameters.
BusPlacer creates a bus to which all child nodes and the local root node are connected.BusPlacer with default settings.
BusPlacer instance that uses the transformation defined by the given matrix.
BusRouter with default settings.
BusRouter.distance with the given scale factor.
NodeHalos.
Rectangle2D
objects and puts the result into the specified destination
Rectangle2D object.
core layout algorithm without changing the input
graph.
core layout algorithm without changing the input
graph.
GraphInterface and GraphLayout instances.
interval between the given intervals.
YLabel.calculateSize(java.awt.font.FontRenderContext)
CellEntrance to the neighboring PartitionCell using
different enter intervals.
PartitionCell via the given enter OrthogonalInterval.
FixNodeLayoutStage.getFixPointPolicy().
CellEntrance for the next step in
the path search.
CellEntrance that describe the minimal costs that will
arise to finish the path if the given cell entrance is used as next step.
intervals.
orthogonal intervals.
NodeLayout.
LineSegments created by the calculated path points.
GenericEdgeRealizer.calculatePath(java.awt.geom.Point2D, java.awt.geom.Point2D) ()}.
YPoints containing the source port, bend and target port locations.
PortCandidates.
segment infos in the given channel.
intervals.
intervals.
intervals and the given value.
orthogonal intervals.
Rectangle2D objects
and puts the result into the specified destination
Rectangle2D object.
GenericEdgeRealizer.calcUnionRect(java.awt.geom.Rectangle2D) method.
GenericNodeRealizer.UnionRectCalculator implementation to
delegate the actual work to.
GenericNodeRealizer.calcUnionRect(java.awt.geom.Rectangle2D) method.
NodePorts.
YLabel.calcUnionRect(java.awt.geom.Rectangle2D)
NodePorts associated to this realizer.
YPoint instances.
true iff er.getClass() == getRealizerClass().
true iff n.getNamespaceURI().equals(getNamespaceURI())
&& n.getLocalName().equals(getName()).
true iff nr.getClass() == getRealizerClass().
true iff n.getNamespaceURI().equals(getNamespaceURI())
&& n.getLocalName().equals(getName()).
er in the given context.
n in the given context.
nr in the given context.
n in the given context.
DeserializationEvent.
DeserializationEvent.getXmlNode() satisfies the properties of this class.
SerializationEvent.
core layout algorithm.
core layout algorithm.
pipeline of LayoutStages.
LayoutStages can arrange the given graph.
core layout algorithm.
core layout algorithm.
core layout algorithm.
core layout algorithm.
core layout algorithm.
core layout algorithm after this stage has finished preparing the graph.
core layout algorithm after the insertion
of the parent-edges.
core layouter.
core layout algorithm.
core layout algorithm.
0 and that the specified
core layout algorithm can handle.
core layout algorithm can handle.
core layout algorithm.
DataProviders are registered
(MultiPageLayouter.NODE_ID_DPKEY, MultiPageLayouter.EDGE_ID_DPKEY, MultiPageLayouter.NODE_LABEL_ID_DPKEY and MultiPageLayouter.EDGE_LABEL_ID_DPKEY).
core layout algorithm accepts.
core layout algorithm.
core layout algorithm.
core layout algorithm accepts.
core layout algorithm.
core layout algorithm after removing all
parallel edges.
core layout algorithm.
core layout algorithm.
core layout algorithm.
core layout algorithm.
core layout algorithm.
core layout algorithm.
core layout algorithm.
core layout algorithm.
0 and that the specified
core layout algorithm can handle.
core layout algorithm.
core layout algorithm.
core layout algorithm.
core layout algorithm.
core layout algorithm.
core layout algorithm.
core layout algorithm.
core layout algorithm.
core layout algorithm after removing all
self-loops.
layout algorithm in the current chain.
specified subgraph can be handled by the
core layout algorithm.
core layout algorithm.
core layout algorithm and a
tree layout algorithm.
core layout algorithm can arrange the given graph.
core layout algorithm itself.CanonicMultiStageLayouter instance with default settings.
false.
ViewMode is designed to use instances of NodeCellEditor to
display a visual editor inline in the Graph2DView to edit a node's data.ViewMode that is responsible for displaying
NodeCellEditor instances during editing.
ViewMode that is responsible for displaying
NodeCellEditor instances during editing.
partition cell has been
entered during a path search.CellEntrance instance for a given PartitionCell.
CellEntrance instance that is a copy of a given other CellEntrance.
partition cell.CellSegmentInfo instance.
CellSegmentInfo of this segment info.
AbstractRotatableNodePlacer.RootAlignment at the center of the subtrees.
NodeLabel.INTERNAL.
snap type.
0 as center nodes.
DiscreteEdgeLabelModel.CENTER of the edge's path.
RotatedDiscreteEdgeLabelModel.CENTER of the edge's path.
Channel that contains the given segment info.
Path information.ChannelBasedPathRouting.
ChannelEdgeRouter instance with default settings.
OrthogonalEdgeRouter that can be used as a path
finding strategy for the ChannelEdgeRouter.ChannelEdgeRouter.OrthogonalShortestPathPathFinder.
ChannelEdgeRouter.ChannelRouter.
ChannelRouter for a channel with horizontal orientation.
VetoableChangeListener instead.
true if the specified event should trigger event
play back and false otherwise.
0.
0.
NodeRealizer.
NodeLabel.
edgeRealizer.
EdgeLabel.
Bend.
Port.
NodePort.
0.
0.
DataProvider key for specifying the comparator for the outgoing edges.
PropertyChangeEvent.getPropertyName().
PropertyChange and VetoableChange notifications
of child elements.GraphMLParseContext that delegates most calls to
a ChildParseContext.getParentContext(), but adds the capability to locally add
lookup results and
deserialization properties.ChildParseContext class
that delegates to the provided context and adds the currentObject
to the ChildParseContext.getObjectStack().
ChildParseContext class
that delegates to the provided context.
GraphMLWriteContext implementation for use in the context of GraphMLWriter
that wraps a given instance and delegates most of the calls to it but allows for modifying
ChildWriteContext.setLookup(Class,Object) and ChildWriteContext.setSerializationProperty(Object,Object).ChildWriteContext class that delegates to the provided context
and has the ChildWriteContext.getCurrentObject() set to the given value.
ChildWriteContext class that delegates to the given parent context.
DataAcceptor key for publishing the final circle information
For each node, the ID of the circle on which it was placed will be stored.
Arrow.CIRCLE.
DataProvider key for defining custom node partitions
The DataProvider needs to provide a mapping from Nodes to unique Object IDs for each
group of nodes.
CircularLayouter instance with the default settings.
CircularLayouter.HierarchicLayouter (i.e.,
the order of the nodes within each layer is determined).ClassicLayerSequencer instance with default settings.
channel information and the reference to the configuration.
configuration
and GraphPartition.
configuration
and context.
GraphPartitionExtensions from a given GraphPartition instance.
DynamicObstacleDecomposition can be reused and
initialized with new Obstacles.
partition data such that the GraphPartition can be reused and
initialized with a new configuration.
ObstaclePartition can be reused and
initialized with new Obstacles.
PathSearchExtensions and DataProviders added to this PathSearch.
from to to inclusive from this list.
SnapLines.
AbstractSnapContext.addSnapResult(SnapResult)
PartitionCell.
CompoundEditor.
layout algorithms and therefore removes all layout algorithms.
JComponent.putClientProperty(Object, Object) for the scroll
buttons.
JComponent.putClientProperty(Object, Object) for the
scroll buttons.
JComponent.putClientProperty(Object, Object) for the zoom
buttons.
JComponent.putClientProperty(Object, Object) for the
zoom buttons.
NodePlacer instance.
Graph2DViewActions.getCloseGroupsAction().
Graph2DViewActions.CloseGroupsAction.acceptNode(Graph2D,y.base.Node)
returns true.
graph whose coordinates lie inside the specified
bounds and stores them in the contentBends container.
contentNodes container.
view's graph into the provided
collection that will have their bounds fixed during the upcoming operation.
MoveSnapContext.adjustMouseCoordinates(y.geom.YPoint).
true iff the given points are collinear, that is, all
three points lie on a common line.
CollinearBendHider temporarily hides collinear bends on edge paths.CollinearBendHider using the given
core layout algorithm.
AnimationObject that changes the appropriate color
properties of the specified NodeRealizer to the given color
values.
AnimationObject that changes the
lineColor property of the specified EdgeRealizer
to the given color value.
TableGroupNodeRealizer.
TableGroupNodeRealizer.
null if no column in the table's model contains the specified
point.
partition grid structure.DropTargetListener can be used to create new columns in a TableGroupNodeRealizer
via drag'n'drop.commitValue() of all contained editors.
CompactNodePlacer produces a compact placement of the children.CompactNodePlacer instance with default settings.
CompactOrthogonalLayouter instance with default settings.
CompactOrthogonalLayouter.DataProvider key for defining a (global) order for edges
DataProvider key for defining a (global) order for nodes
Comparator or comparable implementations that do not
define a total order but only a partial order.PortConstraints.
DataProvider.
ColumnDescriptor instance with a given other ColumnDescriptor instance based on the
indices of the two instances.
PartitionCellId.Pair instance with a given other PartitionCellId.Pair instance.
RowDescriptor instance with a given other RowDescriptor instance based on the indices
of the two instances.
Comparable interface using the SwimLaneDescriptor.getComparator() and
SwimLaneDescriptor.getClientObject() fields.
Comparable interface using SnapResult.getWeight()
complex.
InputHandler implementation that uses an DataAcceptor
instance to associate the values with the keys.ComplexDataAcceptorInputHandler class
that uses the GraphMLParseContext for deserialization.
ComplexDataAcceptorInputHandler class
that uses the event handler for deserialization.
AbstractOutputHandler class,
that can use a ComplexDataProviderOutputHandler.getSerializer() callback for the serialization
or delegate to one of GraphMLWriteContext's
serialize callbacks.ComplexDataProviderOutputHandler class.
1:1 aspect ratio for the graph.
DataProvider key for defining custom subgraph components.
edge betweenness centrality.
DataProvider key for specifying components of the input graph
Nodes with the same component Id constitute a component and are assigned to the same, temporary, group node,
which is visible during the execution of the core layout algorithm
and again removed afterwards.
DataProvider key for specifying a layout algorithm for each component node
when used with the recursive group layout stage
If this stage is used in conjunction with RecursiveGroupLayouter, the layout algorithm
specified here is mapped to be responsible for the arrangement of the nodes forming a specified component.
ComponentLayouter arranges the connected components of a graph.ComponentLayouter instance using the given core layout algorithm.
ComponentLayouter instance with default settings.
ComponentLayouter.Drawables into oneCompositeLayouter allows for wrapping a core layout algorithm with multiple LayoutStages.CompositeLayouter instance that prepends the specified LayoutStage to the given
layout algorithm.
CompositeLayoutStage allows for combining multiple LayoutStages.CompositeLayoutStage instance with an empty pipeline.
CompositeLayoutStage instance with two LayoutStages in the pipeline.
Arrow.CONCAVE.
OptionHandler.
PartitionGrid was registered.
OptionHandler.
ComponentLayouter to take fixed nodes in components into account.
ComponentLayouter according to the view.
IncrementalHierarchicLayouter instance.
GraphMLParser.fireDeserializationEvent(DeserializationEvent) event.
QueryInputHandlersEvent event.
QueryOutputHandlersEvent event.
GraphMLWriter.fireSerializationEvent(y.io.graphml.output.SerializationEvent) event.
Font,
Color,
Boolean,
Byte,
Short,
Integer,
Long,
Float,
Double,
String, and
TransformAttribute.
DeserializationEvent event.
GraphMLHandler.
GraphListener, Graph2DListener, and Graph2DSelectionListener
references that are registered with the parent graph to the newly created graph.
ParseEventListener for the yfiles.foldertype
attribute.
GraphMLParser to handle the given graph.
WriteEventListener for the yfiles.foldertype
attribute.
GraphMLWriter for writing the given graph.
GraphPartitionExtensions instances to a given GraphPartition instance.
GraphMLParser.fireQueryInputHandlersEvent(y.io.graphml.input.QueryInputHandlersEvent) event.
writer.
parser.
writer to use the namespace declarations set with
GraphMLHandler.addNamespace(String, String).
EditMode.createNode(Graph2D,double,double,y.base.Node)
right after a new node has been created (and prior to assigning the new
node a parent node).
QueryOutputHandlersEvent event.
parser.
PathSearchExtensions to a given PathSearch instance.
ImageOutputHandler according
to the settings in the module's rendering specific options.
writer to use the schema locations set with
GraphMLHandler.addSchemaLocation(String, String).
Font,
Color,
Boolean,
Byte,
Short,
Integer,
Long,
Float,
Double,
String, and
TransformAttribute.
SerializationEvent event.
GraphMLHandler.
GraphMLHandler.
ImageOutputHandler for tiling
according to the tiling specific options.
writer.
writer.
LabelCandidates as nodes and edges between them as conflicts, i.e.,
overlaps among candidates.
Layerer implementation that observes relative and absolute layering constraints defined by
the layer constraint factory.ConstraintIncrementalLayerer with the given Layerer instance.
ConstraintLayerer considers relative and absolute layering constraints when assigning the nodes to layers.ConstraintLayerer with the given core Layerer instance.
ConstraintLayerer with the default settings.
ConstraintLayerer instance.ConstraintManager.performActionOnPropertyChange(y.option.ConstraintManager.EditorAction, OptionItem)
or
ConstraintManager.performActionOnCondition(y.option.ConstraintManager.EditorAction, y.option.ConstraintManager.Condition).path of edges from the
result returned by one of the shortest paths methods defined in this class.
ShortestPaths.constructEdgePath(Node, Node, Edge[]) but the path edges are given by a DataProvider.
path of nodes from a given path of edges.
path of nodes from the
result returned by one of the shortest paths methods defined in this class.
ShortestPaths.constructNodePath(Node, Node, Edge[]) but the path edges are given by a DataProvider.
YRectangle contains the
given point.
YRectangle contains the
given point.
YRectangle contains the
given rectangle.
YRectangle contains the
rectangle defined by the given frame.
(x,y) lies within the given visual
representation of a node.
EdgeRealizer.contains(double, double).
GenericNodeRealizer.ContainsTest implementation to
delegate the actual work to.
GenericNodeRealizer.contains(double, double) method.
true if this port's visual representation
contains the specified point and false otherwise.
true if the specified port contains the specified
point and false otherwise.
true if the specified port contains the specified
point and false otherwise.
(x,y) lies within the given visual
representation of a node.
YLabel.contains(double, double)
true if this group contains the specified option item.
EdgeRealizer.containsSeg(double, double).
Drawable instances registered via the
Graph2DView.addBackgroundDrawable(Drawable) method) in the calculation of the
content bounding box.
Drawable instances registered via the
Graph2DView.addDrawable(Drawable) method) in the calculation of the content
bounding box.
Drawable instances registered via the
Graph2D.addDrawable(Drawable) method) in the calculation of
the content bounding box.
HierarchyManager.convertToInterEdge(y.base.Edge, y.base.Node, y.base.Node) method.
Node to a label node.
AbstractStringConverter.convertToObject(String)
null
String
AbstractStringConverter.convertToString(Object)
null
object.
Arrow.CONVEX.
CopiedLayoutGraph is a LayoutGraph that serves as a copy of another graph with layout information.CopiedLayoutGraph instance which is a copy of the given graph.
CopiedLayoutGraph instance which is a copy of the graph specified by the given
GraphInterface and GraphLayout.
originalEdge from the source graph to the new targetGraph
using the specified new source and target node in the target graph.
GraphCopier.GraphDataCopyFactory.copyData(y.base.Edge,y.base.Edge)
Graph2DClipboard.getCopyFactory(y.base.Graph) and the provide
new source and target nodes.
EdgeLabelLayout.
AbortHandler instance of the given source graph to the target
graph as well.
originalNode from the source graph to the new targetGraph
GraphCopier.GraphDataCopyFactory.copyData(y.base.Node,y.base.Node)
Graph2DClipboard.getCopyFactory(y.base.Graph).
NodeLabelLayout.
GraphCopier, sets the copier as this
Graph2DCopyFactory.RecursiveGraph2DCopyFactory.getFolderGraphCopier() and then calls GraphCopier.copy(y.base.Graph, y.base.Graph)
on it.
GenericNodeRealizer.createCopy(NodeRealizer) method
to copy the user data from the original node to the target node.
DataProvider key for identifying the core nodes of the BFS layering.
interval fully covers this interval.
interval fully covers this interval given a small
epsilon value.
orthogonal interval is fully covered by the given
orthogonal interval.
NodeHalo with the specified values.
NodeHalo object with the specified value on each side of the node.
PortConstraint that constrains the edge to connect to the given side of a node.
PortConstraint that constrains the edge to connect to the given side of a node and
that can be either strong or weak.
x and y
data correspond to the specified YPoint's x and
y coordinates.
x and y
data correspond to the specified Point2D's x and
y coordinates.
x and y
both equal to 0.
AnimationObject that will be used after the layout has been calculated.
layout executor that itself is used by LayoutModule.launchLayouter(y.layout.Layouter, boolean).
LayoutMorpher to play the animation.
OutputRestriction that confines the layout result to a rectangular area which roughly complies
with the given aspect ratio.
EditMode.mouseDraggedLeft(double,double) when
a bend should be created.
EdgeRealizer.createBend(double, double, Bend, int)
Node for the given Edge in the given Layer.
Node for the given Edge in the given Layer and assigns it to the given
SwimLaneDescriptor instance.
NodeData object for a bend Node and associates it with the Node.
NodeData object for a bend Node and associates it with the Node.
EdgeLayout.
OrthogonalInterval that defines the location, the size and the orientation of the given
PartitionCell.PartitionCellBorder.
BorderLine for the given side or returns the current
BorderLine instance if it already exists.
PortCandidate instance with the given direction and
zero cost of usage.
PortCandidate instance with the given direction and cost of
usage.
PortCandidate instance with zero cost of usage, the given direction
and the given offset values.
PortCandidate instance with the given cost of usage, direction and
offset values.
PortCandidate instance with zero cost of usage and the
direction specified by the side of the given PortConstraint.
partition cell identifier that represents the cell defined by the given
column and row.
partition cell identifier that represents the cell defined by the given column
and row index.
partition cell identifier that represents a multi-cell spanning multiple columns
and rows.
partition cell identifier that represents a multi-cell spanning multiple columns
and rows.
partition cell identifier that represents a multi-cell spanning multiple columns
and rows.
OutputRestriction that confines the layout result to a circle.
NodeLabel instance, adds the created
instance to the specified realizer, and associates the instance
to the specified column.
bounds used to indicate the new position of the moved column.
bounds indicating the new size of the given column.
partition cell identifier that represents a cell spanning a whole column.
Comparator that compares to Objects of type
Comparable.
Comparator that compares objects of arbitrary type.
Comparator for outgoing edges that takes the rotation into account.
from-sketch comparators
to the two NodePlacers handling assistant and non-assistant nodes.
Comparator for outgoing edges that takes the rotation into account.
Comparator for outgoing edges which takes the initial coordinates of the edges' targets into
account.
Comparator that sorts outgoing edges according to the x-coordinate of their target nodes.
Comparator for outgoing edges that considers the locations of the target nodes.
Comparator that compares outgoing edges connecting to assistant nodes and edges connecting to
non-assistant nodes separately.
CompositeAnimationObject that represents
a set of regular animations that will run concurrently.
CompositeAnimationObject that represents
a set of regular animations that will run concurrently and conveniently
adds the two specified AnimationObject instances.
true if the item
which is identified by the source parameter changes its value to the given value.
true if the source item
changes its value to the given value.
true if the source item
changes its value to the given value.
true if the source item
changes its value to one of the values from the provided collection.
true if the source item
changes its value to one of the values from the provided collection.
true if the source item
changes its value to one of the values from the provided array of values.
true if the source item
changes its value to one of the values from the provided array of values.
true if the source item
changes its value to one of the values from the provided collection of values.
EdgeLabelDeserializer.parseEdgeLabel(y.io.graphml.input.GraphMLParseContext, org.w3c.dom.Node, y.view.EdgeLabel)
if the specified configuration is not registered.
GenericEdgeRealizerSerializer.parse(y.view.EdgeRealizer,org.w3c.dom.Node,y.io.graphml.input.GraphMLParseContext)
if the specified configuration is not registered.
GenericNodeRealizerSerializer.parse(y.view.NodeRealizer,org.w3c.dom.Node,y.io.graphml.input.GraphMLParseContext)
if the specified configuration is not registered.
NodeLabelDeserializer.parseNodeLabel(y.io.graphml.input.GraphMLParseContext, org.w3c.dom.Node, y.view.NodeLabel)
if the specified configuration is not registered.
NodePortGraphicsReader.readPort(y.view.NodePort, org.w3c.dom.Node, y.io.graphml.input.GraphMLParseContext)
if the specified configuration is not registered.
PathSearchConfiguration that is used during the path searching process.
NodeRealizer adapter instance for
GenericNodeRealizer behavior implementations used by this
class.
AnimationPlayer that is set to be
non-blocking and on which an AnimationListener, which
ensures that this factory's Graph2DView gets updated
on animation events, has been registered.
EdgeInfo.TYPE_CONNECTOR.
NodeInfo.TYPE_CONNECTOR.
Node that mimics a connector to a group Node.
ConstraintLayerer.ConstraintFactory that is suitable for this
layerer implementation.
EdgeLayoutDescriptor instance.
EdgeLayoutDescriptor instance.
EdgeLayoutDescriptor instance.
PenaltySettings instance.
EdgeLayoutDescriptor instance.
GenericTreeLayouter.SubtreeShape instance, modifying it using the provided modification matrix.
NodePort instances.
Comparator instance to determine the order of the edges according to which
they will be routed.
Node for the drawing phase using the given bounds in the given Layer.
Comparator that compares objects of arbitrary type.
Comparator that compares objects of type
Edge.
Comparator that compares objects of type
Edge.
bounds of the new column.
bounds of the new row.
Drawable representation of the specified
NodeRealizer that is independent of the graph to which the
realizer's node belongs.
Drawable representation of the specified
EdgeRealizer that is independent of the graph to which the
realizer's edge belongs.
Drawable representation of the specified
YLabel.
HierarchicLayouter.getDrawingDistanceCalculator() if the given
DrawingDistanceCalculator instance is null.
Edge using the given data.
changeEdge
operations.
currentRealizer.createCopy();
currentRealizer.createCopy();
MovePortMode.setChangeEdgeEnabled(boolean) is set to true.
AnimationObject.
AnimationObject, which results
in a linear increase in animation speed up to stopAcceleration
and a linear decrease in animation speed from
startDeceleration.
ElementFactory have to use this method to create an edge.
v to node w.
v to node w.
Node in the given Layer.
NodeData object for an edge group Node and associates it with the Node.
GenericEdgeRealizer.createEdgeLabel()
method to create new edge labels for the specified realizer.
EdgeLabel instance and adds the created
instance to the specified realizer.
LabelLayout for the given edge.
LabelLayout for the given edge.
EdgeLayout.
EdgeLayoutDescriptor instance that will be used during the various
phases of the layout algorithm to determine the drawing details of the edges of the graph.
EdgeLayoutDescriptor instance that will be used during the various phases of the layout
algorithm to determine the drawing details of the edges of the graph.
EdgeLayoutDescriptor instance that will be used during the various phases of the layout
algorithm to determine the drawing details of the edges of the graph.
EdgeLayoutDescriptor instance that will be used during the various phases of the layout
algorithm to determine the drawing details of the edges of the graph.
EdgeLayoutInputHandler.
EdgeLayoutOutputHandler.
HierarchicLayouter.doLayoutCore(LayoutGraph) and reates an appropriate EdgeReverser
implementation.
LabelCandidates intersect.
EdgeSplitSupport to handle
edge splitting on node drops if
edge splitting is enabled.
element factory for multi-page layouts.
OutputRestriction that confines the layout result to an elliptical area.
TaskExecutor.
NavigationComponent.createFitContentButton().
NavigationComponent.createFitContentAction()
HierarchyManager.createFolderNode(Node).
nodesToFold.
ParseEventListener that parses
yfiles.foldertype attributes.
WriteEventListener instance that marks group nodes.
handler instance and attaches it to the given graph.
AbstractRotatableNodePlacer.createComparator().
edge comparator which takes the initial coordinates of the nodes into account.
DefaultNodePlacer.createComparator().
Comparator for the edges which takes the initial x-coordinates of the nodes into account.
edge comparator which takes the initial coordinates of the nodes into account.
Comparator that sorts the outgoing edges according to the rows and x-coordinates of their target
nodes.
Graph.
DefaultLayoutGraph.
Graph2D.
Graph2D.
configured
as a copy of the given parent graph, basically.
Graph.getGraphCopyFactory()
to create a (possibly shared) instance.
CopiedLayoutGraph when copying a graph using GraphCopier.
LayoutGraph when copying a graph using GraphCopier.
GraphCopier.CopyFactory that can be used by
GraphCopier to create a copy of a LayoutGraph instance.
Graph2DCopyFactory.HierarchicGraph2DCopyFactory
GraphElementFactory instance that creates the graph elements for the graph instance.
GroupingKeys that reference
DataAcceptor implementations.
GraphicsContext that will be used
for the graphics object during the rendering of the image.
GraphicsContext that will be used for the
graphics object during printing.
GraphicsContext for the subsequent rendering.
GraphMLParser that can handle the given graph.
GraphMLWriter that is used for writing
the specified graph.
GraphPartition instance that divides the area of the graph into several rectangles.
Edge that connects two group border Nodes.
Node for a group node in the given Layer.
HierarchicLayouter.doLayoutCore(LayoutGraph) and creates a Grouping instance
in case of a grouped graph.
Node for a group layer.
HierarchyManager.createGroupNode(Node).
Edge between two group Nodes.
nodesToGroup.
HierarchicLayouter instance.
HierarchySupport instance that supports group nodes
and normal nodes.
PortAssignmentMoveSelectionMode.selectionMovedAction(double, double, double, double).
hit info for a given type of graph elements at
the specified location.
hit information object for a given type of graph
elements at the specified location.
hit information object for a given type of graph
elements at the specified location.
ViewMode that triggers local view creation
after the mouse has been hovering over a graph element for a short
period of time (the trigger delay).
GroupingKeys.NODE_ID_DPKEY
and GroupingKeys.PARENT_NODE_ID_DPKEY.
GIFIOHandler.
ImageIoOutputHandler for the ImageWriter of this
class.
ImageOutputHandler instance that is used for
image export.
JPGIOHandler.
Object for a group Node that should be inserted incrementally during the layering phase.
IncrementalHintsFactory implementation used for obtaining hint objects associated with nodes
and edges of the graph prior to the invocation of the layout algorithm.
IncrementalHintsFactory instance that must be used
to obtain hints to be associated with graph elements that
should be laid out incrementally.
HierarchicLayouter.doLayoutCore(LayoutGraph) and creates an appropriate
Layerer implementation.
NodeMap to store hierarchy information for each node.
Layers instance that can be used on the same graph instance for temporary results.
Comparator that compares objects of arbitrary type.
Comparator that compares objects of type
Edge.
Comparator that compares objects of type
Edge.
GMLIOHandler.
GMLIOHandler.
GraphMLIOHandler.
GraphMLIOHandler.
ImageOutputHandler instance.
TGFIOHandler.
TGFIOHandler.
GMLIOHandler.
GMLIOHandler.
YGFIOHandler.
YGFIOHandler.
HierarchicLayouter.doLayoutCore(LayoutGraph), creates the NodeData
and EdgeData instances and binds them to the elements using the given itemFactory.
Iterator view of the given cursor.
root.
root.
NodeLabel for the given TableGroupNodeRealizer.Row.
NodeLabel for the given TableGroupNodeRealizer.Column.
LabelLayoutFactory for this CopiedLayoutGraph.
LabelLayoutFactory for this LayoutGraph that can be used for copying layout
information of labels.
HierarchicLayouter instance that creates a
label layouter.
layer constraint factory that allows to create hints that affect
the assignment of the nodes to layers.
LayerConstraintFactory instance that can be used for specifying layer constraints for the given
graph.
HierarchicLayouter.getLayerer() if no Layerer instance is
given as input.
Object for a Node that should be inserted incrementally during the layering phase.
HierarchicLayouter.doLayoutCore(LayoutGraph) and creates an appropriate Layers
implementation using the given LayoutDataProvider instance.
layout executor property.
layout executor to create the LayoutMorpher
instance that will be used for the animation of the layout.
layout morpher
used for the animation.
CompositeAnimationObject that represents
a sequence of regular animations.
CompositeAnimationObject that represents
a sequence of regular animations and conveniently adds the
two specified AnimationObject instances.
LineType.serializeLineType(ObjectOutput, LineType).
Graph2DView that is used to
render the view content for the magnifier.
PortCandidateSet.CandidateMatcher that retrieves entries from this
PortCandidateSet.
SmartEdgeLabelModel with values from the graphML structure.
SmartNodeLabelModel with values from the graphML structure.
NodeScaledPortLocationModel.
MoveLabelHelper for the specified
label.
MoveLabelHelper instance.
SmartEdgeLabelModel instance.
XmlNamespaceManager instance
that can be used by this writer instance
ElementFactory have to use this method to create a node.
DropSupport.dropNodeRealizer(Graph2DView, NodeRealizer, double,
double).
EditMode.paperClicked(Graph2D,double,double,boolean)
when a node should be created.
EditMode.groupNodeClicked(y.base.Node) when a node
should be created.
(x,y).
(x,y) and
the given label text.
(x,y),
dimension (w,h) and the given label text.
LayoutStage which temporarily increases the sizes of the nodes to avoid overlaps.
GenericNodeRealizer.LabelFactory implementation
to delegate the actual work to.
GenericNodeRealizer.createNodeLabel()
method to create new node labels for the specified realizer.
NodeLabel instance and adds the created
instance to the specified realizer.
LabelLayout for the given node.
LabelLayout for the given node.
NodeLayout.
NodeLayoutDescriptor instance that will be used during the various
phases of the layout algorithm to determine the drawing details of the nodes of the graph.
NodeLayoutInputHandler.
NodeLayoutOutputHandler.
HierarchicLayouter.getNodePlacer() if the given
NodePlacer instance is null.
NodePortGraphicsReader,
NodePortGeometryReader, and NodePortUserDataReader.
NodePortGraphicsWriter,
NodePortGeometryWriter, and NodePortUserDataWriter.
PreferredPlacementDescriptor of the given potentially ambiguous one.
EdgeData object for a normal Edge and associates it with the edge.
NodeData object for a normal Node and associates it with the Node.
ObjectInputStream.
ObjectOutputStream.
Obstacle using the given bounds and data.
DynamicObstacleDecomposition that is used by the GraphPartition to divide the graph
area in rectangles.
OrientationLayouter.createOrientedInsets(YInsets) instead.
YInsets that are a geometric transformation of the given YInsets.
NodeHalo that is a geometric transformation of the given NodeHalo.
YDimension that is a geometric transformation of the given size.
OrthogonalEdgeRouter that is used for orthogonal routing of edges.
SmartEdgeLabelModel with values from the graphML structure.
SmartNodeLabelModel with values from the graphML structure.
GraphMLParseContext instance.
ChannelBasedPathRouting instance that routes the edges using pre-calculated Path objects.
PathSearch instance that finds the paths of the edges through the GraphPartition.
PathSearchContext that provides context information for the path searching algorithm.
AnimationObject that blocks for the
specified duration.
g in such a way that it becomes
planar, e. g. by removing (hiding) all edges which cause crossings.
pi.
NodePort instances that are bound to the specified node's
visual representation (its NodeRealizer).
owner
HierarchicLayouter.getPortAllocator() if the given
PortAllocator instance is null.
PortConstraint for the given edge.
HierarchicLayouter.getPortConstraintOptimizer() if the given
PortConstraintOptimizer instance is null.
PortConstraints for all edges of the given graph.
PortConstraints for some edges of the given graph.
PostprocessorInputHandler.
PreferredPlacementDescriptor instance with values from the graphML structure.
Processor for pre- and post-processing.
Processor for pre- and post-processing.
Processor that prepares the graph for placing assistant node.
Processor.
Processor that partitions child nodes of the current root node into two subsets.
Processor for pre- and post-processing.
Processor that will change all descending NodePlacers to FreePlacer.
Processor that prepares the graph for edge grouping.
Processor that distributes the nodes over the layers.
Processor for pre- and post-processing.
Processor for pre- and post-processing.
EdgeInfo.TYPE_PROXY.
Node for an Edge during the drawing phase, changing the Edge to end/start
at the proxy.
Node for an Edge during the drawing phase, changing the Edge to end/start
at the proxy and assigns it to a SwimLaneDescriptor instance.
NodeInfo.TYPE_PROXY.
NodeData object for a proxy Node and associates it with the proxy node.
EdgeInfo.TYPE_PROXY_REFERENCE.
NodeInfo.TYPE_PROXY_REFERENCE.
ReadEdgeRealizerHandler.
ReadNodeRealizerHandler.
node realizer
and edge realizer instances onto the provided
view.
OutputRestriction that confines the layout to a rectangular area.
Edge.
Node that represents a bend node of a recursive Edge.
NodeData for a dummy Node of a recursive Edge.
EdgeData object for a same-layer recursive Edge and associates it with the edge.
Edge to replace an Edge connected to a group Node.
AnimationObject that repeats the specified
animation for the specified number of times.
AnimationObject that repeats the specified
animation for the specified duration.
Edge using the given data.
Iterator view of the given cursor.
NodeLabel instance, adds the created
instance to the specified realizer, and associates the instance
to the specified row.
bounds used to indicate the new position of the moved row.
bounds indicating the new size of the given row.
partition cell identifier that represents a cell spanning a whole row.
EdgeData object for a same-layer Edge and associates it with the edge.
Edge proxy connecting a newly created proxy Node and a given proxy Node in
the given Layer.
Node for a same-layer Edge during the drawing phase that ends at the side of a node.
Node for a same-layer Edge during the drawing phase that ends at the side of a node.
Node (switching between two same-layer Edges on two different sides
of the layer).
CompositeAnimationObject that represents
a set of regular animations that will run concurrently.
CompositeAnimationObject that represents
a set of regular animations that will run concurrently and conveniently
adds the two specified AnimationObject instances.
NavigationComponent.createScrollButton(byte).
comparator for sorting the SegmentInfos in a Channel from
left to right (for vertical segments) or top to bottom (for horizontal segments), respectively.
Graph2DSelectionListener that creates
local view upon selection changes.
EdgeData object for a self-loop Edge and associates it with the edge.
CompositeAnimationObject that represents
a sequence of regular animations.
CompositeAnimationObject that represents
a sequence of regular animations and conveniently adds the
two specified AnimationObject instances.
SequenceConstraintFactory
instance that can be used for specifying sequence constraints for the given
graph.
Object for a Node or Edge that should be inserted incrementally
during the sequencing phase.
HierarchicLayouter.getSequencer() if the given Sequencer
instance is null.
MoveSnapContext that will be used by this instance to snap the mouse coordinates.
MoveSnapContext that will be used by this instance to snap the mouse coordinates.
LabelSnapContext that will be used by this instance to snap the mouse coordinates.
MoveSnapContext that will be used by this instance to snap the mouse coordinates.
MoveSnapContext that will be used by this instance to snap the mouse coordinates.
AnimationObject that ignores calls to
initAnimation if initAnimation has and
disposeAnimation has not been called already
(and vice versa).
HierarchicLayouter.doLayoutCore(LayoutGraph) and creates a Sequencer implementation that
can sequence subgraphs incrementally.
Graph2DView that will enable the provided view to react to
started drag operations.
bounds indicating the new size of the given table.
Theme object, which can be used to customize
the look of editors created by a TableEditorFactory.
Thread.MIN_PRIORITY.
Transferable for the given NodeRealizer that is understood
by this instance's support for dropping nodes.
Transferable for the given EdgeRealizer that is understood
by this instance's support for DropSupport.dropEdgeRealizer(Graph2DView, EdgeRealizer, double, double) dropping edges}.
Object for a Node that should be inserted incrementally into the graph on
its exact current position.
Object for a Node that should be inserted incrementally into the graph on
its exact current layer position.
Object for a Node that should be inserted incrementally into the graph on
its exact current sequence position.
Point2D.
YPoint.
Graph.
GraphMLWriteContext instance.
WriteEdgeRealizerHandler.
WriteNodeRealizerHandler.
XmlWriter implementation that
can write the graph to the given Writer with the given settings
XmlWriter implementation that
can write the graph to the given OutputStream with the given settings.