An edit handle manipulates a feature or some part of that feature, usually its shape, based on input from the user.

Edit handles are created by an CreateController becomes active on the map.

Edit handles generally correspond to the shape of the feature being edited. For example, to edit a four-sided polygon, an Editor creates five handles: four to move each of the individual vertices of the polygon, and a fifth one to move the polygon as a whole.

For more information, check out the Customizing creation and editing guide.

Since

2022.1

Hierarchy (view full)

Constructors

Accessors

Methods

  • Emits an "EditShape" event.

    Typically, a handle emits this right after changing the shape.

    Parameters

    Returns void

  • Returns the mouse cursor to show.

    CreateController will check the active handle's cursor on every map's cursor when the returned cursor string changes.

    The default implementation always returns null.

    Parameters

    Returns null | string

    a cursor, or null if no mouse cursor should be shown for this handle.

  • Invalidates this edit handle.

    This will cause onDraw and onDrawLabel to be called again.

    Use this if you need to update the visualization of the handle. For example, the handle has changed style and onDraw needs to be re-evaluated.

    Returns void

    Since

    2024.0.02

  • Populates a context menu with entries.

    For example, a handle for a point in a polyline might add a "Delete point" context menu entry.

    Parameters

    • event: GestureEvent

      the input event that triggered opening the context menu.

    • context: EditContext

      the edit context

    • contextMenu: ContextMenu

      the context menu to add entries to.

    • onDone: (() => void)

      a callback that needs to be called when a menu action is performed. Call this at the end of the ContextMenuItem.action implementation.

        • (): void
        • Returns void

    Returns void

  • This method allows the handle to draw shapes on the map.

    For example, a point handle draws an icon at its point using EditHandleStyles.handleIconStyle.

    A handle can also draw "helper" shapes. These are shapes that are not interactive, but help the user while editing. For example, the base shape of an extruded shape, draped over terrain. Or lines showing how a point can move.

    For consistency with built-in handles, it's recommended to draw helper shapes using EditHandleStyles.handleIconStyle.

    The default implementation draws nothing.

    Parameters

    Returns void

  • This method allows the handle to draw labels on the map.

    For example, you can use this to show coordinates of points, or the current radius of a circle on top of an edit handle.

    The default implementation draws nothing.

    Parameters

    Returns void

  • Indicates whether the feature being created or edited, should be painted by the controller. The feature is painted using the layer's painter.

    For handles used in editing, this is typically always true. For handles used in creation, this typically returns false in the early steps of the creation process. For example, when the user is still choosing a location for a point (before the first click).

    Parameters

    Returns boolean

    Since

    2024.0

  • Called when (another) handle changes the feature or shape, as indicated by the "EditShape" event.

    This handle can update its own state, based on the changed shape.

    For example, a PointListInsertHandle just inserted a point in a polyline. The PointListTranslateHandle uses the update to recalculate new sub-handles, based on the new polyline (with the extra point).

    The default implementation does nothing.

    Returns void

Events

"EditShape" event

  • on("EditShape", callback: ((event) => void)) : Handle
  • An event that is emitted whenever this handle changes the shape of a feature.

    EditShape

    Parameters

    • event: "EditShape"
    • callback: ((event) => void)

    Returns Handle

"Invalidated" event

  • on("Invalidated", callback: (() => void)) : Handle
  • An event that is emitted whenever this handle is invalidated.

    Invalidated

    Parameters

    • event: "Invalidated"
    • callback: (() => void)
        • (): void
        • Returns void

    Returns Handle