pxt-common-packages 12.3.4 → 12.3.9

package/libs/base/pxtbase.h

@@ -1166,9 +1166,13 @@ bool removeElement(RefCollection *c, TValue x);
 #define FLASH_TOP 0x00000000
 #else
 #if MICROBIT_CODAL
+#if MICROBIT_TOP_OF_FLASH
 #define FLASH_TOP MICROBIT_TOP_OF_FLASH
 #else
 #define FLASH_TOP 0x00000000
+#endif
+#else
+#define FLASH_TOP 0x00000000
 #endif         
 #endif
 

package/libs/browser-events/browserEvents.cpp

@@ -27,6 +27,10 @@ int wheelDz() {
     return -1;
 }
 
+//%
+void _setCursorVisible(bool visible) {
+}
+
 //%
 int currentTime() {
     return -1;

package/libs/browser-events/browserEvents.ts

@@ -4,66 +4,94 @@
 //% block="Browser Events"
 namespace browserEvents {
     export enum Event {
+        //% block="pointer down"
         PointerDown = 6857,
+        //% block="pointer up"
         PointerUp = 6858,
+        //% block="pointer move"
         PointerMove = 6859,
+        //% block="pointer leave"
         PointerLeave = 6860,
+        //% block="pointer enter"
         PointerEnter = 6861,
+        //% block="pointer cancel"
         PointerCancel = 6862,
+        //% block="pointer over"
         PointerOver = 6863,
+        //% block="pointer out"
         PointerOut = 6864,
+        //% block="wheel"
         Wheel = 6865,
+        //% block="key down"
         KeyDown = 6866,
+        //% block="key up"
         KeyUp = 6867
     }
 
     export enum MouseButtonId {
+        //% block="left"
         Left = 1,
+        //% block="right"
         Right = 3,
+        //% block="wheel"
         Wheel = 2,
+        //% block="back"
         Back = 4,
+        //% block="forward"
         Forward = 5
     }
 
     export enum MouseButtonEvent {
+        //% block="pressed"
         Pressed = Event.PointerDown,
+        //% block="released"
         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);
             }
         }
 
@@ -73,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
@@ -98,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"
@@ -147,6 +218,14 @@ namespace browserEvents {
         });
     }
 
+    //% blockId=browserEvents_setCursorVisible
+    //% block="set cursor visible $visible"
+    //% group="Mouse"
+    //% weight=0
+    export function setCursorVisible(visible: boolean) {
+        _setCursorVisible(visible);
+    }
+
     //% fixedInstance whenUsed block="left"
     export const MouseLeft = new MouseButton(MouseButtonId.Left);
 

package/libs/browser-events/keyboard.ts

@@ -62,14 +62,29 @@ namespace browserEvents {
         ArrowRight = 39,
         PageDown = 34,
         End = 35,
-        Home = 36
+        Home = 36,
+        LeftShift = 1016,
+        RightShift = 1017,
+        LeftControl = 1018,
+        RightControl = 1019,
+        Backspace = 8,
+        Delete = 46,
     }
 
     export enum KeyEvent {
-        Pressed,
-        Released
+        //% block="pressed"
+        Pressed = 6872,
+        //% block="released"
+        Released = 6873,
+        //% block="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:
@@ -198,44 +213,95 @@ namespace browserEvents {
                 return "-";
             case Key.Equals:
                 return "=";
+            case Key.LeftShift:
+                return "LeftShift";
+            case Key.RightShift:
+                return "RightShift";
+            case Key.LeftControl:
+                return "LeftControl";
+            case Key.RightControl:
+                return "RightControl";
+            case Key.Backspace:
+                return "Backspace";
+            case Key.Delete:
+                return "Delete";
         }
     }
 
