AbstractWidget

Introduction

vtkAbstractWidget is an abstract class to construct a widget.

Methods

activateHandle

Activate a handle, identified by both a state and a representation.
Will also invoke appropriate events.

Argument Type Required Description
locator Yes An object describing the handle to activate.

deactivateAllHandles

Deactivate all the handles on the widget instance.

extend

Method used to decorate a given object (publicAPI+model) with vtkAbstractWidget characteristics.

Argument Type Required Description
publicAPI Yes object on which methods will be bounds (public)
model Yes object on which data structure will be bounds (protected)
initialValues Yes (default: {})

getBounds

Get the bounds of the widget

getContextVisibility

Get the context visibility.

getHandleVisibility

Returns true if the handles are visible, false otherwise.

getNestedProps

Get all representations of the widget.

getPlaceFactor

Get the place factor.

getRepresentationFromActor

Get the vtkWidgetRepresentation instance associated with the given vtkActor instance.

Argument Type Required Description
actor vtkProp Yes

getRepresentations

Get all the representations of the widget instance.

getViewWidgets

Get all the underlyings view widgets.

getWidgetManager

Get the widget manager associated with the widget instance.

getWidgetState

Get the the state of the widget instance.

grabFocus

Make the widget instance grab the focus.
Should not be called directly or this will lead to unexpected behavior.
To grab the focus on a widget, one should call vtkWidgetManager.grabFocus(widgetInstanceToGiveFocusTo)

hasActor

Returns true if the widget instance holds the given actor, false otherwise.

Argument Type Required Description
actor vtkProp Yes

hasFocus

Returns true if the widget instance holds the focus, false otherwise.

invokeActivateHandle

Invoke the ActivateHandle event with the given payload.

Argument Type Required Description
args Yes The event payload

loseFocus

Make the widget instance release the focus.

newInstance

Method used to create a new instance of vtkAbstractWidget

Argument Type Required Description
initialValues Yes For pre-setting some of its content

onActivateHandle

Register a callback to be invoked when the ActivateHandle event occurs.

Argument Type Required Description
cb EventHandler Yes The callback to register
priority Number No Priority of this subscription

placeWidget

Place a widget at the given bounds.

Argument Type Required Description
bounds Bounds Yes

setContextVisibility

Set the context visibility.

Argument Type Required Description
visible Boolean Yes

setHandleVisibility

Defines if the handles should be visible or not.

Argument Type Required Description
visible Boolean Yes

setPlaceFactor

Set the place factor.

Argument Type Required Description
factor Number Yes The place factor.

setWidgetManager

Set the widget manager associated with the widget instance.

Argument Type Required Description
wm vtkWidgetManager Yes The widget manager instance

updateRepresentationForRender

Update all the widget representations for render.

Argument Type Required Description
renderingType RenderingTypes Yes Default value if RenderingTypes.FRONT_BUFFER

Source

Constants.js
export const WIDGET_PRIORITY = 0.5;

export default { WIDGET_PRIORITY };
index.d.ts
import vtkInteractorObserver from '../../../Rendering/Core/InteractorObserver';
import vtkProp from '../../../Rendering/Core/Prop';
import vtkRenderer from "../../../Rendering/Core/Renderer";
import vtkWidgetManager from '../WidgetManager';
import vtkWidgetRepresentation from '../../Representations/WidgetRepresentation';
import vtkWidgetState from '../WidgetState';
import { Bounds } from "../../../types";
import { RenderingTypes } from "../WidgetManager/Constants";
import { EventHandler, vtkSubscription } from '../../../interfaces';

