lvfulong
598 lines
20 KiB
TypeScript
598 lines
20 KiB
TypeScript
|
|
interface EventListener {
|
|
(evt: Event): void;
|
|
}
|
|
interface EventListenerObject {
|
|
handleEvent(evt: Event): void;
|
|
}
|
|
|
|
declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
|
|
|
|
interface EventHandler {
|
|
obj: Object;
|
|
listener: EventListenerOrEventListenerObject;
|
|
useCapture: boolean;
|
|
}
|
|
|
|
interface EventInit {
|
|
bubbles?: boolean;
|
|
cancelable?: boolean;
|
|
}
|
|
|
|
interface GlobalEventHandlers {
|
|
addEventListener(type: "pointercancel", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
|
|
addEventListener(type: "pointerdown", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
|
|
addEventListener(type: "pointerenter", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
|
|
addEventListener(type: "pointerleave", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
|
|
addEventListener(type: "pointermove", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
|
|
addEventListener(type: "pointerout", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
|
|
addEventListener(type: "pointerover", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
|
|
addEventListener(type: "pointerup", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
|
|
addEventListener(type: "wheel", listener: (ev: WheelEvent) => any, useCapture?: boolean): void;
|
|
addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
|
|
}
|
|
|
|
class GlobalEventHandlers implements GlobalEventHandlers {
|
|
constructor() {
|
|
|
|
}
|
|
onpointercancel(ev: PointerEvent): any {
|
|
return null;
|
|
}
|
|
onpointerdown(ev: PointerEvent): any {
|
|
return null;
|
|
}
|
|
onpointerenter(ev: PointerEvent): any {
|
|
return null;
|
|
}
|
|
onpointerleave(ev: PointerEvent): any {
|
|
return null;
|
|
}
|
|
onpointermove(ev: PointerEvent): any {
|
|
return null;
|
|
}
|
|
onpointerout(ev: PointerEvent): any {
|
|
return null;
|
|
}
|
|
onpointerover(ev: PointerEvent): any {
|
|
return null;
|
|
}
|
|
onpointerup(ev: PointerEvent): any {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
class ErrorEvent implements ErrorEvent {
|
|
constructor() {
|
|
|
|
}
|
|
initErrorEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, messageArg: string, filenameArg: string, linenoArg: number): void {
|
|
//TODO
|
|
}
|
|
}
|
|
|
|
class Event {
|
|
//TODO 下面的属性应该是只读的。
|
|
/**
|
|
* 是否允许冒泡
|
|
*/
|
|
bubbles: boolean;
|
|
cancelBubble: boolean; //阻止冒泡
|
|
/**
|
|
* 如果为false，则不允许cancle
|
|
*/
|
|
cancelable: boolean;
|
|
currentTarget: EventTarget;
|
|
defaultPrevented: boolean;
|
|
eventPhase: number;
|
|
isTrusted: boolean;
|
|
returnValue: boolean;
|
|
srcElement: Element;
|
|
target: EventTarget;
|
|
timeStamp: number;
|
|
type: string;
|
|
_propagationStopped = false;
|
|
constructor(type: string, eventInitDict?: EventInit) {
|
|
this.type = type;
|
|
this.timeStamp = Date.now();
|
|
this.bubbles = false;//默认为false
|
|
this.cancelable = false;
|
|
this.eventPhase = Event.AT_TARGET;
|
|
if (eventInitDict) {
|
|
this.bubbles = eventInitDict.bubbles;
|
|
this.cancelable = eventInitDict.cancelable;
|
|
}
|
|
}
|
|
initEvent(eventTypeArg: string, canBubbleArg: boolean, cancelableArg: boolean): void {
|
|
this.type = eventTypeArg;
|
|
this.bubbles = canBubbleArg;
|
|
this.cancelable = cancelableArg;
|
|
}
|
|
preventDefault(): void {
|
|
if (!this.cancelable)
|
|
return;
|
|
this.defaultPrevented = true;
|
|
}
|
|
stopImmediatePropagation(): void {
|
|
|
|
}
|
|
/**
|
|
* 阻止事件的传播。但是不阻止在本节点的传播
|
|
*/
|
|
stopPropagation(): void {
|
|
this._propagationStopped = true;
|
|
}
|
|
|
|
static AT_TARGET = 2; //处于目标阶段
|
|
static BUBBLING_PHASE = 3; //冒泡阶段
|
|
static CAPTURING_PHASE = 1; //捕获阶段
|
|
}
|
|
var _lbEvent= window['Event'] = Event;
|
|
|
|
interface _EventTarget {
|
|
addEventListener(type: "mousedown", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
|
|
addEventListener(type: "mouseenter", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
|
|
addEventListener(type: "mouseleave", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
|
|
addEventListener(type: "mousemove", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
|
|
addEventListener(type: "mouseout", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
|
|
addEventListener(type: "mouseover", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
|
|
addEventListener(type: "mouseup", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
|
|
addEventListener(type: "mousewheel", listener: (ev: MouseWheelEvent) => any, useCapture?: boolean): void;
|
|
addEventListener(type: "pointercancel", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
|
|
addEventListener(type: "pointerdown", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
|
|
addEventListener(type: "pointerenter", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
|
|
addEventListener(type: "pointerleave", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
|
|
addEventListener(type: "pointermove", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
|
|
addEventListener(type: "pointerout", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
|
|
addEventListener(type: "pointerover", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
|
|
addEventListener(type: "pointerup", listener: (ev: PointerEvent) => any, useCapture?: boolean): void;
|
|
addEventListener(type: "touchcancel", listener: (ev: TouchEvent) => any, useCapture?: boolean): void;
|
|
addEventListener(type: "touchend", listener: (ev: TouchEvent) => any, useCapture?: boolean): void;
|
|
addEventListener(type: "touchmove", listener: (ev: TouchEvent) => any, useCapture?: boolean): void;
|
|
addEventListener(type: "touchstart", listener: (ev: TouchEvent) => any, useCapture?: boolean): void;
|
|
addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
|
|
dispatchEvent(evt: Event): boolean;
|
|
removeEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
|
|
}
|
|
var _lbMap=Map;
|
|
class EventTarget implements _EventTarget {
|
|
protected _evtMaps = new _lbMap<string, EventHandler[]>();
|
|
dispatchEvent:(evt: Event)=>boolean ;
|
|
fireEventListeners:(evt: Event)=>void;
|
|
constructor(){
|
|
this.dispatchEvent = this._dispatchEvent.bind(this);
|
|
//this.addEventListener=this._addEventListener.bind(this);
|
|
this.fireEventListeners = this._fireEventListeners.bind(this);
|
|
}
|
|
/**
|
|
* TODO
|
|
* 没有考虑 useCapture
|
|
*/
|
|
addEventListener (type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void {
|
|
//console.log('addevtlistener:' + type);
|
|
var listeners = this._evtMaps.get(type) || [];
|
|
listeners.push({ obj: this, listener: listener, useCapture: useCapture });
|
|
this._evtMaps.set(type, listeners);
|
|
}
|
|
/*
|
|
addEventListener (type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void{
|
|
|
|
}
|
|
*/
|
|
/**
|
|
* @param
|
|
* @return boolean fase 则不允许触发缺省处理，表示有人曾经调用过 preventDefault.
|
|
*/
|
|
protected _dispatchEvent(evt: Event): boolean {
|
|
this.fireEventListeners(evt);
|
|
return !evt.defaultPrevented;
|
|
}
|
|
/**
|
|
* 要考虑一个listener被add了多次的情况
|
|
*/
|
|
removeEventListener = (type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void => {
|
|
var listeners = this._evtMaps.get(type);
|
|
if(!listeners)
|
|
return;
|
|
var newlisteners = [];
|
|
for (var i = 0, sz = listeners.length; i < sz; i++) {
|
|
if (listeners[i].listener != listener || listeners[i].useCapture != useCapture) {
|
|
newlisteners.push(listeners[i]);
|
|
}
|
|
}
|
|
this._evtMaps.set(type, newlisteners);
|
|
}
|
|
|
|
/**
|
|
* 需要绑定this
|
|
*/
|
|
protected _fireEventListeners (evt: Event):void {
|
|
var listeners: EventHandler[] = this._evtMaps.get(evt.type);
|
|
if (listeners) {
|
|
listeners.forEach(function(listener: EventHandler) {
|
|
switch (evt.eventPhase) {
|
|
case Event.CAPTURING_PHASE:
|
|
if (listener.useCapture && listener.listener)
|
|
(<any>listener.listener).call(listener.obj, evt);
|
|
break;
|
|
case Event.AT_TARGET:
|
|
if (listener.listener)
|
|
(<any>listener.listener).call(listener.obj, evt);
|
|
break;
|
|
case Event.BUBBLING_PHASE:
|
|
if (!listener.useCapture && listener.listener)
|
|
(<any>listener.listener).call(listener.obj, evt);
|
|
break;
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
interface UIEventInit extends EventInit {
|
|
view?: any; //window
|
|
detail?: number;
|
|
}
|
|
|
|
interface SharedKeyboardAndMouseEventInit extends UIEventInit {
|
|
ctrlKey?: boolean;
|
|
shiftKey?: boolean;
|
|
altKey?: boolean;
|
|
metaKey?: boolean;
|
|
keyModifierStateAltGraph?: boolean;
|
|
keyModifierStateCapsLock?: boolean;
|
|
keyModifierStateFn?: boolean;
|
|
keyModifierStateFnLock?: boolean;
|
|
keyModifierStateHyper?: boolean;
|
|
keyModifierStateNumLock?: boolean;
|
|
keyModifierStateOS?: boolean;
|
|
keyModifierStateScrollLock?: boolean;
|
|
keyModifierStateSuper?: boolean;
|
|
keyModifierStateSymbol?: boolean;
|
|
keyModifierStateSymbolLock?: boolean;
|
|
}
|
|
|
|
class UIEvent extends Event {
|
|
constructor(type: string, eventInitDict?: UIEventInit) {
|
|
super(type);
|
|
this.bubbles = true; //UIEVent的默认为true
|
|
if (eventInitDict) {
|
|
this.initUIEvent(type, eventInitDict.bubbles, eventInitDict.cancelable, eventInitDict.view, eventInitDict.detail);
|
|
}
|
|
}
|
|
detail: number;
|
|
view: Window;
|
|
initUIEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, detailArg: number): void {
|
|
this.type = typeArg;
|
|
this.cancelable = canBubbleArg;
|
|
this.cancelable = cancelableArg;
|
|
this.view = viewArg;
|
|
this.detail = detailArg;
|
|
}
|
|
}
|
|
|
|
interface KeyboardEventInit extends SharedKeyboardAndMouseEventInit {
|
|
key?: string;
|
|
location?: number;
|
|
repeat?: boolean;
|
|
}
|
|
|
|
interface MouseEventInit extends SharedKeyboardAndMouseEventInit {
|
|
screenX?: number;
|
|
screenY?: number;
|
|
clientX?: number;
|
|
clientY?: number;
|
|
button?: number;
|
|
buttons?: number;
|
|
relatedTarget?: EventTarget;
|
|
}
|
|
interface PointerEventInit extends MouseEventInit {
|
|
pointerId?: number;
|
|
width?: number;
|
|
height?: number;
|
|
pressure?: number;
|
|
tiltX?: number;
|
|
tiltY?: number;
|
|
pointerType?: string;
|
|
isPrimary?: boolean;
|
|
}
|
|
|
|
interface WheelEventInit extends MouseEventInit {
|
|
deltaX?: number;
|
|
deltaY?: number;
|
|
deltaZ?: number;
|
|
deltaMode?: number;
|
|
}
|
|
|
|
class PointerEvent {
|
|
constructor(typeArg: string, eventInitDict?: PointerEventInit) {
|
|
|
|
}
|
|
}
|
|
|
|
class MouseEvent extends UIEvent {
|
|
altKey: boolean;
|
|
button: number;
|
|
buttons: number;
|
|
clientX: number;
|
|
clientY: number;
|
|
ctrlKey: boolean;
|
|
fromElement: Element;
|
|
layerX: number;
|
|
layerY: number;
|
|
metaKey: boolean;
|
|
movementX: number;
|
|
movementY: number;
|
|
offsetX: number;
|
|
offsetY: number;
|
|
pageX: number;
|
|
pageY: number;
|
|
relatedTarget: EventTarget;
|
|
screenX: number;
|
|
screenY: number;
|
|
shiftKey: boolean;
|
|
toElement: Element;
|
|
which: number;
|
|
x: number;
|
|
y: number;
|
|
constructor(typeArg: string, eventInitDict?: MouseEventInit) {
|
|
super(typeArg, eventInitDict);
|
|
if (eventInitDict) {
|
|
for (var v in eventInitDict) {
|
|
this[v] = eventInitDict[v];
|
|
}
|
|
}
|
|
}
|
|
getModifierState(keyArg: string): boolean {
|
|
//not implements
|
|
return false;
|
|
}
|
|
|
|
initMouseEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, detailArg: number, screenXArg: number, screenYArg: number,
|
|
clientXArg: number, clientYArg: number, ctrlKeyArg: boolean, altKeyArg: boolean, shiftKeyArg: boolean, metaKeyArg: boolean,
|
|
buttonArg: number, relatedTargetArg: EventTarget): void {
|
|
var args = arguments;
|
|
['type', 'bubbles', 'cancelable', 'view', 'detail', 'screenX', 'screenY', 'clientX', 'clientY', 'ctrlKey', 'altKey', 'shiftKey', 'metaKey', 'button', 'relatedTarget'].forEach((v, i, a) => {
|
|
this[v] = args[i];
|
|
});
|
|
}
|
|
}
|
|
var _lbMouseEvent= window['MouseEvent'] = MouseEvent;
|
|
|
|
class MouseWheelEvent extends MouseEvent {
|
|
wheelDelta: number;
|
|
wheelDeltaX: number;
|
|
wheelDeltaY: number;
|
|
initMouseWheelEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, buttonArg: number, relatedTargetArg: EventTarget, modifiersListArg: string, wheelDeltaArg: number): void {
|
|
|
|
}
|
|
constructor() {
|
|
super("mousewheel");
|
|
}
|
|
}
|
|
|
|
class WheelEvent extends MouseEvent {
|
|
deltaMode: number;
|
|
deltaX: number;
|
|
deltaY: number;
|
|
deltaZ: number;
|
|
getCurrentPoint(element: Element): void {
|
|
|
|
}
|
|
initWheelEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, buttonArg: number, relatedTargetArg: EventTarget, modifiersListArg: string, deltaXArg: number, deltaYArg: number, deltaZArg: number, deltaMode: number): void {
|
|
|
|
}
|
|
|
|
constructor(typeArg: string, eventInitDict?: WheelEventInit) {
|
|
super(typeArg, eventInitDict);
|
|
if (eventInitDict) {
|
|
this.deltaMode = eventInitDict.deltaMode;
|
|
this.deltaX = eventInitDict.deltaX;
|
|
this.deltaY = eventInitDict.deltaY;
|
|
this.deltaZ = eventInitDict.deltaZ;
|
|
}
|
|
}
|
|
static DOM_DELTA_LINE = 1;
|
|
static DOM_DELTA_PAGE = 2;
|
|
static DOM_DELTA_PIXEL = 0;
|
|
}
|
|
|
|
class Touch {
|
|
clientX: number;
|
|
clientY: number;
|
|
identifier: number;
|
|
pageX: number;
|
|
pageY: number;
|
|
screenX: number;
|
|
screenY: number;
|
|
target: EventTarget;
|
|
constructor(){
|
|
|
|
}
|
|
}
|
|
|
|
class TouchList extends Array {
|
|
item(index: number): Touch {
|
|
return this[index];
|
|
}
|
|
}
|
|
|
|
interface TouchEvent extends UIEvent {
|
|
altKey: boolean;
|
|
changedTouches: TouchList;
|
|
ctrlKey: boolean;
|
|
metaKey: boolean;
|
|
shiftKey: boolean;
|
|
targetTouches: TouchList;
|
|
touches: TouchList;
|
|
new(type: number, id: number, name: string, x: number, y: number):TouchEvent;
|
|
}
|
|
/*
|
|
var exp={exp:null};
|
|
(function(exp:{exp:any}) {
|
|
'use strict';
|
|
//这个需要闭包
|
|
var APP_TOUCH_DOWN = 0;
|
|
var APP_TOUCH_UP = 1;
|
|
var APP_TOUCH_MOV = 2;
|
|
var APP_TOUCH_PT_DOWN = 5;
|
|
var APP_TOUCH_PT_UP = 6;
|
|
var m_vTouchs: Touch[] = []
|
|
|
|
exp.exp = class TouchEvent extends UIEvent {
|
|
altKey = false;
|
|
changedTouches: Touch[] = [];// TouchList;
|
|
ctrlKey = false;
|
|
metaKey = false;
|
|
shiftKey = false;
|
|
targetTouches: Touch[] = [];// TouchList;
|
|
touches: Touch[] = [];
|
|
constructor(type: number, id: number, name: string, x: number, y: number) {
|
|
super('');
|
|
var touch = new Touch();
|
|
touch.identifier = id;
|
|
touch.pageX = touch.screenX = touch.clientX = x;
|
|
touch.pageY = touch.screenY = touch.clientY = y;
|
|
this.touches.push(touch);
|
|
switch(type) {
|
|
case APP_TOUCH_DOWN:
|
|
case APP_TOUCH_PT_DOWN:
|
|
m_vTouchs.push(touch);
|
|
break;
|
|
case APP_TOUCH_PT_UP: {
|
|
//DEL. 已知事件都是一个一个发送的。
|
|
var epos = 0;
|
|
var tnum = m_vTouchs.length;
|
|
while (epos < tnum) {
|
|
var ce = m_vTouchs[epos];
|
|
if (ce.identifier == id) {
|
|
break;
|
|
}
|
|
epos++;
|
|
}
|
|
if (epos >= tnum) {
|
|
//error not find
|
|
} else {
|
|
m_vTouchs.splice(epos, 1);
|
|
}
|
|
}
|
|
break;
|
|
case APP_TOUCH_MOV: {
|
|
//修改. 已知事件都是一个一个发送的。
|
|
var tnum = m_vTouchs.length;
|
|
var ti = 0;
|
|
while (ti < tnum) {
|
|
var ce = m_vTouchs[ti];
|
|
if (ce.identifier == id) {
|
|
m_vTouchs[ti] = touch;
|
|
break;
|
|
}
|
|
ti++;
|
|
}
|
|
}
|
|
break;
|
|
case APP_TOUCH_UP:
|
|
m_vTouchs = [];
|
|
break;
|
|
}
|
|
this.touches = m_vTouchs;
|
|
switch (type) {
|
|
case 0:
|
|
case 5:
|
|
this.type = "touchstart";
|
|
break;
|
|
case 1:
|
|
case 6:
|
|
this.type = "touchend";
|
|
break;
|
|
case 2:
|
|
this.type = "touchmove";
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
})(exp);
|
|
|
|
var TouchEvent:TouchEvent = <TouchEvent>((<any>exp).exp);
|
|
*/
|
|
interface DeviceAcceleration {
|
|
x: number;
|
|
y: number;
|
|
z: number;
|
|
}
|
|
|
|
interface DeviceRotationRate {
|
|
alpha: number;
|
|
beta: number;
|
|
gamma: number;
|
|
}
|
|
|
|
interface DeviceAccelerationDict {
|
|
x?: number;
|
|
y?: number;
|
|
z?: number;
|
|
}
|
|
|
|
interface DeviceRotationRateDict {
|
|
alpha?: number;
|
|
beta?: number;
|
|
gamma?: number;
|
|
}
|
|
|
|
|
|
class DeviceMotionEvent extends Event {
|
|
acceleration: DeviceAcceleration;
|
|
accelerationIncludingGravity: DeviceAcceleration;
|
|
interval: number;
|
|
rotationRate: DeviceRotationRate;
|
|
constructor() {
|
|
super('devicemotion');
|
|
}
|
|
initDeviceMotionEvent(type: string, bubbles: boolean, cancelable: boolean, acceleration: DeviceAccelerationDict, accelerationIncludingGravity: DeviceAccelerationDict, rotationRate: DeviceRotationRateDict, interval: number): void {
|
|
|
|
}
|
|
}
|
|
window["DeviceMotionEvent"]=DeviceMotionEvent;
|
|
|
|
class DeviceOrientationEvent extends Event {
|
|
absolute: boolean;
|
|
alpha: number;
|
|
beta: number;
|
|
gamma: number;
|
|
constructor() {
|
|
super('deviceorientation');
|
|
}
|
|
initDeviceOrientationEvent(type: string, bubbles: boolean, cancelable: boolean, alpha: number, beta: number, gamma: number, absolute: boolean): void {
|
|
|
|
}
|
|
}
|
|
window["DeviceOrientationEvent"]=DeviceOrientationEvent;
|
|
|
|
class DocumentEvent {
|
|
constructor() {
|
|
|
|
}
|
|
createEvent(eventInterface: string): Event {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
class ProgressEvent extends Event {
|
|
lengthComputable: boolean;
|
|
loaded: number;
|
|
total: number;
|
|
constructor(type:string) {
|
|
super(type);
|
|
}
|
|
initProgressEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, lengthComputableArg: boolean, loadedArg: number, totalArg: number): void {
|
|
//TODO
|
|
this.type=typeArg;
|
|
this.cancelBubble=canBubbleArg;
|
|
this.cancelable=cancelableArg;
|
|
this.lengthComputable=lengthComputableArg;
|
|
this.loaded=loadedArg;
|
|
this.total=totalArg;
|
|
}
|
|
}
|
|
|
|
var _lbProgressEvent=window["ProgressEvent"]=ProgressEvent; |