restore events to method that works with pong (events in a blocking wait are queued but not processed). But still investigating if it is possible to allow events inside a blocking wait.

Author: twiddlingbits

docs/gettingstarted/events.md

@@ -1,6 +1,6 @@
 ---
 title: Using events in C/C++ and WebAssembly with twr-wasm
-description: Certain twr-wasm APIs support events.  This section describes how they function.
+description: Certain twr-wasm APIs support events.  This section describes how events function.
 ---
 
 # Overview of Events
@@ -55,7 +55,7 @@ You can use the same event/callback with multiple APIs if you wish.  When the ev
 
 # When using twrWasmModuleAsync
 
-With a `twrWasmModuleAsync` module, various blocking APIs are available. For example: `twr_sleep`.  When these functions are blocking (waiting), event callbacks are still processed. For example, in the `tests-timer` example, you can see the repeating timer callback happen while the function sleeps.
+With a `twrWasmModuleAsync` module, various blocking APIs are available. For example: `twr_sleep`.  When these functions are blocking (waiting), event callbacks are queued and not processed until wait unblocks. 
 
 With a `twrWasmModuleAsync` module, events are sent from the JavaScript main thread to the worker thread that is running the C/C++ code.
 

source/twr-ts/twreventqueue.ts

@@ -50,14 +50,8 @@ export class twrEventQueueReceive {
       if (!(eventID in twrEventQueueReceive.onEventCallbacks))
          throw new Error("internal error");
 
-      const onEventCallback=twrEventQueueReceive.onEventCallbacks[eventID];
-      if (onEventCallback) {
-         onEventCallback(eventID, ...args);
-      }
-      else {  // events with not callback must be read, eg with waitEvent
-         this.pendingEventIDs.push(eventID);
-         this.pendingEventArgs.push(args);
-      }
+      this.pendingEventIDs.push(eventID);
+      this.pendingEventArgs.push(args);
    }
 
    private readMallocRemainder() {
@@ -89,17 +83,17 @@ export class twrEventQueueReceive {
       this.readCommandRemainder(firstValue);
    }
 
-   private findEvent(filterEvent:number) : [undefined | number, undefined | number[]] {
+   private findEvent(filterEvent:number) : [undefined | number, undefined | number[], undefined | number] {
 
       if (filterEvent===undefined) {
-         return [this.pendingEventIDs.shift(), this.pendingEventArgs.shift()]
+         return [this.pendingEventIDs.shift(), this.pendingEventArgs.shift(), 0]
       }
 
       const index=this.pendingEventIDs.indexOf(filterEvent);
       if (index!=-1)
-         return [this.pendingEventIDs.splice(index, 1)[0], this.pendingEventArgs.splice(index, 1)[0]]
+         return [this.pendingEventIDs.splice(index, 1)[0], this.pendingEventArgs.splice(index, 1)[0], index];
 
-      return [undefined, undefined];
+      return [undefined, undefined, undefined];
    }
 
 
@@ -110,19 +104,23 @@ export class twrEventQueueReceive {
             this.readCommand();
 
          // is our event in the queue?
-         const [eventID, args]=this.findEvent(filterEvent);
-         if (eventID && args) return [eventID, args];
+         const [eventID, args, index]=this.findEvent(filterEvent);
+         // execute callbacks up to this filterEvent (so as to call them in order)
+         // if filterEvent not found, index is undefined, which causes doCallbacks to execute all pendingEventIDs
+         //this.doCallbacks(index); causes all kinds of problems. See notes in twrlibrary.ts
+         if (eventID && args) {
+         return [eventID, args];
+         }
 
          // wait for a new event
          this.readWaitCommand();
       }
    }
 
-   processIncomingCommands() {
-      while (!this.circBuffer.isEmpty())
-         this.readCommand();
-
-      for (let i=0; i<this.pendingEventIDs.length; i++) {
+   private doCallbacks(upToIndex?:number) {
+      const end=upToIndex?upToIndex:this.pendingEventIDs.length;
+      console.log("end",end, upToIndex, this.pendingEventIDs.length);
+      for (let i=0; i<end; i++) {
          const eventID=this.pendingEventIDs[i];
          const args=this.pendingEventArgs[i];
          const onEventCallback=twrEventQueueReceive.onEventCallbacks[eventID];
@@ -134,6 +132,13 @@ export class twrEventQueueReceive {
       }
    }
 
+   processIncomingCommands() {
+      while (!this.circBuffer.isEmpty())
+         this.readCommand();
+
+      this.doCallbacks();
+   }
+
    //see twrWasmModule.constructor - imports - twr_register_callback:this.registerCallback.bind(this), 
    //TODO!! This static method works for twrWasmModuleAsync, but when/if I implement message loop for twrWasmModule, this may need to change?
    static registerCallback(funcName:string, onEventCallback:TOnEventCallback) {

source/twr-ts/twrlibrary.ts

@@ -7,8 +7,15 @@ import {twrEventQueueReceive} from "./twreventqueue.js"
 /////////////////////////////////////////////////////////////////////
 
 // TODO List
+// Working on: Allow callbacks while blocking call is waiting.
+// see commented out doCallbacks in WaitEvents
+// what if printf in callback and char waits for ret val?
+// that is what drawseq does
+// is animateframe being called before drawseq retval?
+// ie, recursive  waitEvent
+// update doc, can't block in a callback?
+// finish test_timer
 
-// doc event behavior
 // fix example/lib/out and .gitignore so correct build artifacts are checked in  
 // resolve fact that libraries with interfaces are passed in the "io" option.  Eg Allow "libs" or other synonym.
 // current implementation has no libs: (akin to io:).