InteractorStyleManipulator

Methods

addGestureManipulator

Adds a gesture manipulator.

Argument Type Required Description
manipulator Yes the manipulator to add

Returns

Type Description
whether the manipulator has been added

addKeyboardManipulator

Adds a keyboard manipulator.

Argument Type Required Description
manipulator Yes the manipulator to add

Returns

Type Description
whether the manipulator has been added

addMouseManipulator

Adds a mouse manipulator.

Argument Type Required Description
manipulator Yes the manipulator to add

Returns

Type Description
whether the manipulator has been added

addVRManipulator

Adds a VR manipulator.

Argument Type Required Description
manipulator Yes the manipulator to add

Returns

Type Description
whether the manipulator has been added

findMouseManipulator

Finds a mouse manipulator with a given control set.

Argument Type Required Description
button Yes which button
shift Yes shift enabled
scroll Yes scroll enabled
alt Yes alt enabled

findVRManipulator

Finds a VR manipulator with a given device + input.

Argument Type Required Description
device Yes
input Yes

getCenterOfRotation

Gets the center of rotation.

Returns

Type Description
Vector3

getNumberOfGestureManipulators

Gets the number of gesture manipulators.

getNumberOfKeyboardManipulators

Gets the number of keyboard manipulators.

getNumberOfMouseManipulators

Gets the number of mouse manipulators.

getNumberOfVRManipulators

Gets the number of VR manipulators.

getRotationFactor

Gets the rotation factor.

handleButton3D

Handles a 3D button event.

Argument Type Required Description
callData Yes event data

handleEndMouseWheel

Handles the end of a wheel event.

Argument Type Required Description
callData Yes event data

handleEndPan

Handles the end of a pan gesture.

Argument Type Required Description
callData Yes event data

handleEndPinch

Handles the end of a pinch gesture.

Argument Type Required Description
callData Yes event data

handleEndRotate

Handles the end of a rotate gesture.

Argument Type Required Description
callData Yes event data

handleKeyDown

Handles a keydown event.

Argument Type Required Description
callData Yes event data

handleKeyPress

Handles a keypress.

Argument Type Required Description
callData Yes event data

handleKeyUp

Handles a keyup event.

Argument Type Required Description
callData Yes event data

handleLeftButtonPress

Handles a left button press event.

Argument Type Required Description
callData Yes event data

handleLeftButtonRelease

Handles a left button release event.

Argument Type Required Description
callData Yes event data

handleMiddleButtonPress

Handles a middle button press event.

Argument Type Required Description
callData Yes event data

handleMiddleButtonRelease

Handles a middle button release event.

Argument Type Required Description
callData Yes event data

handleMouseMove

Handles a mouse move.

Argument Type Required Description
callData Yes event data

handleMouseWheel

Handles a wheel event.

Argument Type Required Description
callData Yes event data

handleMove3D

Handles a 3D move event.

Argument Type Required Description
ed Yes event data

handlePan

Handles a pan gesture.

Argument Type Required Description
callData Yes event data

handlePinch

Handles a pinch gesture.

Argument Type Required Description
callData Yes event data

handleRightButtonPress

Handles a right button press event.

Argument Type Required Description
callData Yes event data

handleRightButtonRelease

Handles a right button release event.

Argument Type Required Description
callData Yes event data

handleRotate

Handles a rotate gesture.

Argument Type Required Description
callData Yes event data

handleStartMouseWheel

Handles the start of a wheel event.

Argument Type Required Description
callData Yes event data

handleStartPan

Handles the start of a pan gesture.

Argument Type Required Description
callData Yes event data

handleStartPinch

Handles the start of a pinch gesture.

Argument Type Required Description
callData Yes event data

handleStartRotate

Handles the start of a rotate gesture.

Argument Type Required Description
callData Yes event data

onButtonDown

Handles a button down event.

Argument Type Required Description
button Yes which button
callData Yes event data

onButtonUp

Handles a button up event.

Argument Type Required Description
button Yes which button

removeAllGestureManipulators

Remove gesture manipulators.

removeAllKeyboardManipulators

Remove keyboard manipulators.

removeAllManipulators

Remove all manipulators.

removeAllMouseManipulators

Remove mouse manipulators.

removeAllVRManipulators

Remove VR manipulators.

removeGestureManipulator

Removes a gesture manipulator.

Argument Type Required Description
manipulator Yes the manipulator to remove

removeKeyboardManipulator

Removes a keyboard manipulator.

Argument Type Required Description
manipulator Yes the manipulator to remove

removeMouseManipulator

Removes a mouse manipulator.

Argument Type Required Description
manipulator Yes the manipulator to remove

removeVRManipulator

Removes a VR manipulator.

Argument Type Required Description
manipulator Yes the manipulator to remove

resetCurrentManipulator

Resets/clears the current manipulator.

setCenterOfRotation

Sets the center of rotation

Argument Type Required Description
x Number Yes
y Number Yes
z Number Yes

setRotationFactor

Sets the rotation factor.

Argument Type Required Description
factor Yes rotation factor

