Class: Polyline

• new Polyline(options)

• new Polyline(options?)

AbstractPointSetEditor<PolylineShape>.constructor

▸ addListener(eventName, listener): Polyline

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)

Polyline

AbstractPointSetEditor.addListener

▸ addPointAt(index, eventArgs?): Polyline

Start to add joint point at specified node index (can be 0 or end index)

Polyline

this

▸ apply(command): Polyline

Applies command to the current node

Polyline

this

AbstractPointSetEditor.apply

▸ Protected canInsert(eventArgs): boolean

Determines if the editor can insert a new node at the point

boolean

AbstractPointSetEditor.canInsert

▸ canRedo(): boolean

Checks if there is command in history to redo

boolean

AbstractPointSetEditor.canRedo

▸ canUndo(): boolean

Checks if there is command in history to undo

boolean

AbstractPointSetEditor.canUndo

▸ 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

AbstractPointSetEditor.captureMouseUp

▸ changeNodeOrder(order, anchor?): Polyline

changes the z-order of the nodes being rendered.

Polyline

this

AbstractPointSetEditor.changeNodeOrder

▸ close(): Polygon

Convert active shape to Polygon

Polygon

▸ Protected createGhost(): Node

Creates a clone of the current node

Node

AbstractPointSetEditor.createGhost

▸ deleteNode(trash?, shape?): Polyline

Delete node or array of nodes to specified trash container

Polyline

this

AbstractPointSetEditor.deleteNode

▸ deletePointAt(index): Polyline

Delete joint point at specified index

Polyline

this

AbstractPointSetEditor.deletePointAt

▸ dispose(): void

Dispose tool.

void

AbstractPointSetEditor.dispose

▸ Protected end(eventArgs): void

Ends current node creation, fires the corresponding event and clones new empty node for the new creation

void

AbstractPointSetEditor.end

▸ 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

AbstractPointSetEditor.fireEvent

▸ flipNodeOrientation(flipX, flipY): Polyline

Flip node vertically and/or horizontally

Polyline

this

AbstractPointSetEditor.flipNodeOrientation

▸ getActiveHandle(): number

Returns active handle index

number

active handle index if any

AbstractPointSetEditor.getActiveHandle

▸ getActiveNode(): Node

Returns the ghost if ghost mode is enabled and initialized and the original node otherwise

Node

AbstractPointSetEditor.getActiveNode

▸ Protected getActivePlot(): Plot

Gets an active plot

Plot

AbstractPointSetEditor.getActivePlot

▸ Protected getBboxHandle(eventArgs?): EditHandleId

Returns current bounding box handle if no arguments provided, or bounding box element index that is currently under mouse event, null if nothing is

EditHandleId

AbstractPointSetEditor.getBboxHandle

▸ getBounds(): Rect

Returns bounds for the bounding box elements

Rect

AbstractPointSetEditor.getBounds

▸ getClassName(): string

string

AbstractPointSetEditor.getClassName

▸ Protected getDataLayer(): Node

Gets the edited nodes' parent layer

Node

AbstractPointSetEditor.getDataLayer

▸ getDeviceTransform(): Transformation

Returns current node-to-device transformation

Transformation

AbstractPointSetEditor.getDeviceTransform

▸ getEditMode(): EditMode

Returns current edit mode

EditMode

AbstractPointSetEditor.getEditMode

▸ Protected getEventRadius(eventArgs): number

Returns device radius for the provided event

number

AbstractPointSetEditor.getEventRadius

▸ Protected getGhost(): Node

Returns the ghost registered with this editor. If ghost does not exist, returns null

Node

AbstractPointSetEditor.getGhost

▸ getHandlesGroup(): Group<Node>

Returns handles group

Group<Node>

AbstractPointSetEditor.getHandlesGroup

▸ getHistory(): History

Returns current history

History

AbstractPointSetEditor.getHistory

▸ Protected getLocalTransform(): Transformation

Returns current node local transformation

Transformation

AbstractPointSetEditor.getLocalTransform

▸ getManipulatorLayer(): CompositeNode<Node>

return manipulator layer

CompositeNode<Node>

layer

AbstractPointSetEditor.getManipulatorLayer

▸ getMouseRadius(): number

Returns current device radius for mouse events

number

AbstractPointSetEditor.getMouseRadius

▸ getName(): string

return tool name if any

string

name of the tool

AbstractPointSetEditor.getName

▸ getNode(): Polyline

Returns current node

Polyline

AbstractPointSetEditor.getNode

▸ getParentTool(): AbstractCompositeTool

Gets parent tool

AbstractCompositeTool

parent tool

AbstractPointSetEditor.getParentTool

▸ getProperties(): OptionsOut

Returns properties to the editing elements

OptionsOut

editor properties

AbstractPointSetEditor.getProperties

▸ getProperty(name): any

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

any

AbstractPointSetEditor.getProperty

▸ getPropertyKeys(): string[]

Returns known properties keys

string[]

AbstractPointSetEditor.getPropertyKeys

