com.luciad.edit.geometries

Interface PolylineHandlesProvider.IHandleFactory

Enclosing class:

PolylineHandlesProvider

public static interface PolylineHandlesProvider.IHandleFactory

Allows you to specify which handles are used by this handles provider.

It allows you to:

• replace handles with other handle implementations
• (dynamically) disable or re-enable specific handles

Additional handles can not be added using this factory. The way to do this is to wrap the IEditHandles provided by PolylineHandlesProvider, and to insert additional handles in the IEditHandles#getList method.

Method Summary

Modifier and Type	Method and Description
IEditHandle	createAppendPointHandle(Observable<Polyline> polyline, IPointEditAction editAction, FeatureEditContext context) Creates a handle that allows you to insert a new point at the end of a Polyline.
IEditHandle	createElevationPointHandle(Observable<Polyline> polyline, long pointIndex, IPointEditAction editAction, FeatureEditContext context) Creates a handle that allows you to change the elevation of the point of a Polyline.
IEditHandle	createInsertPointHandle(Observable<Polyline> polyline, long insertIndex, IPointEditAction editAction, FeatureEditContext context) Creates a handle that allows you to insert a new point between two existing points of a Polyline.
IEditHandle	createMovePointHandle(Observable<Polyline> polyline, long pointIndex, IPointEditAction editAction, FeatureEditContext context) Creates a handle that allows you to move a point of the Polyline.
IEditHandle	createPrependPointHandle(Observable<Polyline> polyline, IPointEditAction editAction, FeatureEditContext context) Creates a handle that allows you to insert a new point at the start of a Polyline.
IEditHandle	createRemovePointHandle(Observable<Polyline> polyline, long pointIndex, IPointEditAction editAction, FeatureEditContext context) Creates a handle that allows you to remove a point of the Polyline.
boolean	isAppendPointHandleValid(IEditHandle appendPointHandle, Observable<Polyline> polyline, FeatureEditContext context) Returns true if the given handle is still valid, or false if it should be removed.
boolean	isElevationPointHandleValid(IEditHandle elevationPointHandle, Observable<Polyline> polyline, long pointIndex, FeatureEditContext context) Returns true if the given handle is still valid, or false if it should be removed.
boolean	isInsertPointHandleValid(IEditHandle insertPointHandle, Observable<Polyline> polyline, long insertIndex, FeatureEditContext context) Returns true if the given handle is still valid, or false if it should be removed.
boolean	isMovePointHandleValid(IEditHandle movePointHandle, Observable<Polyline> polyline, long pointIndex, FeatureEditContext context) Returns true if the given handle is still valid, or false if it should be removed.
boolean	isPrependPointHandleValid(IEditHandle prependPointHandle, Observable<Polyline> polyline, FeatureEditContext context) Returns true if the given handle is still valid, or false if it should be removed.
boolean	isRemovePointHandleValid(IEditHandle removePointHandle, Observable<Polyline> polyline, long pointIndex, FeatureEditContext context) Returns true if the given handle is still valid, or false if it should be removed.

Method Detail

createMovePointHandle

@Nullable
IEditHandle createMovePointHandle(@NotNull
                                            Observable<Polyline> polyline,
                                            long pointIndex,
                                            @NotNull
                                            IPointEditAction editAction,
                                            @NotNull
                                            FeatureEditContext context)

Creates a handle that allows you to move a point of the Polyline.

While the handle is not already present, this method is called whenever the edited geometry changes.

Parameters:

polyline - the Geometry that is being edited

pointIndex - the index of the point to move

editAction - the move-point edit action, to be used by the handle. If a constraint was configured on the handles provider, this action applies that constraint when it is executed, providing a PolylineChange parameter with one moved point index.

context - the context

Returns:

a new handle, or null if no handle should be used

isMovePointHandleValid

boolean isMovePointHandleValid(@NotNull
                               IEditHandle movePointHandle,
                               @NotNull
                               Observable<Polyline> polyline,
                               long pointIndex,
                               @NotNull
                               FeatureEditContext context)