export interface vtkAbstractWidget extends vtkProp, vtkInteractorObserver {
/**
* Get the bounds of the widget
*/
getBounds(): Bounds;

/**
* Get all representations of the widget.
*/
getNestedProps(): vtkWidgetRepresentation[];

/**
* Activate a handle, identified by both a state and a representation.
* Will also invoke appropriate events.
*
* @param locator An object describing the handle to activate.
*/
activateHandle(locator: {
selectedState: vtkWidgetState;
representation: vtkWidgetRepresentation;
}): void;

/**
* Deactivate all the handles on the widget instance.
*/
deactivateAllHandles(): void;

/**
* Returns true if the widget instance holds the given actor, false otherwise.
*
* @param {vtkProp} actor
*/
hasActor(actor: vtkProp): boolean;

/**
* Make the widget instance grab the focus.
* Should not be called directly or this will lead to unexpected behavior.
* To grab the focus on a widget, one should call `vtkWidgetManager.grabFocus(widgetInstanceToGiveFocusTo)`
*/
grabFocus(): void;

/**
* Make the widget instance release the focus.
*/
loseFocus(): void;

/**
* Returns true if the widget instance holds the focus, false otherwise.
*/
hasFocus(): boolean;

/**
* Place a widget at the given bounds.
*
* @param {Bounds} bounds
*/
placeWidget(bounds: Bounds): void;

/**
* Get the place factor.
*/
getPlaceFactor(): number;

/**
* Set the place factor.
*
* @param {Number} factor The place factor.
*/
setPlaceFactor(factor: number): void;

/**
* Get the `vtkWidgetRepresentation` instance associated with the given `vtkActor` instance.
*
* @param {vtkProp} actor
*/
getRepresentationFromActor(actor: vtkProp): vtkWidgetRepresentation;

/**
* Update all the widget representations for render.
*
* @param {RenderingTypes} renderingType Default value if `RenderingTypes.FRONT_BUFFER`
*/
updateRepresentationForRender(renderingType: RenderingTypes): void;

/**
* Get all the underlyings view widgets.
*/
getViewWidgets(): vtkAbstractWidget[];


/**
* Set the context visibility.
*
* @param {Boolean} visible
*/
setContextVisibility(visible: boolean): void;

/**
* Get the context visibility.
*/
getContextVisibility(): boolean;

/**
* Defines if the handles should be visible or not.
*
* @param {Boolean} visible
*/
setHandleVisibility(visible: boolean): void;

/**
* Returns true if the handles are visible, false otherwise.
*/
getHandleVisibility(): boolean;

/**
* Set the widget manager associated with the widget instance.
*
* @param {vtkWidgetManager} wm The widget manager instance
*/
setWidgetManager(wm: vtkWidgetManager): void;

/**
* Get the widget manager associated with the widget instance.
*/
getWidgetManager(): vtkWidgetManager;

/**
* Get all the representations of the widget instance.
*/
getRepresentations(): vtkWidgetRepresentation[];

/**
* Get the the state of the widget instance.
*/
getWidgetState(): vtkWidgetState;

/**
* Register a callback to be invoked when the `ActivateHandle` event occurs.
*
* @param {EventHandler} cb The callback to register
* @param {Number} [priority] Priority of this subscription
*/
onActivateHandle(cb: EventHandler, priority?: number): Readonly<vtkSubscription>;

/**
* Invoke the `ActivateHandle` event with the given payload.
*
* @param args The event payload
*/
invokeActivateHandle(...args: unknown[]): void;
}

/**
* Method used to decorate a given object (publicAPI+model) with vtkAbstractWidget characteristics.
*
* @param publicAPI object on which methods will be bounds (public)
* @param model object on which data structure will be bounds (protected)
* @param initialValues (default: {})
*/
export function extend(publicAPI: object, model: object, initialValues? : object): void;

/**
* Method used to create a new instance of vtkAbstractWidget
*
* @param initialValues For pre-setting some of its content
*/
export function newInstance(initialValues?: object): vtkAbstractWidget;

/**
* vtkAbstractWidget is an abstract class to construct a widget.
*/
export declare const vtkAbstractWidget: {
newInstance: typeof newInstance,
extend: typeof extend,
};

export default vtkAbstractWidget;
index.js
import macro from 'vtk.js/Sources/macros';
import vtkInteractorObserver from 'vtk.js/Sources/Rendering/Core/InteractorObserver';
import vtkProp from 'vtk.js/Sources/Rendering/Core/Prop';