▸ getRoot(): AbstractCompositeTool

Gets root tool

AbstractCompositeTool

parent tool

AbstractPointSetEditor.getRoot

▸ getTouchRadius(): number

Returns current device radius for touch events

number

AbstractPointSetEditor.getTouchRadius

▸ Protected getVisible(): boolean

Gets the edited node visibility state

boolean

AbstractPointSetEditor.getVisible

▸ hasEventListener(type, callback?): boolean

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

boolean

AbstractPointSetEditor.hasEventListener

▸ Protected initialize(options): void

void

AbstractPointSetEditor.initialize

▸ isActive(): boolean

return active state

boolean

AbstractPointSetEditor.isActive

▸ isDisposed(): boolean

Returns whether this object has been disposed

boolean

AbstractPointSetEditor.isDisposed

▸ Protected isDoubleClick(point, eventArgs?): boolean

returns true if double clicked

boolean

AbstractPointSetEditor.isDoubleClick

▸ isEnabled(): boolean

returns enable state

boolean

state

AbstractPointSetEditor.isEnabled

▸ isEndHandle(handle): boolean

Checks if current node handle should end node creation

boolean

AbstractPointSetEditor.isEndHandle

▸ isSilent(): boolean

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

boolean

AbstractPointSetEditor.isSilent

▸ isStarted(): boolean

Tests if editing was started (editor is active and at least one command was applied)

boolean

AbstractPointSetEditor.isStarted

▸ Protected isSupported(options): boolean

Checks if editor supports the options provided

boolean

AbstractPointSetEditor.isSupported

▸ isTouchEvent(eventArgs): boolean

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

boolean

AbstractPointSetEditor.isTouchEvent

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

Notify listeners

Polyline

this

AbstractPointSetEditor.notify

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

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.

Polyline

this

AbstractPointSetEditor.off

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

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;
// ...
}

Polyline

AbstractPointSetEditor.on

▸ Protected onActiveStateChanged(): void

Fires

Events.onStateChanged

void

AbstractPointSetEditor.onActiveStateChanged

▸ Protected onBeforeCommandApplied(command): void

Fires the EditEvents.BeforeCommandApplied event

void

AbstractPointSetEditor.onBeforeCommandApplied

▸ Protected onCommandApplied(command): void

Fires the EditEvents.CommandApplied and the command.getEventName() events

void

AbstractPointSetEditor.onCommandApplied

▸ Protected onCommandApplying(command): void

Fires the EditEvents.CommandApplying event

void

AbstractPointSetEditor.onCommandApplying

▸ Protected onCommandRedo(command): void

Fires the EditEvents.Redo event

void

AbstractPointSetEditor.onCommandRedo

▸ Protected onCommandUndo(command): void

Fires the EditEvents.Undo event

void

AbstractPointSetEditor.onCommandUndo

▸ Protected onDoubleClick(eventArgs): void

Handles mouse double click event

void

AbstractPointSetEditor.onDoubleClick

▸ Protected onEnabledStateChanged(): void

Fires

Events.onEnabledStateChanged

void

AbstractPointSetEditor.onEnabledStateChanged

▸ Protected onKeyDown(eventArgs): void

Handles key down event

void

AbstractPointSetEditor.onKeyDown

▸ Protected onKeyUp(eventArgs): void

Handles key up event

void

AbstractPointSetEditor.onKeyUp

▸ Protected onLeave(eventArgs): void

Handles mouse leave event

void

AbstractPointSetEditor.onLeave

▸ Protected onMouseDown(eventArgs): void

Handles mouse down event

void

AbstractPointSetEditor.onMouseDown

▸ Protected onMouseMove(eventArgs): void

Handles mouse move event

void

AbstractPointSetEditor.onMouseMove

▸ Protected onMouseUp(eventArgs): void

Handles mouse up event

void

AbstractPointSetEditor.onMouseUp

▸ Protected onNodeCreated(node, eventArgs?): void

Fires the EditEvents.End event

void

AbstractPointSetEditor.onNodeCreated

▸ pageToCanvas(eventArgs, externalPlot?): Object

return position relative to the canvas

Object

AbstractPointSetEditor.pageToCanvas

▸ pointToModel(model, eventArgs): Point

converts device coordinates to inner coordinates of node

Point

AbstractPointSetEditor.pointToModel

▸ Protected push(command): Polyline

Pushes command to the history after applying it and firing the corresponding event

Polyline

this

AbstractPointSetEditor.push

▸ redo(): Polyline

Reapplies last canceled command in history (if possible)

Polyline

this

AbstractPointSetEditor.redo

▸ removeListener(eventName, listener?): Polyline

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

Deprecated

since 4.0 use .off() instead.

Polyline

AbstractPointSetEditor.removeListener

▸ Protected resetNode(unlink?): Polyline

Resets current node to the initial state before all the changes were made

Polyline

this

AbstractPointSetEditor.resetNode

▸ Protected resetNodeToGhost(): Polyline

Resets the current node to its ghost state

Polyline

AbstractPointSetEditor.resetNodeToGhost

