initial commit
This commit is contained in:
@@ -0,0 +1,425 @@
|
||||
shadow$provide.module$node_modules$pixi_DOT_js$lib$events$EventBoundary = function(global, require, module, exports) {
|
||||
var EventEmitter = require("module$node_modules$eventemitter3$index");
|
||||
global = require("module$node_modules$pixi_DOT_js$lib$maths$point$Point");
|
||||
var warn = require("module$node_modules$pixi_DOT_js$lib$utils$logging$warn"), EventTicker = require("module$node_modules$pixi_DOT_js$lib$events$EventTicker"), FederatedMouseEvent = require("module$node_modules$pixi_DOT_js$lib$events$FederatedMouseEvent"), FederatedPointerEvent = require("module$node_modules$pixi_DOT_js$lib$events$FederatedPointerEvent"), FederatedWheelEvent = require("module$node_modules$pixi_DOT_js$lib$events$FederatedWheelEvent");
|
||||
"use strict";
|
||||
const tempHitLocation = new global.Point(), tempLocalMapping = new global.Point();
|
||||
class EventBoundary {
|
||||
constructor(rootTarget) {
|
||||
this.dispatch = new EventEmitter();
|
||||
this.moveOnAll = !1;
|
||||
this.enableGlobalMoveEvents = !0;
|
||||
this.mappingState = {trackingData:{}};
|
||||
this.eventPool = new Map();
|
||||
this._allInteractiveElements = [];
|
||||
this._hitElements = [];
|
||||
this._isPointerMoveEvent = !1;
|
||||
this.rootTarget = rootTarget;
|
||||
this.hitPruneFn = this.hitPruneFn.bind(this);
|
||||
this.hitTestFn = this.hitTestFn.bind(this);
|
||||
this.mapPointerDown = this.mapPointerDown.bind(this);
|
||||
this.mapPointerMove = this.mapPointerMove.bind(this);
|
||||
this.mapPointerOut = this.mapPointerOut.bind(this);
|
||||
this.mapPointerOver = this.mapPointerOver.bind(this);
|
||||
this.mapPointerUp = this.mapPointerUp.bind(this);
|
||||
this.mapPointerUpOutside = this.mapPointerUpOutside.bind(this);
|
||||
this.mapWheel = this.mapWheel.bind(this);
|
||||
this.mappingTable = {};
|
||||
this.addEventMapping("pointerdown", this.mapPointerDown);
|
||||
this.addEventMapping("pointermove", this.mapPointerMove);
|
||||
this.addEventMapping("pointerout", this.mapPointerOut);
|
||||
this.addEventMapping("pointerleave", this.mapPointerOut);
|
||||
this.addEventMapping("pointerover", this.mapPointerOver);
|
||||
this.addEventMapping("pointerup", this.mapPointerUp);
|
||||
this.addEventMapping("pointerupoutside", this.mapPointerUpOutside);
|
||||
this.addEventMapping("wheel", this.mapWheel);
|
||||
}
|
||||
addEventMapping(type, fn) {
|
||||
this.mappingTable[type] || (this.mappingTable[type] = []);
|
||||
this.mappingTable[type].push({fn, priority:0});
|
||||
this.mappingTable[type].sort((a, b) => a.priority - b.priority);
|
||||
}
|
||||
dispatchEvent(e, type) {
|
||||
e.propagationStopped = !1;
|
||||
e.propagationImmediatelyStopped = !1;
|
||||
this.propagate(e, type);
|
||||
this.dispatch.emit(type || e.type, e);
|
||||
}
|
||||
mapEvent(e) {
|
||||
if (this.rootTarget) {
|
||||
var mappers = this.mappingTable[e.type];
|
||||
if (mappers) {
|
||||
for (let i = 0, j = mappers.length; i < j; i++) {
|
||||
mappers[i].fn(e);
|
||||
}
|
||||
} else {
|
||||
warn.warn(`[EventBoundary]: Event mapping not defined for ${e.type}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
hitTest(x, y) {
|
||||
EventTicker.EventsTicker.pauseUpdate = !0;
|
||||
return (x = this[this._isPointerMoveEvent && this.enableGlobalMoveEvents ? "hitTestMoveRecursive" : "hitTestRecursive"](this.rootTarget, this.rootTarget.eventMode, tempHitLocation.set(x, y), this.hitTestFn, this.hitPruneFn)) && x[0];
|
||||
}
|
||||
propagate(e, type) {
|
||||
if (e.target) {
|
||||
var composedPath = e.composedPath();
|
||||
e.eventPhase = e.CAPTURING_PHASE;
|
||||
for (let i = 0, j = composedPath.length - 1; i < j; i++) {
|
||||
if (e.currentTarget = composedPath[i], this.notifyTarget(e, type), e.propagationStopped || e.propagationImmediatelyStopped) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
e.eventPhase = e.AT_TARGET;
|
||||
e.currentTarget = e.target;
|
||||
this.notifyTarget(e, type);
|
||||
if (!e.propagationStopped && !e.propagationImmediatelyStopped) {
|
||||
e.eventPhase = e.BUBBLING_PHASE;
|
||||
for (let i = composedPath.length - 2; 0 <= i && (e.currentTarget = composedPath[i], this.notifyTarget(e, type), !e.propagationStopped && !e.propagationImmediatelyStopped); i--) {
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
all(e, type, targets = this._allInteractiveElements) {
|
||||
if (0 !== targets.length) {
|
||||
e.eventPhase = e.BUBBLING_PHASE;
|
||||
type = Array.isArray(type) ? type : [type];
|
||||
for (let i = targets.length - 1; 0 <= i; i--) {
|
||||
type.forEach(event => {
|
||||
e.currentTarget = targets[i];
|
||||
this.notifyTarget(e, event);
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
propagationPath(target) {
|
||||
const propagationPath = [target];
|
||||
for (let i = 0; 2048 > i && target !== this.rootTarget && target.parent; i++) {
|
||||
if (!target.parent) {
|
||||
throw Error("Cannot find propagation path to disconnected target");
|
||||
}
|
||||
propagationPath.push(target.parent);
|
||||
target = target.parent;
|
||||
}
|
||||
propagationPath.reverse();
|
||||
return propagationPath;
|
||||
}
|
||||
hitTestMoveRecursive(currentTarget, eventMode, location, testFn, pruneFn, ignore = !1) {
|
||||
var shouldReturn = !1;
|
||||
if (this._interactivePrune(currentTarget)) {
|
||||
return null;
|
||||
}
|
||||
if ("dynamic" === currentTarget.eventMode || "dynamic" === eventMode) {
|
||||
EventTicker.EventsTicker.pauseUpdate = !1;
|
||||
}
|
||||
if (currentTarget.interactiveChildren && currentTarget.children) {
|
||||
var children = currentTarget.children;
|
||||
for (let i = children.length - 1; 0 <= i; i--) {
|
||||
var child = children[i];
|
||||
if ((child = this.hitTestMoveRecursive(child, this._isInteractive(eventMode) ? eventMode : child.eventMode, location, testFn, pruneFn, ignore || pruneFn(currentTarget, location))) && (!(0 < child.length) || child[child.length - 1].parent)) {
|
||||
shouldReturn = currentTarget.isInteractive();
|
||||
if (0 < child.length || shouldReturn) {
|
||||
shouldReturn && this._allInteractiveElements.push(currentTarget), child.push(currentTarget);
|
||||
}
|
||||
0 === this._hitElements.length && (this._hitElements = child);
|
||||
shouldReturn = !0;
|
||||
}
|
||||
}
|
||||
}
|
||||
eventMode = this._isInteractive(eventMode);
|
||||
(children = currentTarget.isInteractive()) && children && this._allInteractiveElements.push(currentTarget);
|
||||
return ignore || 0 < this._hitElements.length ? null : shouldReturn ? this._hitElements : eventMode && !pruneFn(currentTarget, location) && testFn(currentTarget, location) ? children ? [currentTarget] : [] : null;
|
||||
}
|
||||
hitTestRecursive(currentTarget, eventMode, location, testFn, pruneFn) {
|
||||
if (this._interactivePrune(currentTarget) || pruneFn(currentTarget, location)) {
|
||||
return null;
|
||||
}
|
||||
if ("dynamic" === currentTarget.eventMode || "dynamic" === eventMode) {
|
||||
EventTicker.EventsTicker.pauseUpdate = !1;
|
||||
}
|
||||
if (currentTarget.interactiveChildren && currentTarget.children) {
|
||||
const children = currentTarget.children;
|
||||
for (let i = children.length - 1; 0 <= i; i--) {
|
||||
var child = children[i];
|
||||
if ((child = this.hitTestRecursive(child, this._isInteractive(eventMode) ? eventMode : child.eventMode, location, testFn, pruneFn)) && (!(0 < child.length) || child[child.length - 1].parent)) {
|
||||
return location = currentTarget.isInteractive(), (0 < child.length || location) && child.push(currentTarget), child;
|
||||
}
|
||||
}
|
||||
}
|
||||
eventMode = this._isInteractive(eventMode);
|
||||
pruneFn = currentTarget.isInteractive();
|
||||
return eventMode && testFn(currentTarget, location) ? pruneFn ? [currentTarget] : [] : null;
|
||||
}
|
||||
_isInteractive(int) {
|
||||
return "static" === int || "dynamic" === int;
|
||||
}
|
||||
_interactivePrune(container) {
|
||||
return container && container.visible && container.renderable && container.measurable && "none" !== container.eventMode && ("passive" !== container.eventMode || container.interactiveChildren) ? !1 : !0;
|
||||
}
|
||||
hitPruneFn(container, location) {
|
||||
if (container.hitArea && (container.worldTransform.applyInverse(location, tempLocalMapping), !container.hitArea.contains(tempLocalMapping.x, tempLocalMapping.y))) {
|
||||
return !0;
|
||||
}
|
||||
if (container.effects && container.effects.length) {
|
||||
for (let i = 0; i < container.effects.length; i++) {
|
||||
const effect = container.effects[i];
|
||||
if (effect.containsPoint && !effect.containsPoint(location, this.hitTestFn)) {
|
||||
return !0;
|
||||
}
|
||||
}
|
||||
}
|
||||
return !1;
|
||||
}
|
||||
hitTestFn(container, location) {
|
||||
return container.hitArea ? !0 : container?.containsPoint ? (container.worldTransform.applyInverse(location, tempLocalMapping), container.containsPoint(tempLocalMapping)) : !1;
|
||||
}
|
||||
notifyTarget(e, type) {
|
||||
e.currentTarget.isInteractive() && (type ?? (type = e.type), e.currentTarget[`on${type}`]?.(e), this._notifyListeners(e, e.eventPhase === e.CAPTURING_PHASE || e.eventPhase === e.AT_TARGET ? `${type}capture` : type), e.eventPhase === e.AT_TARGET && this._notifyListeners(e, type));
|
||||
}
|
||||
mapPointerDown(from) {
|
||||
if (from instanceof FederatedPointerEvent.FederatedPointerEvent) {
|
||||
var e = this.createPointerEvent(from);
|
||||
this.dispatchEvent(e, "pointerdown");
|
||||
"touch" === e.pointerType ? this.dispatchEvent(e, "touchstart") : ("mouse" === e.pointerType || "pen" === e.pointerType) && this.dispatchEvent(e, 2 === e.button ? "rightdown" : "mousedown");
|
||||
this.trackingData(from.pointerId).pressTargetsByButton[from.button] = e.composedPath();
|
||||
this.freeEvent(e);
|
||||
} else {
|
||||
warn.warn("EventBoundary cannot map a non-pointer event as a pointer event");
|
||||
}
|
||||
}
|
||||
mapPointerMove(from) {
|
||||
if (from instanceof FederatedPointerEvent.FederatedPointerEvent) {
|
||||
this._allInteractiveElements.length = 0;
|
||||
this._hitElements.length = 0;
|
||||
this._isPointerMoveEvent = !0;
|
||||
var e = this.createPointerEvent(from);
|
||||
this._isPointerMoveEvent = !1;
|
||||
var isMouse = "mouse" === e.pointerType || "pen" === e.pointerType, trackingData = this.trackingData(from.pointerId), outTarget = this.findMountedTarget(trackingData.overTargets);
|
||||
if (0 < trackingData.overTargets?.length && outTarget !== e.target) {
|
||||
var outEvent = this.createPointerEvent(from, "mousemove" === from.type ? "mouseout" : "pointerout", outTarget);
|
||||
this.dispatchEvent(outEvent, "pointerout");
|
||||
isMouse && this.dispatchEvent(outEvent, "mouseout");
|
||||
if (!e.composedPath().includes(outTarget)) {
|
||||
const leaveEvent = this.createPointerEvent(from, "pointerleave", outTarget);
|
||||
for (leaveEvent.eventPhase = leaveEvent.AT_TARGET; leaveEvent.target && !e.composedPath().includes(leaveEvent.target);) {
|
||||
leaveEvent.currentTarget = leaveEvent.target, this.notifyTarget(leaveEvent), isMouse && this.notifyTarget(leaveEvent, "mouseleave"), leaveEvent.target = leaveEvent.target.parent;
|
||||
}
|
||||
this.freeEvent(leaveEvent);
|
||||
}
|
||||
this.freeEvent(outEvent);
|
||||
}
|
||||
if (outTarget !== e.target) {
|
||||
from = this.clonePointerEvent(e, "mousemove" === from.type ? "mouseover" : "pointerover");
|
||||
this.dispatchEvent(from, "pointerover");
|
||||
isMouse && this.dispatchEvent(from, "mouseover");
|
||||
for (outEvent = outTarget?.parent; outEvent && outEvent !== this.rootTarget.parent && outEvent !== e.target;) {
|
||||
outEvent = outEvent.parent;
|
||||
}
|
||||
if (!outEvent || outEvent === this.rootTarget.parent) {
|
||||
outEvent = this.clonePointerEvent(e, "pointerenter");
|
||||
for (outEvent.eventPhase = outEvent.AT_TARGET; outEvent.target && outEvent.target !== outTarget && outEvent.target !== this.rootTarget.parent;) {
|
||||
outEvent.currentTarget = outEvent.target, this.notifyTarget(outEvent), isMouse && this.notifyTarget(outEvent, "mouseenter"), outEvent.target = outEvent.target.parent;
|
||||
}
|
||||
this.freeEvent(outEvent);
|
||||
}
|
||||
this.freeEvent(from);
|
||||
}
|
||||
outTarget = [];
|
||||
from = this.enableGlobalMoveEvents ?? !0;
|
||||
this.moveOnAll ? outTarget.push("pointermove") : this.dispatchEvent(e, "pointermove");
|
||||
from && outTarget.push("globalpointermove");
|
||||
"touch" === e.pointerType && (this.moveOnAll ? outTarget.splice(1, 0, "touchmove") : this.dispatchEvent(e, "touchmove"), from && outTarget.push("globaltouchmove"));
|
||||
isMouse && (this.moveOnAll ? outTarget.splice(1, 0, "mousemove") : this.dispatchEvent(e, "mousemove"), from && outTarget.push("globalmousemove"), this.cursor = e.target?.cursor);
|
||||
0 < outTarget.length && this.all(e, outTarget);
|
||||
this._allInteractiveElements.length = 0;
|
||||
this._hitElements.length = 0;
|
||||
trackingData.overTargets = e.composedPath();
|
||||
this.freeEvent(e);
|
||||
} else {
|
||||
warn.warn("EventBoundary cannot map a non-pointer event as a pointer event");
|
||||
}
|
||||
}
|
||||
mapPointerOver(from) {
|
||||
if (from instanceof FederatedPointerEvent.FederatedPointerEvent) {
|
||||
var trackingData = this.trackingData(from.pointerId);
|
||||
from = this.createPointerEvent(from);
|
||||
var isMouse = "mouse" === from.pointerType || "pen" === from.pointerType;
|
||||
this.dispatchEvent(from, "pointerover");
|
||||
isMouse && this.dispatchEvent(from, "mouseover");
|
||||
"mouse" === from.pointerType && (this.cursor = from.target?.cursor);
|
||||
var enterEvent = this.clonePointerEvent(from, "pointerenter");
|
||||
for (enterEvent.eventPhase = enterEvent.AT_TARGET; enterEvent.target && enterEvent.target !== this.rootTarget.parent;) {
|
||||
enterEvent.currentTarget = enterEvent.target, this.notifyTarget(enterEvent), isMouse && this.notifyTarget(enterEvent, "mouseenter"), enterEvent.target = enterEvent.target.parent;
|
||||
}
|
||||
trackingData.overTargets = from.composedPath();
|
||||
this.freeEvent(from);
|
||||
this.freeEvent(enterEvent);
|
||||
} else {
|
||||
warn.warn("EventBoundary cannot map a non-pointer event as a pointer event");
|
||||
}
|
||||
}
|
||||
mapPointerOut(from) {
|
||||
if (from instanceof FederatedPointerEvent.FederatedPointerEvent) {
|
||||
var trackingData = this.trackingData(from.pointerId);
|
||||
if (trackingData.overTargets) {
|
||||
const isMouse = "mouse" === from.pointerType || "pen" === from.pointerType, outTarget = this.findMountedTarget(trackingData.overTargets), outEvent = this.createPointerEvent(from, "pointerout", outTarget);
|
||||
this.dispatchEvent(outEvent);
|
||||
isMouse && this.dispatchEvent(outEvent, "mouseout");
|
||||
from = this.createPointerEvent(from, "pointerleave", outTarget);
|
||||
for (from.eventPhase = from.AT_TARGET; from.target && from.target !== this.rootTarget.parent;) {
|
||||
from.currentTarget = from.target, this.notifyTarget(from), isMouse && this.notifyTarget(from, "mouseleave"), from.target = from.target.parent;
|
||||
}
|
||||
trackingData.overTargets = null;
|
||||
this.freeEvent(outEvent);
|
||||
this.freeEvent(from);
|
||||
}
|
||||
this.cursor = null;
|
||||
} else {
|
||||
warn.warn("EventBoundary cannot map a non-pointer event as a pointer event");
|
||||
}
|
||||
}
|
||||
mapPointerUp(from) {
|
||||
if (from instanceof FederatedPointerEvent.FederatedPointerEvent) {
|
||||
var now = performance.now(), e = this.createPointerEvent(from);
|
||||
this.dispatchEvent(e, "pointerup");
|
||||
"touch" === e.pointerType ? this.dispatchEvent(e, "touchend") : ("mouse" === e.pointerType || "pen" === e.pointerType) && this.dispatchEvent(e, 2 === e.button ? "rightup" : "mouseup");
|
||||
var trackingData = this.trackingData(from.pointerId), pressTarget = this.findMountedTarget(trackingData.pressTargetsByButton[from.button]), clickTarget = pressTarget;
|
||||
if (pressTarget && !e.composedPath().includes(pressTarget)) {
|
||||
for (clickTarget = pressTarget; clickTarget && !e.composedPath().includes(clickTarget);) {
|
||||
e.currentTarget = clickTarget, this.notifyTarget(e, "pointerupoutside"), "touch" === e.pointerType ? this.notifyTarget(e, "touchendoutside") : ("mouse" === e.pointerType || "pen" === e.pointerType) && this.notifyTarget(e, 2 === e.button ? "rightupoutside" : "mouseupoutside"), clickTarget = clickTarget.parent;
|
||||
}
|
||||
delete trackingData.pressTargetsByButton[from.button];
|
||||
}
|
||||
clickTarget && (pressTarget = this.clonePointerEvent(e, "click"), pressTarget.target = clickTarget, pressTarget.path = null, trackingData.clicksByButton[from.button] || (trackingData.clicksByButton[from.button] = {clickCount:0, target:pressTarget.target, timeStamp:now}), from = trackingData.clicksByButton[from.button], from.target === pressTarget.target && 200 > now - from.timeStamp ? ++from.clickCount : from.clickCount = 1, from.target = pressTarget.target, from.timeStamp = now, pressTarget.detail =
|
||||
from.clickCount, "mouse" === pressTarget.pointerType ? this.dispatchEvent(pressTarget, 2 === pressTarget.button ? "rightclick" : "click") : "touch" === pressTarget.pointerType && this.dispatchEvent(pressTarget, "tap"), this.dispatchEvent(pressTarget, "pointertap"), this.freeEvent(pressTarget));
|
||||
this.freeEvent(e);
|
||||
} else {
|
||||
warn.warn("EventBoundary cannot map a non-pointer event as a pointer event");
|
||||
}
|
||||
}
|
||||
mapPointerUpOutside(from) {
|
||||
if (from instanceof FederatedPointerEvent.FederatedPointerEvent) {
|
||||
var trackingData = this.trackingData(from.pointerId), pressTarget = this.findMountedTarget(trackingData.pressTargetsByButton[from.button]), e = this.createPointerEvent(from);
|
||||
if (pressTarget) {
|
||||
for (; pressTarget;) {
|
||||
e.currentTarget = pressTarget, this.notifyTarget(e, "pointerupoutside"), "touch" === e.pointerType ? this.notifyTarget(e, "touchendoutside") : ("mouse" === e.pointerType || "pen" === e.pointerType) && this.notifyTarget(e, 2 === e.button ? "rightupoutside" : "mouseupoutside"), pressTarget = pressTarget.parent;
|
||||
}
|
||||
delete trackingData.pressTargetsByButton[from.button];
|
||||
}
|
||||
this.freeEvent(e);
|
||||
} else {
|
||||
warn.warn("EventBoundary cannot map a non-pointer event as a pointer event");
|
||||
}
|
||||
}
|
||||
mapWheel(from) {
|
||||
from instanceof FederatedWheelEvent.FederatedWheelEvent ? (from = this.createWheelEvent(from), this.dispatchEvent(from), this.freeEvent(from)) : warn.warn("EventBoundary cannot map a non-wheel event as a wheel event");
|
||||
}
|
||||
findMountedTarget(propagationPath) {
|
||||
if (!propagationPath) {
|
||||
return null;
|
||||
}
|
||||
let currentTarget = propagationPath[0];
|
||||
for (let i = 1; i < propagationPath.length; i++) {
|
||||
if (propagationPath[i].parent === currentTarget) {
|
||||
currentTarget = propagationPath[i];
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
return currentTarget;
|
||||
}
|
||||
createPointerEvent(from, type, target) {
|
||||
const event = this.allocateEvent(FederatedPointerEvent.FederatedPointerEvent);
|
||||
this.copyPointerData(from, event);
|
||||
this.copyMouseData(from, event);
|
||||
this.copyData(from, event);
|
||||
event.nativeEvent = from.nativeEvent;
|
||||
event.originalEvent = from;
|
||||
event.target = target ?? this.hitTest(event.global.x, event.global.y) ?? this._hitElements[0];
|
||||
"string" === typeof type && (event.type = type);
|
||||
return event;
|
||||
}
|
||||
createWheelEvent(from) {
|
||||
const event = this.allocateEvent(FederatedWheelEvent.FederatedWheelEvent);
|
||||
this.copyWheelData(from, event);
|
||||
this.copyMouseData(from, event);
|
||||
this.copyData(from, event);
|
||||
event.nativeEvent = from.nativeEvent;
|
||||
event.originalEvent = from;
|
||||
event.target = this.hitTest(event.global.x, event.global.y);
|
||||
return event;
|
||||
}
|
||||
clonePointerEvent(from, type) {
|
||||
const event = this.allocateEvent(FederatedPointerEvent.FederatedPointerEvent);
|
||||
event.nativeEvent = from.nativeEvent;
|
||||
event.originalEvent = from.originalEvent;
|
||||
this.copyPointerData(from, event);
|
||||
this.copyMouseData(from, event);
|
||||
this.copyData(from, event);
|
||||
event.target = from.target;
|
||||
event.path = from.composedPath().slice();
|
||||
event.type = type ?? event.type;
|
||||
return event;
|
||||
}
|
||||
copyWheelData(from, to) {
|
||||
to.deltaMode = from.deltaMode;
|
||||
to.deltaX = from.deltaX;
|
||||
to.deltaY = from.deltaY;
|
||||
to.deltaZ = from.deltaZ;
|
||||
}
|
||||
copyPointerData(from, to) {
|
||||
from instanceof FederatedPointerEvent.FederatedPointerEvent && to instanceof FederatedPointerEvent.FederatedPointerEvent && (to.pointerId = from.pointerId, to.width = from.width, to.height = from.height, to.isPrimary = from.isPrimary, to.pointerType = from.pointerType, to.pressure = from.pressure, to.tangentialPressure = from.tangentialPressure, to.tiltX = from.tiltX, to.tiltY = from.tiltY, to.twist = from.twist);
|
||||
}
|
||||
copyMouseData(from, to) {
|
||||
from instanceof FederatedMouseEvent.FederatedMouseEvent && to instanceof FederatedMouseEvent.FederatedMouseEvent && (to.altKey = from.altKey, to.button = from.button, to.buttons = from.buttons, to.client.copyFrom(from.client), to.ctrlKey = from.ctrlKey, to.metaKey = from.metaKey, to.movement.copyFrom(from.movement), to.screen.copyFrom(from.screen), to.shiftKey = from.shiftKey, to.global.copyFrom(from.global));
|
||||
}
|
||||
copyData(from, to) {
|
||||
to.isTrusted = from.isTrusted;
|
||||
to.srcElement = from.srcElement;
|
||||
to.timeStamp = performance.now();
|
||||
to.type = from.type;
|
||||
to.detail = from.detail;
|
||||
to.view = from.view;
|
||||
to.which = from.which;
|
||||
to.layer.copyFrom(from.layer);
|
||||
to.page.copyFrom(from.page);
|
||||
}
|
||||
trackingData(id) {
|
||||
this.mappingState.trackingData[id] || (this.mappingState.trackingData[id] = {pressTargetsByButton:{}, clicksByButton:{}, overTarget:null});
|
||||
return this.mappingState.trackingData[id];
|
||||
}
|
||||
allocateEvent(constructor) {
|
||||
this.eventPool.has(constructor) || this.eventPool.set(constructor, []);
|
||||
constructor = this.eventPool.get(constructor).pop() || new constructor(this);
|
||||
constructor.eventPhase = constructor.NONE;
|
||||
constructor.currentTarget = null;
|
||||
constructor.defaultPrevented = !1;
|
||||
constructor.path = null;
|
||||
constructor.target = null;
|
||||
return constructor;
|
||||
}
|
||||
freeEvent(event) {
|
||||
if (event.manager !== this) {
|
||||
throw Error("It is illegal to free an event not managed by this EventBoundary!");
|
||||
}
|
||||
const constructor = event.constructor;
|
||||
this.eventPool.has(constructor) || this.eventPool.set(constructor, []);
|
||||
this.eventPool.get(constructor).push(event);
|
||||
}
|
||||
_notifyListeners(e, type) {
|
||||
const listeners = e.currentTarget._events[type];
|
||||
if (listeners) {
|
||||
if ("fn" in listeners) {
|
||||
listeners.once && e.currentTarget.removeListener(type, listeners.fn, void 0, !0), listeners.fn.call(listeners.context, e);
|
||||
} else {
|
||||
for (let i = 0, j = listeners.length; i < j && !e.propagationImmediatelyStopped; i++) {
|
||||
listeners[i].once && e.currentTarget.removeListener(type, listeners[i].fn, void 0, !0), listeners[i].fn.call(listeners[i].context, e);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
exports.EventBoundary = EventBoundary;
|
||||
};
|
||||
|
||||
//# sourceMappingURL=module$node_modules$pixi_DOT_js$lib$events$EventBoundary.js.map
|
||||
Reference in New Issue
Block a user