Source

Presets.js
import Manipulators from 'vtk.js/Sources/Interaction/Manipulators';

const MANIPULTOR_TYPES = {
slice: Manipulators.vtkMouseCameraSliceManipulator,
multiRotate: Manipulators.vtkMouseCameraTrackballMultiRotateManipulator,
pan: Manipulators.vtkMouseCameraTrackballPanManipulator,
roll: Manipulators.vtkMouseCameraTrackballRollManipulator,
rotate: Manipulators.vtkMouseCameraTrackballRotateManipulator,
axisRotate: Manipulators.vtkMouseCameraAxisRotateManipulator,
zoom: Manipulators.vtkMouseCameraTrackballZoomManipulator,
zoomToMouse: Manipulators.vtkMouseCameraTrackballZoomToMouseManipulator,
range: Manipulators.vtkMouseRangeManipulator,
vrPan: Manipulators.vtkVRButtonPanManipulator,
gestureCamera: Manipulators.vtkGestureCameraManipulator,
movement: Manipulators.vtkKeyboardCameraManipulator,
freeLook: Manipulators.vtkMouseCameraTrackballFirstPersonManipulator,
unicam: Manipulators.vtkMouseCameraUnicamManipulator,
unicamRotate: Manipulators.vtkMouseCameraUnicamRotateManipulator,
};

const STYLES = {
'3D': [
{ type: 'rotate' },
{ type: 'pan', options: { shift: true } },
{ type: 'zoom', options: { control: true } },
{ type: 'zoom', options: { alt: true } },
{ type: 'zoom', options: { dragEnabled: false, scrollEnabled: true } },
{ type: 'zoom', options: { button: 3 } },
{ type: 'roll', options: { shift: true, control: true } },
{ type: 'roll', options: { shift: true, alt: true } },
{ type: 'roll', options: { shift: true, button: 3 } },
{ type: 'vrPan' },
{ type: 'gestureCamera' },
],
'2D': [
{ type: 'pan', options: { shift: true } },
{ type: 'zoom', options: { control: true } },
{ type: 'zoom', options: { alt: true } },
{ type: 'zoom', options: { button: 3 } },
{ type: 'roll', options: { shift: true, alt: true } },
{ type: 'roll', options: { shift: true, button: 3 } },
{ type: 'roll', options: { shift: true } },
{ type: 'vrPan' },
{ type: 'gestureCamera' },
],
FirstPerson: [{ type: 'movement' }, { type: 'freeLook' }],
Unicam: [{ type: 'unicam' }],
zRotateTop: [
{ type: 'pan', options: { shift: true } },
{
type: 'axisRotate',
options: { rotationAxis: [0, 0, 1], useHalfAxis: true },
},
{ type: 'zoom', options: { control: true } },
{ type: 'zoom', options: { alt: true } },
{ type: 'zoom', options: { dragEnabled: false, scrollEnabled: true } },
{ type: 'zoom', options: { button: 3 } },
],
zRotateAll: [
{ type: 'pan', options: { shift: true } },
{
type: 'axisRotate',
options: { rotationAxis: [0, 0, 1], useHalfAxis: false },
},
{ type: 'zoom', options: { control: true } },
{ type: 'zoom', options: { alt: true } },
{ type: 'zoom', options: { dragEnabled: false, scrollEnabled: true } },
{ type: 'zoom', options: { button: 3 } },
],
};

function applyDefinitions(definitions, manipulatorStyle) {
manipulatorStyle.removeAllManipulators();
for (let idx = 0; idx < definitions.length; idx++) {
const definition = definitions[idx];
const instance = MANIPULTOR_TYPES[definition.type].newInstance(
definition.options
);
if (instance.isA('vtkCompositeVRManipulator')) {
manipulatorStyle.addVRManipulator(instance);
} else if (instance.isA('vtkCompositeGestureManipulator')) {
manipulatorStyle.addGestureManipulator(instance);
} else if (instance.isA('vtkCompositeKeyboardManipulator')) {
manipulatorStyle.addKeyboardManipulator(instance);
} else {
manipulatorStyle.addMouseManipulator(instance);
}
}

return true;
}

function applyPreset(name, manipulatorStyle) {
return applyDefinitions(STYLES[name], manipulatorStyle);
}

function registerManipulatorType(type, classDef) {
MANIPULTOR_TYPES[type] = classDef;
}

function registerStylePreset(name, definitions) {
STYLES[name] = definitions;
}

export default {
applyDefinitions,
applyPreset,
registerManipulatorType,
registerStylePreset,
};
index.d.ts
import vtkCompositeGestureManipulator from '../../Manipulators/CompositeGestureManipulator';
import vtkCompositeKeyboardManipulator from '../../Manipulators/CompositeKeyboardManipulator';
import vtkCompositeMouseManipulator from '../../Manipulators/CompositeMouseManipulator';
import vtkCompositeVRManipulator from '../../Manipulators/CompositeVRManipulator';
import vtkInteractorStyle from '../../../Rendering/Core/InteractorStyle';
import {
Device,
Input,
} from '../../../Rendering/Core/RenderWindowInteractor/Constants';
import { Nullable, Vector3 } from '../../../types';

