Package 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 Details

    • createMovePointHandle

      @Nullable IEditHandle createMovePointHandle(@NotNull Observable<@Nullable 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<@Nullable 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<@Nullable 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<@Nullable 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<@Nullable 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<@Nullable 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.