|
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
DeserializationEvent
hierarchic 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.NodePlacer
s 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.
SerializationHandler
MoveSnapContext
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 NodeMap
s and
DataProvider
s 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()
.
EnterIntervalCalculator
s.
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.
DataProvider
under the given key to the graph.
DeserializationEvent
s.
DeserializationEvent
s.
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.
ListCell
object at the head of this list.
HotSpotSnapContext.getFixedSnapLines(java.util.Collection)
that
collects SnapLine
instances for a given fixed node.
SnapLine
methods to the result
Collection for the given NodeRealizer
.
SnapLine
s 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()
.
QueryInputHandlersEvent
s.
QueryInputHandlersEvent
s.
EdgeLabelLayout
to the given edge.
ListCell
object at the tail of this list.
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.
QueryOutputHandlersEvent
s.
QueryOutputHandlersEvent
s.
ParseEventListener
.
ParseEventListener
.
PathSearchExtension
s.
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.MovingInfo
s.
segment group
to this channel
.
Graph2DSelectionListener
to the creator's
model graph that creates a local view on selection changes.
SerializationEvent
s.
SerializationEvent
s.
SnapResult
to this instance that will be honored during calls to
AbstractSnapContext.processSnapResults(java.util.List,y.geom.YPoint)
current path request
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 path request
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 Drawable
s.
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 TaskExecutor
s 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.
DataProvider
key for specifying the size of affected nodes.
NodeAggregation.aggregate(Graph, NodeMap)
run is a hierarchical nested clustering structure.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.RootAlignment
s.
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 LayoutStage
s.
LayoutStage
to the previously added LayoutStage
s.
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
.DataProvider
key for specifying the group node inside which the cleared area should be located
The area
that is cleared of elements can be associated to one specific group node.
DataProvider
key for specifying a set of nodes that define the area which should be cleared
These nodes define a sort of component from which the area that must be cleared is derived by
calling method ClearAreaLayouter.createAreaOutline(LayoutGraph, NodeList, EdgeList)
.
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 NodeMap
s and DataProvider
s 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
.
BorderLine
with the given value from -Double.MAX_VALUE
to +Double.MAX_VALUE
.
BorderLine
from a single segment.
BorderLine
from a single segment.
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.
LabelCandidate
s to the corresponding nodes in the MISLabelingAlgorithm.conflictGraph
.
PathIterator
s.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
.
RootAlignment
with the bus of the grid so that the position of the root
depends on the selected bus placement
.
DataProvider
key for specifying the bus to which an edge belongs to.
DataProvider
key for specifying a bus descriptor for each edge
Edges can be assigned to a BusDescriptor
instance; all edges associated to the same descriptor
are routed in a bus-like style.
BusDescriptor
defines settings for edges routed on a common bus and forming a bus substructure
for IncrementalHierarchicLayouter
.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.
BusDescriptor
defines settings for edges routed on a common bus by EdgeRouter
.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.
NodeHalo
s.
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
.
LineSegment
s created by the calculated path points
.
GenericEdgeRealizer.calculatePath(java.awt.geom.Point2D, java.awt.geom.Point2D)
()}.
YPoint
s containing the source port, bend and target port locations.
PortCandidate
s.
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.
NodePort
s.
YLabel.calcUnionRect(java.awt.geom.Rectangle2D)
NodePort
s associated to this realizer.
PathRequest
.
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 LayoutStage
s.
LayoutStage
s can arrange the given graph.
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 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
.
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
.
NodeRealizer
.
NodeLabel
.
edgeRealizer
.
EdgeLabel
.
Bend
.
Port
.
NodePort
.
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 Node
s 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
.
GraphPartitionExtension
s from a given GraphPartition
instance.
DynamicObstacleDecomposition
can be reused and
initialized
with new Obstacle
s.
partition
data such that the GraphPartition
can be reused and
initialized
with a new configuration.
ObstaclePartition
can be reused and
initialized
with new Obstacle
s.
PathSearchExtension
s and DataProviders
added to this PathSearch
.
from
to to
inclusive from this list.
SnapLine
s.
AbstractSnapContext.addSnapResult(SnapResult)
ClearAreaLayouter
with default settings.
ClearAreaLayouter
.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.PortConstraint
s.
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
.
edge betweenness centrality
.
edge betweenness centrality
.
DataProvider
key for defining custom components whose elements should preferably not be separated
While the algorithm may move a whole component, it should preferably not move only a subset of
its elements.
DataProvider
key for defining custom components whose elements should preferably not be separated
While the algorithm may move a whole component, it should preferably not move only a subset of
its elements.
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
.Drawable
s into oneCompositeLayouter
allows for wrapping a core layout algorithm with multiple LayoutStage
s.CompositeLayouter
instance that prepends the specified LayoutStage
to the given
layout algorithm.
CompositeLayoutStage
allows for combining multiple LayoutStage
s.CompositeLayoutStage
instance with an empty pipeline.
CompositeLayoutStage
instance with two LayoutStage
s 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.
GraphPartitionExtension
s 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
.
PathSearchExtension
s 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
.
LabelCandidate
s 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.
bus substructure
.
EdgeData
instance for a
bus dummy edge
.
bus-style routing
edges at a certain root node.
NodeData
instance for a bus
dummy node
.
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 NodePlacer
s 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
.
DataProvider
that returns the given value for each
key.
ConstraintLayerer.ConstraintFactory
that is suitable for this
layerer implementation.
EdgeLayoutDescriptor
instance.
EdgeLayoutDescriptor
instance.
CurveEdgeLayoutDescriptor
instance.
EdgeLayoutDescriptor
instance.
PenaltySettings
instance.
EdgeLayoutDescriptor
instance.
GenericTreeLayouter.SubtreeShape
instance, modifying it using the provided modification matrix.
DataMap
view of the given map.
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
.
DataProvider
view of a double array defined for edges.
DataProvider
view of an int array defined for edges.
DataProvider
view of a boolean array defined for edges.
DataProvider
view of an Object
array defined for edges.
DataProvider
view of a double, int, boolean and Object
array defined for edges.
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
.
EdgeMap
view of the given map.
HierarchicLayouter.doLayoutCore(LayoutGraph)
and reates an appropriate EdgeReverser
implementation.
LabelCandidate
s 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 Node
s.
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 Node
s.
nodesToGroup
.
DataMap
that is based on hashing.
EdgeMap
that is based on hashing.
NodeMap
that is based on hashing.
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.
EdgeMap
view of a double array defined for edges.
EdgeMap
view of an int array defined for edges.
EdgeMap
view of a boolean array defined for edges.
EdgeMap
view of an Object
array defined for edges.
EdgeMap
view of a double, int, boolean and Object
array defined for edges.
NodeMap
view of a double array defined for nodes.
NodeMap
view of an int array defined for nodes.
NodeMap
view of a boolean array defined for nodes.
NodeMap
view of an Object
array defined for nodes.
NodeMap
view of a double, int, boolean and Object
array defined for nodes.
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
DataProvider
that returns the negated boolean values
provided by another data provider.
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.
DataProvider
view of a double array defined for nodes.
DataProvider
view of an int array defined for nodes.
DataProvider
view of a boolean array defined for nodes.
DataProvider
view of an Object
array defined for nodes.
DataProvider
view of a double, int, boolean and Object
array defined for nodes.
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
.
NodeMap
view of the given map.
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
.
PortConstraint
s for all edges of the given graph.
PortConstraint
s 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 NodePlacer
s 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 Edge
s 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 SegmentInfo
s in a Channel
from
left to right (for vertical segments) or top to bottom (for horizontal segments), respectively.