react-native-gesture-handler
Version:
Declarative API exposing native platform touch and gesture system to React Native
108 lines (106 loc) • 3.46 kB
JavaScript
;
import { PointerType } from '../../PointerType';
import { EventTypes } from '../interfaces';
import { viewportToLocal } from '../utils';
import EventManager from './EventManager';
export default class KeyboardEventManager extends EventManager {
static activationKeys = new Set(['Enter', ' ']);
static cancelationKeys = new Set(['Tab']);
keyPointer = null;
static registeredStaticListeners = false;
static instances = new Set();
static keyUpStaticCallback = event => {
// We need a global listener, as in some cases, keyUp event gets stop-propagated.
// Then, if we used only component-level listeners the gesture would never end,
// causing other gestues to fail.
if (!this.activationKeys.has(event.key)) {
return;
}
this.instances.forEach(item => {
item.onKeyUp(event);
});
};
keyDownCallback = event => {
if (this.keyPointer !== null) {
if (KeyboardEventManager.cancelationKeys.has(event.key)) {
this.dispatchEvent(event, EventTypes.CANCEL);
this.keyPointer = null;
}
return;
}
if (!KeyboardEventManager.activationKeys.has(event.key) || event.repeat) {
return;
}
this.keyPointer = event.key;
this.dispatchEvent(event, EventTypes.DOWN);
};
onKeyUp = event => {
if (this.keyPointer !== event.key) {
return;
}
this.dispatchEvent(event, EventTypes.UP);
this.keyPointer = null;
};
dispatchEvent(event, eventType) {
if (!(event.target instanceof HTMLElement)) {
return;
}
const adaptedEvent = this.mapEvent(event, eventType);
switch (eventType) {
case EventTypes.UP:
this.onPointerUp(adaptedEvent);
break;
case EventTypes.DOWN:
this.onPointerDown(adaptedEvent);
break;
case EventTypes.CANCEL:
this.onPointerCancel(adaptedEvent);
break;
}
}
registerListeners() {
this.view.addEventListener('keydown', this.keyDownCallback);
KeyboardEventManager.instances.add(this);
if (!KeyboardEventManager.registeredStaticListeners) {
KeyboardEventManager.registeredStaticListeners = true;
document.addEventListener('keyup', KeyboardEventManager.keyUpStaticCallback, {
capture: true
});
}
}
unregisterListeners() {
this.view.removeEventListener('keydown', this.keyDownCallback);
KeyboardEventManager.instances.delete(this);
if (KeyboardEventManager.instances.size === 0) {
document.removeEventListener('keyup', KeyboardEventManager.keyUpStaticCallback, {
capture: true
});
KeyboardEventManager.registeredStaticListeners = false;
}
}
resetManager() {
super.resetManager();
this.keyPointer = null;
}
mapEvent(event, eventType) {
const viewRect = event.target.getBoundingClientRect();
// The center of the focused element, which is where its own center lands
// whatever the transforms.
const viewportPosition = {
x: viewRect?.x + viewRect?.width / 2,
y: viewRect?.y + viewRect?.height / 2
};
const relativePosition = viewportToLocal(this.view, viewportPosition);
return {
x: viewportPosition.x,
y: viewportPosition.y,
offsetX: relativePosition.x,
offsetY: relativePosition.y,
pointerId: 0,
eventType: eventType,
pointerType: PointerType.KEY,
time: event.timeStamp
};
}
}
//# sourceMappingURL=KeyboardEventManager.js.map