export interface vtkInteractorStyleManipulator extends vtkInteractorStyle {
/**
* Remove all manipulators.
*/
removeAllManipulators(): void;

/**
* Remove mouse manipulators.
*/
removeAllMouseManipulators(): void;

/**
* Remove keyboard manipulators.
*/
removeAllKeyboardManipulators(): void;

/**
* Remove VR manipulators.
*/
removeAllVRManipulators(): void;

/**
* Remove gesture manipulators.
*/
removeAllGestureManipulators(): void;

/**
* Adds a mouse manipulator.
* @param manipulator the manipulator to add
* @returns whether the manipulator has been added
*/
addMouseManipulator(manipulator: vtkCompositeMouseManipulator): boolean;

/**
* Adds a keyboard manipulator.
* @param manipulator the manipulator to add
* @returns whether the manipulator has been added
*/
addKeyboardManipulator(manipulator: vtkCompositeKeyboardManipulator): boolean;

/**
* Adds a VR manipulator.
* @param manipulator the manipulator to add
* @returns whether the manipulator has been added
*/
addVRManipulator(manipulator: vtkCompositeVRManipulator): boolean;

/**
* Adds a gesture manipulator.
* @param manipulator the manipulator to add
* @returns whether the manipulator has been added
*/
addGestureManipulator(manipulator: vtkCompositeGestureManipulator): boolean;

/**
* Removes a mouse manipulator.
* @param manipulator the manipulator to remove
*/
removeMouseManipulator(manipulator: vtkCompositeMouseManipulator): void;

/**
* Removes a keyboard manipulator.
* @param manipulator the manipulator to remove
*/
removeKeyboardManipulator(manipulator: vtkCompositeKeyboardManipulator): void;

/**
* Removes a VR manipulator.
* @param manipulator the manipulator to remove
*/
removeVRManipulator(manipulator: vtkCompositeVRManipulator): void;

/**
* Removes a gesture manipulator.
* @param manipulator the manipulator to remove
*/
removeGestureManipulator(manipulator: vtkCompositeGestureManipulator): void;

/**
* Gets the number of mouse manipulators.
*/
getNumberOfMouseManipulators(): number;

/**
* Gets the number of keyboard manipulators.
*/
getNumberOfKeyboardManipulators(): number;

/**
* Gets the number of VR manipulators.
*/
getNumberOfVRManipulators(): number;

/**
* Gets the number of gesture manipulators.
*/
getNumberOfGestureManipulators(): number;

/**
* Resets/clears the current manipulator.
*/
resetCurrentManipulator(): void;

/**
* Finds a mouse manipulator with a given control set.
* @param button which button
* @param shift shift enabled
* @param scroll scroll enabled
* @param alt alt enabled
*/
findMouseManipulator(
button: number,
shift: boolean,
scroll: boolean,
alt: boolean
): Nullable<vtkCompositeMouseManipulator>;

/**
* Finds a VR manipulator with a given device + input.
* @param device
* @param input
*/
findVRManipulator(
device: Device,
input: Input
): Nullable<vtkCompositeVRManipulator>;

/**
* Handles a left button press event.
* @param callData event data
*/
handleLeftButtonPress(callData: unknown): void;

/**
* Handles a middle button press event.
* @param callData event data
*/
handleMiddleButtonPress(callData: unknown): void;

/**
* Handles a right button press event.
* @param callData event data
*/
handleRightButtonPress(callData: unknown): void;

/**
* Handles a left button release event.
* @param callData event data
*/
handleLeftButtonRelease(callData: unknown): void;

/**
* Handles a middle button release event.
* @param callData event data
*/
handleMiddleButtonRelease(callData: unknown): void;

/**
* Handles a right button release event.
* @param callData event data
*/
handleRightButtonRelease(callData: unknown): void;

/**
* Handles the start of a wheel event.
* @param callData event data
*/
handleStartMouseWheel(callData: unknown): void;

/**
* Handles a wheel event.
* @param callData event data
*/
handleMouseWheel(callData: unknown): void;

/**
* Handles the end of a wheel event.
* @param callData event data
*/
handleEndMouseWheel(callData: unknown): void;

/**
* Handles a mouse move.
* @param callData event data
*/
handleMouseMove(callData: unknown): void;

/**
* Handles a 3D button event.
* @param callData event data
*/
handleButton3D(ed: unknown): void;

/**
* Handles a 3D move event.
* @param ed event data
*/
handleMove3D(ed: unknown): void;

/**
* Handles a keypress.
* @param callData event data
*/
handleKeyPress(callData: unknown): void;

/**
* Handles a keydown event.
* @param callData event data
*/
handleKeyDown(callData: unknown): void;

/**
* Handles a keyup event.
* @param callData event data
*/
handleKeyUp(callData: unknown): void;

/**
* Handles the start of a pinch gesture.
* @param callData event data
*/
handleStartPinch(callData: unknown): void;

/**
* Handles the end of a pinch gesture.
* @param callData event data
*/
handleEndPinch(callData: unknown): void;

/**
* Handles the start of a rotate gesture.
* @param callData event data
*/
handleStartRotate(callData: unknown): void;

/**
* Handles the end of a rotate gesture.
* @param callData event data
*/
handleEndRotate(callData: unknown): void;

/**
* Handles the start of a pan gesture.
* @param callData event data
*/
handleStartPan(callData: unknown): void;

/**
* Handles the end of a pan gesture.
* @param callData event data
*/
handleEndPan(callData: unknown): void;

/**
* Handles a pinch gesture.
* @param callData event data
*/
handlePinch(callData: unknown): void;

/**
* Handles a rotate gesture.
* @param callData event data
*/
handleRotate(callData: unknown): void;

/**
* Handles a pan gesture.
* @param callData event data
*/
handlePan(callData: unknown): void;

/**
* Handles a button down event.
* @param button which button
* @param callData event data
*/
onButtonDown(button: number, callData: unknown): void;

/**
* Handles a button up event.
* @param button which button
*/
onButtonUp(button: number): void;

/**
* Sets the rotation factor.
* @param factor rotation factor
*/
setRotationFactor(factor: number): boolean;

/**
* Gets the rotation factor.
*/
getRotationFactor(): number;

getMouseManipulators(): vtkCompositeMouseManipulator[];
getMouseManipulators(): vtkCompositeMouseManipulator[];
getMouseManipulators(): vtkCompositeMouseManipulator[];
getMouseManipulators(): vtkCompositeMouseManipulator[];

/**
* Sets the center of rotation
* @param {Number} x
* @param {Number} y
* @param {Number} z
*/
setCenterOfRotation(x: number, y: number, z: number): boolean;
setCenterOfRotation(xyz: Vector3): boolean;

/**
* Gets the center of rotation.
* @returns {Vector3}
*/
getCenterOfRotation(): Vector3;
}

