760 lines
22 KiB
TypeScript
760 lines
22 KiB
TypeScript
import {
|
|
vtkSubscription,
|
|
vtkDebouncedFunction,
|
|
vtkProperty,
|
|
vtkPropertyDomain,
|
|
vtkObject,
|
|
} from './interfaces';
|
|
|
|
/**
|
|
* Allow user to redefine vtkXXXMacro method call.
|
|
* @param name of the macro type [Log, Info, Debug, Error, Warning]
|
|
* @param fn function to use when vtkXXXMacro is called.
|
|
*/
|
|
export function setLoggerFunction(
|
|
name: string,
|
|
fn: (...args: any) => void
|
|
): void;
|
|
|
|
/**
|
|
* Logging function used for level: Log
|
|
* @param args arguments to print
|
|
*/
|
|
export function vtkLogMacro(...args: any): void;
|
|
|
|
/**
|
|
* Logging function used for level: Info
|
|
* @param args arguments to print
|
|
*/
|
|
export function vtkInfoMacro(...args: any): void;
|
|
|
|
/**
|
|
* Logging function used for level: Debug
|
|
* @param args arguments to print
|
|
*/
|
|
export function vtkDebugMacro(...args: any): void;
|
|
|
|
/**
|
|
* Logging function used for level: Error
|
|
* @param args arguments to print
|
|
*/
|
|
export function vtkErrorMacro(...args: any): void;
|
|
|
|
/**
|
|
* Logging function used for level: Warning
|
|
* @param args arguments to print
|
|
*/
|
|
export function vtkWarningMacro(...args: any): void;
|
|
|
|
/**
|
|
* Output error only once
|
|
* This is convenient when the error happen in a loop.
|
|
* This allow you to catch the issue while not overloading your output console.
|
|
*/
|
|
export function vtkOnceErrorMacro(str: string): void;
|
|
|
|
/**
|
|
* A way to create typed array based on its name without using the window namespace
|
|
*/
|
|
export enum TYPED_ARRAYS {
|
|
Float32Array,
|
|
Float64Array,
|
|
Uint8Array,
|
|
Int8Array,
|
|
Uint16Array,
|
|
Int16Array,
|
|
Uint32Array,
|
|
Int32Array,
|
|
}
|
|
|
|
/**
|
|
* Capitalize provided string.
|
|
* This is typically used to convert the name of a field into its method name.
|
|
*
|
|
* ```
|
|
* const set = `set${capitalize(fieldName)}`;
|
|
* ```
|
|
* @param str String to capitalize
|
|
*/
|
|
export function capitalize(str: string): string;
|
|
|
|
/**
|
|
* Capitalize provided string.
|
|
* This is typically used to convert the name of a field into its method name.
|
|
* Ignore the first letter if it starts with underscore (i.e. _).
|
|
*
|
|
* ```
|
|
* const set = `set${capitalize(fieldName)}`;
|
|
* ```
|
|
*/
|
|
export function _capitalize(str: string): string;
|
|
|
|
/**
|
|
* Lowercase the first letter of the provided string.
|
|
*/
|
|
export function uncapitalize(str: string): string;
|
|
|
|
/**
|
|
* Convert byte size into a well formatted string.
|
|
*
|
|
* @param size number of bytes
|
|
* @param precision (default: 2) how many digit you want behind the unit
|
|
* @param chunkSize (default: 1000) base 1000 or 1024
|
|
*/
|
|
export function formatBytesToProperUnit(
|
|
size: number,
|
|
precision?: number,
|
|
chunkSize?: number
|
|
): string;
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Convert thousand number with proper separator
|
|
// ----------------------------------------------------------------------------
|
|
|
|
/**
|
|
*
|
|
* @param n number to format
|
|
* @param separator (default: ' ')
|
|
*/
|
|
export function formatNumbersWithThousandSeparator(
|
|
n: number,
|
|
separator?: string
|
|
): string;
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Array helper
|
|
// ----------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Replace internal arrays with new reference but with same content
|
|
*
|
|
* @param model
|
|
*/
|
|
declare function safeArrays(model: object): void;
|
|
|
|
/**
|
|
* Extract the key of an object where the given value match the given one
|
|
*
|
|
* @param e enum object to search key/value from
|
|
* @param value to look for inside object
|
|
*/
|
|
declare function enumToString(e: object, value: any): string;
|
|
|
|
/**
|
|
* If item is a VtkObject, return its getState() otherwise return itself.
|
|
*
|
|
* @param item object to extract its state from
|
|
*/
|
|
declare function getStateArrayMapFunc(item: any): any;
|
|
|
|
/**
|
|
* Call provided function on the next EDT pass
|
|
*
|
|
* @param fn function to execute
|
|
*/
|
|
export function setImmediateVTK(fn: () => void): void;
|
|
|
|
/**
|
|
* Measures the time it takes for a promise to finish from the time this function is invoked.
|
|
*
|
|
* The callback receives the time it took for the promise to resolve or reject.
|
|
*
|
|
* @param promise promise to measure
|
|
* @param callback called with the elapsed time for the promise
|
|
*/
|
|
export function measurePromiseExecution(
|
|
promise: Promise<any>,
|
|
callback: (elapsed: number) => void
|
|
): void;
|
|
|
|
/**
|
|
* Turns the provided publicAPI into a VtkObject
|
|
*
|
|
* @param publicAPI (default: {}) object on which public methods get attached to
|
|
* @param model (default: {}) object on which protected fields are stored
|
|
* @returns publicAPI
|
|
*/
|
|
export function obj(publicAPI?: object, model?: object): object;
|
|
|
|
/**
|
|
* Add getter methods to the provided publicAPI
|
|
*
|
|
* @param publicAPI object on which public methods get attached to
|
|
* @param model object on which protected fields are stored
|
|
* @param fieldNames list of fields available in model that we want to expose as get{FieldName} methods on the publicAPI
|
|
*/
|
|
export function get(
|
|
publicAPI: object,
|
|
model: object,
|
|
fieldNames: Array<string>
|
|
): void;
|
|
|
|
/**
|
|
* Add setter methods to the provided publicAPI
|
|
*
|
|
* @param publicAPI object on which public methods get attached to
|
|
* @param model object on which protected fields are stored
|
|
* @param fieldNames list of fields available in model that we want to expose as set{FieldName} methods on the publicAPI
|
|
* * Can be a string (the name of the field to expose) or an object (e.g. {type:enum, name: {FieldName}, enum: FieldEnum}).
|
|
*/
|
|
export function set(
|
|
publicAPI: object,
|
|
model: object,
|
|
fields: Array<string | object>
|
|
): void;
|
|
|
|
/**
|
|
* Add setter+getter methods to the provided publicAPI
|
|
*
|
|
* @param publicAPI object on which public methods get attached to
|
|
* @param model object on which protected fields are stored
|
|
* @param fieldNames list of fields available in model that we want to expose as set{FieldName}+get{FieldName} methods on the publicAPI.
|
|
* Can be a string (the name of the field to expose) or an object (e.g. {type:enum, name: {FieldName}, enum: FieldEnum}).
|
|
*/
|
|
export function setGet(
|
|
publicAPI: object,
|
|
model: object,
|
|
fields: Array<string | object>
|
|
): void;
|
|
|
|
/**
|
|
* Add getter methods to the provided publicAPI for arrays.
|
|
* A new array is used as returned value with get{FieldName}() method
|
|
* unless get{FieldName}ByReference() is used.
|
|
*
|
|
* ```
|
|
* get{FieldName}() // add getters for object of type array with copy to be safe
|
|
* get{FieldName}ByReference() // add getters for object of type array without copy
|
|
* ```
|
|
*
|
|
* @param publicAPI object on which public methods get attached to
|
|
* @param model object on which protected fields are stored
|
|
* @param fieldNames list of fields available in model that we want to expose as get{FieldName}+get{FieldName}ByReference methods on the publicAPI
|
|
*/
|
|
export function getArray(
|
|
publicAPI: object,
|
|
model: object,
|
|
fields: Array<string>
|
|
): void;
|
|
|
|
/**
|
|
* Add setter methods to the provided publicAPI for arrays.
|
|
* if 'defaultVal' is supplied, shorter arrays will be padded to 'size' with
|
|
* 'defaultVal'.
|
|
* set{FieldName}From(abc) will copy the content of abc into current field
|
|
* without calling modified.
|
|
*
|
|
* ```
|
|
* set{FieldName}(a, b, c) / set{FieldName}([a, b, c]) / set{FieldName}(new Uint8Array(...)) / set{FieldName}(null)
|
|
* set{FieldName}From([a, b, c])
|
|
* ```
|
|
*
|
|
* @param publicAPI
|
|
* @param model
|
|
* @param fieldNames
|
|
* @param size
|
|
* @param defaultVal
|
|
*/
|
|
export function setArray(
|
|
publicAPI: object,
|
|
model: object,
|
|
fieldNames: Array<string>,
|
|
size: Number,
|
|
defaultVal?: any
|
|
): void;
|
|
|
|
/**
|
|
* set/get XXX: add setter and getter for object of type array
|
|
* @param publicAPI
|
|
* @param model
|
|
* @param fieldNames
|
|
* @param size
|
|
* @param defaultVal
|
|
*/
|
|
export function setGetArray(
|
|
publicAPI: object,
|
|
model: object,
|
|
fieldNames: Array<string>,
|
|
size: Number,
|
|
defaultVal?: any
|
|
): void;
|
|
|
|
/**
|
|
* Convert model and publicAPI references to _fieldName into fieldName.
|
|
* It renames:
|
|
* - model.fieldName into model._fieldName
|
|
* - publicAPI.set_fieldName and publicAPI.set_fieldNameFrom into publicAPI.setFieldName and publicAPI.setFieldNameFrom
|
|
* - publicAPI.get_fieldName and publicAPI.get_fieldNameByReference into publicAPI.getFieldName and publicAPI.getFieldNameByReference
|
|
* @param publicAPI
|
|
* @param model
|
|
* @param fieldNames List of field names to move to protected, e.g. ['interactor', 'renderWindow']
|
|
* @see get
|
|
* @see set
|
|
*/
|
|
export function moveToProtected(
|
|
publicAPI: object,
|
|
model: object,
|
|
fieldNames: Array<string>
|
|
): void;
|
|
|
|
/**
|
|
* Add algorithm methods onto the provided publicAPI
|
|
*
|
|
* @param publicAPI object on which methods will be bounds (public)
|
|
* @param model object on which data structure will be bounds (protected)
|
|
* @param numberOfInputs
|
|
* @param numberOfOutputs
|
|
*/
|
|
export function algo(
|
|
publicAPI: object,
|
|
model: object,
|
|
numberOfInputs: number,
|
|
numberOfOutputs: number
|
|
): void;
|
|
|
|
/**
|
|
* Symbols used as return value for callback
|
|
*/
|
|
export const VOID: Symbol;
|
|
|
|
/**
|
|
* Symbols used as return value for callback when you want to stop
|
|
* any further callback calls after yours.
|
|
*/
|
|
export const EVENT_ABORT: Symbol;
|
|
|
|
export function event(
|
|
publicAPI: object,
|
|
model: object,
|
|
eventName: string
|
|
): void;
|
|
|
|
/**
|
|
* Event callback
|
|
* @param args
|
|
* @returns symbol to either keep going or interrupt existing callback call stack
|
|
*/
|
|
export function VtkCallback(...args: any): void | symbol;
|
|
|
|
// Example of event(,, 'change')
|
|
export interface VtkChangeEvent {
|
|
/**
|
|
* Call any registered callbacks with the given arguments
|
|
* @param args
|
|
*/
|
|
invokeChange(...args: any): void;
|
|
/**
|
|
* Execute higher priority callback first
|
|
* negative priority use setTimeout(cb, -priority) for later callback
|
|
*
|
|
* @param VtkCallback
|
|
* @param priority (default 0.0)
|
|
*/
|
|
onChange(
|
|
VtkCallback: (...args: any) => void | symbol,
|
|
priority?: number
|
|
): vtkSubscription;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// newInstance
|
|
// ----------------------------------------------------------------------------
|
|
|
|
export type VtkExtend = (
|
|
publicAPI: object,
|
|
model: object,
|
|
initialValues: object
|
|
) => void;
|
|
|
|
export function newInstance(extend: VtkExtend, className: string): any;
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Chain function calls
|
|
// ----------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Create a new closure that will chain the call of any provided methods
|
|
* @param fn list of function to call
|
|
*/
|
|
export function chain(...fn: Array<Function>): Function;
|
|
|
|
/**
|
|
* Test if provided object is an actual vtkObject or not
|
|
* @param instance
|
|
*/
|
|
export function isVtkObject(instance: any): boolean;
|
|
|
|
/**
|
|
* Traverse an instance tree of vtkObjects
|
|
*
|
|
* @param instance root of the tree to traverse
|
|
* @param extractFunction function used to decorate vtkObject
|
|
* @param accumulator (default []) array use to capture decorated by the extractFunction
|
|
* @param visitedInstances (default []) array use to capture visitedInstances
|
|
* @returns the accumulator is actually returned
|
|
*/
|
|
export function traverseInstanceTree(
|
|
instance: any,
|
|
extractFunction: any,
|
|
accumulator?: Array<any>,
|
|
visitedInstances?: Array<any>
|
|
): Array<any>;
|
|
|
|
/**
|
|
* Returns a function, that, as long as it continues to be invoked, will not
|
|
* be triggered. The function will be called after it stops being called for
|
|
* N milliseconds. If `immediate` is passed, trigger the function on the
|
|
* leading edge, instead of the trailing.
|
|
*
|
|
* @param func
|
|
* @param wait
|
|
* @param immediate (default false)
|
|
* @returns vtkDebouncedFunction A debounced function that can be called.
|
|
* Use .cancel() to clear any pending debounced call.
|
|
*/
|
|
export function debounce(
|
|
func: (...args: any) => any,
|
|
wait: number,
|
|
immediate?: boolean
|
|
): vtkDebouncedFunction;
|
|
|
|
/**
|
|
* Creates a throttled function that only invokes `func` at most once per
|
|
* every `wait` milliseconds.
|
|
*
|
|
* @param callback
|
|
* @param delay
|
|
*/
|
|
export function throttle(
|
|
callback: (...args: any) => any,
|
|
delay: number
|
|
): (...args: any) => any;
|
|
|
|
/**
|
|
* keystore(publicAPI, model, initialKeystore)
|
|
*
|
|
* - initialKeystore: Initial keystore. This can be either a Map or an
|
|
* object.
|
|
*
|
|
* Generated API
|
|
* setKey(key, value) : mixed (returns value)
|
|
* getKey(key) : mixed
|
|
* getAllKeys() : [mixed]
|
|
* deleteKey(key) : Boolean
|
|
*/
|
|
export interface VtkKeyStore {
|
|
setKey: (key: string, value: any) => void;
|
|
getKey: (key: string) => any;
|
|
getAllKeys: () => Array<string>;
|
|
deleteKey: (key: string) => void;
|
|
clearKeystore: () => void;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param publicAPI
|
|
* @param model
|
|
* @param initialKeystore (default {})
|
|
*/
|
|
export function keystore(
|
|
publicAPI: object,
|
|
model: object,
|
|
initialKeystore?: object
|
|
): void;
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// proxy(publicAPI, model, sectionName, propertyUI)
|
|
//
|
|
// - sectionName: Name of the section for UI
|
|
// - propertyUI: List of props with their UI description
|
|
//
|
|
// Generated API
|
|
// getProxyId() : String
|
|
// listProxyProperties() : [string]
|
|
// updateProxyProperty(name, prop)
|
|
// getProxySection() => List of properties for UI generation
|
|
// ----------------------------------------------------------------------------
|
|
|
|
export interface VtkProxyManager {}
|
|
|
|
export interface VtkProxySection {
|
|
id: string;
|
|
name: string;
|
|
ui: object;
|
|
properties: Array<any>;
|
|
}
|
|
|
|
export interface VtkLink {
|
|
/**
|
|
*
|
|
* @param instance
|
|
* @param propertyName
|
|
* @param updateMe (default: false)
|
|
*/
|
|
bind(instance: VtkProxy, propertyName: string, updateMe?: boolean): void;
|
|
unbind: (instance: VtkProxy, propertyName: string) => void;
|
|
unsubscribe: () => void;
|
|
persistent: boolean;
|
|
}
|
|
|
|
export interface VtkProxy extends VtkKeyStore, vtkObject {
|
|
getProxyId(): string;
|
|
getProxyGroup(): string;
|
|
getProxyName: () => string;
|
|
setProxyManager: (pxm: VtkProxyManager) => boolean;
|
|
getProxyManager: () => VtkProxyManager;
|
|
|
|
updateUI: (ui: object) => void;
|
|
listProxyProperties: (groupName: string) => Array<vtkProperty>;
|
|
updateProxyProperty: (propertyName: string, propUI: object) => void;
|
|
activate: () => void;
|
|
registerPropertyLinkForGC: (otherLink: VtkLink, type: string) => void;
|
|
gcPropertyLinks(type: string): void;
|
|
|
|
/**
|
|
*
|
|
* @param id
|
|
* @param persistent (default: false)
|
|
*/
|
|
getPropertyLink(id: string, persistent?: boolean): VtkLink;
|
|
|
|
/**
|
|
*
|
|
* @param groupName (default: ROOT_GROUP_NAME)
|
|
*/
|
|
getProperties(groupName?: string): Array<any>;
|
|
listPropertyNames: () => Array<string>;
|
|
getPropertyByName: (name: string) => vtkProperty;
|
|
getPropertyDomainByName: (name: string) => vtkPropertyDomain;
|
|
|
|
getProxySection: () => VtkProxySection;
|
|
}
|
|
|
|
export function proxy(publicAPI: object, model: object): void;
|
|
|
|
/**
|
|
* proxyPropertyMapping(publicAPI, model, map)
|
|
*
|
|
* ```
|
|
* map = {
|
|
* opacity: { modelKey: 'property', property: 'opacity' },
|
|
* }
|
|
* ```
|
|
*
|
|
* Generated API:
|
|
* Elevate set/get methods from internal object stored in the model to current one
|
|
*
|
|
* @param publicAPI
|
|
* @param model
|
|
* @param map
|
|
*/
|
|
export function proxyPropertyMapping(
|
|
publicAPI: object,
|
|
model: object,
|
|
map: object
|
|
): void;
|
|
|
|
/**
|
|
* proxyPropertyState(publicAPI, model, state, defaults)
|
|
*
|
|
* ```
|
|
* state = {
|
|
* representation: {
|
|
* 'Surface with edges': { property: { edgeVisibility: true, representation: 2 } },
|
|
* Surface: { property: { edgeVisibility: false, representation: 2 } },
|
|
* Wireframe: { property: { edgeVisibility: false, representation: 1 } },
|
|
* Points: { property: { edgeVisibility: false, representation: 0 } },
|
|
* },
|
|
* }
|
|
*
|
|
* defaults = {
|
|
* representation: 'Surface',
|
|
* }
|
|
* ```
|
|
*
|
|
* Generated API
|
|
* get / set Representation ( string ) => push state to various internal objects
|
|
*
|
|
* @param publicAPI
|
|
* @param model
|
|
* @param state (default: {})
|
|
* @param defaults (default: {})
|
|
*/
|
|
export function proxyPropertyState(
|
|
publicAPI: object,
|
|
model: object,
|
|
state?: object,
|
|
defaults?: object
|
|
): void;
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// From : https://github.com/facebookarchive/fixed-data-table/blob/master/src/vendor_upstream/dom/normalizeWheel.js
|
|
//
|
|
//
|
|
// Copyright (c) 2015, Facebook, Inc.
|
|
// All rights reserved.
|
|
//
|
|
// This source code is licensed under the BSD-style license found in the
|
|
// LICENSE file in the root directory of this source tree. An additional grant
|
|
// of patent rights can be found in the PATENTS file in the same directory.
|
|
//
|
|
//
|
|
// Mouse wheel (and 2-finger trackpad) support on the web sucks. It is
|
|
// complicated, thus this doc is long and (hopefully) detailed enough to answer
|
|
// your questions.
|
|
//
|
|
// If you need to react to the mouse wheel in a predictable way, this code is
|
|
// like your bestest friend.// hugs//
|
|
//
|
|
// As of today, there are 4 DOM event types you can listen to:
|
|
//
|
|
// 'wheel' -- Chrome(31+), FF(17+), IE(9+)
|
|
// 'mousewheel' -- Chrome, IE(6+), Opera, Safari
|
|
// 'MozMousePixelScroll' -- FF(3.5 only!) (2010-2013) -- don't bother!
|
|
// 'DOMMouseScroll' -- FF(0.9.7+) since 2003
|
|
//
|
|
// So what to do? The is the best:
|
|
//
|
|
// normalizeWheel.getEventType();
|
|
//
|
|
// In your event callback, use this code to get sane interpretation of the
|
|
// deltas. This code will return an object with properties:
|
|
//
|
|
// spinX -- normalized spin speed (use for zoom) - x plane
|
|
// spinY -- " - y plane
|
|
// pixelX -- normalized distance (to pixels) - x plane
|
|
// pixelY -- " - y plane
|
|
//
|
|
// Wheel values are provided by the browser assuming you are using the wheel to
|
|
// scroll a web page by a number of lines or pixels (or pages). Values can vary
|
|
// significantly on different platforms and browsers, forgetting that you can
|
|
// scroll at different speeds. Some devices (like trackpads) emit more events
|
|
// at smaller increments with fine granularity, and some emit massive jumps with
|
|
// linear speed or acceleration.
|
|
//
|
|
// This code does its best to normalize the deltas for you:
|
|
//
|
|
// - spin is trying to normalize how far the wheel was spun (or trackpad
|
|
// dragged). This is super useful for zoom support where you want to
|
|
// throw away the chunky scroll steps on the PC and make those equal to
|
|
// the slow and smooth tiny steps on the Mac. Key data: This code tries to
|
|
// resolve a single slow step on a wheel to 1.
|
|
//
|
|
// - pixel is normalizing the desired scroll delta in pixel units. You'll
|
|
// get the crazy differences between browsers, but at least it'll be in
|
|
// pixels!
|
|
//
|
|
// - positive value indicates scrolling DOWN/RIGHT, negative UP/LEFT. This
|
|
// should translate to positive value zooming IN, negative zooming OUT.
|
|
// This matches the newer 'wheel' event.
|
|
//
|
|
// Why are there spinX, spinY (or pixels)?
|
|
//
|
|
// - spinX is a 2-finger side drag on the trackpad, and a shift + wheel turn
|
|
// with a mouse. It results in side-scrolling in the browser by default.
|
|
//
|
|
// - spinY is what you expect -- it's the classic axis of a mouse wheel.
|
|
//
|
|
// - I dropped spinZ/pixelZ. It is supported by the DOM 3 'wheel' event and
|
|
// probably is by browsers in conjunction with fancy 3D controllers .. but
|
|
// you know.
|
|
//
|
|
// Implementation info:
|
|
//
|
|
// Examples of 'wheel' event if you scroll slowly (down) by one step with an
|
|
// average mouse:
|
|
//
|
|
// OS X + Chrome (mouse) - 4 pixel delta (wheelDelta -120)
|
|
// OS X + Safari (mouse) - N/A pixel delta (wheelDelta -12)
|
|
// OS X + Firefox (mouse) - 0.1 line delta (wheelDelta N/A)
|
|
// Win8 + Chrome (mouse) - 100 pixel delta (wheelDelta -120)
|
|
// Win8 + Firefox (mouse) - 3 line delta (wheelDelta -120)
|
|
//
|
|
// On the trackpad:
|
|
//
|
|
// OS X + Chrome (trackpad) - 2 pixel delta (wheelDelta -6)
|
|
// OS X + Firefox (trackpad) - 1 pixel delta (wheelDelta N/A)
|
|
//
|
|
// On other/older browsers.. it's more complicated as there can be multiple and
|
|
// also missing delta values.
|
|
//
|
|
// The 'wheel' event is more standard:
|
|
//
|
|
// http://www.w3.org/TR/DOM-Level-3-Events/#events-wheelevents
|
|
//
|
|
// The basics is that it includes a unit, deltaMode (pixels, lines, pages), and
|
|
// deltaX, deltaY and deltaZ. Some browsers provide other values to maintain
|
|
// backward compatibility with older events. Those other values help us
|
|
// better normalize spin speed. Example of what the browsers provide:
|
|
//
|
|
// | event.wheelDelta | event.detail
|
|
// ------------------+------------------+--------------
|
|
// Safari v5/OS X | -120 | 0
|
|
// Safari v5/Win7 | -120 | 0
|
|
// Chrome v17/OS X | -120 | 0
|
|
// Chrome v17/Win7 | -120 | 0
|
|
// IE9/Win7 | -120 | undefined
|
|
// Firefox v4/OS X | undefined | 1
|
|
// Firefox v4/Win7 | undefined | 3
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
|
|
export interface VtkNormalizedWheelEvent {
|
|
spinX: number;
|
|
spinY: number;
|
|
pixelX: number;
|
|
pixelY: number;
|
|
}
|
|
|
|
export function normalizeWheel(wheelEvent: object): VtkNormalizedWheelEvent;
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Default export
|
|
// ----------------------------------------------------------------------------
|
|
|
|
declare const Macro: {
|
|
algo: typeof algo;
|
|
capitalize: typeof capitalize;
|
|
chain: typeof chain;
|
|
debounce: typeof debounce;
|
|
enumToString: typeof enumToString;
|
|
event: typeof event;
|
|
EVENT_ABORT: typeof EVENT_ABORT;
|
|
formatBytesToProperUnit: typeof formatBytesToProperUnit;
|
|
formatNumbersWithThousandSeparator: typeof formatNumbersWithThousandSeparator;
|
|
get: typeof get;
|
|
getArray: typeof getArray;
|
|
getCurrentGlobalMTime(): Number;
|
|
getStateArrayMapFunc: typeof getStateArrayMapFunc;
|
|
isVtkObject: typeof isVtkObject;
|
|
keystore: typeof keystore;
|
|
measurePromiseExecution: typeof measurePromiseExecution;
|
|
moveToProtected: typeof moveToProtected;
|
|
newInstance: typeof newInstance;
|
|
normalizeWheel: typeof normalizeWheel;
|
|
obj: typeof obj;
|
|
proxy: typeof proxy;
|
|
proxyPropertyMapping: typeof proxyPropertyMapping;
|
|
proxyPropertyState: typeof proxyPropertyState;
|
|
safeArrays: typeof safeArrays;
|
|
set: typeof set;
|
|
setArray: typeof setArray;
|
|
setGet: typeof setGet;
|
|
setGetArray: typeof setGetArray;
|
|
setImmediate: typeof setImmediateVTK;
|
|
setLoggerFunction: typeof setLoggerFunction;
|
|
throttle: typeof throttle;
|
|
traverseInstanceTree: typeof traverseInstanceTree;
|
|
TYPED_ARRAYS: typeof TYPED_ARRAYS;
|
|
uncapitalize: typeof uncapitalize;
|
|
VOID: typeof VOID;
|
|
vtkDebugMacro: typeof vtkDebugMacro;
|
|
vtkErrorMacro: typeof vtkErrorMacro;
|
|
vtkInfoMacro: typeof vtkInfoMacro;
|
|
vtkLogMacro: typeof vtkLogMacro;
|
|
vtkOnceErrorMacro: typeof vtkOnceErrorMacro;
|
|
vtkWarningMacro: typeof vtkWarningMacro;
|
|
};
|
|
|
|
export default Macro;
|