org.eclipse.gef4.mvc.fx.policies

Class FXTransformPolicy

java.lang.Object

org.eclipse.gef4.mvc.policies.AbstractPolicy<javafx.scene.Node>

org.eclipse.gef4.mvc.fx.policies.FXTransformPolicy

All Implemented Interfaces:

IAdaptable.Bound<IVisualPart<javafx.scene.Node,? extends javafx.scene.Node>>, ITransactional, IPolicy<javafx.scene.Node>

Direct Known Subclasses:

FXTransformConnectionPolicy

public class FXTransformPolicy
extends AbstractPolicy<javafx.scene.Node>
implements ITransactional

The FXTransformPolicy is a transactional policy that handles the transformation of its host.

When working with transformations, the order in which the individual transformations are concatenated is important. The transformation that is concatenated last will be applied first. For example, the rotation around a pivot point consists of 3 steps:

1. Translate the coordinate system, so that the pivot point is in the origin (-px, -py).
2. Rotate the coordinate system.
3. Translate back to the original position (px, py).

But the corresponding transformations have to be concatenated in reverse order, i.e. translate back first, rotate then, translate pivot to origin last. This is easy to confuse, that's why this policy manages a list of pre-transforms and a list of post-transforms. These transformations (as well as the initial node transformation) are concatenated as follows to yield the new node transformation for the host:

            --> --> -->  direction of concatenation --> --> -->

            postTransforms  initialNodeTransform  preTransforms
            |------------|                        |-----------|
 postIndex: n, n-1, ...  0              preIndex: 0, 1,  ...  m

            <-- <-- <-- <-- direction of effect <-- <-- <-- <--
 

As you can see, the last pre-transform is concatenated last, and therefore, will affect the host first. Generally, a post-transform manipulates the transformed node, while a pre-transform manipulates the coordinate system before the node is transformed.

You can use the createPreTransform() and createPostTransform() methods to create a pre- or a post-transform and append it to the respective list. Therefore, the most recently created pre-transform will be applied first, and the most recently created post-transform will be applied last. When creating a pre- or post-transform, the index of that transform within the respective list will be returned. This index can later be used to manipulate the transform.

Additionally, the createPostRotate(Point), and createPostScale(Point) methods can be used to create a rotation or scaling around a pivot point (in scene coordinates) for convenience.

The setPostRotate(int, Angle), setPostScale(int, double, double), setPostTransform(int, AffineTransform), setPostTranslate(int, double, double), setPreRotate(int, Angle), setPreScale(int, double, double), setPreTransform(int, AffineTransform), and setPreTranslate(int, double, double) methods can be used to change a previously created pre- or post-transform. Additionally, the setPostTranslateInScene(int, double, double) method can be used to set a translation in scene coordinates for convenience.

Nested Class Summary

Nested classes/interfaces inherited from interface org.eclipse.gef4.mvc.operations.ITransactional

ITransactional.NoOperation, ITransactional.UnexecutableOperation

Field Summary

Fields

Modifier and Type	Field and Description
protected boolean	initialized Stores the initialized flag for this policy, i.e.
protected AffineTransform	initialNodeTransform The initial node transformation of the manipulated part.
protected java.util.List<AffineTransform>	postTransforms The List of transformations that are applied after the old transformation.
protected java.util.List<AffineTransform>	preTransforms The List of transformations that are applied before the old transformation.
static java.lang.String	TRANSFORMATION_PROVIDER_ROLE The role name for the Provider<Affine> that will be used to obtain the host's Affine transformation.
protected FXTransformOperation	transformOperation The FXTransformOperation that is updated to reflect the transformation changes that are performed by this policy.

Fields inherited from interface org.eclipse.gef4.mvc.operations.ITransactional

NOOP, UNEXECUTABLE

Constructor Summary

Constructors

Constructor and Description
FXTransformPolicy()

Method Summary