+    //% whenUsed
+    let _buttonsPendingInit: KeyButton[];
+
+    let defaultRepeatDelay = 500;
+    let defaultRepeatInterval = 30;
+
+    type KeyHandler = () => void;
 
     //% fixedInstances
     export class KeyButton {
         protected _pressed: boolean;
-        protected pressHandler: () => void;
-        protected pressListeners: (() => void)[];
-        protected releaseHandler: () => void;
-        protected releaseListeners: (() => void)[];
+        public repeatDelay: number;
+        public repeatInterval: number;
+        private _repeatCount: number;
+        private _pressedElapsed: number;
 
-        constructor(public id: number) {
-            control.onEvent(Event.KeyUp, this.id, () => this.setPressed(false), 16);
-            control.onEvent(Event.KeyDown, this.id, () => this.setPressed(true), 16);
+        protected sceneStack: _SceneButtonHandlers<KeyHandler>[];
+
+        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 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.pressListeners = [];
-            this.releaseListeners = [];
+
+            // this code may run before game/scene.ts, in which case calling this.__registerUpdate
+            // will trigger an exception. to prevent that, start a thread that pauses until we
+            // detect that an event context has been registered and then call it
+            if (control.eventContext()) {
+                this.__registerUpdate();
+            }
+            else {
+                if (!_buttonsPendingInit) {
+                    _buttonsPendingInit = [];
+                    control.runInBackground(() => {
+                        pauseUntil(() => !!control.eventContext());
+                        for (const button of _buttonsPendingInit) {
+                            button.__registerUpdate();
+                        }
+                        _buttonsPendingInit = undefined;
+                    });
+                }
+                _buttonsPendingInit.push(this);
+            }
+
+            this.sceneStack = [new _SceneButtonHandlers<KeyHandler>(id, invokeKeyHandler)];
+
+            game.addScenePushHandler(() => {
+                this.sceneStack.push(new _SceneButtonHandlers<KeyHandler>(id, invokeKeyHandler));
+                this.__registerUpdate();
+            });
+            game.addScenePopHandler(() => {
+                this.sceneStack.pop();
+                if (this.sceneStack.length === 0) {
+                    this.sceneStack = [new _SceneButtonHandlers<KeyHandler>(id, invokeKeyHandler)];
+                    this.__registerUpdate();
+                }
+            });
         }
 
         setPressed(pressed: boolean) {
+            if (this._pressed === pressed) return;
+
             this._pressed = pressed;
             if (pressed) {
-                if (this.pressHandler) {
-                    this.pressHandler();
-                }
-                for (const handler of this.pressListeners) {
-                    handler();
-                }
+                this._repeatCount = 0;
+                this._pressedElapsed = 0;
+                control.raiseEvent(KeyEvent.Pressed, this.id);
             }
             else {
-                if (this.releaseHandler) {
-                    this.releaseHandler();
-                }
-                for (const handler of this.releaseListeners) {
-                    handler();
-                }
+                control.raiseEvent(KeyEvent.Released, this.id);
             }
         }
 
@@ -244,12 +310,7 @@ namespace browserEvents {
         //% group="Keyboard"
         //% weight=100
         onEvent(event: KeyEvent, handler: () => void) {
-            if (event === KeyEvent.Pressed) {
-                this.pressHandler = handler;
-            }
-            else {
-                this.releaseHandler = handler;
-            }
+            this.state.onEvent(event, handler);
         }
 
         //% blockId=browserEvents_key_isPressed
@@ -269,22 +330,38 @@ namespace browserEvents {
         }
 
         addEventListener(event: KeyEvent, handler: () => void) {
-            if (event === KeyEvent.Pressed) {
-                this.pressListeners.push(handler);
-            }
-            else {
-                this.releaseListeners.push(handler);
-            }
+            this.state.addEventListener(event, handler);
         }
 
         removeEventListener(event: KeyEvent, handler: () => void) {
-            if (event === KeyEvent.Pressed) {
-                this.pressListeners = this.pressListeners.filter(p => p !== handler);
-            }
-            else {
-                this.releaseListeners = this.releaseListeners.filter(p => p !== handler);
+            this.state.removeEventListener(event, handler);
+        }
+
+        __update() {
+            const delay = this.repeatDelay === undefined ? defaultRepeatDelay : this.repeatDelay;
+            const interval = this.repeatInterval === undefined ? defaultRepeatInterval : this.repeatInterval;
+            if (!this._pressed) return;
+            this._pressedElapsed += game.eventContext().deltaTimeMillis;
+
+            // inital delay
+            if (this._pressedElapsed < delay)
+                return;
+
+            // repeat count for this step
+            const count = Math.floor((this._pressedElapsed - delay - interval) / interval);
+            if (count != this._repeatCount) {
+                this._repeatCount = count;
+                control.raiseEvent(KeyEvent.Repeat, this.id);
             }
         }
+
+        __registerUpdate() {
+            game.eventContext().registerFrameHandler(scene.CONTROLLER_PRIORITY, () => this.__update());
+        }
+    }
+
+    function invokeKeyHandler(handler: KeyHandler) {
+        handler();
     }
 
     //% fixedInstance whenUsed
@@ -476,6 +553,35 @@ namespace browserEvents {
     //% fixedInstance whenUsed
     export const Home = new KeyButton(Key.Home);
 
+    //% fixedInstance whenUsed
+    export const LeftShift = new KeyButton(Key.LeftShift);
+
+    //% fixedInstance whenUsed
+    export const RightShift = new KeyButton(Key.RightShift);
+
+    //% fixedInstance whenUsed
+    export const LeftControl = new KeyButton(Key.LeftControl);
+
+    //% fixedInstance whenUsed
+    export const RightControl = new KeyButton(Key.RightControl);
+
+    //% fixedInstance whenUsed
+    export const Backspace = new KeyButton(Key.Backspace);
+
+    //% fixedInstance whenUsed
+    export const Delete = new KeyButton(Key.Delete);
+
     //% fixedInstance whenUsed
     export const Any = new KeyButton(0);
+
+    //% blockId=browser_events_setKeyboardRepeatDefault
+    //% block="set keyboard repeat delay $delay ms interval $interval ms"
+    //% delay.defl=500
+    //% interval.defl=30
+    //% group="Keyboard"
+    //% weight=0
+    export function setKeyboardRepeatDefault(delay: number, interval: number) {
+        defaultRepeatDelay = Math.max(delay, 0);
+        defaultRepeatInterval = Math.max(interval, 1);
+    }
 }

package/libs/browser-events/shims.d.ts

@@ -9,6 +9,8 @@ declare namespace browserEvents {
     function wheelDy(): number;
     //% shim=browserEvents::wheelDz
     function wheelDz(): number;
+    //% shim=browserEvents::_setCursorVisible
+    function _setCursorVisible(visible: boolean): void;
 
     //% shim=browserEvents::currentTime
     function currentTime(): number;

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

@@ -62,15 +62,44 @@ namespace pxsim.browserEvents {
         ArrowRight = 39,
         PageDown = 34,
         End = 35,
-        Home = 36
+        Home = 36,
+        LeftShift = 1016,
+        RightShift = 1017,
+        LeftControl = 1018,
+        RightControl = 1019,
+        Backspace = 8,
+        Delete = 46,
     }
 
     export function onKeyboardEvent(event: KeyboardEvent, pressed: boolean) {
+        const eventValue = getValueForKey(event);
+
+        fireEvent(eventValue as Key, pressed);
+
+        if (eventValue === Key.Shift) {
+            if (event.location === event.DOM_KEY_LOCATION_LEFT) {
+                fireEvent(Key.LeftShift, pressed);
+            }
+            else if (event.location === event.DOM_KEY_LOCATION_RIGHT) {
+                fireEvent(Key.RightShift, pressed);
+            }
+        }
+        if (eventValue === Key.Control) {
+            if (event.location === event.DOM_KEY_LOCATION_LEFT) {
+                fireEvent(Key.LeftControl, pressed);
+            }
+            else if (event.location === event.DOM_KEY_LOCATION_RIGHT) {
+                fireEvent(Key.RightControl, pressed);
+            }
+        }
+    }
+
+    function fireEvent(key: Key, pressed: boolean) {
         if (pressed) {
-            board().bus.queue(6866, getValueForKey(event));
+            board().bus.queue(INTERNAL_KEY_DOWN, key);
         }
         else {
-            board().bus.queue(6867, getValueForKey(event));
+            board().bus.queue(INTERNAL_KEY_UP, key);
         }
     }
 
@@ -249,6 +278,10 @@ namespace pxsim.browserEvents {
                 return Key.End;
             case "Home":
                 return Key.Home;
+            case "Delete":
+                return Key.Delete;
+            case "Backspace":
+                return Key.Backspace;
             default:
                 return 0;
         }

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/libs/color/built/debug/binary.js

@@ -56,7 +56,7 @@ const pxsim_pxtrt = pxsim.pxtrt;
 const pxsim_numops = pxsim.numops;
 
 
-function _main___P141050(s) {
+function _main___P141198(s) {
 let r0 = s.r0, step = s.pc;
 s.pc = -1;
 
@@ -66,19 +66,19 @@ if (yieldSteps-- < 0 && maybeYield(s, step, r0) || runtime !== pxsim.runtime) re
 switch (step) {
   case 0:
 
-    globals._intervals___141293 = (undefined);
-    globals._pollEventQueue___141306 = (undefined);
+    globals._intervals___141441 = (undefined);
+    globals._pollEventQueue___141454 = (undefined);
     r0 = undefined;
     return leave(s, r0)
   default: oops()
 } } }
-_main___P141050.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"colorbuffer.ts","functionName":"<main>","argumentNames":[]}
-_main___P141050.continuations = [  ]
+_main___P141198.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"colorbuffer.ts","functionName":"<main>","argumentNames":[]}
+_main___P141198.continuations = [  ]
 
-function _main___P141050_mk(s) {
+function _main___P141198_mk(s) {
     checkStack(s.depth);
     return {
-        parent: s, fn: _main___P141050, depth: s.depth + 1,
+        parent: s, fn: _main___P141198, depth: s.depth + 1,
         pc: 0, retval: undefined, r0: undefined, overwrittenPC: false, lambdaArgs: null,
 } }
 
@@ -88,5 +88,5 @@ function _main___P141050_mk(s) {
 
 const breakpoints = setupDebugger(1, [])
 
-return _main___P141050
+return _main___P141198
 })

package/libs/color-sensor/built/debug/binary.js

@@ -56,7 +56,7 @@ const pxsim_pxtrt = pxsim.pxtrt;
 const pxsim_numops = pxsim.numops;
 
 
-function _main___P98645(s) {
+function _main___P98756(s) {
 let r0 = s.r0, step = s.pc;
 s.pc = -1;
 
@@ -66,19 +66,19 @@ if (yieldSteps-- < 0 && maybeYield(s, step, r0) || runtime !== pxsim.runtime) re
 switch (step) {
   case 0:
 
-    globals._intervals___98888 = (undefined);
-    globals._pollEventQueue___98901 = (undefined);
+    globals._intervals___98999 = (undefined);
+    globals._pollEventQueue___99012 = (undefined);
     r0 = undefined;
     return leave(s, r0)
   default: oops()
 } } }
-_main___P98645.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"tcs34725.ts","functionName":"<main>","argumentNames":[]}
-_main___P98645.continuations = [  ]
+_main___P98756.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"tcs34725.ts","functionName":"<main>","argumentNames":[]}
+_main___P98756.continuations = [  ]
 
-function _main___P98645_mk(s) {
+function _main___P98756_mk(s) {
     checkStack(s.depth);
     return {
-        parent: s, fn: _main___P98645, depth: s.depth + 1,
+        parent: s, fn: _main___P98756, depth: s.depth + 1,
         pc: 0, retval: undefined, r0: undefined, overwrittenPC: false, lambdaArgs: null,
 } }
 
@@ -88,5 +88,5 @@ function _main___P98645_mk(s) {
 
 const breakpoints = setupDebugger(1, [])
 
-return _main___P98645
+return _main___P98756
 })