View source for GEF/GEF4/MVC

''Note to non-wiki readers: This documentation is generated from the Eclipse wiki - if you have corrections or additions it would be awesome if you added them in [http://wiki.eclipse.org/GEF/GEF4/MVC the original wiki page]''.

__NOTOC__

== Introduction ==
The <span style="color:#05124E">[[GEF/GEF4/MVC|GEF4 MVC]]</span> component provides support for building up graphical editors and views based on a model-view-controller architecture and is the intended replacement for [https://www.eclipse.org/gef/gef_mvc/index.php GEF (MVC) 3.x]. It is internally composed out of four modules, which provide toolkit-independent base abstractions and implementations ('''[[#MVC|MVC]]'''), JavaFX-specific specializations ('''[[#MVC.FX|MVC.FX]]'''), and Eclipse UI-integration for both ('''[[#MVC.UI|MVC.UI]]''', [[#MVC.FX.UI|MVC.FX.UI]]). In addition there is a deployed [[GEF/GEF4/MVC/Examples#Logo Example (Standalone, Eclipse UI, Web)|MVC Logo Example]].

[[Image:GEF4-Components-MVC.png|600px]]

----

== MVC ==

*'''feature: org.eclipse.gef4.mvc'''
*'''bundle: org.eclipse.gef4.mvc'''

The [[#MVC|MVC]] module of [[GEF/GEF4/MVC|GEF4 MVC]] offers those core concepts that are independent of any concrete rendering toolkit as well as of the Eclipse UI. As indicated by its name, the module provides a model-view-controller architecture that can be used to build up graphical editors and views. In good tradition with [https://www.eclipse.org/gef/gef_mvc/index.php GEF (MVC) 3.x], 'controllers' are referred to as 'parts' (while the term 'visual part' instead of 'edit part' is used here, to depict that the MVC framework is not limited to editors alone).

A graphical application is thus composed of one or more ''viewers'', where each ''viewer'' ([[#IViewer, AbstractViewer|IViewer]]) is populated by a set of ''visual parts'' ([[#IVisualPart, AbstractVisualPart|IVisualPart]]), which control the visuals that are rendered inside the viewer's controls. Those ''visual parts'' that are responsible of controlling to be visualized contents, are referred to as ''content parts'' ([[#IContentPart, AbstractContentPart|IContentPart]]). They are accompanied by ''feedback parts'' ([[#IFeedbackPart, AbstractFeedbackPart|IFeedbackPart]]) and ''handle parts'' ([[#IHandlePart, AbstractHandlePart|IHandlePart]]), which do not control visualized contents but feedback or handle visuals that are needed for user interaction. All visual parts are arranged in a hierarchy (which resembles the hierarchy of visuals) that is rooted by a 'root part' ([[#IRootPart, AbstractRootPart|IRootPart]]). 

Besides the ''parent-child'' relationship that establishes the hierarchy, ''visual parts'' may also be related to each other by means of an ''anchorage-anchor'' relationship. That is, a ''visual part'' that is placed at an arbitrary location within the hierarchy may be ''anchored'' on another ''anchorage'' part. As the visual part hierarchy has to correspond to the visual hierarchy, this mechanism is very useful when parts that control visuals that are placed in arbitrary places within the visual hierarchy have to be related to each other. In a graphical application that usually organizes visuals into layers, it can for instance be used to update feedback or handles. By explicitly anchoring a ''feedback part'' on an underlying (''anchorage'') target ''content part'', the ''feedback part'' inter alia obtains the necessary hooks to listen for changes of the ''content part'' visual (e.g. position changes) and to update its own feedback visual accordingly.

''Tools'' ([[#ITool, AbstractTool|ITool]]) are used to interact with the parts inside a viewer. Each tool should be responsible of handling a certain interaction gesture (e.g. mouse click/drag or touch-based pinch/spread), by locating respective target parts (e.g. via hit-testing on the visual) and forwarding the interaction to them. While a tool should not have own interaction logic, it is responsible of handling the interaction, to which several parts may contribute e.g. by updating their visuals and contents, as a whole. That is, the tool has to ensure that all modifying operations that result from a certain interaction, are executed in a single (undoable) transaction. As an interaction may span several viewers (e.g. a drag/drop operation), tools are bound to a ''domain'' ([[#IDomain, AbstractDomain|IDomain]]), to which also all viewers that make up a graphical application are bound. The ''domain'' maintains a global operation history and facilities to initialize and commit transactions.

The handling of an interaction is not performed directly by the target visual parts themselves, but by respective ''policies'' ([[#IPolicy, AbstractPolicy|IPolicy]]) that are bound to them. A policy is a (passive) strategy that encapsulates a certain undoable logic. The active tool that handles an interaction takes this into account, as it locates target parts also by evaluating their supported policies, and interacts with these (interaction) policies instead of the visual part itself. Each (interaction) policy is related to one or more gestures (e.g. what to do on click/drag) and may thus be accessed by several tools. It may handle the response to an interaction directly, e.g. by manipulating the viewer state (e.g. changing the current selection when the target part gets clicked), or can delegate it to certain (transaction) policies that manipulate the contents as a result of an interaction (and have to do this by means of executing operations within the currently active transaction, the respective interaction tool has opened via the domain).

The viewer state (e.g. the current selection), which might be manipulated as the result of an interaction, is represented by means of dedicated models (e.g. [[#ContentModel|ContentModel]] or [[#SelectionModel|SelectionModel]]), which are bound to each viewer. As changes to the viewer state, as well as to the visualized contents, may lead to necessary viewer updates as well, behaviors ([[#IBehavior, AbstractBehavior|IBehavior]]) may be bound to parts similar to policies. In contrast to policies, behaviors are active themselves, that is they will actively listen for changes (e.g. newly added content) and perform a certain. Behaviors are also responsible of creating and disposing respective ''visual parts'' as needed (e.g. to update selection feedback as a result of changes to the selection model). In contrast to policies, the reactions performed by behaviors are not executed on the operation history and are thus not undoable.

----

<div id="MVC:Root"></div>
=== {Root} ===

* '''package: org.eclipse.gef4.mvc'''

The [[#MVC:Root|{Root}]] package contains a [http://google.github.io/guice/api-docs/3.0/javadoc/com/google/inject/Module.html com.google.inject.Module]] that defines default bindings for [[#MVC|MVC]].

[[File:GEF4-MVC-root.png|735px]]

==== MvcModule ====

The <code>MvcModule</code> defines methods that register certain default bindings, which can be refined (overridden) by sub-classes. It also defines a couple of (empty) hook methods for bindings that subclasses should define.

----

<div id="MVC:Behaviors"></div>

=== Behaviors ===

* '''package: org.eclipse.gef4.mvc.behaviors'''

The [[#MVC:Behaviors|Behaviors]] package contains the [[#IBehavior, AbstractBehavior|IBehavior]] and [[#IBehavior, AbstractBehavior|AbstractBehavior]] definitions. Additionally, it provides various [[#IBehavior, AbstractBehavior|IBehavior]] implementations and a related utility class.

[[File:GEF4-MVC-behaviors.png|1344px]]

==== IBehavior, AbstractBehavior ====
An <code>IBehavior</code> is bound to an [[#IVisualPart, AbstractVisualPart|IVisualPart]], referred to as the ''host'' of the behavior. It actively listens to changes (usually of a viewer model like the [[#SelectionModel|SelectionModel]] or [[#ContentModel|ContentModel]]) that affect its host and encapsulates a (not undoable) reaction to these changes, like showing or hiding feedback or handles. The [[#SelectionBehavior|SelectionBehavior]] for instance listens to changes of the [[#SelectionModel|SelectionModel]] and generates (or removes) selection feedback and handles in case its host is selected or deselected. To support proper registration of listeners, <code>IBehavior</code> extends [[GEF/GEF4/Common#IActivatable|org.eclipse.gef4.common.activate.IActivatable]], so it is activated/deactivated by its host whenever the host itself is activated/deactivated. Registering and unregistering listeners can thus be performed during the activation and deactivation respectively.

An <code>IBehavior</code> is similar to an [[#IPolicy, AbstractPolicy|IPolicy]] in that it is bound to an [[#IVisualPart, AbstractVisualPart|IVisualPart]]. However, policies are not active by themselves (they are always called from the outside). Further, the response of an <code>IBehavior</code> is not meant to be undoable, whereas the response of an [[#IPolicy, AbstractPolicy|IPolicy]] is.

The <code>AbstractBehavior</code> handles activation and deactivation and provides methods to add/remove feedback and handle parts using the [[#IFeedbackPartFactory|IFeedbackPartFactory]] and [[#IHandlePartFactory|IHandlePartFactory]] of the [[#IViewer, AbstractViewer|IViewer]].

==== BehaviorUtils ====

The <code>BehaviorUtils</code> class provides utility methods for establishing/unestablishing anchored-anchorage relations. These methods are used by the [[#IBehavior, AbstractBehavior|AbstractBehavior]] when adding/removing feedback or handles.

==== ContentBehavior, ContentPartPool ====

The <code>ContentBehavior</code> is listening for [[#ContentModel|ContentModel]] changes to initiate a content synchronization upon changes. During a content synchronization, the currently active content parts are checked against the current content objects, i.e. content parts are created or removed based on the parent-child and anchored-anchorage relations between the content objects as defined by the content parts.

A content part that is removed is stored in a <code>ContentPartPool</code>, so that it can be re-used if it is needed later, and does not have to be re-created.

==== HoverBehavior ====

The <code>HoverBehavior</code> reacts to [[#HoverModel|HoverModel]] changes. It can be bound to all content parts that should generate feedback/handles when the mouse hovers the part.

==== SelectionBehavior ====
The <code>SelectionBehavior</code> reacts to [[#SelectionModel|SelectionModel]] changes. It can be bound to all content parts that should generate feedback/handles when the part is selected.

----

<div id="MVC:Domain"></div>

=== Domain ===

* '''package: org.eclipse.gef4.mvc.domain'''

The [[#MVC:Domain|Domain]] package contains the [[#IDomain, AbstractDomain|IDomain]] abstraction and its related [[#IDomain, AbstractDomain|AbstractDomain]] realization.

[[File:GEF4-MVC-domain.png|430px]]

==== IDomain, AbstractDomain ====
The <code>IDomain</code> represents the collective state of a graphical application, i.e. it is composed of all [[#IViewer, AbstractViewer|IViewers]] and [[#ITool, AbstractTool|ITools]]. Additionally, the <code>IDomain</code> provides an [http://help.eclipse.org/topic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/core/commands/operations/IOperationHistory.html org.eclipse.core.commands.operations.IOperationHistory] and [http://help.eclipse.org/topic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/core/commands/operations/IUndoContext.html org.eclipse.core.commands.operations.IUndoContext], which are used by policies to change the state of the application. 

----

<div id="MVC:Models"></div>

=== Models ===

* '''package: org.eclipse.gef4.mvc.models'''

The [[#MVC:Models|Models]] package contains all viewer models, i.e. the data constituting a viewer state.

[[File:GEF4-MVC-models.png|903px]]

==== ContentModel ====

The <code>ContentModel</code> stores the viewer's contents, i.e. the data that is processed by your application.

==== FocusModel ====

The <code>FocusModel</code> stores the [[#IVisualPart, AbstractVisualPart|IVisualPart]] with keyboard focus, i.e. the part that will receive all keyboard input.

==== GridModel ====

The <code>GridModel</code> stores the viewer's background grid settings:
* ''snap-to-grid'', <code>true</code> or <code>false</code>, indicates whether the visualization should snap to grid points.
* ''show-grid'', <code>true</code> or <code>false</code>, indicates whether to show the grid, or not.
* ''zoom-grid'', <code>true</code> or <code>false</code>, indicates whether to zoom the grid, or not.
* ''grid-cell-width'', <code>Double</code>, specifies the width of grid cells.
* ''grid-cell-height'', <code>Double</code>, specifies the height of grid cells.

==== HoverModel ====

The <code>HoverModel</code> stores the currently hovered [[#IVisualPart, AbstractVisualPart|IVisualPart]].

==== SelectionModel ====

The <code>SelectionModel</code> stores all currently selected [[#IContentPart, AbstractContentPart|IContentParts]].

----

<div id="MVC:Operations"></div>

=== Operations ===

* '''package: org.eclipse.gef4.mvc.operations'''

The [[#MVC:Operations|Operations]] package contains implementations of [http://help.eclipse.org/topic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/core/commands/operations/IUndoableOperation.html IUndoableOperation] which can be used to manipulate the default models, especially content creation and removal.

[[File:GEF4-MVC-operations.png|1174px]]

==== ITransactionalOperation ====
The <code>ITransactionalOperation</code> is a specialization of [http://help.eclipse.org/topic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/core/commands/operations/IUndoableOperation.html org.eclipse.core.commands.operations.IUndoableOperation], which further supports querying for content relevance and effect of the encapsulated operation.

==== AbstractCompositeOperation ====

The <code>AbstractCompositeOperation</code> is the base class for two concrete [http://help.eclipse.org/topic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/core/commands/operations/ICompositeOperation.html org.eclipse.core.commands.operations.ICompositeOperation] implementations: [[#ForwardUndoCompositeOperation|ForwardUndoCompositeOperation]] and [[#ReverseUndoCompositeOperation|ReverseUndoCompositeOperation]].

==== AddContentChildOperation ====

The <code>AddContentChildOperation</code> can be used to add a content child to an [[#IContentPart, AbstractContentPart|IContentPart]]. It relies on the [[#IContentPart, AbstractContentPart|IContentPart]]'s <code>addContentChild()</code> method for doing this.

This operation is the counterpart of the [[#RemoveContentChildOperation|RemoveContentChildOperation]].

==== AttachToContentAnchorageOperation ====

The <code>AttachToContentAnchorageOperation</code> can be used to attach an [[#IContentPart, AbstractContentPart|IContentPart]] to a content anchorage. It relies on the [[#IContentPart, AbstractContentPart|IContentPart]]'s <code>attachToContentAnchorage()</code> method for doing this.

This operation is the counterpart of the [[#DetachFromContentAnchorageOperation|DetachFromContentAnchorageOperation]].

==== BendContentOperation ====

The <code>BendContentOperation</code> allows to bend the content of an [[#IBendableContentPart|BendableContentPart]].

==== ChangeContentsOperation ====

The <code>ChangeContentsOperation</code> allows to exchange the contents hold by the [[#ContentModel|ContentModel]].

==== ChangeFocusOperation ====

The <code>ChangeFocusOperation</code> can be used to set the currently focused part by manipulating the [[#FocusModel|FocusModel]].

==== DeselectOperation ====

The <code> DeselectOperation </code> can be used to clear the currently selected parts by manipulating the [[#SelectionModel|SelectionModel]].

==== DetachFromContentAnchorageOperation ====

The <code>DetachFromContentAnchorageOperation</code> can be used to detach an [[#IContentPart, AbstractContentPart|IContentPart]] from a content anchorage. It relies on the [[#IContentPart, AbstractContentPart|IContentPart]]'s <code>detachFromContentAnchorage()</code> method for doing this.

This operation is the counterpart of the [[#AttachToContentAnchorageOperation|AttachToContentAnchorageOperation]].

==== ForwardUndoCompositeOperation ====

The <code>ForwardUndoCompositeOperation</code> is a specific [[#AbstractCompositeOperation|AbstractCompositeOperation]]. It will <code>execute()</code>, <code>redo()</code>, and <code>undo()</code> its operations in the order they were added to the composite operation.

==== RemoveContentChildOperation ====

The <code>RemoveContentChildOperation</code> can be used to remove a content child from an [[#IContentPart, AbstractContentPart|IContentPart]]. It relies on the [[#IContentPart, AbstractContentPart|IContentPart]]'s <code>removeContentChild()</code> method for doing this.

This operation is the counterpart of the [[#AddContentChildOperation|AddContentChildOperation]].

==== ResizeContentOperation ====
The <code>ResizeContentOperation</code> allows to resize the contents of an [[#IResizableContentPart | ResizableContentPart]].

==== ReverseUndoCompositeOperation ====

The <code>ReverseUndoCompositeOperation</code> is a specific [[#AbstractCompositeOperation|AbstractCompositeOperation]]. It will <code>execute()</code> and <code>redo()</code> its operations in the order they were added to the composite operation, however it will <code>undo()</code> its operations in reverse order.

==== SelectOperation ====
The <code>SelectOperation </code> can be used to manipulate the currently selected parts by manipulating the [[#SelectionModel|SelectionModel]].

==== SetRefreshVisualOperation ====

The <code>SetRefreshVisualOperation</code> can be used to enable/disable the <code>#refreshVisual()</code> method for a specific [[#IVisualPart, AbstractVisualPart|IVisualPart]].

==== TransformContentOperation ====
The <code>TransformContentOperation</code> can be used to transform the content of an [[#ITransformableContentPart | ITransformableContentPart]].

----

<div id="MVC:Parts"></div>

=== Parts ===

* '''package: org.eclipse.gef4.mvc.parts'''

The [[#MVC:Parts|Parts]] package contains all abstractions related to controllers (aka ''parts'') in a model-view-controller architecture. For each abstraction, a corresponding (abstract) realization is provided, from which specific controllers can be sub-classed.

[[File:GEF4-MVC-parts-abstractions.png|1218px]]

==== IVisualPart, AbstractVisualPart ====

The <code>IVisualPart</code> interface is the main [[#MVC|MVC]] abstraction for controller objects, and therefore, controls a visual and handles user interaction. Visual parts are organized in a hierarchy, i.e. every part (except the root part) is associated with a parent part, and can control a number of children parts. Additional to the parent-child relations, visual parts can be part of anchored-anchorage relations, which are independent to the hierarchy, i.e. anchoreds and anchorages can be located at arbitrary places within the hierarchy.

Visual parts are adaptable, so that you can adapt policies and behaviors to them (as well as anything else if needed). This is an integral part of user interaction, because the tools will delegate input events to corresponding policies of the visual part which controls the event target (visual). Visual parts are also activatable. During activation/deactivation they will activate/deactivate their adapters.

Moreover, an <code>IVisualPart</code> exposes observable properties for:
* <code>"active"</code>: This visual part was activated/deactivated.
* <code>"adapters"</code>: The adapters (policies, behaviors, etc.) of this visual part changed.
* <code>"parent"</code>: The parent of this visual part changed.
* <code>"children"</code>: The children of this visual part changed.
* <code>"anchorages"</code>: The anchorages of this visual part changed.
* <code>"anchoreds"</code>: The anchoreds of this visual part changed.

==== IRootPart, AbstractRootPart ====

The <code>IRootPart</code> interface is a specialization of the [[#IVisualPart, AbstractVisualPart|IVisualPart]] interface. There is exactly one <code>IRootPart</code> per [[#IViewer, AbstractViewer|IViewer]]. It contains all [[#IContentPart, AbstractContentPart|IContentParts]], [[#IFeedbackPart, AbstractFeedbackPart|IFeedbackParts]], and [[#IHandlePart, AbstractHandlePart|IHandleParts]] as children and manages the root visuals.

==== IContentPart, AbstractContentPart ====

The <code>IContentPart</code> interface is a specialization of the [[#IVisualPart, AbstractVisualPart|IVisualPart]] interface. Content parts are bound to content model elements, i.e. they provide a link to the model, and allow manipulations of the model via <code>addContentChild()</code>, <code>removeContentChild()</code>, <code>attachToContentAnchorage()</code>, and <code>detachFromContentAnchorage()</code>.

==== IFeedbackPart, AbstractFeedbackPart ====

The <code>IFeedbackPart</code> interface is a specialization of the [[#IVisualPart, AbstractVisualPart|IVisualPart]] interface. Feedback parts are used to give visual feedback to the user during interactions. They are usually rendered on top of the content parts.

==== IHandlePart, AbstractHandlePart ====

The <code>IHandlePart</code> interface is a specialization of the [[#IVisualPart, AbstractVisualPart|IVisualPart]] interface. Handle parts are used for visual handles, which can be used for interaction, i.e. to manipulate elements. They are usually rendered on top of the feedback parts.

==== IContentPartFactory ====

The <code>IContentPartFactory</code> interface is part of a default mechanic in [[#MVC|MVC]]: It is used during the content synchronization within the [[#ContentBehavior, ContentPartPool|ContentBehavior]] to create new content parts. Therefore, if you want to use this default mechanic, you have to supply an <code>IContentPartFactory</code> suitable to your content model.

==== ITransformableContentPart ====
The <code>ITransformableContentPart</code> interface is to be implemented by [[#IContentPart, AbstractContentPart|IContentPart]]s, which support transformations of their content. This is e.g. used to persist a translate operation.

==== IResizableContentPart ====
The <code> IResizableContentPart </code> interface is to be implemented by [[#IContentPart, AbstractContentPart|IContentPart]]s, which support resize of their content. This is e.g. used to persist a resize operation.

==== IBendableContentPart ====
The <code> IBendableContentPart </code> interface is to be implemented by [[#IContentPart, AbstractContentPart|IContentPart]]s, which support bending of their content (i.e. manipulation throw inserting or moving of bend points). This is e.g. used to persist a bend operation.

==== IFeedbackPartFactory ====

The <code>IFeedbackPartFactory</code> interface is part of a default mechanic in [[#MVC|MVC]]: It is used for creating feedback parts within the default behaviors, i.e. in response to mouse hover or selection changes.

==== IHandlePartFactory ====

The <code>IHandlePartFactory</code> interface is part of a default mechanic in [[#MVC|MVC]]: It is used for creating handle parts within the default behaviors, i.e. in response to mouse hover or selection changes.

==== PartUtils ====

The <code>PartUtils</code> class is a collection of utility methods when working with visual parts.

----

<div id="MVC:Policies"></div>

=== Policies ===

* '''package: org.eclipse.gef4.mvc.policies'''

The [[#MVC:Policies|Policies]] package contains the [[#IPolicy, AbstractPolicy|IPolicy]] abstraction, a related abstract base implementation ([[#IPolicy, AbstractPolicy|AbstractPolicy]]), and concrete implementations for the manipulation of the [[#ContentModel|ContentModel]], namely [[#ContentPolicy|ContentPolicy]], [[#CreationPolicy|CreationPolicy]], and [[#DeletionPolicy|DeletionPolicy]].

[[File:GEF4-MVC-policies.png|864px]]

==== IPolicy, AbstractPolicy ====
An <code>IPolicy</code> is bound to an [[#IVisualPart, AbstractVisualPart|IVisualPart]], referred to as the ''host'' of the policy. There are basically two kinds of policies, interaction and transaction policies. An interaction policy is called by a [[#ITool, AbstractTool|ITool]] to handle part of an interaction (e.g. click, drag). A transaction policy is one that may be used by other (interaction or transaction) policies to actually perform a visual or semantic operation (e.g. create model element). It has to encapsulate the to be performed operation as an [[#ITransactionalOperation|ITransactionalOperation]].

An <code>IPolicy</code> is similar to an [[#IBehavior, AbstractBehavior|IBehavior]] in that it is bound to an [[#IVisualPart, AbstractVisualPart|IVisualPart]]. However, behaviors are active by themselves (they actively listen to changes), while policies are always called from the outside (they are passive). Further, the response of an <code>IPolicy</code> is meant to be undoable, whereas the response of an [[#IBehavior, AbstractBehavior|IBehavior]] is not.

==== AbstractTransactionPolicy ====

The <code> AbstractTransactionPolicy </code> is the base class for all policies that perform undoable changes. The offer <code>init()</code>, <code>commit()</code>, and <code>rollback()</code>, which enclose an undoable transaction.

==== AbstractInteractionPolicy ====
The <code>AbstractInteractionPolicy</code> is the base class for all policies that response to an interaction gesture. They usually delegate to some transactional policies to perform a visual or content relevant reaction.

==== ContentPolicy ====

The <code>ContentPolicy</code> is an [[#AbstractTransactionPolicy|AbstractTransactionPolicy]] to handle content changes, i.e. adding/removing of content children, as well as attaching/detaching to/from content anchorages. Therefore, it can be used to retrieve an operation which performs the desired content changes.

==== CreationPolicy ====

The <code>CreationPolicy</code> is an [[#AbstractTransactionPolicy|AbstractTransactionPolicy]] that handles the creation of new content objects using the [[#ContentPolicy|ContentPolicy]]. Therefore, it can be used to retrieve an operation which performs the desired creations.

==== DeletionPolicy ====

The <code>DeletionPolicy</code> is an [[#AbstractTransactionPolicy|AbstractTransactionPolicy]] that handles the deletion of existing content objects using the [[#ContentPolicy|ContentPolicy]]. Therefore, it can be used to retrieve an operation which performs the desired deletions.

==== AbstractTransformPolicy ====
The <code>AbstractTransformPolicy</code> is an [[#AbstractTransactionPolicy|AbstractTransactionPolicy]] that supports content transformation of [[#ITransformableContentPart|ITransformableContentPart]]s.

==== AbstractResizePolicy ====
The <code>AbstractResizePolicy</code> is an [[#AbstractTransactionPolicy|AbstractTransactionPolicy]] that supports content resizing of [[#IResizableContentPart|IResizableContentPart]]s.

==== AbstractBendPolicy ====
The <code>AbstractBendPolicy</code> is an [[#AbstractTransactionPolicy|AbstractTransactionPolicy]] that supports content bending of [[#IBendableContentPart|IBendableContentPart]]s.

----

<div id="MVC:Tools"></div>

=== Tools ===

* '''package: org.eclipse.gef4.mvc.tools'''

The [[#MVC:Tools|Tools]] package contains the [[#ITool, AbstractTool|ITool]] abstraction and its related [[#ITool, AbstractTool|AbstractTool]] realization.

[[File:GEF4-MVC-tools.png|377px]]

==== ITool, AbstractTool ====

An <code>ITool</code> delegates input events to corresponding (interaction) [[#IPolicy, AbstractPolicy|IPolicies]], which are responsible of handling the interaction.

----

<div id="MVC:Viewer"></div>

=== Viewer ===

* '''package: org.eclipse.gef4.mvc.viewer'''

The [[#MVC:Viewer|Viewer]] package contains the [[#IViewer, AbstractViewer|IViewer]] abstraction and the related [[#IViewer, AbstractViewer|AbstractViewer]] realization.

[[File:GEF4-MVC-viewer.png|538px]]

==== IViewer, AbstractViewer ====

An <code>IViewer</code> is the container for an [[#IVisualPart, AbstractVisualPart|IVisualPart]] hierarchy and provides a link to the [[#IDomain, AbstractDomain|IDomain]].

----

== MVC.FX ==

*'''feature: org.eclipse.gef4.mvc.fx'''
*'''bundle: org.eclipse.gef4.mvc.fx'''

The [[#MVC.FX|MVC.FX]] module of [[GEF/GEF4/MVC|GEF4 MVC]] provides specializations of the abstractions and implementations provided by [[#MVC|MVC]], which are bound to [http://docs.oracle.com/javase/8/javase-clienttechnologies.htm JavaFX]-based visualizations.

----

<div id="MVC.FX:Root"></div>
=== {Root} ===

* '''package: org.eclipse.gef4.mvc.fx'''

The [[#MVC.FX:Root|{Root}]] package contains a Guice Module with default bindings for [[#MVC.FX|MVC.FX]].

[[File:GEF4-MVC-FX-root.png|819px]]

==== MvcFxModule ====

The <code>MvcFxModule</code> extends [[#MvcModule|MvcModule]]. It defines methods to register bindings for the JavaFX-specific extensions to [[#MVC|MVC]] and adds respective default bindings.

----

<div id="MVC.FX:Behaviors"></div>

=== Behaviors ===

* '''package: org.eclipse.gef4.mvc.fx.behaviors'''

The [[#MVC.FX:Behaviors|Behaviors]] package contains JavaFX/[[#MVC.FX|MVC.FX]]-specific [[#IBehavior, AbstractBehavior|IBehavior]] implementations.

[[File:GEF4-MVC-FX-behaviors.png|985px]]

==== FXConnectionClickableAreaBehavior ====

The <code> FXConnectionClickableAreaBehavior </code> controls the size of the connection's curve node visible area dependent on the zoom level.

==== FXFocusBehavior ====

The <code>FXFocusBehavior</code> is listening for [[#FocusModel|FocusModel]] changes and transfers them over to JavaFX.

==== FXGridBehavior ====

The <code>FXGridBehavior</code> is listening for [[#GridModel|GridModel]] changes in order to apply those changes to the GridLayout of the [[#IViewer, AbstractViewer|IViewer]].

==== FXHoverBehavior ====

The <code>FXHoverBehavior</code> is listening for [[#HoverModel|HoverModel]] changes in order to generate feedback/handles when hovering a part.

----

<div id="MVC.FX:Domain"></div>

=== Domain ===

* '''package: org.eclipse.gef4.mvc.fx.domain'''

The [[#MVC.FX:Domain|Domain]] package contains a JavaFX-specific [[#IDomain, AbstractDomain|IDomain]] implementation, which does not provide own logic but is used as a target for adapter map bindings within [[#MVC.FX|MVC.FX]].

[[File:GEF4-MVC-FX-domain.png|353px]]

==== FXDomain ====

The <code>FXDomain</code> parameterizes the [[#MVC:Domain|AbstractDomain]] with [http://docs.oracle.com/javafx/2/api/index.html?javafx/scene/Node.html javafx.scene.Node], but does not extend it further. It is basically intended to provide a target for adapter bindings and adapter scoping (see [[GEF/GEF4/Common#Adapt.Inject|GEF4 Common]]).

----

<div id="MVC.FX:Operations"></div>

=== Operations ===

* '''package: org.eclipse.gef4.mvc.fx.operations'''

The [[#MVC.FX:Operations|Operations]] package contains all [http://help.eclipse.org/topic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/core/commands/operations/IUndoableOperation.html IUndoableOperation] implementations contributed by [[#MVC.FX|MVC.FX]].

[[File:GEF4-MVC-FX-operations.png|889px]]

==== FXBendConnectionOperation ====

The <code>FXBendConnectionOperation</code> can be used to manipulate the points constituting an [[GEF/GEF4/FX#Connection|Connection]], i.e. its start point, way points, and end point. When manipulating the start or end point, it does also connect it to the [[#IVisualPart, AbstractVisualPart|IVisualPart]] under mouse when applicable.

==== FXChangeViewportOperation ====

The <code>FXChangeViewportOperation</code> can be used to manipulate the [[GEF/GEF4/FX#InfiniteCanvas|InfiniteCanvas]] of the content [[#FXViewer|FXViewer]], i.e. the scroll offset and content transformation.

==== FXResizeOperation ====

The <code>FXResizeOperation</code> can be used to resize a [http://docs.oracle.com/javafx/2/api/index.html?javafx/scene/Node.html javafx.scene.Node].

==== FXRevealOperation ====

The <code>FXRevealOperation</code> can be used to reveal an [[#IVisualPart, AbstractVisualPart|IVisualPart]] in its [[#IViewer, AbstractViewer|IViewer]].

==== FXTransformOperation ====

The <code>FXTransformOperation</code> can be used to manipulate the transformation associated with an [[#IVisualPart, AbstractVisualPart|IVisualPart]] due to [[#ChopBoxAnchorProvider, FXTransformProvider, VisualBoundsGeometryProvider, VisualOutlineGeometryProvider|FXTransformProvider]].

----

<div id="MVC.FX:Parts"></div>

=== Parts ===

* '''package: org.eclipse.gef4.mvc.fx.parts'''

The [[#MVC.FX:Parts|Parts]] package contains all [[#IContentPart, AbstractContentPart|IContentPart]], [[#IVisualPart, AbstractVisualPart|IVisualPart]], IFeedbackPart, and [[#IHandlePart, AbstractHandlePart|IHandlePart]] implementations and related classes.

==== AbstractFXContentPart ====

The <code>AbstractFXContentPart</code> is a specialization of the AbstractContentPart which establishes [http://docs.oracle.com/javafx/2/api/index.html?javafx/scene/Node.html javafx.scene.Node] as the visual root type. It does also register its whole visual hierarchy at the visual-part-map.

[[File:GEF4-MVC-FX-parts-contents.png|496px]]

==== AbstractFXFeedbackPart, FXHoverFeedbackPart, FXSelectionFeedbackPart, FXSelectionLinkFeedbackPart ====

The <code>AbstractFXFeedbackPart</code> is a specialization of the [[#IFeedbackPart, AbstractFeedbackPart|AbstractFeedbackPart]] which establishes [http://docs.oracle.com/javafx/2/api/index.html?javafx/scene/Node.html javafx.scene.Node] as the visual root type. It does also register a [[GEF/GEF4/FX#VisualChangeListener|org.eclipse.gef4.fx.listeners.VisualChangeListener]] upon attachment to an anchorage which refreshes the feedback visual upon anchorage visual changes.

[[File:GEF4-MVC-FX-parts-feedback.png|662px]]

The <code>FXHoverFeedbackPart</code> displays a feedback geometry in response to [[#HoverModel|HoverModel]] changes.

The <code>FXSelectionFeedbackPart</code> displays a feedback geometry in response to [[#SelectionModel|SelectionModel]] changes and [[#FocusModel|FocusModel]] changes.

The <code>FXSelectionLinkFeedbackPart</code> is a specialization of the <code>FXSelectionFeedbackPart</code> which displays a dashed feedback geometry in response to [[#SelectionModel|SelectionModel]] changes and [[#FocusModel|FocusModel]] changes.

==== FXDefaultFocusFeedbackPartFactory, FXDefaultHoverFeebackPartFactory, FXDefaultSelectionFeedbackPartFactory ====

The <code> FXDefaultFocusFeedbackPartFactory </code>, <code>FXDefaultHoverFeebackPartFactory</code> and <code> FXDefaultSelectionFeedbackPartFactory</code> use <code>FXHoverFeedbackPart</code>, <code>FXSelectionFeedbackPart</code>, and <code>FXSelectionLinkFeedbackPart</code> for generating feedback if the associated geometry provider is bound as an adapter on the hovered/selected part.

==== AbstractFXHandlePart, AbstractFXSegmentHandlePart, FXCircleSegmentHandlePart, FXRectangleSegmentHandlePart, FXSquareSegmentHandlePart ====

The <code>AbstractFXHandlePart</code> is a specialization of the [[#IHandlePart, AbstractHandlePart|AbstractHandlePart]] which establishes [http://docs.oracle.com/javafx/2/api/index.html?javafx/scene/Node.html javafx.scene.Node] as the visual root type. It does also register a [[GEF/GEF4/FX#VisualChangeListener|org.eclipse.gef4.fx.listeners.VisualChangeListener]] upon attachment to an anchorage which refreshes the handle visual upon anchorage visual changes.

[[File:GEF4-MVC-FX-parts-handles.png|1044px]]

The <code>AbstractFXSegmentHandlePart</code> is a specialization of the <code>AbstractFXHandlePart</code> which is bound to a segment of a poly-bezier handle geometry, represented by an array of BezierCurves. A segment index identifies that segment (0, 1, 2, ...). A segment parameter specifies the position of this handle part on the segment (0 = start, 0.5 = mid, 1 = end).

The <code>FXCircleSegmentHandlePart</code> is a specialization of the <code>AbstractFXSegmentHandlePart</code> which uses a [http://docs.oracle.com/javafx/2/api/index.html?javafx/scene/shape/Circle.html javafx.scene.shape.Circle] for the handle visualization.

The <code>FXRectangleSegmentHandlePart</code> is a specialization of the <code>AbstractFXSegmentHandlePart</code> which uses a [http://docs.oracle.com/javafx/2/api/index.html?javafx/scene/shape/Rectangle.html javafx.scene.shape.Rectangle] for the handle visualization.

The <code>AbstractFXRootPart</code> is a specialization of the [[#IRootPart, AbstractRootPart|AbstractRootPart]] which establishes [http://docs.oracle.com/javafx/2/api/index.html?javafx/scene/Node.html javafx.scene.Node] as the visual root type. It does also register the part as soon as a link to the [[#IViewer, AbstractViewer|IViewer]] is obtained.

==== FXDefaultHoverHandlePartFactory, FXDefaultSelectionHandlePartFactory ====

The <code> FXDefaultHoverHandlePartFactory </code> and <code> FXDefaultSelectionHandlePartFactory </code> use <code>FXCircleSegmentHandlePart</code>, <code>FXRectangleSegmentHandlePart</code>, and <code>FXSquareSegmentHandlePart</code> for generating handles if the associated geometry provider is bound as an adapter on the hovered/selected part.

==== FXRootPart ====

The <code>FXRootPart</code> provides a content layer, a feedback layer, and a handle layer in which the visuals of the corresponding parts are displayed. The feedback layer is above the content layer, and the handle layer is above the feedback layer.

[[File:GEF4-MVC-FX-parts-root.png|356px]]

==== FXPartUtils ====

[[File:GEF4-MVC-FX-parts-utils.png|551px]]

<div id="MVC.FX:Policies"></div>
=== Policies ===

* '''package: org.eclipse.gef4.mvc.fx.policies'''

The [[#MVC.FX:Policies|Policies]] package contains all [[#IPolicy, AbstractPolicy|IPolicy]] implementations contributed by [[#MVC.FX|MVC.FX]]. These can be divided into transactional policies, which can be used to generate an operation that performs certain changes, and interaction policies, which are associated with certain user interactions (mouse click/drag, touch pinch/spread, etc.).

[[File:GEF4-MVC-FX-policies-interaction.png|812px]]

[[File:GEF4-MVC-FX-policies-transactional.png|1027px]]

==== IFXOnClickPolicy ====

An <code>IFXOnClickPolicy</code> is called upon mouse click events by the [[#FXClickDragTool|FXClickDragTool]]. You can use it as an adapter on any [[#IVisualPart, AbstractVisualPart|IVisualPart]] for which mouse click interaction is desired, and you can also register multiple instances of <code>IFXOnClickPolicy</code> on the same [[#IVisualPart, AbstractVisualPart|IVisualPart]] (with different adapter roles).

==== IFXOnDragPolicy ====
An <code>IFXOnDragPolicy</code> is called during a mouse press-drag-release gesture by the [[#FXClickDragTool|FXClickDragTool]]. You can use it as an adapter on any [[#IVisualPart, AbstractVisualPart|IVisualPart]] for which mouse drag interaction is desired, and you can also register multiple instances of <code>IFXOnDragPolicy</code> on the same [[#IVisualPart, AbstractVisualPart|IVisualPart]] (with different adapter roles).

==== IFXOnHoverPolicy ====
An <code>IFXOnHoverPolicy</code> is called upon mouse hover by the [[#FXHoverTool|FXHoverTool]]. You can use it as an adapter on any [[#IVisualPart, AbstractVisualPart|IVisualPart]] for which mouse hover interaction is desired, and you can also register multiple instances of <code>IFXOnHoverPolicy</code> on the same [[#IVisualPart, AbstractVisualPart|IVisualPart]] (with different adapter roles).

==== IFXOnPinchSpreadPolicy ====
An <code>IFXOnPinchSpreadPolicy</code> is called during a pinch/spread touch gesture by the [[#FXPinchSpreadTool|FXPinchSpreadTool]]. You can use it as an adapter on any [[#IVisualPart, AbstractVisualPart|IVisualPart]] for which pinch/spread touch interaction is desired, and you can also register multiple instances of <code>IFXOnPinchSpreadPolicy</code> on the same [[#IVisualPart, AbstractVisualPart|IVisualPart]] (with different adapter roles).

==== IFXOnRotatePolicy ====
An <code>IFXOnRotatePolicy</code> is called during a rotate touch gesture by the [[#FXRotateTool|FXRotateTool]]. You can use it as an adapter on any [[#IVisualPart, AbstractVisualPart|IVisualPart]] for which rotate touch interaction is desired, and you can also register multiple instances of <code>IFXOnRotatePolicy</code> on the same [[#IVisualPart, AbstractVisualPart|IVisualPart]] (with different adapter roles).

==== IFXOnScrollPolicy ====
An <code>IFXOnScrollPolicy</code> is called upon mouse wheel scrolling or during a touch scroll gesture by the [[#FXScrollTool|FXScrollTool]]. You can use it as an adapter on any [[#IVisualPart, AbstractVisualPart|IVisualPart]] for which scroll interaction is desired, and you can also register multiple instances of <code>IFXOnScrollPolicy</code> on the same [[#IVisualPart, AbstractVisualPart|IVisualPart]] (with different adapter roles).

==== IFXOnTypePolicy ====
An <code>IFXOnTypePolicy</code> is called upon key presses and releases by the FXTypeTool. You can use it as an adapter on any [[#IVisualPart, AbstractVisualPart|IVisualPart]] for which keyboard interaction is desired, and you can also register multiple instances of <code>IFXOnTypePolicy</code> on the same [[#IVisualPart, AbstractVisualPart|IVisualPart]] (with different adapter roles).

==== FXFocusAndSelectOnClickPolicy ====
The <code>FXFocusAndSelectOnClickPolicy</code> is an [[#IFXOnClickPolicy|IFXOnClickPolicy]] that focusses and selects the host part upon mouse click. It manipulates the [[#FocusModel|FocusModel]] and [[#SelectionModel|SelectionModel]].

==== FXMarqueeOnDragPolicy ====
The <code>FXMarqueeOnDragPolicy</code> is an [[#IFXOnDragPolicy|IFXOnDragPolicy]] that can be used to span a marquee selection area covering multiple parts using mouse drag. It manipulates the [[#SelectionModel|SelectionModel]].

==== FXTranslateSelectedOnDragPolicy ====
The <code> FXTranslateSelectedOnDragPolicy</code> is an [[#IFXOnDragPolicy|IFXOnDragPolicy]] that relocates the host visual when dragging with the mouse. It is based on the [[#FXTransformPolicy|FXTransformPolicy]] of its host.

==== FXBendOnSegmentDragPolicy ====
The <code>FXBendOnSegmentDragPolicy</code> is an [[#IFXOnDragPolicy|IFXOnDragPolicy]] that can be used to drag individual segments of a [[GEF/GEF4/FX#Connection|Connection]] with an orthogonal [[GEF/GEF4/FX#IConnectionRouter, StraightRouter, OrthogonalRouter|org.eclipse.gef4.fx.nodes.OrthogonalRouter]]. It is based on the [[#FXBendConnectionPolicy|FXBendConnectionPolicy]] of its host.

==== FXNormalizeConnectedOnDragPolicy ====
The <code>FXNormalizeConnectedOnDragPolicy</code> is an [[#IFXOnDragPolicy|IFXOnDragPolicy]] used to remove superfluous segments of outgoing or incoming [[GEF/GEF4/FX#Connection|org.eclipse.gef4.fx.connection.Connection]]s with an orthogonal [[GEF/GEF4/FX#IConnectionRouter, StraightRouter, OrthogonalRouter|OrthogonalRouter]] when dragging the source or target element. It is based on the [[#FXBendConnectionPolicy|FXBendConnectionPolicy]] of the connected parts.

==== FXBendFirstAnchorageOnSegmentHandleDragPolicy ====
The <code>FXBendOnSegmentHandleDragPolicy</code> is an [[#IFXOnDragPolicy|IFXOnDragPolicy]] which can be applied to [[#AbstractFXHandlePart, AbstractFXSegmentHandlePart, FXCircleSegmentHandlePart, FXRectangleSegmentHandlePart, FXSquareSegmentHandlePart|FXSegmentHandlePart]] to bend the host's first anchorage, i.e. manipulate the [[GEF/GEF4/FX#Connection|org.eclipse.gef4.fx.nodes.Connection]] visual of the first anchorage of the host [[#AbstractFXHandlePart, AbstractFXSegmentHandlePart, FXCircleSegmentHandlePart, FXRectangleSegmentHandlePart, FXSquareSegmentHandlePart|FXSegmentHandlePart]]. It uses the [[#FXBendConnectionPolicy|FXBendConnectionPolicy]] of the first anchorage.

==== FXResizeTransformSelectedOnHandleDragPolicy ====
The <code>FXResizeRelocateOnHandleDragPolicy</code> is an [[#IFXOnDragPolicy|IFXOnDragPolicy]] that can be applied to [[#AbstractFXHandlePart, AbstractFXSegmentHandlePart, FXCircleSegmentHandlePart, FXRectangleSegmentHandlePart, FXSquareSegmentHandlePart|FXSegmentHandlePart]] to resize and relocate the first anchorage of its host on mouse drag. It is based on [[#FXResizePolicy|FXResizePolicy]] and [[#FXTransformPolicy|FXTransformPolicy]] of the selected parts.

==== FXRotateSelectedOnHandleDragPolicy ====
The <code>FXRotateSelectedOnHandleDragPolicy</code> is an [[#IFXOnDragPolicy|IFXOnDragPolicy]] that that can be applied to [[#AbstractFXHandlePart, AbstractFXSegmentHandlePart, FXCircleSegmentHandlePart, FXRectangleSegmentHandlePart, FXSquareSegmentHandlePart|FXSegmentHandlePart]] to rotate the selected parts on mouse drag. It is based on the [[#FXTransformPolicy| FXTransformPolicy]] of the selected parts.

==== FXResizeTransformFirstAnchorageOnHandleDragPolicy ====
The <code>FXResizeTransformFirstAnchorageOnHandleDragPolicy</code> is an [[#IFXOnDragPolicy|IFXOnDragPolicy]] that that can be applied to [[#AbstractFXHandlePart, AbstractFXSegmentHandlePart, FXCircleSegmentHandlePart, FXRectangleSegmentHandlePart, FXSquareSegmentHandlePart|FXSegmentHandlePart]] to resize and transform the visual of its host's first anchorage on mouse drag. It is based on the [[#FXResizePolicy|FXResizePolicy]] and [[#FXTransformPolicy|FXTransformPolicy]] of the host's first anchorage.

==== FXHoverOnHoverPolicy ====
The <code>FXHoverOnHoverPolicy</code> is an [[#IFXOnHoverPolicy|IFXOnHoverPolicy]] that hovers the host part upon mouse hover. It manipulates the [[#HoverModel|HoverModel]].

==== FXZoomOnPinchSpreadPolicy ====
The <code>FXZoomOnPinchSpreadPolicy</code> is an is an [[#IFXOnPinchSpreadPolicy|IFXOnPinchSpreadPolicy]]zooms the [[GEF/GEF4/FX#InfiniteCanvas|InfiniteCanvas]] of the content [[#FXViewer|FXViewer]] with a touch pinch/spread gesture. It is based on the [[#FXChangeViewportPolicy|FXChangeViewportPolicy]] of its host.

==== FXRotateSelectedOnRotatePolicy ====
The <code>FXRotateSelectedOnRotatePolicy</code> is an is an [[#IFXOnRotatePolicy|IFXOnRotatePolicy]] that rotates the selected parts with a touch rotate gesture. It is based on the [[#FXTransformPolicy|FXTransformPolicy]] of the selected parts.

==== FXPanOrZoomOnScrollPolicy ====
The <code>FXPanOrZoomOnScrollPolicy</code> changes the scroll offset or zoom level of the [[GEF/GEF4/FX#InfiniteCanvas|org.eclipse.gef4.fx.nodes.InfiniteCanvas]] of the content [[#FXViewer|FXViewer]] upon mouse/touch scroll events. It is based on the [[#FXChangeViewportPolicy|FXChangeViewportPolicy]] of the [[#FXRootPart|FXRootPart]].

==== FXDeleteSelectedOnTypePolicy====
The <code>FXDeleteSelectedOnTypePolicy</code> is an [[#IFXOnTypePolicy|IFXOnTypePolicy]] that deletes the selected parts when pressing the &lt;Delete&gt; key. It manipulates the [[#ContentModel|ContentModel]].

==== FXPanOnTypePolicy ====
The <code>FXPanOnTypePolicy</code> is an [[#IFXOnTypePolicy|IFXOnTypePolicy]] that changes the scroll offset of the [[GEF/GEF4/FX#InfiniteCanvas|org.eclipse.gef4.fx.nodes.InfiniteCanvas]] of the content [[#FXViewer|FXViewer]] upon arrow key presses. It is based on the [[#FXChangeViewportPolicy|FXChangeViewportPolicy]] of the [[#FXRootPart|FXRootPart]].

==== FXSelectFocusedOnTypePolicy ====
The <code>FXSelectFocusedOnTypePolicy</code> is an [[#IFXOnTypePolicy|IFXOnTypePolicy]] that selects/deselects the focus element on (select) key type. It manipulates the [[#FocusModel|FocusModel]].

==== FXTraverseFocusOnTypePolicy ==== 
The <code>FXTraverseFocusOnTypePolicy</code> is an [[#IFXOnTypePolicy|IFXOnTypePolicy]] that traverses the focus element on (tab) key type. It manipulates the [[#FocusModel|FocusModel]].

==== FXChangeViewportPolicy ====
The <code>FXChangeViewportPolicy</code> is a transaction policy that can be used to manipulate [[GEF/GEF4/FX#InfiniteCanvas|org.eclipse.gef4.fx.nodes.InfiniteCanvas]] of the content [[#FXViewer|FXViewer]].

==== FXTransformPolicy ====
The <code>FXTransformPolicy</code> is a transaction policy that can be used to transform the visual of its host.

==== FXResizePolicy ====
The <code>FXResizePolicy</code> is a transaction policy that can be used to resize the visual of its host.

==== FXBendConnectionPolicy ====
The <code>FXBendConnectionPolicy</code> is a transaction policy that can be used to manipulate the points constituting an [[GEF/GEF4/FX#Connection|org.eclipse.gef4.fx.nodes.Connection]], i.e. its start point, way points, and end point. When moving a point the policy takes care of:
* Removing overlaid neighbor points.
* Re-adding temporarily removed neighbor points.
* Reconnecting points to the [[#IVisualPart, AbstractVisualPart|IVisualPart]] under mouse when applicable.

Per default, the <code>FXBendConnectionPolicy</code> can only be applied to those [[#IVisualPart, AbstractVisualPart|IVisualParts]] which use [[GEF/GEF4/FX#Connection|org.eclipse.gef4.fx.nodes.Connection]] as their visual. This can be adjusted by sub-classing and overriding the corresponding <code>#getConnection()</code> method.

==== FXTransformConnectionPolicy ====
The <code>FXTransformConnectionPolicy</code> is a specialization of [[#FXTransformPolicy|#FXTransformPolicy]] that can be applied to [[#IVisualPart, AbstractVisualPart|IVisualParts]] which use [[GEF/GEF4/FX#Connection|org.eclipse.gef4.fx.nodes.Connection]] as their visual. Per default, it transforms only those points of a connection that are not bound to an anchorage.

----

<div id="MVC.FX:Providers"></div>

=== Providers ===

* '''package: org.eclipse.gef4.mvc.fx.providers'''

The [[#MVC.FX:Providers|Providers]] package provides a number of [http://google.github.io/guice/api-docs/3.0/javadoc/com/google/inject/Provider.html com.google.inject.Provider], which are used by several mechanisms:
* [[#FXTransformPolicy, FXResizePolicy, FXBendPolicy, FXRelocateConnectionPolicy|FXBendPolicy]] uses a <code>Provider&lt;IFXAnchor&gt;</code> to find an [[GEF/GEF4/FX#IFXAnchor, AbstractFXAnchor, AnchorKey|org.eclipse.gef4.fx.anchors.IFXAnchor]] for an [[#IVisualPart, AbstractVisualPart|IVisualPart]] at which a point of an [[GEF/GEF4/FX#FXConnection, IFXDecoration, IFXConnectionRouter, FXPolyBezierConnectionRouter, FXPolylineConnectionRouter|org.eclipse.gef4.fx.nodes.FXConnection]] can be attached.
* [[#FXTransformPolicy, FXResizePolicy, FXBendPolicy, FXRelocateConnectionPolicy|FXTransformPolicy]] uses a <code>Provider&lt;Affine&gt;</code> to transform the visual of an [[#IVisualPart, AbstractVisualPart|IVisualPart]].
* [[#AbstractFXFeedbackPart, FXHoverFeedbackPart, FXSelectionFeedbackPart, FXSelectionLinkFeedbackPart, FXDefaultFeedbackPartFactory|FXDefaultFeedbackPartFactory]] and [[#AbstractFXHandlePart, AbstractFXSegmentHandlePart, FXCircleSegmentHandlePart, FXRectangleSegmentHandlePart, FXDefaultHandlePartFactory|FXDefaultHandlePartFactory]] use a <code>Provider&lt;IGeometry&gt;</code> to determine the position and shape of feedback and handle visuals.

[[File:GEF4-MVC-FX-providers.png|870px]]

==== DefaultAnchorProvider ====

The <code> DefaultAnchorProvider </code> provides an anchor for a given (anchorage) [[#IVisualPart, AbstractVisualPart|IVisualPart]].

==== FXTransformProvider ====
The <code>FXTransformProvider</code> adds an [http://docs.oracle.com/javafx/2/api/index.html?javafx/scene/transform/Affine.html javafx.scene.transform.Affine] to the transforms list of the visual of the part at which it is bound as an adapter. It does also allow access to that [http://docs.oracle.com/javafx/2/api/index.html?javafx/scene/transform/Affine.html javafx.scene.transform.Affine], which is used by several (transaction) policies to perform transformations.

==== GeometricOutlineProvider, GeometricBoundsProvider, ShapeOutlineProvider, ShapeBoundsProvider ====

The <code>GeometricOutlineProvider</code> and <code>GeometricBoundsProvider</code> return the core geometry and related bounds of the visual of the part to which they are bound as an adapter.

The <code>ShapeOutlineProvider</code> and <code>ShapeBoundsProvider</code> do likewise for the visual (shape) outline and bounds.

----

<div id="MVC.FX:Tools"></div>

=== Tools ===

* '''package: org.eclipse.gef4.mvc.fx.tools'''

The [[#MVC.FX:Tools|Tools]] package contains JavaFX-specific ITool implementations for different interactions (e.g. mouse drag).

[[File:GEF4-MVC-FX-tools.png|1068px]]

==== FXClickDragTool ====

The <code>FXClickDragTool</code> registers listeners for mouse click and drag interactions. The target [[#IVisualPart, AbstractVisualPart|IVisualPart]] is determined by searching the visual part hierarchy, beginning at the part that controls the visual, which was pressed, until a part is found that supports at least one [[#AbstractFXOnClickPolicy, FXFocusAndSelectOnClickPolicy|AbstractFXOnClickPolicy]] or [[#AbstractFXOnDragPolicy, FXMarqueeOnDragPolicy, FXRelocateOnDragPolicy|AbstractFXOnDragPolicy]], respectively. In addition, the target part for a specific [http://docs.oracle.com/javafx/2/api/index.html?javafx/event/EventTarget.html javafx.event.EventTarget] can be specified explicitly to bypass the target part search, as follows:

<source lang="java" style="border-style:solid;border-color:#f2f2f2;border-width:1px;padding:10px;margin-bottom:10px">
// override drag target to let another part continue the interaction
getHost().getRoot().getViewer().getDomain().getAdapter(FXClickDragTool.class)
	.overrideTargetForThisInteraction(eventTarget, newDragTargetPart);
</source>

A target override can be specified at any time, and will be maintained for the current interaction (or the next interaction if the mouse is not pressed, currently). All target overrides are cleared when the mouse is released.

==== FXFocusTool ====

The <code>FXFocusTool</code> registers listeners for window focus events and changes the ''viewer-focused'' flag in the [[#FocusModel|FocusModel]] accordingly.

==== FXHoverTool ====

The <code>FXHoverTool</code> registers listeners for mouse hover interaction, i.e. mouse enter and mouse exit events for visuals. The target [[#IVisualPart, AbstractVisualPart|IVisualPart]] is determined by searching the visual part hierarchy, beginning at the part that controls the visual, which was hovered, until a part is found that supports at least one [[#AbstractFXOnHoverPolicy, FXHoverOnHoverPolicy|AbstractFXOnHoverPolicy]].

==== FXPinchSpreadTool ====

The <code>FXPinchSpreadTool</code> registers listeners for touch pinch/spread gesture interaction, i.e. moving two fingers apart or bringing them together (the default zoom gesture on many touch displays). The target [[#IVisualPart, AbstractVisualPart|IVisualPart]] is determined by searching the visual part hierarchy, beginning at the part that controls the visual, which was touched, until a part is found that supports at least one [[#AbstractFXOnPinchSpreadPolicy, FXZoomOnPinchSpreadPolicy|AbstractFXOnPinchSpreadPolicy]].

==== FXRotateTool ====

The <code>FXRotateTool</code> registers listeners for touch rotate gesture interaction, i.e. moving two fingers around each other (or moving one finger around another). The target [[#IVisualPart, AbstractVisualPart|IVisualPart]] is determined by searching the visual part hierarchy, beginning at the part that controls the visual, which was touched, until a part is found that supports at least one [[#AbstractFXOnRotatePolicy, FXRotateSelectedOnRotatePolicy|AbstractFXOnRotatePolicy]].

==== FXScrollTool ====

The <code>FXScrollTool</code> registers listeners for scroll interaction, which may either be mouse wheel scrolling, or touch scrolling, i.e. dragging two fingers up or down. The target [[#IVisualPart, AbstractVisualPart|IVisualPart]] is determined by searching the visual part hierarchy, beginning at the part that controls the visual, which was scrolled or touched, until a part is found that supports at least one [[#AbstractFXOnScrollPolicy, FXPanOnScrollPolicy, FXZoomOnScrollPolicy|AbstractFXOnScrollPolicy]].

==== FXTypeTool ====

The <code>FXTypeTool</code> registers listeners for keyboard interaction. The currently focused (see [[#FocusModel|FocusModel]]) [[#IVisualPart, AbstractVisualPart|IVisualPart]] is used as the target part for keyboard interaction if it supports at least one [[#AbstractFXOnTypePolicy, FXDeleteSelectedOnTypePolicy, FXPanOnTypePolicy|AbstractFXOnTypePolicy]].

----

<div id="MVC.FX:Viewer"></div>

=== Viewer ===

* '''package: org.eclipse.gef4.mvc.fx.viewer'''

The [[#MVC.FX:Viewer|Viewer]] package contains a JavaFX-specific [[#IViewer, AbstractViewer|IViewer]] implementation.

[[File:GEF4-MVC-FX-viewer.png|290px]]

==== FXViewer ====

The <code>FXViewer</code> is a JavaFX-specific [[#IViewer, AbstractViewer|IViewer]] implementation. It provides a [[GEF/GEF4/FX#FXGridLayer|org.eclipse.gef4.fx.nodes.FXGridLayer]] and a [[GEF/GEF4/FX#ScrollPaneEx|org.eclipse.gef4.fx.nodes.ScrollPaneEx]], which are arranged so that the [[GEF/GEF4/FX#FXGridLayer|org.eclipse.gef4.fx.nodes.FXGridLayer]] is displayed behind the contents of the [[GEF/GEF4/FX#ScrollPaneEx|org.eclipse.gef4.fx.nodes.ScrollPaneEx]].

----

== MVC.UI ==

*'''feature: org.eclipse.gef4.mvc.ui'''
*'''bundle: org.eclipse.gef4.mvc.ui'''

The [[#MVC.UI|MVC.UI]] module of [[GEF/GEF4/MVC|GEF4 MVC]] provides aspects for an integration into the Eclipse UI:
* Binding the operation history from the Eclipse Workbench.
* An [[#UndoablePropertySheetPage, UndoablePropertySheetEntry|UndoablePropertySheetPage]] for contribution to the Eclipse 'Properties' view.

----

<div id="MVC.UI:Root"></div>
=== {Root} ===
*'''package: org.eclipse.gef4.mvc.ui'''

[[File:GEF4-MVC-UI-root.png|656px]]

==== MvcUiModule ====

The <code>MvcUiModule</code> contains bindings for the Eclipse integration. Currently, only a binding for the [http://help.eclipse.org/topic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/core/commands/operations/IOperationHistory.html org.eclipse.core.commands.operations.IOperationHistory] of the Eclipse workbench is provided, so that operations executed in the context of an [[#IDomain, AbstractDomain|IDomain]] are undoable/redoable from the Eclipse UI.

<div id="MVC.UI:Parts"></div>
=== Parts ===
*'''package: org.eclipse.gef4.mvc.ui.parts'''

[[File:GEF4-MVC-UI-parts.png|668px]]


==== ISelectionProviderFactory ====
The <code>ISelectionProviderFactory</code> interface can be used to implement a factory that creates an [http://help.eclipse.org/topic/org.eclipse.platform.doc.isv/reference/api/org.eclipse.jface.viewers.ISelectionProvider.html org.eclipse.jface.viewers.ISelectionProvider] for a given [http://help.eclipse.org/topic/org.eclipse.platform.doc.isv/reference/api/org.eclipse.ui.IWorkbenchPart.html org.eclipse.ui.IWorkbenchPart].

==== ContentSelectionProvider ====

The <code>ContentSelectionProvider</code> is an implementation of the [http://help.eclipse.org/topic/org.eclipse.platform.doc.isv/reference/api/org.eclipse.jface.viewers.ISelectionProvider.html org.eclipse.jface.viewers.ISelectionProvider] interface that provides the content elements of the currently selected [[#IContentPart, AbstractContentPart|IContentPart]]s, and can select [[#IContentPart, AbstractContentPart|IContentPart]]s based on their content elements.

----

<div id="MVC.UI:Properties"></div>

=== Properties ===
*'''package: org.eclipse.gef4.mvc.ui.properties'''

[[File:GEF4-MVC-UI-properties.png|868px]]

==== IPropertySheetPageFactory ====
The <code>IPropertySheetPageFactory</code> interface allows to implement a factory to create an [http://help.eclipse.org/topic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/ui/views/properties/IPropertySheetPage.html org.eclipse.ui.views.properties.IPropertySheetPage] for an [http://help.eclipse.org/topic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/ui/IWorkbenchPart.html org.eclipse.ui.IWorkbenchPart].

==== UndoablePropertySheetPage, UndoablePropertySheetEntry ====

The <code>UndoablePropertySheetPage</code> is a [http://help.eclipse.org/topic/org.eclipse.platform.doc.isv/reference/api/org.eclipse.ui.views.properties.PropertySheetPage.html org.eclipse.ui.views.properties.PropertySheetPage] extension that allows to perform undo/redo of property value changes also in case the viewer/editor is not active.

The <code>UndoablePropertySheetEntry</code> provides undo support for changes made to [http://help.eclipse.org/topic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/ui/views/properties/IPropertySource.html org.eclipse.ui.views.properties.IPropertySource] by the Eclipse 'Properties' view. Clients can construct a [http://help.eclipse.org/topic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/ui/views/properties/PropertySheetPage.html org.eclipse.ui.views.properties.PropertySheetPage] and use this class as the root entry. All changes made to property sources displayed on that page will be done using the provided [http://help.eclipse.org/topic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/core/commands/operations/IOperationHistory.html org.eclipse.core.commands.operations.IOperationHistory].

==== SetPropertyValueOperation ====

The <code>SetPropertyValueOperation</code> can be used to set or reset the value of a property. It is used by the [[#UndoablePropertySheetPage, UndoablePropertySheetEntry|UndoablePropertySheetEntry]].

==== ContentPropertySourceAdapterFactory ====

The <code>ContentPropertySourceAdapterFactory</code> adapts the content model objects of [[#IContentPart, AbstractContentPart|IContentPart]] to [http://help.eclipse.org/topic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/ui/views/properties/IPropertySource.html org.eclipse.ui.views.properties.IPropertySource].

----

== MVC.FX.UI ==

*'''feature: org.eclipse.gef4.mvc.fx.ui'''
*'''bundle: org.eclipse.gef4.mvc.fx.ui'''

The [[#MVC.FX.UI|MVC.FX.UI]] module of [[GEF/GEF4/MVC|GEF4 MVC]] provides JavaFX-specific aspects for an integration into the Eclipse UI.

----

<div id="MVC.FX.UI:Root"></div>
=== {Root} ===
*'''package: org.eclipse.gef4.mvc.fx.ui'''

The [[#MVC.FX.UI:Root|{Root}]] package contains a Guice Module which binds an [http://help.eclipse.org/topic/org.eclipse.platform.doc.isv/reference/api/org.eclipse.jface.viewers.ISelectionProvider.html org.eclipse.jface.viewers.ISelectionProvider] and handles the construction of an FXCanvas to render the JavaFX scene graph.

[[File:GEF4-MVC-FX-UI-root.png|465px]]

==== MvcFxUiModule ====

The <code>MvcFxUiModule</code> contains bindings for the JavaFX/Eclipse integration:
* Binding an [[#IFXCanvasFactory|IFXCanvasFactory]] for the construction of an [http://docs.oracle.com/javafx/2/api/index.html?javafx/embed/swt/FXCanvas.html javafx.embed.swt.FXCanvas].
* Binding the [[#ISelectionProviderFactory|ISelectionProviderFactory]] which provides a [[#ContentSelectionProvider|ContentSelectionProvider]].

----

<div id="MVC.FX.UI:Parts"></div>

=== Parts ===
*'''package: org.eclipse.gef4.mvc.fx.ui.parts'''

The [[#MVC.FX.UI:Parts|Parts]] package contains spcific [http://help.eclipse.org/topic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/ui/part/ViewPart.html org.eclipse.ui.part.ViewPart] and [http://help.eclipse.org/topic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/ui/part/EditorPart.html org.eclipse.ui.part.EditorPart] implementations which wrap an FXCanvas.

[[File:GEF4-MVC-FX-UI-parts.png|573px]]

<small>The JavaFX-unrelated classes in this package will be moved to the [[#MVC.UI|MVC.UI]] module as outlined in Bugzilla [https://bugs.eclipse.org/bugs/show_bug.cgi?id=469478 #469478].</small>

==== FXEditor ====

The <code>AbstractFXEditor</code> is a [http://help.eclipse.org/topic/org.eclipse.platform.doc.isv/reference/api/org.eclipse.ui.part.EditorPart.html org.eclipse.ui.part.EditorPart] extension, which can be used to embed an editor, based on [[#MVC.FX|MVC.FX]], into the Eclipse UI.

==== FXEditorActionBarContributor ====

The <code>FXEditorActionBarContributor</code> is an [http://help.eclipse.org/topic/org.eclipse.platform.doc.isv/reference/api/org.eclipse.ui.part.EditorActionBarContributor.html org.eclipse.ui.part.EditorActionBarContributor] extension, which lets the undo/redo action group of the corresponding [http://help.eclipse.org/topic/org.eclipse.platform.doc.isv/reference/api/org.eclipse.ui.part.IEditorPart.html org.eclipse.ui.part.IEditorPart] contribute to the action bars.

==== FXView ====

The <code>AbstractFXView</code> is a [http://help.eclipse.org/topic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/ui/part/ViewPart.html org.eclipse.ui.part.ViewPart] extension, which can be used to embed a viewer, based on [[#MVC.FX|MVC.FX]], into the Eclipse UI.

==== DeleteActionHandler ====

The <code>DeleteActionHandler</code> handles deletion based on the selected [[#IContentPart, AbstractContentPart| IContentPart]]s.

== MVC.FX.UI ==

The '''[[#MVC.FX.UI|MVC.FX.UI]]''' module of [[GEF/GEF4/FX|GEF4 FX]] provides enhanced support for integrating with the Eclipse UI.
[[Category:GEF]]

=== Properties ===

*'''package: org.eclipse.gef4.mvc.fx.ui.properties'''

The [[#Properties |Properties]] package provides support for integrating JavaFX-related cell editors into the Eclipse 'Properties' view.

[[File:GEF4-MVC-FX-UI-properties.png|255px]]

==== FXPaintPropertyDescriptor ====

An <code>FXPaintPropertyDescriptor</code> is a property descriptor that integrates an [[#FXPaintCellEditor| FXPaintCellEditor]].

----

== Migration from GEF (MVC) 3.x to MVC, MVC.FX, MVC.UI, MVC.FX.UI ==

[[GEF/GEF4/MVC|GEF4 MVC]] was written completely from scratch. While some proven concepts have been transferred from GEF (MVC) 3.x, central concepts and mechanisms have been reworked. The most notable differences are:

* More modularity, separating out Eclipse Workbench UI dependencies: While GEF (MVC) 3.x provided a single bundle (with Eclipse UI dependencies), [[GEF/GEF4/MVC|GEF4 MVC]] clearly separates out those dependencies into the [[#MVC.UI|MVC.UI]] and [[#MVC.FX.UI|MVC.FX.UI]] bundles, so that standalone graphical applications can be realized based on [[#MVC|MVC]] and [[#MVC.FX|MVC.FX]] alone. Furthermore, rendering toolkit independent abstractions (provided by [[#MVC|MVC]]) are now clearly separated from rendering toolkit (i.e. JavaFX) specific concretizations (provided by [[#MVC.FX|MVC.FX]]. 
* Usage of JavaFX instead of SWT/Draw2d.
* Usage of adapter pattern throughout: While GEF (MVC) 3.x only used the Eclipse Platform provided adaptable pattern for Eclipse Workbench UI integration tasks (e.g. integration with properties view), this mechanism is used intensively within [[GEF/GEF4/MVC|GEF4 MVC]] to configure the complete graphical application. That is, tools and viewers are adapted to the domain, viewer models and the root part are adapted to the viewer, policies and behaviors are adapted to visual parts.
* Usage of dependency injection
* Own visual parts for feedback and handles (compared to 'lightweight' feedback)
* Separation of policies (passive, invoked by tools) and behaviors (active, listening for changes)
* Separation of interaction policies (directly invoked by tools, related to interaction) and transaction policies (called by interaction policies, realize the content manipulation)
* Pure interaction-gesture-based tools without own transactional logic (compared to monolithic 'selection tool'): In contrast to GEF (MVC) 3.x, where tools were dedicated to certain semantic operations (creation, selection, etc.), tools are now pretty dumb and dedicated to interaction gestures (click/drag, scroll, etc.), and forward all interactions to respective interaction policies. While the tools provides the transactional context (i.e. it opens and closes a respective operation via the domain, so that all operations that are executed as a result of the interaction can be undone together) they do not translate the gesture-based interaction into semantical operations themselves. This responsibility lies with the interaction policies alone. Where a GEF (MVC) 3.x application had thus to specialize one of the default tools to add different semantic behavior, this can now be achieved by registering different interaction policies, which is much more lightweight. 

[[Category:GEF]]