Modifier and Type	Method and Description
protected void	applyTransform(AffineTransform newTransform) Applies the given AffineTransform as the new transformation matrix to the host.
ITransactionalOperation	commit() Returns an ITransactionalOperation that performs all manipulations applied by the policy since the last ITransactional.init() call.
int	createPostRotate(Point pivotInScene) Creates three transformations that are used as follows: Translates the host so that its origin is at the given pivot point.
int	createPostScale(Point pivotInScene) Creates three transformations that are used as follows: Translates the host so that its origin is at the given pivot point.
int	createPostTransform() Creates a new AffineTransform and appends it to the postTransforms list.
int	createPreTransform() Creates a new AffineTransform and appends it to the preTransforms list.
AffineTransform	getInitialNodeTransform() Returns a copy of the initial node transformation of the host (obtained via getNodeTransform()).
javafx.scene.transform.Affine	getNodeTransform() Returns the Affine transformation that is returned by the Provider<Affine> that is installed on the host under the TRANSFORMATION_PROVIDER_ROLE role.
protected static Dimension	getSnapToGridOffset(GridModel gridModel, double localX, double localY, double gridCellWidthFraction, double gridCellHeightFraction) Computes the offset which needs to be added to the given local coordinates in order to stay on the grid/snap to the grid.
void	init() Initializes the policy, so that the policy's "work" methods can be used.
protected void	reset() Resets this FXTransformPolicy, i.e. clears the pre- and post-transforms lists and sets the operation and the initial node transform to null.
void	setPostRotate(int index, Angle rotation) Sets the specified post-transform to a rotation by the given angle.
void	setPostScale(int index, double sx, double sy) Sets the specified post-transform to a scaling by the given factors.
void	setPostTransform(int postTransformIndex, AffineTransform transform) Sets the specified post-transform to the given AffineTransform.
void	setPostTranslate(int index, double tx, double ty) Sets the specified post-transform to a translation by the given offsets.
void	setPostTranslateInScene(int index, double tx, double ty) Sets the specified pre-transform to a translation by the given offsets.
void	setPreRotate(int index, Angle rotation) Sets the specified pre-transform to a rotation by the given angle.
void	setPreScale(int index, double sx, double sy) Sets the specified pre-transform to a scaling by the given factors.
void	setPreTransform(int preTransformIndex, AffineTransform transform) Sets the specified pre-transform to the given AffineTransform.
void	setPreTranslate(int index, double tx, double ty) Sets the specified pre-transform to a translation by the given offsets.
void	setTransform(AffineTransform newTransform) Changes the host's transformation to the given AffineTransform.
protected void	updateTransform() Composes the pre- and post-transforms lists and the initial node transform to one composite transformation.

Methods inherited from class org.eclipse.gef4.mvc.policies.AbstractPolicy

commit, disableRefreshVisuals, enableRefreshVisuals, getAdaptable, getHost, init, setAdaptable

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

TRANSFORMATION_PROVIDER_ROLE

public static final java.lang.String TRANSFORMATION_PROVIDER_ROLE

The role name for the Provider<Affine> that will be used to obtain the host's Affine transformation.

See Also:

Constant Field Values

initialized

protected boolean initialized

Stores the initialized flag for this policy, i.e. true after init() was called, and false after commit() was called, respectively.

transformOperation

protected FXTransformOperation transformOperation

The FXTransformOperation that is updated to reflect the transformation changes that are performed by this policy. The operation can later be executed on the operation history so that transformation changes are undoable.

initialNodeTransform

protected AffineTransform initialNodeTransform

The initial node transformation of the manipulated part.

preTransforms

protected java.util.List<AffineTransform> preTransforms

The List of transformations that are applied before the old transformation.

postTransforms

protected java.util.List<AffineTransform> postTransforms

The List of transformations that are applied after the old transformation.

Constructor Detail

FXTransformPolicy

public FXTransformPolicy()

Method Detail

getSnapToGridOffset

protected static Dimension getSnapToGridOffset(GridModel gridModel,
                                               double localX,
                                               double localY,
                                               double gridCellWidthFraction,
                                               double gridCellHeightFraction)

Computes the offset which needs to be added to the given local coordinates in order to stay on the grid/snap to the grid.

Parameters:

gridModel - The GridModel of the host's IViewer.

localX - The x-coordinate in host coordinates.

localY - The y-coordinate in host coordinates.

gridCellWidthFraction - The granularity of the horizontal grid steps.

