Class EditController

Creates a new edit controller

Return the editor used by this controller

The feature being edited by this controller.

The layer being edited by this controller.

Finishes the editing process.

This calls the onFinish hook and handles its result. The edit controller stays active. To deactivate, call:

map.controller = null.
Copy

Return the maximum number of points that should be allowed during editing.

Return the minimum number of points that should be allowed during editing.

Returns the settings configured on this EditController. These settings are passed to the EditContext.settings.

You can override this to add additional settings. For example, a custom constraint like a minimum and maximum radius of a circle. LuciadRIA will add these additional settings to EditContext.settings, which is passed to the EditHandles.

interface ConstrainedCircleEditorSettings2 extends EditSettings {
  minRadius: number;
  maxRadius: number;
}

class ConstrainedCircleEditController extends EditController {

  private readonly _minRadius: number;
  private readonly _maxRadius: number;

  constructor(layer: FeatureLayer, feature: Feature, minRadius: number, maxRadius: number) {
    super(layer, feature, {editor: new ConstrainedCircleEditor2()});
    this._minRadius = minRadius;
    this._maxRadius = maxRadius;
  }

  getSettings(): ConstrainedCircleEditorSettings2 {
    return {
      ...super.getSettings(),
      minRadius: this._minRadius,
      maxRadius: this._maxRadius
    };
  }
}

class ConstrainedCircleEditor2 extends CircleByCenterPointEditor {

  createRadiusHandle(context: EditContext): EditHandle {
    const settings = context.settings as ConstrainedCircleEditorSettings2;
    const circle = context.feature.shape as CircleByCenterPoint;

    const geodesy = (circle.reference?.referenceType === ReferenceType.GEODETIC)
                    ? createEllipsoidalGeodesy(circle.reference) : createCartesianGeodesy(circle.reference!);

    let radiusPointAzimuth = 90;
    return new PointDragHandle(
        (): Point => geodesy.interpolate(circle.center, circle.radius, radiusPointAzimuth),
        (point: Point): void => {
          const distance = geodesy.distance(circle.center, point);
          circle.radius = Math.max(settings.minRadius, Math.min(settings.maxRadius, distance));

          radiusPointAzimuth = geodesy.forwardAzimuth(circle.center, point);
        });
  }
}

const MIN_RADIUS = 1e3;
const MAX_RADIUS = 5e3;
map.controller = new ConstrainedCircleEditController(layer, feature, MIN_RADIUS, MAX_RADIUS);
Copy

Note in this case, it is important to also keep these default settings, because without them, the default editors might no longer work as expected. You can do that like this:

getSettings(): YourCustomSettings {
 return {
   ...super.getSettings(),
   yourCustomSetting: yourCustomValue,
 }
}
Copy

Your own custom settings should also extend the EditSettings

Callback that is invoked when this controller is activated on a map. This method allows controller implementations to perform setup work.

Called when the EditController deactivates.

This will return a Promise if there is an asynchronous WorkingSet.put operation on-going from onFinish. Otherwise, it will de-activate synchronously.

Callback that allows controller implementations to perform custom drawing on the map. Controller shapes and icons are drawn on top of all other content in the map. Note that the map may perform caching which may cause this method to only be invoked once. When a controller implementation's appearance changes the implementation should call invalidate on itself.

Callback that allows controller implementations to draw labels on the map. Note that the map may perform caching which may cause this method to only be invoked once. When a controller implementation's appearance changes the implementation should call invalidate on itself.

Called whenever an edit operation finishes.

By default, this calls WorkingSet.put on the layer's workingSet to update the feature in the layer/model. This will return a Promise if there is an asynchronous WorkingSet.put operation on-going.

Called when a gesture event has been received. This method must return a HandleEventResult value to indicate if the event was handled or not, If this method returns EVENT_IGNORED, the map will be given the opportunity to perform default gesture event behaviour. If default event handling is not desired, this method should return EVENT_HANDLED. (See the Controller class description for the default behavior.)

Immediately restarts editing for the given feature and layer. This can be used to force editing to a specific shape. For example, to apply an undo step or to synchronize the edited shape with coordinates from a form.

The feature that was currently being edited will not be updated in the model.

function synchronizeEditControllerWithForm() {
  const newShape = createShapeFromFormValues(); // implemented in your code
  feature.shape = newShape;
  editController.restart(feature, layer);
}
Copy

Set the minimum and maximum number of points that should be allowed during editing using this controller. Once the maximum number of points is reached, the controller will not allow insertion of new points. Once the minimum number of points is reached, the controller will not allow deletion of new points. Note that this method should be called before the edit controller is activated on the map, subsequent calls to this method will be ignored.

An event that fires whenever EditController.restart was called.

Use this event to get notified whenever something external (like an undoable) restarts this EditController (ie. changes its shape / feature).

An event that fires whenever the user edited the shape.

You can use this event to create "edit shape" undoables. See the Adding undo/redo support to your application guide for more information on how to work with undo/redo in LuciadRIA.

An event that fires whenever the user edits a property of the feature.

This event isn't fired by any of the default LuciadRIA edit handles, but a custom handle can emit an EditProperty event.

You can use this event to create "edit property" undoables. See the Adding undo/redo support to your application guide for more information on how to work with undo/redo in LuciadRIA.