▸ Protected rotateNode(node, angle, hint?): boolean

boolean

AbstractPointSetEditor.rotateNode

▸ setActive(active): Polyline

set active state

Fires

Events.onStateChanged

Polyline

AbstractPointSetEditor.setActive

▸ setActiveHandle(handle): Polyline

Set active handle index

Polyline

this

AbstractPointSetEditor.setActiveHandle

▸ Protected setCoordinates(node, x, y): Polyline

Sets coordinates to the specified point set

Polyline

AbstractPointSetEditor.setCoordinates

▸ setEditMode(mode): Polyline

Sets edit mode to determine operations that can be applied to the current node. Use bitwise operations for the full customization.

Polyline

this

AbstractPointSetEditor.setEditMode

▸ setEnabled(enabled): Polyline

set enable state

Fires

Events.onEnabledStateChanged

Fires

Events.onStateChanged

Polyline

this

AbstractPointSetEditor.setEnabled

▸ setMouseRadius(radius): Polyline

Sets device radius for mouse events

Polyline

this

AbstractPointSetEditor.setMouseRadius

▸ setName(name): Polyline

set tool name

Polyline

AbstractPointSetEditor.setName

▸ Protected setNode(node): Polyline

Sets node to edit

Polyline

this

AbstractPointSetEditor.setNode

▸ Protected setNodeBounds(node, p1, p2, hint?): boolean

boolean

AbstractPointSetEditor.setNodeBounds

▸ setProperties(properties?): Polyline

Sets properties to the editing elements

Polyline

this

AbstractPointSetEditor.setProperties

▸ setProperty(name, value): Polyline

Sets dynamic property by name

Polyline

this

AbstractPointSetEditor.setProperty

▸ setSilent(bool): Polyline

Set silent mode

Polyline

this

AbstractPointSetEditor.setSilent

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

Sets slot enabled

Polyline

AbstractPointSetEditor.setSlotEnabled

▸ setSlots(slots?, merge?): Polyline

Sets new slots.

Example

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

Polyline

this

AbstractPointSetEditor.setSlots

▸ setTouchRadius(radius): Polyline

Sets device radius for touch events

Polyline

this

AbstractPointSetEditor.setTouchRadius

▸ Protected start(eventArgs?): Polyline

start

Polyline

AbstractPointSetEditor.start

▸ Protected stop(): Polyline

stop

Polyline

AbstractPointSetEditor.stop

▸ Protected swapActiveHandles(handleId, vertical): EditHandleId

Swaps active handles vertically/horizontally

EditHandleId

swapped handle id

AbstractPointSetEditor.swapActiveHandles

▸ toggle(): Polyline

switch enable state to opposite state

Polyline

AbstractPointSetEditor.toggle

▸ Protected transformNode(node, tr, hint?): boolean

boolean

AbstractPointSetEditor.transformNode

▸ Protected translateNode(node, x, y, hint?): boolean

boolean

AbstractPointSetEditor.translateNode

▸ undo(): Polyline

Cancels last command in history (if possible)

Polyline

this

AbstractPointSetEditor.undo

▸ update(): Polyline

Forces editing shapes and handles to be updated

Polyline

this

AbstractPointSetEditor.update

▸ Protected updateBrowserCursor(eventArgs, cursor?): void

void

AbstractPointSetEditor.updateBrowserCursor

▸ updateHandles(): Polyline

Forces editing handles to be updated

Polyline

this

AbstractPointSetEditor.updateHandles

▸ Protected updateNodePosition(): void

Updates active node's position if scene transformation was changed but pointer position wasn't

void

AbstractPointSetEditor.updateNodePosition

▸ Static canvasToClient(plotPoint, plot): Point

Convert plot coordinates to global coordinates

Point

AbstractPointSetEditor.canvasToClient

▸ Static clientToCanvas(nativeEvent, plot): Point

Convert global coordinates to plot coordinates

Point

AbstractPointSetEditor.clientToCanvas

▸ Static getClassName(): string

string

AbstractPointSetEditor.getClassName

▸ Static getExclusiveTool(plot): AbstractTool

return exclusive tool associated with plot

AbstractTool

tool

AbstractPointSetEditor.getExclusiveTool

▸ Static getNativeEventName(eventName): string[]

Returns native event name

string[]

AbstractPointSetEditor.getNativeEventName

▸ Static isTouchEvent(eventArgs): eventArgs is TouchEvent

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

eventArgs is TouchEvent

AbstractPointSetEditor.isTouchEvent

▸ Static lock(plot, tool): void

Set exclusive tool for plot

void

AbstractPointSetEditor.lock

▸ Static setDefaultMouseRadius(radius): void

Sets default device radius for mouse events

void

AbstractPointSetEditor.setDefaultMouseRadius

▸ Static setDefaultTouchRadius(radius): void

Sets default device radius for touch events

void

AbstractPointSetEditor.setDefaultTouchRadius

▸ Static unlock(value): void

Remove exclusive tool from plot

void

AbstractPointSetEditor.unlock