gridCellHeightFraction - The granularity of the vertical grid steps.

Returns:

A Dimension representing the offset that needs to be added to the local coordinates so that they snap to the grid.

applyTransform

protected void applyTransform(AffineTransform newTransform)

Applies the given AffineTransform as the new transformation matrix to the host. All transformation changes are applied via this method. Therefore, subclasses can override this method to perform adjustments that are necessary for its host .

Parameters:

newTransform - The new transformation matrix for the host.

commit

public ITransactionalOperation commit()

Description copied from interface: ITransactional

Returns an ITransactionalOperation that performs all manipulations applied by the policy since the last ITransactional.init() call. When called multiple times in sequence, only the first call will yield an operation, the subsequent calls will yield null.

You can return ITransactional.NOOP if no changes have to be applied. The domain will filter out all ITransactional.NOOPs before their execution.

You can return ITransactional.UNEXECUTABLE to prevent any composite operation that contains the ITransactional.UNEXECUTABLE from execution.

Specified by:

commit in interface ITransactional

Returns:

An ITransactionalOperation that performs all manipulations applied by the policy since the last ITransactional.init() call.

createPostRotate

public int createPostRotate(Point pivotInScene)

Creates three transformations that are used as follows:

1. Translates the host so that its origin is at the given pivot point.
2. Rotates the host (the rotation angle can later be set using setPostRotate(int, Angle)).
3. Translates the host back to its original position.

The transformations are appended to the postTransforms list. Therefore, they are applied last, as shown below:

            --> --> -->  direction of concatenation --> --> -->

            postTransforms  initialNodeTransform  preTransforms
            |------------|                        |-----------|
 postIndex: n, n-1, ...  0              preIndex: 0, 1,  ...  m

            <-- <-- <-- <-- direction of effect <-- <-- <-- <--
 

Parameters:

pivotInScene - The pivot Point in scene coordinates.

Returns:

The rotation transformation index for later manipulation.

createPostScale

public int createPostScale(Point pivotInScene)

Creates three transformations that are used as follows:

1. Translates the host so that its origin is at the given pivot point.
2. Scales the host (the rotation angle can later be set using setPreScale(int, double, double)).
3. Translates the host back to its original position.

The transformations are appended to the preTransforms list. Therefore, they are applied first, as shown below:

            --> --> -->  direction of concatenation --> --> -->

            postTransforms  initialNodeTransform  preTransforms
            |------------|                        |-----------|
 postIndex: n, n-1, ...  0              preIndex: 0, 1,  ...  m

            <-- <-- <-- <-- direction of effect <-- <-- <-- <--
 

Parameters:

pivotInScene - The pivot Point in scene coordinates.

Returns:

The scaling transformation index for later manipulation.

createPostTransform

public int createPostTransform()

Creates a new AffineTransform and appends it to the postTransforms list. Therefore, the new AffineTransform will affect the host after all other transforms, as shown below:

            --> --> -->  direction of concatenation --> --> -->

            postTransforms  initialNodeTransform  preTransforms
            |------------|                        |-----------|
 postIndex: n, n-1, ...  0              preIndex: 0, 1,  ...  m

            <-- <-- <-- <-- direction of effect <-- <-- <-- <--
 

A post-transform manipulates the transformed node, while a pre-transform manipulates the coordinate system before the node is transformed.

Returns:

A new AffineTransform that is appended to the postTransforms list.

createPreTransform

public int createPreTransform()

Creates a new AffineTransform and appends it to the preTransforms list. Therefore, the new AffineTransform will affect the host before all other transforms, as shown below:

            --> --> -->  direction of concatenation --> --> -->

            postTransforms  initialNodeTransform  preTransforms
            |------------|                        |-----------|
 postIndex: n, n-1, ...  0              preIndex: 0, 1,  ...  m

            <-- <-- <-- <-- direction of effect <-- <-- <-- <--
 

A post-transform manipulates the transformed node, while a pre-transform manipulates the coordinate system before the node is transformed.

Returns:

A new AffineTransform that is appended to the preTransforms list.

getInitialNodeTransform

public AffineTransform getInitialNodeTransform()

Returns a copy of the initial node transformation of the host (obtained via getNodeTransform()).

