# All Classes

All Classes Interface Summary Class Summary Enum Summary
AbstractAnchor: `AbstractAnchor` is the abstract base implementation for `IAnchor`s.
AbstractInterpolator: Abstract base class for `IConnectionInterpolator` implementations, which supports updating the geometry for an `IGeometry` curve node, as well as arranging and clipping the decorations.
AbstractRouter: Abstract base class for `IConnectionRouter`s implementing a routing strategy that can be specialized by subclasses: Remove anchors previously inserted by the router.
AbstractRouter.ControlPointManipulator: A `AbstractRouter.ControlPointManipulator` can be used to record, perform, and roll back control point changes during routing.
AbstractRouter.VolatileStaticAnchor: The `AbstractRouter.VolatileStaticAnchor` is a `StaticAnchor` that may be inserted by an `AbstractRouter` during `route(Connection)`, and, hence, will be removed when routing is performed again.
AnchorKey: AnchorKey combines an anchored `Node` with a `String` qualifier to identify an anchor target.
ChopBoxStrategy: A specific projection strategy that is based on a center-projection of the given reference point.
Connection: A (binary) `Connection` is a visual curveProperty, whose appearance is defined through a single start and end point, and a set of control points, which may be 'connected', i.e. be attached to an `IAnchor`.
CursorUtils: The `CursorUtils` class contains utility methods for determining the current pointer location (`CursorUtils.getPointerLocation()`).
DynamicAnchor: The `DynamicAnchor` computes anchor positions through a `IComputationStrategy`.
DynamicAnchor.AnchorageReferenceGeometry: An `IComputationStrategy.Parameter` that encapsulates an (anchorage) reference geometry.
DynamicAnchor.AnchorageReferencePosition: An `IComputationStrategy.Parameter` that encapsulates an (anchorage) reference point.
DynamicAnchor.AnchoredReferencePoint: An `IComputationStrategy.Parameter` that encapsulates a projection reference point.
DynamicAnchor.PreferredOrientation: An `IComputationStrategy.Parameter` that encapsulates the preferred orientation to be used for orthogonal projections.
FXAdvancedLinearGradientPicker: A picker for multi-stop `LinearGradient`s.
FxBundle: The `BundleActivator` for the FX bundle.
FXCanvasEx: A replacement of `FXCanvas` that fixes the following issues: JDK-8088147 - [SWT] FXCanvas: implement custom cursors [workaround for JavaSE-1.8 only, as fixed by SWTCursors in JavaSE-1.9] JDK-8161282 - FXCanvas does not forward horizontal mouse scroll events to the embedded scene.
FXColorPicker: An SWT control that can be used to select a JavaFX color (and indicates the selected color via an image).
FXControlAdapter<T extends Control>: The FXControlAdapter can be used to embed SWT controls into a JavaFX scene graph.
FXControlAdapter.IControlFactory<T extends Control>: The `FXControlAdapter.IControlFactory` can be used in conjunction with `FXControlAdapter` to create the wrapped SWT `Control` when the surrounding `FXCanvas` changes.
FXPaintCellEditor: The `FXPaintCellEditor` is a `DialogCellEditor` that is capable of displaying a currently selected `Color` and of changing that color via a dialog.
FXPaintLabelProvider: A label provider for a `Paint` value.
FXPaintSelectionDialog: The `FXPaintSelectionDialog` is a `Dialog` that allows to select a JavaFX `Paint`.
FXPaintUtils: Provides utilities for dealing with `Paint` representations.
FXSimpleLinearGradientPicker: The `FXSimpleLinearGradientPicker` allows the selection of two colors from which a gradient is constructed.
Geometry2Shape: The utility class `Geometry2Shape` provides methods for the conversion of `IGeometry` implementations to JavaFX `Shape` implementations.
GeometryNode<T extends IGeometry>: A `GeometryNode` is a `Node` which can be constructed using an underlying `IGeometry`.
HoverOverlayImageView: A `Group` that combines two `ImageView`s, realizing an overlay effect (by adjusting the respective opacities) upon mouse hover.
IAnchor: An `IAnchor` is a visual anchor that will provide positions for attached `AnchorKey`s (i.e. anchored `Node`s) in local coordinates of the `AnchorKey`'s anchored `Node`.
IComputationStrategy: The `IComputationStrategy` is responsible for computing anchor positions based on the anchorage `Node`, the anchored `Node`, and respective (strategy-specific) `parameters`.
IComputationStrategy.Parameter<T>: Base class for all computation parameters that can be passed to an `IComputationStrategy`.
IComputationStrategy.Parameter.Kind: Indicates whether the parameter value can be shared to compute positions of all attached anchors or not.
IConnectionInterpolator: An `IConnectionInterpolator` is responsible for updating the `Connection`'s `curve node` (which includes to properly clip it at the start and end decorations), as well as for arranging the decorations.
IConnectionRouter: An `IConnectionRouter` is responsible for `adjustment` of a `Connection`'s points.
IFXCanvasFactory: The `IFXCanvasFactory` provides a method for the creation of an `FXCanvas` inside a `Composite`.
InfiniteCanvas: An `InfiniteCanvas` provides a means to render a portion of a hypothetically infinite canvas, on which arbitrary contents can be placed.

NodeUtils

The `NodeUtils` class contains utility methods for working with JavaFX: transforming `IGeometry`s from/to different JavaFX coordinate systems (`NodeUtils.localToParent(Node, IGeometry)`, `NodeUtils.localToScene(Node, IGeometry)`, `NodeUtils.localToScene(Node, Point)`, `NodeUtils.parentToLocal(Node, IGeometry)`, `NodeUtils.sceneToLocal(Node, IGeometry)`) determining the actual local-to-scene or scene-to-local transform for a JavaFX `Node` (`NodeUtils.getLocalToSceneTx(Node)`, `NodeUtils.getSceneToLocalTx(Node)`) perform picking of `Node`s at a specific position within the JavaFX scene graph (`NodeUtils.getNodesAt(Node, double, double)`)

OrthogonalProjectionStrategy: An `IComputationStrategy` that computes anchor position by orthogonally projecting the respective anchored reference point to the outline of the anchorage reference geometry so that the respective point has minimal distance to the anchored reference point and resembles the same x- (vertical projection) or y-coordinate (horizontal projection).
OrthogonalRouter: An `IConnectionRouter` that interprets the `Connection` control points as way points and adjusts the way points (if necessary) so that the `Connection` is routed orthogonally.
PolyBezierInterpolator: The `PolyBezierInterpolator` interpolates a cubic Bezier spline through the supplied `way points`.
PolylineInterpolator: The `PolylineInterpolator` constructs a `Polyline` through the given `Connection`'s points.
ProjectionStrategy: An `IComputationStrategy` that computes anchor position by projecting the respective anchored reference point to the outline of the anchorage reference geometry so that the respective point has minimal distance to the anchored reference point.
Shape2Geometry: The utility class `Shape2Geometry` provides methods for the conversion of JavaFX `Shape` implementations to `IGeometry` implementations.
StaticAnchor: An `StaticAnchor` provides a position for each `AnchorKey`, based on a reference position relative to the anchorage `Node`, to which the `StaticAnchor` is bound, or based on a (global) static reference position in case the `StaticAnchor` is unbound.
StraightRouter: The `StraightRouter` is an `IConnectionRouter` that leaves the `Connection`'s control points untouched and only provides reference points for the `Connection`'s anchors.
VisualChangeListener: You can use a VisualChangeListener to register/unregister specific listeners for catching changes in the visual representation of a JavaFX `Node`.