pxt-common-packages 12.2.13 → 12.2.14

package/built/common-sim.d.ts

@@ -356,6 +356,10 @@ declare namespace pxsim.browserEvents {
     interface BrowserEventsBoard extends CommonBoard {
         mouseState: MouseState;
     }
+    const INTERNAL_KEY_DOWN = 6870;
+    const INTERNAL_KEY_UP = 6871;
+    const INTERNAL_POINTER_DOWN = 6868;
+    const INTERNAL_POINTER_UP = 6869;
     type MouseEvent = "pointerdown" | "pointerup" | "pointermove" | "pointerleave" | "pointerenter" | "pointercancel" | "pointerover" | "pointerout";
     class MouseState {
         protected x: number;

package/built/common-sim.js

@@ -843,10 +843,10 @@ var pxsim;
         browserEvents.onKeyboardEvent = onKeyboardEvent;
         function fireEvent(key, pressed) {
             if (pressed) {
-                pxsim.board().bus.queue(6866, key);
+                pxsim.board().bus.queue(browserEvents.INTERNAL_KEY_DOWN, key);
             }
             else {
-                pxsim.board().bus.queue(6867, key);
+                pxsim.board().bus.queue(browserEvents.INTERNAL_KEY_UP, key);
             }
         }
         function getValueForKey(event) {
@@ -1040,6 +1040,10 @@ var pxsim;
     var browserEvents;
     (function (browserEvents) {
         const THROTTLE_INTERVAL = 50;
+        browserEvents.INTERNAL_KEY_DOWN = 6870;
+        browserEvents.INTERNAL_KEY_UP = 6871;
+        browserEvents.INTERNAL_POINTER_DOWN = 6868;
+        browserEvents.INTERNAL_POINTER_UP = 6869;
         class MouseState {
             constructor() {
                 this.onMove = pxsim.U.throttle(() => {
@@ -1062,9 +1066,16 @@ var pxsim;
                     "pointerover",
                     "pointerout",
                 ];
+                let eventId = 6857 + events.indexOf(event.type);
+                if (event.type === "pointerdown") {
+                    eventId = browserEvents.INTERNAL_POINTER_DOWN;
+                }
+                else if (event.type === "pointerup") {
+                    eventId = browserEvents.INTERNAL_POINTER_UP;
+                }
                 // We add 1 to the button here because the left button is 0 and
                 // that's used as a wildcard in our event bus
-                pxsim.board().bus.queue(6857 + events.indexOf(event.type), (event.button || 0) + 1);
+                pxsim.board().bus.queue(eventId, (event.button || 0) + 1);
             }
             onWheelEvent(dx, dy, dz) {
                 this.dx = dx;

package/libs/browser-events/browserEvents.ts

@@ -48,40 +48,50 @@ namespace browserEvents {
         Released = Event.PointerUp,
     }
 
+    //% whenUsed
+    const INTERNAL_POINTER_DOWN = 6868;
+    //% whenUsed
+    const INTERNAL_POINTER_UP = 6869;
+
+    type MouseHandler = (x: number, y: number) => void;
+
     //% fixedInstances
     export class MouseButton {
         protected _pressed: boolean;
-        protected pressHandler: (x: number, y: number) => void;
-        protected pressListeners: ((x: number, y: number) => void)[];
-        protected releaseHandler: (x: number, y: number) => void;
-        protected releaseListeners: ((x: number, y: number) => void)[];
+
+        protected sceneStack: _SceneButtonHandlers<MouseHandler>[];
+
+        protected get state(): _SceneButtonHandlers<MouseHandler> {
+            return this.sceneStack[this.sceneStack.length - 1];
+        }
 
         constructor(public id: number) {
-            control.internalOnEvent(Event.PointerDown, this.id, () => this.setPressed(true), 16);
-            control.internalOnEvent(Event.PointerUp, this.id, () => this.setPressed(false), 16);
+            control.internalOnEvent(INTERNAL_POINTER_DOWN, this.id, () => this.setPressed(true), 16);
+            control.internalOnEvent(INTERNAL_POINTER_UP, this.id, () => this.setPressed(false), 16);
 
             this._pressed = false;
-            this.pressListeners = [];
-            this.releaseListeners = [];
+
+            this.sceneStack = [new _SceneButtonHandlers<MouseHandler>(id, invokeMouseHandler)];
+
+            game.addScenePushHandler(() => {
+                this.sceneStack.push(new _SceneButtonHandlers<MouseHandler>(id, invokeMouseHandler));
+            });
+            game.addScenePopHandler(() => {
+                this.sceneStack.pop();
+                if (this.sceneStack.length === 0) {
+                    this.sceneStack = [new _SceneButtonHandlers<MouseHandler>(id, invokeMouseHandler)];
+                }
+            });
         }
 
         setPressed(pressed: boolean) {
             this._pressed = pressed;
+
             if (pressed) {
-                if (this.pressHandler) {
-                    this.pressHandler(mouseX(), mouseY());
-                }
-                for (const handler of this.pressListeners) {
-                    handler(mouseX(), mouseY());
-                }
+                control.raiseEvent(MouseButtonEvent.Pressed, this.id);
             }
             else {
-                if (this.releaseHandler) {
-                    this.releaseHandler(mouseX(), mouseY());
-                }
-                for (const handler of this.releaseListeners) {
-                    handler(mouseX(), mouseY());
-                }
+                control.raiseEvent(MouseButtonEvent.Released, this.id);
             }
         }
 
@@ -91,12 +101,7 @@ namespace browserEvents {
         //% group="Mouse"
         //% weight=50
         onEvent(event: MouseButtonEvent, handler: (x: number, y: number) => void) {
-            if (event === MouseButtonEvent.Pressed) {
-                this.pressHandler = handler;
-            }
-            else {
-                this.releaseHandler = handler;
-            }
+            this.state.onEvent(event, handler);
         }
 
         //% blockId=browserEvents_mouseButton_isPressed
@@ -116,24 +121,72 @@ namespace browserEvents {
         }
 
         addEventListener(event: MouseButtonEvent, handler: (x: number, y: number) => void) {
-            if (event === MouseButtonEvent.Pressed) {
-                this.pressListeners.push(handler);
-            }
-            else {
-                this.releaseListeners.push(handler);
-            }
+            this.state.addEventListener(event, handler);
         }
 
         removeEventListener(event: MouseButtonEvent, handler: (x: number, y: number) => void) {
-            if (event === MouseButtonEvent.Pressed) {
-                this.pressListeners = this.pressListeners.filter(p => p !== handler);
+            this.state.removeEventListener(event, handler);
+        }
+    }
+
+    export class _SceneButtonHandlers<U> {
+        protected handlers: ButtonHandler<U>[];
+
+        constructor(public id: number, protected invokeHandler: (handler: U) => void) {
+            this.handlers = [];
+        }
+
+        onEvent(event: number, handler: U) {
+            this.getHandler(event, true).handler = handler;
+        }
+
+        addEventListener(event: number, handler: U) {
+            this.getHandler(event, true).listeners.push(handler);
+        }
+
+        removeEventListener(event: number, handler: U) {
+            const eventHandler = this.getHandler(event);
+
+            if (eventHandler) {
+                eventHandler.listeners = eventHandler.listeners.filter(h => h !== handler);
             }
-            else {
-                this.releaseListeners = this.releaseListeners.filter(p => p !== handler);
+        }
+
+        protected getHandler(event: number, createIfMissing?: boolean) {
+            for (const handler of this.handlers) {
+                if (handler.event === event) return handler;
             }
+
+            if (createIfMissing) {
+                const newHandler = new ButtonHandler<U>(event, this.id, this.invokeHandler);
+                this.handlers.push(newHandler);
+                return newHandler;
+            }
+
+            return undefined;
         }
     }
 
+    class ButtonHandler<U> {
+        handler: U;
+        listeners: U[] = [];
+
+        constructor(public readonly event: number, id: number, invokeHandler: (handler: U) => void) {
+            control.onEvent(event, id, () => {
+                if (this.handler) {
+                    invokeHandler(this.handler);
+                }
+                for (const listener of this.listeners) {
+                    invokeHandler(listener);
+                }
+            });
+        }
+    }
+
+    function invokeMouseHandler(handler: MouseHandler) {
+        handler(mouseX(), mouseY());
+    }
+
     //% blockId=browserEvents_onEvent
     //% block="on browser event $event"
     //% draggableParameters="reporter"

package/libs/browser-events/keyboard.ts

@@ -73,13 +73,18 @@ namespace browserEvents {
 
     export enum KeyEvent {
         //% block="pressed"
-        Pressed,
+        Pressed = 6872,
         //% block="released"
-        Released,
+        Released = 6873,
         //% block="repeat"
-        Repeat
+        Repeat = 6874
     }
 
+    //% whenUsed
+    const INTERNAL_KEY_DOWN = 6870;
+    //% whenUsed
+    const INTERNAL_KEY_UP = 6871;
+
     export function keyToString(key: Key) {
         switch (key) {
             case Key.Q:
@@ -229,83 +234,7 @@ namespace browserEvents {
     let defaultRepeatDelay = 500;
     let defaultRepeatInterval = 30;
 
-    class KeySceneState {
-        protected pressHandler: () => void;
-        protected pressListeners: (() => void)[];
-        protected releaseHandler: () => void;
-        protected releaseListeners: (() => void)[];
-        protected repeatHandler: () => void;
-        protected repeatListeners: (() => void)[];
-
-        constructor(public id: number) {
-            this.pressListeners = [];
-            this.releaseListeners = [];
-            this.repeatListeners = [];
-        }
-
-        onEvent(event: KeyEvent, handler: () => void) {
-            if (event === KeyEvent.Pressed) {
-                this.pressHandler = handler;
-            }
-            else if (event === KeyEvent.Released) {
-                this.releaseHandler = handler;
-            }
-            else {
-                this.repeatHandler = handler;
-            }
-        }
-
-        addEventListener(event: KeyEvent, handler: () => void) {
-            if (event === KeyEvent.Pressed) {
-                this.pressListeners.push(handler);
-            }
-            else if (event === KeyEvent.Released) {
-                this.releaseListeners.push(handler);
-            }
-            else {
-                this.repeatListeners.push(handler);
-            }
-        }
-
-        removeEventListener(event: KeyEvent, handler: () => void) {
-            if (event === KeyEvent.Pressed) {
-                this.pressListeners = this.pressListeners.filter(p => p !== handler);
-            }
-            else if (event === KeyEvent.Released) {
-                this.releaseListeners = this.releaseListeners.filter(p => p !== handler);;
-            }
-            else {
-                this.repeatListeners = this.repeatListeners.filter(p => p !== handler);
-            }
-        }
-
-        raiseButtonPressed() {
-            if (this.pressHandler) {
-                this.pressHandler();
-            }
-            for (const handler of this.pressListeners) {
-                handler();
-            }
-        }
-
-        raiseButtonReleased() {
-            if (this.releaseHandler) {
-                this.releaseHandler();
-            }
-            for (const handler of this.releaseListeners) {
-                handler();
-            }
-        }
-
-        raiseButtonRepeat() {
-            if (this.repeatHandler) {
-                this.repeatHandler();
-            }
-            for (const handler of this.repeatListeners) {
-                handler();
-            }
-        }
-    }
+    type KeyHandler = () => void;
 
     //% fixedInstances
     export class KeyButton {
@@ -315,16 +244,16 @@ namespace browserEvents {
         private _repeatCount: number;
         private _pressedElapsed: number;
 
-        protected sceneStack: KeySceneState[];
+        protected sceneStack: _SceneButtonHandlers<KeyHandler>[];
 
-        protected get state(): KeySceneState {
+        protected get state(): _SceneButtonHandlers<KeyHandler> {
             return this.sceneStack[this.sceneStack.length - 1];
         }
 
         constructor(public id: number) {
-            // use internalOnEvent so that events fire regardless of the current scen
-            control.internalOnEvent(Event.KeyUp, this.id, () => this.setPressed(false), 16);
-            control.internalOnEvent(Event.KeyDown, this.id, () => this.setPressed(true), 16);
+            // use internalOnEvent so that events fire regardless of the current scene
+            control.internalOnEvent(INTERNAL_KEY_UP, this.id, () => this.setPressed(false), 16);
+            control.internalOnEvent(INTERNAL_KEY_DOWN, this.id, () => this.setPressed(true), 16);
             this._pressed = false;
 
             // this code may run before game/scene.ts, in which case calling this.__registerUpdate
@@ -347,16 +276,16 @@ namespace browserEvents {
                 _buttonsPendingInit.push(this);
             }
 
-            this.sceneStack = [new KeySceneState(id)];
+            this.sceneStack = [new _SceneButtonHandlers<KeyHandler>(id, invokeKeyHandler)];
 
             game.addScenePushHandler(() => {
-                this.sceneStack.push(new KeySceneState(id));
+                this.sceneStack.push(new _SceneButtonHandlers<KeyHandler>(id, invokeKeyHandler));
                 this.__registerUpdate();
             });
             game.addScenePopHandler(() => {
                 this.sceneStack.pop();
                 if (this.sceneStack.length === 0) {
-                    this.sceneStack = [new KeySceneState(id)];
+                    this.sceneStack = [new _SceneButtonHandlers<KeyHandler>(id, invokeKeyHandler)];
                     this.__registerUpdate();
                 }
             });
@@ -369,10 +298,10 @@ namespace browserEvents {
             if (pressed) {
                 this._repeatCount = 0;
                 this._pressedElapsed = 0;
-                this.state.raiseButtonPressed();
+                control.raiseEvent(KeyEvent.Pressed, this.id);
             }
             else {
-                this.state.raiseButtonReleased();
+                control.raiseEvent(KeyEvent.Released, this.id);
             }
         }
 
@@ -422,7 +351,7 @@ namespace browserEvents {
             const count = Math.floor((this._pressedElapsed - delay - interval) / interval);
             if (count != this._repeatCount) {
                 this._repeatCount = count;
-                this.state.raiseButtonRepeat();
+                control.raiseEvent(KeyEvent.Repeat, this.id);
             }
         }
 
@@ -431,6 +360,10 @@ namespace browserEvents {
         }
     }
 
+    function invokeKeyHandler(handler: KeyHandler) {
+        handler();
+    }
+
     //% fixedInstance whenUsed
     export const A = new KeyButton(Key.A);
 

package/libs/browser-events/sim/keyboard.ts

@@ -96,10 +96,10 @@ namespace pxsim.browserEvents {
 
     function fireEvent(key: Key, pressed: boolean) {
         if (pressed) {
-            board().bus.queue(6866, key);
+            board().bus.queue(INTERNAL_KEY_DOWN, key);
         }
         else {
-            board().bus.queue(6867, key);
+            board().bus.queue(INTERNAL_KEY_UP, key);
         }
     }
 

package/libs/browser-events/sim/mouseState.ts

@@ -5,6 +5,11 @@ namespace pxsim.browserEvents {
 
     const THROTTLE_INTERVAL = 50;
 
+    export const INTERNAL_KEY_DOWN = 6870;
+    export const INTERNAL_KEY_UP = 6871;
+    export const INTERNAL_POINTER_DOWN = 6868;
+    export const INTERNAL_POINTER_UP = 6869;
+
     export type MouseEvent = "pointerdown" | "pointerup" | "pointermove" | "pointerleave" | "pointerenter" | "pointercancel" | "pointerover" | "pointerout";
     export class MouseState {
         protected x: number;
@@ -43,10 +48,19 @@ namespace pxsim.browserEvents {
                 "pointerout",
             ];
 
+            let eventId = 6857 + events.indexOf(event.type);
+
+            if (event.type === "pointerdown") {
+                eventId = INTERNAL_POINTER_DOWN;
+            }
+            else if (event.type === "pointerup") {
+                eventId = INTERNAL_POINTER_UP;
+            }
+
             // We add 1 to the button here because the left button is 0 and
             // that's used as a wildcard in our event bus
             board().bus.queue(
-                6857 + events.indexOf(event.type),
+                eventId,
                 (event.button || 0) + 1
             );
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pxt-common-packages",
-  "version": "12.2.13",
+  "version": "12.2.14",
   "description": "Microsoft MakeCode (PXT) common packages",
   "keywords": [
     "MakeCode",