Returns:

A copy of the initial node transformation of the host (obtained via getNodeTransform()).

getNodeTransform

public javafx.scene.transform.Affine getNodeTransform()

Returns the Affine transformation that is returned by the Provider<Affine> that is installed on the host under the TRANSFORMATION_PROVIDER_ROLE role.

Returns:

The Affine transformation that is returned by the Provider<Affine> that is installed on the host under the TRANSFORMATION_PROVIDER_ROLE role.

init

public void init()

Description copied from interface: ITransactional

Initializes the policy, so that the policy's "work" methods can be used. Calling a "work" method while the policy is not initialized will result in an IllegalStateException. It is safe to call ITransactional.init() multiple times in sequence.

Specified by:

init in interface ITransactional

reset

protected void reset()

Resets this FXTransformPolicy, i.e. clears the pre- and post-transforms lists and sets the operation and the initial node transform to null. This method is called by init() and commit().

setPostRotate

public void setPostRotate(int index,
                          Angle rotation)

Sets the specified post-transform to a rotation by the given angle.

Parameters:

index - The index of the post-transform to manipulate.

rotation - The counter clock-wise rotation Angle.

setPostScale

public void setPostScale(int index,
                         double sx,
                         double sy)

Sets the specified post-transform to a scaling by the given factors.

Parameters:

index - The index of the post-transform to manipulate.

sx - The horizontal scale factor.

sy - The vertical scale factor.

setPostTransform

public void setPostTransform(int postTransformIndex,
                             AffineTransform transform)

Sets the specified post-transform to the given AffineTransform.

Parameters:

postTransformIndex - The index of the post-transform to manipulate.

transform - The AffineTransform that replaces the specified post-transform.

setPostTranslate

public void setPostTranslate(int index,
                             double tx,
                             double ty)

Sets the specified post-transform to a translation by the given offsets.

Parameters:

index - The index of the post-transform to manipulate.

tx - The horizontal translation offset (in local coordinates).

ty - The vertical translation offset (in local coordinates).

setPostTranslateInScene

public void setPostTranslateInScene(int index,
                                    double tx,
                                    double ty)

Sets the specified pre-transform to a translation by the given offsets.

Parameters:

index - The index of the pre-transform to manipulate.

tx - The horizontal translation offset (in scene coordinates).

ty - The vertical translation offset (in scene coordinates).

setPreRotate

public void setPreRotate(int index,
                         Angle rotation)

Sets the specified pre-transform to a rotation by the given angle.

Parameters:

index - The index of the pre-transform to manipulate.

rotation - The counter clock-wise rotation Angle.

setPreScale

public void setPreScale(int index,
                        double sx,
                        double sy)

Sets the specified pre-transform to a scaling by the given factors.

Parameters:

index - The index of the pre-transform to manipulate.

sx - The horizontal scale factor.

sy - The vertical scale factor.

setPreTransform

public void setPreTransform(int preTransformIndex,
                            AffineTransform transform)

Sets the specified pre-transform to the given AffineTransform.

Parameters:

preTransformIndex - The index of the pre-transform to manipulate.

transform - The AffineTransform that replaces the specified pre-transform.

setPreTranslate

public void setPreTranslate(int index,
                            double tx,
                            double ty)

Sets the specified pre-transform to a translation by the given offsets.

Parameters:

index - The index of the pre-transform to manipulate.

tx - The horizontal translation offset (in parent coordinates).

ty - The vertical translation offset (in parent coordinates).

setTransform

public void setTransform(AffineTransform newTransform)

Changes the host's transformation to the given AffineTransform. Clears the pre- and post-transforms lists.

Parameters:

newTransform - The new AffineTransform for the host.

updateTransform

protected void updateTransform()

Composes the pre- and post-transforms lists and the initial node transform to one composite transformation. This composite transformation is then applied to the host using applyTransform(AffineTransform).

            --> --> -->  direction of concatenation --> --> -->

            postTransforms  initialNodeTransform  preTransforms
            |------------|                        |-----------|
 postIndex: n, n-1, ...  0              preIndex: 0, 1,  ...  m

            <-- <-- <-- <-- direction of effect <-- <-- <-- <--