export interface IInteractorStyleManipulatorInitialValues {
centerOfRotation?: Vector3;
rotationFactor?: number;
}

export function newInstance(
initialValues?: IInteractorStyleManipulatorInitialValues
): vtkInteractorStyleManipulator;

export function extend(
publicAPI: object,
model: object,
initialValues?: IInteractorStyleManipulatorInitialValues
): void;

export const vtkInteractorStyleManipulator: {
newInstance: typeof newInstance;
extend: typeof extend;
};

export default vtkInteractorStyleManipulator;
index.js
import macro from 'vtk.js/Sources/macros';
import vtkInteractorStyle from 'vtk.js/Sources/Rendering/Core/InteractorStyle';

const { vtkDebugMacro } = macro;
const { States } = vtkInteractorStyle;

// ----------------------------------------------------------------------------
// Event Types
// ----------------------------------------------------------------------------

const START_INTERACTION_EVENT = { type: 'StartInteractionEvent' };
const INTERACTION_EVENT = { type: 'InteractionEvent' };
const END_INTERACTION_EVENT = { type: 'EndInteractionEvent' };

// ----------------------------------------------------------------------------
// Global methods
// ----------------------------------------------------------------------------

function translateCamera(renderer, rwi, toX, toY, fromX, fromY) {
const cam = renderer.getActiveCamera();
let viewFocus = cam.getFocalPoint();

viewFocus = rwi
.getInteractorStyle()
.computeWorldToDisplay(renderer, viewFocus[0], viewFocus[1], viewFocus[2]);
const focalDepth = viewFocus[2];

const newPickPoint = rwi
.getInteractorStyle()
.computeDisplayToWorld(renderer, toX, toY, focalDepth);
const oldPickPoint = rwi
.getInteractorStyle()
.computeDisplayToWorld(renderer, fromX, fromY, focalDepth);

// camera motion is reversed
const motionVector = [
oldPickPoint[0] - newPickPoint[0],
oldPickPoint[1] - newPickPoint[1],
oldPickPoint[2] - newPickPoint[2],
];

viewFocus = cam.getFocalPoint();
const viewPoint = cam.getPosition();

cam.setFocalPoint(
motionVector[0] + viewFocus[0],
motionVector[1] + viewFocus[1],
motionVector[2] + viewFocus[2]
);
cam.setPosition(
motionVector[0] + viewPoint[0],
motionVector[1] + viewPoint[1],
motionVector[2] + viewPoint[2]
);
}