Returns true if the given handle is still valid, or false if it should be removed.

This method is called whenever the edited geometry changes and allows the factory to dynamically disable or re-create specific edit handles. When this method returns false, the handle is removed and createMovePointHandle is called, in case the handle should immediately be re-created. If the handle should remain absent, make sure to also return null in that method.

Parameters:

movePointHandle - the handle

polyline - the Geometry that is being edited

pointIndex - the index of the point

context - the context

Returns:

true if the given handle is still valid, or false if it should be removed.

createRemovePointHandle

@Nullable
IEditHandle createRemovePointHandle(@NotNull
                                              Observable<Polyline> polyline,
                                              long pointIndex,
                                              @NotNull
                                              IPointEditAction editAction,
                                              @NotNull
                                              FeatureEditContext context)

Creates a handle that allows you to remove a point of the Polyline.

While the handle is not already present, this method is called whenever the edited geometry changes.

Parameters:

polyline - the Geometry that is being edited

pointIndex - the index of the point to remove

editAction - the remove-point edit action, to be used by the handle. If a constraint was configured on the handles provider, this action applies that constraint when it is executed, providing a PolylineChange parameter with one removed point index.

context - the context

Returns:

a new handle, or null if no handle should be used

isRemovePointHandleValid

boolean isRemovePointHandleValid(@NotNull
                                 IEditHandle removePointHandle,
                                 @NotNull
                                 Observable<Polyline> polyline,
                                 long pointIndex,
                                 @NotNull
                                 FeatureEditContext context)

Returns true if the given handle is still valid, or false if it should be removed.

This method is called whenever the edited geometry changes and allows the factory to dynamically disable or re-create specific edit handles. When this method returns false, the handle is removed and createRemovePointHandle is called, in case the handle should immediately be re-created. If the handle should remain absent, make sure to also return null in that method.

Parameters:

removePointHandle - the handle

polyline - the Geometry that is being edited

pointIndex - the index of the point

context - the context

Returns:

true if the given handle is still valid, or false if it should be removed.

createElevationPointHandle

@Nullable
IEditHandle createElevationPointHandle(@NotNull
                                                 Observable<Polyline> polyline,
                                                 long pointIndex,
                                                 @NotNull
                                                 IPointEditAction editAction,
                                                 @NotNull
                                                 FeatureEditContext context)

Creates a handle that allows you to change the elevation of the point of a Polyline.

This method is only called when a 3D Map is used. While the handle is not already present, this method is called whenever the edited geometry changes.

Parameters:

polyline - the Geometry that is being edited

pointIndex - the index of the point to move/remove

editAction - the move-point edit action, to be used by the handle. If a constraint was configured on the handles provider, this action applies that constraint when it is executed, providing a PolylineChange parameter with one moved point index.

context - the context

Returns:

a new handle, or null if no handle should be used

isElevationPointHandleValid

boolean isElevationPointHandleValid(@NotNull
                                    IEditHandle elevationPointHandle,
                                    @NotNull
                                    Observable<Polyline> polyline,
                                    long pointIndex,
                                    @NotNull
                                    FeatureEditContext context)

Returns true if the given handle is still valid, or false if it should be removed.

This method is called whenever the edited geometry changes and allows the factory to dynamically disable or re-create specific edit handles. When this method returns false, the handle is removed and createElevationPointHandle is called, in case the handle should immediately be re-created. If the handle should remain absent, make sure to also return null in that method.

Parameters:

elevationPointHandle - the handle

polyline - the Geometry that is being edited

pointIndex - the index of the point

context - the context

Returns:

true if the given handle is still valid, or false if it should be removed.

createInsertPointHandle

@Nullable
IEditHandle createInsertPointHandle(@NotNull
                                              Observable<Polyline> polyline,
                                              long insertIndex,
                                              @NotNull
                                              IPointEditAction editAction,
                                              @NotNull
                                              FeatureEditContext context)

Creates a handle that allows you to insert a new point between two existing points of a Polyline.

While the handle is not already present, this method is called whenever the edited geometry changes.

Parameters:

polyline - the Geometry that is being edited

