Optionaloptions: PickControllerConstructorOptionsWhether picking should be performed asynchronously.
When set to true, picking will be performed asynchronously, using getCandidatesAsync.
When set to false, picking will be performed synchronously, using getCandidates.
Asynchronous picking is the default and recommended way of picking on TileSet3DLayer.
If you do want to force synchronous picking on 3D layers, you can set TileSet3DLayerConstructorOptions.synchronousPicking to true.,
For FeatureLayer, synchronous picking is usually fast enough, so asynchronous picking is not required.
Note that when async is enabled, onGestureEvent will always return HandleEventResult.EVENT_IGNORED, regardless of handleCandidates's return value.
By default, this is set to false.
ProtectedcursorThe CSS cursor to use on the map, for this controller.
If null, the map will fall back to the previous cursor that was set on the map.
Note that changing this cursor will update the cursor on the map's DOM node. When using multiple controllers (e.g. in a CompositeController), the controller that updates the cursor last (to a non-null value), will override any other non-null cursors of active controllers on the map.
A hook to customize synchronous retrieval of candidates at a certain pixel point. The default implementation returns the closest object under the pixel point, using Map.pickAt.
This method is only called when async is set to false.
The point to query, as returned by getPickPoint
The sensitivity to pick the map with, as returned by getSensitivity
Whether or not to consider multiple candidates, cf. isPickMultiple
A hook to customize asynchronous retrieval of candidates at a certain pixel point. The default implementation returns the closest object under the pixel point, using Map.pickAtAsync.
This method is only called when async is set to true.
The point to query, as returned by getPickPoint
The sensitivity to pick the map with, as returned by getSensitivity
Whether or not to consider multiple candidates, cf. isPickMultiple
A hook to customize the paint representations used to pick the map.
The default implementation always returns a list of PaintRepresentation.BODY
The event to determine paint representations for
A hook to customize at which (pixel) point the map is picked. By default, GestureEvent.viewPoint is returned.
The (pixel) point to pick the map at
A hook to customize the sensitivity of a pick event. The sensitivity is the number of pixels 'padded' around the event's location used to retrieve candidates.
The default behavior returns a small sensitivity for mouse events, and a larger sensitivity for touch events. The type of event is determined by GestureEvent.inputType.
The event to determine sensitivity for
A hook to customize what happens with the list of candidates, retrieved by getCandidates.
Examples:
Note that when async is enabled, onGestureEvent will always return HandleEventResult.EVENT_IGNORED, regardless of handleCandidates's return value.
The gesture event for which the list of candidates was retrieved
The candidates, as returned by getCandidates
Call this method to indicate that the controller's appearance has changed. Calling this method ensures the onDraw will be called during the next rendering pass.
A hook to determine if an event is a hover event. The default implementation checks if it is a GestureEventType.MOVE event and that it's a mouse event.
The event to check
Indicates whether getCandidates should consider multiple candidates.
When this returns false, getCandidates stops when it has found the first (closest) feature.
Picking the closest feature is faster than considering multiple candidates.
By default, this returns false.
The event that triggers the pick
Callback that is invoked when this controller is activated on a map. This method allows controller implementations to perform setup work.
the map on which the controller has been activated
Callback that is invoked when this controller is deactivated on a map. This method allows controller implementations to perform cleanup work. This method must return either any resolved value or a promise to indicate completion of deactivation. This allows controller implementation to perform asynchronous deactivation work. During the period between this method being called and the resolution of the deactivation promise, this controller will no longer receive input events, but will still get the opportunity to draw itself.
the map on which the controller has been deactivated
a concrete value to indicate immediate deactivation or a deactivation promise.
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.
the GeoCanvas on which the controller can draw shapes.
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.
the LabelCanvas on which the controller can draw labels.
Called when a gesture event has been received. This is not intended to be overridden by subclasses. You should override the hooks instead (isPickEvent, isPickMultiple, getSensitivity, getPickPoint, getPaintRepresentations, getCandidates and handleCandidates).
Note that when async is enabled, onGestureEvent will always return HandleEventResult.EVENT_IGNORED, regardless of handleCandidates's return value.
The gesture event to handle
Called when a key 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 key event behaviour. If default event handling is not desired, this method should return EVENT_HANDLED. (See the Controller class description for the default behavior.)
The key event to be handled. Note that this is a KeyEvent and not a DOMEvent. You can access the corresponding DOMEvent through KeyEvent.domEvent.
The key event handling result.
An event that fires whenever async changes.
Optionalcontext: anyController.on AsyncChanged
Optionalcontext: anyController.on Invalidated
Optionalcontext: anyController.on Activated
Optionalcontext: anyController.on Deactivated
A controller that allows the user to hover objects on the map.
Note that FeatureLayer.hoverable needs to be enabled as well, for hovering to work.
This controller only handles mouse events.
Note that this controller consumes GestureEventType.MOVE events. Controllers down the chain (see CompositeController), might also consume MOVE events, for example to update an icon under mouse. Because of this, it's recommended to put this controller after other controllers.
For a list of events handled by this controller, see isPickEvent.
You can customize this controller's behavior by overriding its hooks:
When customizing a HoverController, consider doing the same customizations to SelectController. This ensures that hovering and selection are consistent. Objects that are hovered, are also selection candidates.
See the Managing user input with LuciadRIA controllers tutorial for more information.
Since
2022.1