function dollyToPosition(fact, position, renderer, rwi) {
const cam = renderer.getActiveCamera();

if (cam.getParallelProjection()) {
// Zoom relatively to the cursor
const view = rwi.getView();
const aSize = view.getViewportSize(renderer);
const viewport = renderer.getViewport();
const viewSize = view.getSize();
const w = aSize[0];
const h = aSize[1];
const x0 = w / 2;
const y0 = h / 2;
const x1 = position.x - viewport[0] * viewSize[0];
const y1 = position.y - viewport[1] * viewSize[1];
translateCamera(renderer, rwi, x0, y0, x1, y1);
cam.setParallelScale(cam.getParallelScale() / fact);
translateCamera(renderer, rwi, x1, y1, x0, y0);
} else {
// Zoom relatively to the cursor position

// Move focal point to cursor position
let viewFocus = cam.getFocalPoint();
const norm = cam.getViewPlaneNormal();

viewFocus = rwi
.getInteractorStyle()
.computeWorldToDisplay(
renderer,
viewFocus[0],
viewFocus[1],
viewFocus[2]
);
const newFp = rwi
.getInteractorStyle()
.computeDisplayToWorld(renderer, position.x, position.y, viewFocus[2]);

cam.setFocalPoint(newFp[0], newFp[1], newFp[2]);

// Move camera in/out along projection direction
cam.dolly(fact);
renderer.resetCameraClippingRange();

// Find new focal point
const newCameraPos = cam.getPosition();
viewFocus = cam.getFocalPoint();
const newPoint = [0, 0, 0];
let t =
norm[0] * (viewFocus[0] - newCameraPos[0]) +
norm[1] * (viewFocus[1] - newCameraPos[1]) +
norm[2] * (viewFocus[2] - newCameraPos[2]);
t /= norm[0] ** 2 + norm[1] ** 2 + norm[2] ** 2;
newPoint[0] = newCameraPos[0] + norm[0] * t;
newPoint[1] = newCameraPos[1] + norm[1] * t;
newPoint[2] = newCameraPos[2] + norm[2] * t;

cam.setFocalPoint(newPoint[0], newPoint[1], newPoint[2]);
renderer.resetCameraClippingRange();
}
}

function dollyByFactor(interactor, renderer, factor) {
if (Number.isNaN(factor)) {
return;
}

const camera = renderer.getActiveCamera();
if (camera.getParallelProjection()) {
camera.setParallelScale(camera.getParallelScale() / factor);
} else {
camera.dolly(factor);
renderer.resetCameraClippingRange();
}

if (interactor.getLightFollowCamera()) {
renderer.updateLightsGeometryToFollowCamera();
}
}

// ----------------------------------------------------------------------------
// Static API
// ----------------------------------------------------------------------------

export const STATIC = {
dollyToPosition,
translateCamera,
dollyByFactor,
};

// ----------------------------------------------------------------------------
// vtkInteractorStyleManipulator methods
// ----------------------------------------------------------------------------