import { RenderingTypes } from 'vtk.js/Sources/Widgets/Core/WidgetManager/Constants';
import { WIDGET_PRIORITY } from 'vtk.js/Sources/Widgets/Core/AbstractWidget/Constants';

// ----------------------------------------------------------------------------

function vtkAbstractWidget(publicAPI, model) {
model.classHierarchy.push('vtkAbstractWidget');
model.actorToRepresentationMap = new WeakMap();

// --------------------------------------------------------------------------
publicAPI.getBounds = model.widgetState.getBounds;
publicAPI.getNestedProps = () => model.representations;
// --------------------------------------------------------------------------

publicAPI.activateHandle = ({ selectedState, representation }) => {
model.widgetState.activateOnly(selectedState);
model.activeState = selectedState;
if (selectedState && selectedState.updateManipulator) {
selectedState.updateManipulator();
}
publicAPI.invokeActivateHandle({ selectedState, representation });
if (publicAPI.updateCursor) {
publicAPI.updateCursor();
}
};

// --------------------------------------------------------------------------

publicAPI.deactivateAllHandles = () => {
model.widgetState.deactivate();
};

// --------------------------------------------------------------------------

publicAPI.hasActor = (actor) => model.actorToRepresentationMap.has(actor);

// --------------------------------------------------------------------------

publicAPI.grabFocus = () => {
model.hasFocus = true;
};
publicAPI.loseFocus = () => {
model.hasFocus = false;
};
publicAPI.hasFocus = () => model.hasFocus;

// --------------------------------------------------------------------------

publicAPI.placeWidget = (bounds) => model.widgetState.placeWidget(bounds);
publicAPI.getPlaceFactor = () => model.widgetState.getPlaceFactor();
publicAPI.setPlaceFactor = (factor) =>
model.widgetState.setPlaceFactor(factor);

// --------------------------------------------------------------------------

publicAPI.getRepresentationFromActor = (actor) =>
model.actorToRepresentationMap.get(actor);

// --------------------------------------------------------------------------

publicAPI.updateRepresentationForRender = (
renderingType = RenderingTypes.FRONT_BUFFER
) => {
for (let i = 0; i < model.representations.length; i++) {
const representation = model.representations[i];
representation.updateActorVisibility(
renderingType,
model.contextVisibility,
model.handleVisibility
);
}
};

publicAPI.getViewWidgets = () =>
model._factory
.getViewIds()
.map((viewId) => model._factory.getWidgetForView({ viewId }));

// --------------------------------------------------------------------------
// Initialization calls
// --------------------------------------------------------------------------

publicAPI.setPriority(WIDGET_PRIORITY);
}

// ----------------------------------------------------------------------------

const DEFAULT_VALUES = {
contextVisibility: true,
handleVisibility: true,
hasFocus: false,
};

/**
* @param {*} publicAPI public methods to populate
* @param {*} model internal values to populate
* @param {object} initialValues Contains at least
* {viewType, _renderer, _camera, _openGLRenderWindow, _factory}
*/
export function extend(publicAPI, model, initialValues = {}) {
Object.assign(model, DEFAULT_VALUES, initialValues);

vtkProp.extend(publicAPI, model, initialValues);
vtkInteractorObserver.extend(publicAPI, model, initialValues);

macro.setGet(publicAPI, model, [
'contextVisibility',
'handleVisibility',
'_widgetManager',
]);
macro.get(publicAPI, model, ['representations', 'widgetState']);
macro.moveToProtected(publicAPI, model, ['widgetManager']);
macro.event(publicAPI, model, 'ActivateHandle');

vtkAbstractWidget(publicAPI, model);
}

// ----------------------------------------------------------------------------

export const newInstance = macro.newInstance(extend, 'vtkAbstractWidget');

// ----------------------------------------------------------------------------

export default { newInstance, extend };