Class: AbstractTool

• new AbstractTool(layer?, name?)

Creates AbstractTool

EventDispatcher.constructor

• new AbstractTool(name?)

Creates AbstractTool

EventDispatcher.constructor

• new AbstractTool(options?)

Creates AbstractTool

EventDispatcher.constructor

• new AbstractTool(slots?, name?)

Creates AbstractTool

EventDispatcher.constructor

▸ addListener(eventName, listener): AbstractTool

add event listener. The listener receives the message when the system event happens.

Deprecated

since 4.0 use .on() instead. Note that 3 args callback should be used in subscription via .on(): (eventType, source, args)

AbstractTool

▸ captureMouseUp(): void

listen to window mouse events in order to catch a mouse up action outside of the tool container DOM element. useful for example when you pan and release click outside of DOM element.

void

▸ dispose(): void

Dispose tool.

void

EventDispatcher.dispose

▸ fireEvent(eventName, eventArgs?): void

This method is Protected. Fire an Event.

Deprecated

since 4.0 use .notify() instead. Note that 3 args callback should be used in subscription via .on()

void

▸ getClassName(): string

string

EventDispatcher.getClassName

▸ Protected getEventRadius(eventArgs): number

Returns device radius for the provided event

number

▸ getManipulatorLayer(): CompositeNode<Node>

return manipulator layer

CompositeNode<Node>

layer

▸ getMouseRadius(): number

Returns current device radius for mouse events

number

▸ getName(): string

return tool name if any

string

name of the tool

ITool.getName

▸ getParentTool(): AbstractCompositeTool

Gets parent tool

AbstractCompositeTool

parent tool

ITool.getParentTool

▸ getProperties(context?): OptionsOut

Returns all the properties pertaining to this object

OptionsOut

An object containing the properties

▸ getProperty(name): any

Gets dynamic property by name. These properties can be used as a property bags

any

▸ getPropertyKeys(): string[]

Returns known properties keys

string[]

▸ getRoot(): AbstractCompositeTool

Gets root tool

AbstractCompositeTool

parent tool

▸ getTouchRadius(): number

Returns current device radius for touch events

number

▸ hasEventListener(type, callback?): boolean

Check if a list of event listeners for this type contains this listener

boolean

EventDispatcher.hasEventListener

▸ isActive(): boolean

return active state

boolean

▸ isDisposed(): boolean

Returns whether this object has been disposed

boolean

EventDispatcher.isDisposed

▸ Protected isDoubleClick(point, eventArgs?): boolean

returns true if double clicked

boolean

▸ isEnabled(): boolean

returns enable state

boolean

state

ITool.isEnabled

▸ isSilent(): boolean

Return true if the event dispatcher doesn't notify any events

boolean

EventDispatcher.isSilent

▸ isTouchEvent(eventArgs): boolean

return true if the event is a touch event and false otherwise.

boolean

▸ notify<E>(type, source, args?): AbstractTool

Notify listeners

AbstractTool

this

EventDispatcher.notify

▸ off<E>(type?, callback?): AbstractTool

Detach listener on event. Calling .off() with no arguments removes all attached listeners. Calling .off(type) with no callback removes all attached listeners for specific type.

AbstractTool

this

EventDispatcher.off

▸ on<E>(type, callback): AbstractTool

Attach listener on event that will be called whenever the specified event is delivered to the target

If the callback function is already in the list of event listeners for this target, the function is not added a second time.

If a particular anonymous function is in the list of event listeners registered for a certain target, and then later in the code, an identical anonymous function is given in an "on" call, the second function will also be added to the list of event listeners for that target.

Example

// Using in derived tool
import type {EventMap as EventMapBase} from '@int/geotoolkit/controls/tools/AbstractTool';
export type EventMap = EventMapBase & {
[MyToolEvents.onValueChanged]: MyToolEventArgs
}
export enum MyToolEvents {
onValueChanged = 'onValueChanged'
}
export class MyTool extends AbstractTool {
public declare on: <E extends keyof EventMap>(type: E, callback: (eventType: E, sender: this, args: EventMap[E]) => void) => this;
protected declare notify: <E extends keyof EventMap>(type: E, source: AbstractTool, args?: EventMap[E]) => this;
public declare off: <E extends keyof EventMap>(type: E, callback?: (eventType: E, sender: this, args: EventMap[E]) => void) => this;
// ...
}

AbstractTool

EventDispatcher.on

▸ Protected onActiveStateChanged(): void

Fires

Events.onStateChanged

void

▸ Protected onEnabledStateChanged(): void

Fires

Events.onEnabledStateChanged

void

▸ pageToCanvas(eventArgs, externalPlot?): Object

return position relative to the canvas

Object

▸ pointToModel(model, eventArgs): Point

converts device coordinates to inner coordinates of node

Point

▸ removeListener(eventName, listener?): AbstractTool

remove event listener. The listener reveives the message when the system event happens.

Deprecated

since 4.0 use .off() instead.

AbstractTool

▸ setActive(active): AbstractTool

set active state

Fires

Events.onStateChanged

AbstractTool

▸ setEnabled(enabled): AbstractTool

set enable state

Fires

Events.onEnabledStateChanged

Fires

Events.onStateChanged

AbstractTool

this

ITool.setEnabled

▸ setMouseRadius(radius): AbstractTool

Sets device radius for mouse events

AbstractTool

this

▸ setName(name): AbstractTool

set tool name

AbstractTool

▸ setProperties(properties?, context?): AbstractTool

Sets all the properties pertaining to this object

AbstractTool

this

▸ setProperty(name, value): AbstractTool

Sets dynamic property by name

AbstractTool

this

▸ setSilent(bool): AbstractTool

Set silent mode

AbstractTool

this

EventDispatcher.setSilent

▸ setSlotEnabled(eventName, value, target?): AbstractTool

Sets slot enabled

AbstractTool

▸ setSlots(slots?, merge?): AbstractTool

Sets new slots.

Example

const slots = {
'pointerdown': (event: EventArgs) => {
// event is an instance of @int/geotoolkit/controls/tools/EventArgs
...
}
};
tool.setSlots(slots);

AbstractTool

this

▸ setTouchRadius(radius): AbstractTool

Sets device radius for touch events

AbstractTool

this

▸ Protected start(eventArgs?): AbstractTool

start

AbstractTool

▸ Protected stop(): AbstractTool

stop

AbstractTool

▸ toggle(): AbstractTool

switch enable state to opposite state

AbstractTool

▸ Static canvasToClient(plotPoint, plot): Point

Convert plot coordinates to global coordinates

Point

▸ Static clientToCanvas(nativeEvent, plot): Point

Convert global coordinates to plot coordinates

Point

▸ Static getClassName(): string

string

EventDispatcher.getClassName

▸ Static getExclusiveTool(plot): AbstractTool

return exclusive tool associated with plot

AbstractTool

tool

▸ Static getNativeEventName(eventName): string[]

Returns native event name

string[]

▸ Static isTouchEvent(eventArgs): eventArgs is TouchEvent

return true if the event is a touch event and false otherwise.

eventArgs is TouchEvent

▸ Static lock(plot, tool): void

Set exclusive tool for plot

void

▸ Static setDefaultMouseRadius(radius): void

Sets default device radius for mouse events

void

▸ Static setDefaultTouchRadius(radius): void

Sets default device radius for touch events

void

▸ Static unlock(value): void

Remove exclusive tool from plot

void