function vtkInteractorStyleManipulator(publicAPI, model) {
// Set our className
model.classHierarchy.push('vtkInteractorStyleManipulator');

model.currentVRManipulators = new Map();
model.mouseManipulators = [];
model.keyboardManipulators = [];
model.vrManipulators = [];
model.gestureManipulators = [];
model.currentManipulator = null;
model.currentWheelManipulator = null;
model.centerOfRotation = [0, 0, 0];
model.rotationFactor = 1;

//-------------------------------------------------------------------------
publicAPI.removeAllManipulators = () => {
publicAPI.removeAllMouseManipulators();
publicAPI.removeAllKeyboardManipulators();
publicAPI.removeAllVRManipulators();
publicAPI.removeAllGestureManipulators();
};

//-------------------------------------------------------------------------
publicAPI.removeAllMouseManipulators = () => {
model.mouseManipulators = [];
};

//-------------------------------------------------------------------------
publicAPI.removeAllKeyboardManipulators = () => {
model.keyboardManipulators = [];
};

//-------------------------------------------------------------------------
publicAPI.removeAllVRManipulators = () => {
model.vrManipulators = [];
};

//-------------------------------------------------------------------------
publicAPI.removeAllGestureManipulators = () => {
model.gestureManipulators = [];
};

//-------------------------------------------------------------------------
const removeManipulator = (manipulator, list) => {
const index = list.indexOf(manipulator);
if (index === -1) {
return false;
}
list.splice(index, 1);
publicAPI.modified();
return true;
};

//-------------------------------------------------------------------------
publicAPI.removeMouseManipulator = (manipulator) =>
removeManipulator(manipulator, model.mouseManipulators);

//-------------------------------------------------------------------------
publicAPI.removeKeyboardManipulator = (manipulator) =>
removeManipulator(manipulator, model.keyboardManipulators);

//-------------------------------------------------------------------------
publicAPI.removeVRManipulator = (manipulator) =>
removeManipulator(manipulator, model.vrManipulators);

//-------------------------------------------------------------------------
publicAPI.removeGestureManipulator = (manipulator) =>
removeManipulator(manipulator, model.gestureManipulators);

//-------------------------------------------------------------------------
const addManipulator = (manipulator, list) => {
const index = list.indexOf(manipulator);
if (index !== -1) {
return false;
}
list.push(manipulator);
publicAPI.modified();
return true;
};

//-------------------------------------------------------------------------
publicAPI.addMouseManipulator = (manipulator) =>
addManipulator(manipulator, model.mouseManipulators);

//-------------------------------------------------------------------------
publicAPI.addKeyboardManipulator = (manipulator) =>
addManipulator(manipulator, model.keyboardManipulators);

//-------------------------------------------------------------------------
publicAPI.addVRManipulator = (manipulator) =>
addManipulator(manipulator, model.vrManipulators);

//-------------------------------------------------------------------------
publicAPI.addGestureManipulator = (manipulator) =>
addManipulator(manipulator, model.gestureManipulators);

//-------------------------------------------------------------------------
publicAPI.getNumberOfMouseManipulators = () => model.mouseManipulators.length;

//-------------------------------------------------------------------------
publicAPI.getNumberOfKeyboardManipulators = () =>
model.keyboardManipulators.length;

//-------------------------------------------------------------------------
publicAPI.getNumberOfVRManipulators = () => model.vrManipulators.length;

//-------------------------------------------------------------------------
publicAPI.getNumberOfGestureManipulators = () =>
model.gestureManipulators.length;

//-------------------------------------------------------------------------
publicAPI.resetCurrentManipulator = () => {
model.currentManipulator = null;
model.currentWheelManipulator = null;
};

//-------------------------------------------------------------------------
// Mouse
//-------------------------------------------------------------------------
publicAPI.handleLeftButtonPress = (callData) => {
model.previousPosition = callData.position;
publicAPI.onButtonDown(1, callData);
};

//-------------------------------------------------------------------------
publicAPI.handleMiddleButtonPress = (callData) => {
model.previousPosition = callData.position;
publicAPI.onButtonDown(2, callData);
};

//-------------------------------------------------------------------------
publicAPI.handleRightButtonPress = (callData) => {
model.previousPosition = callData.position;
publicAPI.onButtonDown(3, callData);
};

//-------------------------------------------------------------------------
publicAPI.handleButton3D = (ed) => {
if (!ed) {
return;
}

// Look for a matching 3D camera interactor.
const manipulator = publicAPI.findVRManipulator(
ed.device,
ed.input,
ed.pressed
);

if (manipulator) {
// register the manipulator for this device
model.currentVRManipulators.set(ed.device, manipulator);

manipulator.onButton3D(publicAPI, model.getRenderer(ed), model.state, ed);

if (ed.pressed) {
publicAPI.startCameraPose();
} else {
model.currentVRManipulators.delete(ed.device);

// make sure we don't end camera pose if other VR manipulators are currently interacting
if (model.currentVRManipulators.size === 0) {
publicAPI.endCameraPose();
}
}
} else {
vtkDebugMacro('No manipulator found');
}
};

//-------------------------------------------------------------------------
publicAPI.handleMove3D = (ed) => {
const manipulator = model.currentVRManipulators.get(ed.device);

if (manipulator && model.state === States.IS_CAMERA_POSE) {
manipulator.onMove3D(publicAPI, model.getRenderer(ed), model.state, ed);
}
};

//-------------------------------------------------------------------------
publicAPI.onButtonDown = (button, callData) => {
// Must not be processing an interaction to start another.
if (model.currentManipulator) {
return;
}

// Look for a matching camera interactor.
model.currentManipulator = publicAPI.findMouseManipulator(
button,
callData.shiftKey,
callData.controlKey,
callData.altKey
);
if (model.currentManipulator) {
if (model.currentManipulator.setCenter) {
model.currentManipulator.setCenter(model.centerOfRotation);
}
if (model.currentManipulator.setRotationFactor) {
model.currentManipulator.setRotationFactor(model.rotationFactor);
}
model.currentManipulator.startInteraction();
model.currentManipulator.onButtonDown(
model._interactor,
model.getRenderer(callData),
callData.position
);
model._interactor.requestAnimation(publicAPI.onButtonDown);
publicAPI.invokeStartInteractionEvent(START_INTERACTION_EVENT);
} else {
vtkDebugMacro('No manipulator found');
}
};

//-------------------------------------------------------------------------
publicAPI.findMouseManipulator = (button, shift, control, alt) => {
// Look for a matching camera manipulator
let manipulator = null;
let count = model.mouseManipulators.length;
while (count--) {
const manip = model.mouseManipulators[count];
if (
manip &&
manip.getButton() === button &&
manip.getShift() === shift &&
manip.getControl() === control &&
manip.getAlt() === alt &&
manip.isDragEnabled()
) {
manipulator = manip;
}
}
return manipulator;
};

//-------------------------------------------------------------------------
publicAPI.findVRManipulator = (device, input) => {
// Look for a matching camera manipulator
let manipulator = null;
let count = model.vrManipulators.length;
while (count--) {
const manip = model.vrManipulators[count];
if (manip && manip.getDevice() === device && manip.getInput() === input) {
manipulator = manip;
}
}
return manipulator;
};

//-------------------------------------------------------------------------
publicAPI.handleLeftButtonRelease = () => {
publicAPI.onButtonUp(1);
};

//-------------------------------------------------------------------------
publicAPI.handleMiddleButtonRelease = () => {
publicAPI.onButtonUp(2);
};

//-------------------------------------------------------------------------
publicAPI.handleRightButtonRelease = () => {
publicAPI.onButtonUp(3);
};

//-------------------------------------------------------------------------
publicAPI.onButtonUp = (button) => {
if (!model.currentManipulator) {
return;
}
if (
model.currentManipulator.getButton &&
model.currentManipulator.getButton() === button
) {
model.currentManipulator.onButtonUp(model._interactor);
model.currentManipulator.endInteraction();
model.currentManipulator = null;
model._interactor.cancelAnimation(publicAPI.onButtonDown);
publicAPI.invokeEndInteractionEvent(END_INTERACTION_EVENT);
}
};

//-------------------------------------------------------------------------
publicAPI.handleStartMouseWheel = (callData) => {
// Must not be processing a wheel interaction to start another.
if (model.currentWheelManipulator) {
return;
}

let manipulator = null;
let count = model.mouseManipulators.length;
while (count--) {
const manip = model.mouseManipulators[count];
if (
manip &&
manip.isScrollEnabled() &&
manip.getShift() === callData.shiftKey &&
manip.getControl() === callData.controlKey &&
manip.getAlt() === callData.altKey
) {
manipulator = manip;
}
}
if (manipulator) {
model.currentWheelManipulator = manipulator;
model.currentWheelManipulator.onStartScroll(
model._interactor,
model.getRenderer(callData),
callData.spinY
);
model.currentWheelManipulator.startInteraction();
model._interactor.requestAnimation(publicAPI.handleStartMouseWheel);
publicAPI.invokeStartInteractionEvent(START_INTERACTION_EVENT);
} else {
vtkDebugMacro('No manipulator found');
}
};

//-------------------------------------------------------------------------
publicAPI.handleEndMouseWheel = () => {
if (!model.currentWheelManipulator) {
return;
}
if (model.currentWheelManipulator.onEndScroll) {
model.currentWheelManipulator.onEndScroll(model._interactor);
model.currentWheelManipulator.endInteraction();
model.currentWheelManipulator = null;
model._interactor.cancelAnimation(publicAPI.handleStartMouseWheel);
publicAPI.invokeEndInteractionEvent(END_INTERACTION_EVENT);
}
};

//-------------------------------------------------------------------------
publicAPI.handleMouseWheel = (callData) => {
if (
model.currentWheelManipulator &&
model.currentWheelManipulator.onScroll
) {
model.currentWheelManipulator.onScroll(
model._interactor,
model.getRenderer(callData),
callData.spinY,
model.cachedMousePosition
);
publicAPI.invokeInteractionEvent(INTERACTION_EVENT);
}
};

//-------------------------------------------------------------------------
publicAPI.handleMouseMove = (callData) => {
model.cachedMousePosition = callData.position;
if (model.currentManipulator && model.currentManipulator.onMouseMove) {
model.currentManipulator.onMouseMove(
model._interactor,
model.getRenderer(callData),
callData.position
);
publicAPI.invokeInteractionEvent(INTERACTION_EVENT);
}
};

//-------------------------------------------------------------------------
// Keyboard
//-------------------------------------------------------------------------
publicAPI.handleKeyPress = (callData) => {
model.keyboardManipulators
.filter((m) => m.onKeyPress)
.forEach((manipulator) => {
manipulator.onKeyPress(
model._interactor,
model.getRenderer(callData),
callData.key
);
publicAPI.invokeInteractionEvent(INTERACTION_EVENT);
});
};

//-------------------------------------------------------------------------
publicAPI.handleKeyDown = (callData) => {
model.keyboardManipulators
.filter((m) => m.onKeyDown)
.forEach((manipulator) => {
manipulator.onKeyDown(
model._interactor,
model.getRenderer(callData),
callData.key
);
publicAPI.invokeInteractionEvent(INTERACTION_EVENT);
});
};

//-------------------------------------------------------------------------
publicAPI.handleKeyUp = (callData) => {
model.keyboardManipulators
.filter((m) => m.onKeyUp)
.forEach((manipulator) => {
manipulator.onKeyUp(
model._interactor,
model.getRenderer(callData),
callData.key
);
publicAPI.invokeInteractionEvent(INTERACTION_EVENT);
});
};

//-------------------------------------------------------------------------
// Gesture
//-------------------------------------------------------------------------

publicAPI.handleStartPinch = (callData) => {
publicAPI.startDolly();
let count = model.gestureManipulators.length;
while (count--) {
const manipulator = model.gestureManipulators[count];
if (manipulator && manipulator.isPinchEnabled()) {
manipulator.onStartPinch(model._interactor, callData.scale);
manipulator.startInteraction();
}
}
model._interactor.requestAnimation(publicAPI.handleStartPinch);
publicAPI.invokeStartInteractionEvent(START_INTERACTION_EVENT);
};

//--------------------------------------------------------------------------
publicAPI.handleEndPinch = () => {
publicAPI.endDolly();
let count = model.gestureManipulators.length;
while (count--) {
const manipulator = model.gestureManipulators[count];
if (manipulator && manipulator.isPinchEnabled()) {
manipulator.onEndPinch(model._interactor);
manipulator.endInteraction();
}
}
model._interactor.cancelAnimation(publicAPI.handleStartPinch);
publicAPI.invokeEndInteractionEvent(END_INTERACTION_EVENT);
};

//----------------------------------------------------------------------------
publicAPI.handleStartRotate = (callData) => {
publicAPI.startRotate();
let count = model.gestureManipulators.length;
while (count--) {
const manipulator = model.gestureManipulators[count];
if (manipulator && manipulator.isRotateEnabled()) {
manipulator.onStartRotate(model._interactor, callData.rotation);
manipulator.startInteraction();
}
}
model._interactor.requestAnimation(publicAPI.handleStartRotate);
publicAPI.invokeStartInteractionEvent(START_INTERACTION_EVENT);
};

//--------------------------------------------------------------------------
publicAPI.handleEndRotate = () => {
publicAPI.endRotate();
let count = model.gestureManipulators.length;
while (count--) {
const manipulator = model.gestureManipulators[count];
if (manipulator && manipulator.isRotateEnabled()) {
manipulator.onEndRotate(model._interactor);
manipulator.endInteraction();
}
}
model._interactor.cancelAnimation(publicAPI.handleStartRotate);
publicAPI.invokeEndInteractionEvent(END_INTERACTION_EVENT);
};

//----------------------------------------------------------------------------
publicAPI.handleStartPan = (callData) => {
publicAPI.startPan();
let count = model.gestureManipulators.length;
while (count--) {
const manipulator = model.gestureManipulators[count];
if (manipulator && manipulator.isPanEnabled()) {
manipulator.onStartPan(model._interactor, callData.translation);
manipulator.startInteraction();
}
}
model._interactor.requestAnimation(publicAPI.handleStartPan);
publicAPI.invokeStartInteractionEvent(START_INTERACTION_EVENT);
};

//--------------------------------------------------------------------------
publicAPI.handleEndPan = () => {
publicAPI.endPan();
let count = model.gestureManipulators.length;
while (count--) {
const manipulator = model.gestureManipulators[count];
if (manipulator && manipulator.isPanEnabled()) {
manipulator.onEndPan(model._interactor);
manipulator.endInteraction();
}
}
model._interactor.cancelAnimation(publicAPI.handleStartPan);
publicAPI.invokeEndInteractionEvent(END_INTERACTION_EVENT);
};

//----------------------------------------------------------------------------
publicAPI.handlePinch = (callData) => {
let count = model.gestureManipulators.length;
let actionCount = 0;
while (count--) {
const manipulator = model.gestureManipulators[count];
if (manipulator && manipulator.isPinchEnabled()) {
manipulator.onPinch(
model._interactor,
model.getRenderer(callData),
callData.scale
);
actionCount++;
}
}
if (actionCount) {
publicAPI.invokeInteractionEvent(INTERACTION_EVENT);
}
};

//----------------------------------------------------------------------------
publicAPI.handlePan = (callData) => {
let count = model.gestureManipulators.length;
let actionCount = 0;
while (count--) {
const manipulator = model.gestureManipulators[count];
if (manipulator && manipulator.isPanEnabled()) {
manipulator.onPan(
model._interactor,
model.getRenderer(callData),
callData.translation
);
actionCount++;
}
}
if (actionCount) {
publicAPI.invokeInteractionEvent(INTERACTION_EVENT);
}
};

//----------------------------------------------------------------------------
publicAPI.handleRotate = (callData) => {
let count = model.gestureManipulators.length;
let actionCount = 0;
while (count--) {
const manipulator = model.gestureManipulators[count];
if (manipulator && manipulator.isRotateEnabled()) {
manipulator.onRotate(
model._interactor,
model.getRenderer(callData),
callData.rotation
);
actionCount++;
}
}
if (actionCount) {
publicAPI.invokeInteractionEvent(INTERACTION_EVENT);
}
};
}

// ----------------------------------------------------------------------------
// Object factory
// ----------------------------------------------------------------------------

const defaultValues = (initialValues) => ({
cachedMousePosition: null,
currentManipulator: null,
currentWheelManipulator: null,
// mouseManipulators: null,
// keyboardManipulators: null,
// vrManipulators: null,
// gestureManipulators: null,
centerOfRotation: [0, 0, 0],
rotationFactor: 1,
...initialValues,
});

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

export function extend(publicAPI, model, initialValues = {}) {
Object.assign(model, defaultValues(initialValues));

// Inheritance
vtkInteractorStyle.extend(publicAPI, model, initialValues);

// Create get-set macros
macro.setGet(publicAPI, model, ['rotationFactor']);
macro.get(publicAPI, model, [
'mouseManipulators',
'keyboardManipulators',
'vrManipulators',
'gestureManipulators',
]);

macro.setGetArray(publicAPI, model, ['centerOfRotation'], 3);

// Object specific methods
vtkInteractorStyleManipulator(publicAPI, model);
}

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

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

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

export default { newInstance, extend, ...STATIC };