insertIndex - the index at which to insert a point in the Polyline. After the point is inserted, the new point will have this index. Values lie within [1, pointCount - 1]

editAction - the edit action that inserts the point. If a constraint was configured on the handles provider, this action applies that constraint when it is executed, providing a PolylineChange parameter with one inserted point index.

context - the context

Returns:

a new handle, or null if no handle should be used

isInsertPointHandleValid

boolean isInsertPointHandleValid(@NotNull
                                 IEditHandle insertPointHandle,
                                 @NotNull
                                 Observable<Polyline> polyline,
                                 long insertIndex,
                                 @NotNull
                                 FeatureEditContext context)

Returns true if the given handle is still valid, or false if it should be removed.

This method is called whenever the edited geometry changes and allows the factory to dynamically disable or re-create specific edit handles. When this method returns false, the handle is removed and createInsertPointHandle is called, in case the handle should immediately be re-created. If the handle should remain absent, make sure to also return null in that method.

Parameters:

insertPointHandle - the handle

polyline - the Geometry that is being edited

insertIndex - the insertion index

context - the context

Returns:

true if the given handle is still valid, or false if it should be removed.

createPrependPointHandle

@Nullable
IEditHandle createPrependPointHandle(@NotNull
                                               Observable<Polyline> polyline,
                                               @NotNull
                                               IPointEditAction editAction,
                                               @NotNull
                                               FeatureEditContext context)

Creates a handle that allows you to insert a new point at the start of a Polyline.

While the handle is not already present, this method is called whenever the edited geometry changes.

Parameters:

polyline - the Geometry that is being edited

editAction - the edit action that inserts the point at the start of the polyline. If a constraint was configured on the handles provider, this action applies that constraint when it is executed, providing a PolylineChange parameter with one inserted point index equal to 0.

context - the context

Returns:

a new handle, or null if no handle should be used

isPrependPointHandleValid

boolean isPrependPointHandleValid(@NotNull
                                  IEditHandle prependPointHandle,
                                  @NotNull
                                  Observable<Polyline> polyline,
                                  @NotNull
                                  FeatureEditContext context)

Returns true if the given handle is still valid, or false if it should be removed.

This method is called whenever the edited geometry changes and allows the factory to dynamically disable or re-create specific edit handles. When this method returns false, the handle is removed and createPrependPointHandle is called, in case the handle should immediately be re-created. If the handle should remain absent, make sure to also return null in that method.

Parameters:

prependPointHandle - the handle

polyline - the Geometry that is being edited

context - the context

Returns:

true if the given handle is still valid, or false if it should be removed.

createAppendPointHandle

@Nullable
IEditHandle createAppendPointHandle(@NotNull
                                              Observable<Polyline> polyline,
                                              @NotNull
                                              IPointEditAction editAction,
                                              @NotNull
                                              FeatureEditContext context)

Creates a handle that allows you to insert a new point at the end of a Polyline.

While the handle is not already present, this method is called whenever the edited geometry changes.

Parameters:

polyline - the Geometry that is being edited

editAction - the edit action that inserts the point at the end of the polyline. If a constraint was configured on the handles provider, this action applies that constraint when it is executed, providing a PolylineChange parameter with one inserted point index equal to pointCount (of the new polyline).

context - the context

Returns:

a new handle, or null if no handle should be used

isAppendPointHandleValid

boolean isAppendPointHandleValid(@NotNull
                                 IEditHandle appendPointHandle,
                                 @NotNull
                                 Observable<Polyline> polyline,
                                 @NotNull
                                 FeatureEditContext context)

Returns true if the given handle is still valid, or false if it should be removed.

This method is called whenever the edited geometry changes and allows the factory to dynamically disable or re-create specific edit handles. When this method returns false, the handle is removed and createAppendPointHandle is called, in case the handle should immediately be re-created. If the handle should remain absent, make sure to also return null in that method.

Parameters:

appendPointHandle - the handle

polyline - the Geometry that is being edited

context - the context

Returns:

true if the given handle is still valid, or false if it should be removed.