Rename library_events to library_html5 and other suggested renamings. Add better support for reporting EMSCRIPTEN_RESULT_NOT_SUPPORTED for unsupported features.

7 files changed, 940 insertions, 828 deletions

diff --git a/src/library_events.js b/src/library_html5.js
index d1a86127..703f9a74 100644
--- a/src/library_events.js
+++ b/src/library_html5.js
@@ -1,5 +1,5 @@
-var LibraryJsEvents = {
-  $JsEvents: {
+var LibraryJSEvents = {
+  $JSEvents: {
     // pointers to structs malloc()ed to Emscripten HEAP for JS->C interop.
     keyEvent: 0,
     mouseEvent: 0,
@@ -18,13 +18,13 @@ var LibraryJsEvents = {
     removeEventListenersRegistered: false, 
 
     registerRemoveEventListeners: function() {
-      if (!JsEvents.removeEventListenersRegistered) {
+      if (!JSEvents.removeEventListenersRegistered) {
       __ATEXIT__.push({ func: function() {
-          for(var i = JsEvents.eventHandlers.length-1; i >= 0; --i) {
-            JsEvents._removeHandler(i);
+          for(var i = JSEvents.eventHandlers.length-1; i >= 0; --i) {
+            JSEvents._removeHandler(i);
           }
          } });
-        JsEvents.removeEventListenersRegistered = true;
+        JSEvents.removeEventListenersRegistered = true;
       }
     },
 
@@ -33,20 +33,13 @@ var LibraryJsEvents = {
         if (typeof target == "number") {
           target = Pointer_stringify(target);
         }
-        if (target == '#window') {
-          return window;
-        } else if (target == '#document') {
-          return document;
-        } else if (target == '#screen') {
-          return window.screen;
-        } else if (target == '#canvas') {
-          return Module['canvas'];
-        }
-        if (typeof target == 'string') {
-          return document.getElementById(target);
-        } else {
-          return target;
-        }
+        if (target == '#window') return window;
+        else if (target == '#document') return document;
+        else if (target == '#screen') return window.screen;
+        else if (target == '#canvas') return Module['canvas'];
+
+        if (typeof target == 'string') return document.getElementById(target);
+        else return target;
       } else {
         // The sensible target varies between events, but use window as the default
         // since DOM events mostly can default to that. Specific callback registrations
@@ -64,53 +57,50 @@ var LibraryJsEvents = {
     // and sort by that to always request fullscreen before pointer lock.
     deferCall: function(targetFunction, precedence, argsList) {
       function arraysHaveEqualContent(arrA, arrB) {
-        if (arrA.length != arrB.length) {
-          return false;
-        }
+        if (arrA.length != arrB.length) return false;
+
         for(var i in arrA) {
-          if (arrA[i] != arrB[i]) {
-            return false;
-          }
+          if (arrA[i] != arrB[i]) return false;
         }
         return true;
       }
       // Test if the given call was already queued, and if so, don't add it again.
-      for(var i in JsEvents.deferredCalls) {
-        var call = JsEvents.deferredCalls[i];
+      for(var i in JSEvents.deferredCalls) {
+        var call = JSEvents.deferredCalls[i];
         if (call.targetFunction == targetFunction && arraysHaveEqualContent(call.argsList, argsList)) {
           return;
         }
       }
-      JsEvents.deferredCalls.push({
+      JSEvents.deferredCalls.push({
         targetFunction: targetFunction,
         precedence: precedence,
         argsList: argsList
       });
 
-      JsEvents.deferredCalls.sort(function(x,y) { return x.precedence < y.precedence; });
+      JSEvents.deferredCalls.sort(function(x,y) { return x.precedence < y.precedence; });
     },
     
     // Erases all deferred calls to the given target function from the queue list.
     removeDeferredCalls: function(targetFunction) {
-      for(var i = 0; i < JsEvents.deferredCalls.length; ++i) {
-        if (JsEvents.deferredCalls[i].targetFunction == targetFunction) {
-          JsEvents.deferredCalls.splice(i, 1);
+      for(var i = 0; i < JSEvents.deferredCalls.length; ++i) {
+        if (JSEvents.deferredCalls[i].targetFunction == targetFunction) {
+          JSEvents.deferredCalls.splice(i, 1);
           --i;
         }
       }
     },
     
     canPerformEventHandlerRequests: function() {
-      return JsEvents.inEventHandler && JsEvents.currentEventHandler.allowsDeferredCalls;
+      return JSEvents.inEventHandler && JSEvents.currentEventHandler.allowsDeferredCalls;
     },
     
     runDeferredCalls: function() {
-      if (!JsEvents.canPerformEventHandlerRequests()) {
+      if (!JSEvents.canPerformEventHandlerRequests()) {
         return;
       }
-      for(var i = 0; i < JsEvents.deferredCalls.length; ++i) {
-        var call = JsEvents.deferredCalls[i];
-        JsEvents.deferredCalls.splice(i, 1);
+      for(var i = 0; i < JSEvents.deferredCalls.length; ++i) {
+        var call = JSEvents.deferredCalls[i];
+        JSEvents.deferredCalls.splice(i, 1);
         --i;
         call.targetFunction.apply(this, call.argsList);
       }
@@ -125,165 +115,167 @@ var LibraryJsEvents = {
     eventHandlers: [],
 
     _removeHandler: function(i) {
-      JsEvents.eventHandlers[i].target.removeEventListener(JsEvents.eventHandlers[i].eventTypeString, JsEvents.eventHandlers[i].handlerFunc, true);
-      JsEvents.eventHandlers.splice(i, 1);
+      JSEvents.eventHandlers[i].target.removeEventListener(JSEvents.eventHandlers[i].eventTypeString, JSEvents.eventHandlers[i].handlerFunc, true);
+      JSEvents.eventHandlers.splice(i, 1);
     },
     
     registerOrRemoveHandler: function(eventHandler) {
       var jsEventHandler = function jsEventHandler(event) {
         // Increment nesting count for the event handler.
-        ++JsEvents.inEventHandler;
-        JsEvents.currentEventHandler = eventHandler;
+        ++JSEvents.inEventHandler;
+        JSEvents.currentEventHandler = eventHandler;
         // Process any old deferred calls the user has placed.
-        JsEvents.runDeferredCalls();
+        JSEvents.runDeferredCalls();
         // Process the actual event, calls back to user C code handler.
         eventHandler.handlerFunc(event);
         // Process any new deferred calls that were placed right now from this event handler.
-        JsEvents.runDeferredCalls();
+        JSEvents.runDeferredCalls();
         // Out of event handler - restore nesting count.
-        --JsEvents.inEventHandler;
+        --JSEvents.inEventHandler;
       }
       
       if (eventHandler.callbackfunc) {
         eventHandler.target.addEventListener(eventHandler.eventTypeString, jsEventHandler, eventHandler.useCapture);
-        JsEvents.eventHandlers.push(eventHandler);
-        JsEvents.registerRemoveEventListeners();
+        JSEvents.eventHandlers.push(eventHandler);
+        JSEvents.registerRemoveEventListeners();
       } else {
-        for(var i = 0; i < JsEvents.eventHandlers.length; ++i) {
-          if (JsEvents.eventHandlers[i].target == eventHandler.target
-           && JsEvents.eventHandlers[i].eventTypeString == eventHandler.eventTypeString) {
-             JsEvents._removeHandler(i--);
+        for(var i = 0; i < JSEvents.eventHandlers.length; ++i) {
+          if (JSEvents.eventHandlers[i].target == eventHandler.target
+           && JSEvents.eventHandlers[i].eventTypeString == eventHandler.eventTypeString) {
+             JSEvents._removeHandler(i--);
            }
         }
       }
     },
 
     registerKeyEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) {
-      if (!JsEvents.keyEvent) {
-        JsEvents.keyEvent = _malloc( {{{ C_STRUCTS.emscripten_KeyboardEvent.__size__ }}} );
+      if (!JSEvents.keyEvent) {
+        JSEvents.keyEvent = _malloc( {{{ C_STRUCTS.EmscriptenKeyboardEvent.__size__ }}} );
       }
       var handlerFunc = function(event) {
         var e = event || window.event;
-        writeStringToMemory(e.key ? e.key : "", JsEvents.keyEvent + {{{ C_STRUCTS.emscripten_KeyboardEvent.key }}} );
-        writeStringToMemory(e.code ? e.code : "", JsEvents.keyEvent + {{{ C_STRUCTS.emscripten_KeyboardEvent.code }}} );
-        {{{ makeSetValue('JsEvents.keyEvent', C_STRUCTS.emscripten_KeyboardEvent.location, 'e.location', 'i32') }}}
-        {{{ makeSetValue('JsEvents.keyEvent', C_STRUCTS.emscripten_KeyboardEvent.ctrlKey, 'e.ctrlKey', 'i32') }}}
-        {{{ makeSetValue('JsEvents.keyEvent', C_STRUCTS.emscripten_KeyboardEvent.shiftKey, 'e.shiftKey', 'i32') }}}
-        {{{ makeSetValue('JsEvents.keyEvent', C_STRUCTS.emscripten_KeyboardEvent.altKey, 'e.altKey', 'i32') }}}
-        {{{ makeSetValue('JsEvents.keyEvent', C_STRUCTS.emscripten_KeyboardEvent.metaKey, 'e.metaKey', 'i32') }}}
-        {{{ makeSetValue('JsEvents.keyEvent', C_STRUCTS.emscripten_KeyboardEvent.repeat, 'e.repeat', 'i32') }}}
-        writeStringToMemory(e.locale ? e.locale : "", JsEvents.keyEvent + {{{ C_STRUCTS.emscripten_KeyboardEvent.locale }}} );
-        writeStringToMemory(e.char ? e.char : "", JsEvents.keyEvent + {{{ C_STRUCTS.emscripten_KeyboardEvent.charValue }}} );
-        {{{ makeSetValue('JsEvents.keyEvent', C_STRUCTS.emscripten_KeyboardEvent.charCode, 'e.charCode', 'i32') }}}
-        {{{ makeSetValue('JsEvents.keyEvent', C_STRUCTS.emscripten_KeyboardEvent.keyCode, 'e.keyCode', 'i32') }}}
-        {{{ makeSetValue('JsEvents.keyEvent', C_STRUCTS.emscripten_KeyboardEvent.which, 'e.which', 'i32') }}}
-        var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JsEvents.keyEvent, userData]);
+        writeStringToMemory(e.key ? e.key : "", JSEvents.keyEvent + {{{ C_STRUCTS.EmscriptenKeyboardEvent.key }}} );
+        writeStringToMemory(e.code ? e.code : "", JSEvents.keyEvent + {{{ C_STRUCTS.EmscriptenKeyboardEvent.code }}} );
+        {{{ makeSetValue('JSEvents.keyEvent', C_STRUCTS.EmscriptenKeyboardEvent.location, 'e.location', 'i32') }}}
+        {{{ makeSetValue('JSEvents.keyEvent', C_STRUCTS.EmscriptenKeyboardEvent.ctrlKey, 'e.ctrlKey', 'i32') }}}
+        {{{ makeSetValue('JSEvents.keyEvent', C_STRUCTS.EmscriptenKeyboardEvent.shiftKey, 'e.shiftKey', 'i32') }}}
+        {{{ makeSetValue('JSEvents.keyEvent', C_STRUCTS.EmscriptenKeyboardEvent.altKey, 'e.altKey', 'i32') }}}
+        {{{ makeSetValue('JSEvents.keyEvent', C_STRUCTS.EmscriptenKeyboardEvent.metaKey, 'e.metaKey', 'i32') }}}
+        {{{ makeSetValue('JSEvents.keyEvent', C_STRUCTS.EmscriptenKeyboardEvent.repeat, 'e.repeat', 'i32') }}}
+        writeStringToMemory(e.locale ? e.locale : "", JSEvents.keyEvent + {{{ C_STRUCTS.EmscriptenKeyboardEvent.locale }}} );
+        writeStringToMemory(e.char ? e.char : "", JSEvents.keyEvent + {{{ C_STRUCTS.EmscriptenKeyboardEvent.charValue }}} );
+        {{{ makeSetValue('JSEvents.keyEvent', C_STRUCTS.EmscriptenKeyboardEvent.charCode, 'e.charCode', 'i32') }}}
+        {{{ makeSetValue('JSEvents.keyEvent', C_STRUCTS.EmscriptenKeyboardEvent.keyCode, 'e.keyCode', 'i32') }}}
+        {{{ makeSetValue('JSEvents.keyEvent', C_STRUCTS.EmscriptenKeyboardEvent.which, 'e.which', 'i32') }}}
+        var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JSEvents.keyEvent, userData]);
         if (shouldCancel) {
           e.preventDefault();
         }
       };
 
+      var isInternetExplorer = (navigator.userAgent.indexOf('MSIE') !== -1 || navigator.appVersion.indexOf('Trident/') > 0);
+
       var eventHandler = {
-        target: JsEvents.findEventTarget(target),
-        allowsDeferredCalls: true,
+        target: JSEvents.findEventTarget(target),
+        allowsDeferredCalls: isInternetExplorer ? false : true, // MSIE doesn't allow fullscreen and pointerlock requests from key handlers, others do.
         eventTypeString: eventTypeString,
         callbackfunc: callbackfunc,
         handlerFunc: handlerFunc,
         useCapture: useCapture
       };
-      JsEvents.registerOrRemoveHandler(eventHandler);
+      JSEvents.registerOrRemoveHandler(eventHandler);
     },
 
     fillMouseEventData: function(eventStruct, e) {
       var rect = Module['canvas'].getBoundingClientRect();
-      {{{ makeSetValue('eventStruct', C_STRUCTS.emscripten_MouseEvent.timestamp, 'JsEvents.tick()', 'double') }}}
-      {{{ makeSetValue('eventStruct', C_STRUCTS.emscripten_MouseEvent.screenX, 'e.screenX', 'i32') }}}
-      {{{ makeSetValue('eventStruct', C_STRUCTS.emscripten_MouseEvent.screenY, 'e.screenY', 'i32') }}}
-      {{{ makeSetValue('eventStruct', C_STRUCTS.emscripten_MouseEvent.clientX, 'e.clientX', 'i32') }}}
-      {{{ makeSetValue('eventStruct', C_STRUCTS.emscripten_MouseEvent.clientY, 'e.clientY', 'i32') }}}
-      {{{ makeSetValue('eventStruct', C_STRUCTS.emscripten_MouseEvent.ctrlKey, 'e.ctrlKey', 'i32') }}}
-      {{{ makeSetValue('eventStruct', C_STRUCTS.emscripten_MouseEvent.shiftKey, 'e.shiftKey', 'i32') }}}
-      {{{ makeSetValue('eventStruct', C_STRUCTS.emscripten_MouseEvent.altKey, 'e.altKey', 'i32') }}}
-      {{{ makeSetValue('eventStruct', C_STRUCTS.emscripten_MouseEvent.metaKey, 'e.metaKey', 'i32') }}}
-      {{{ makeSetValue('eventStruct', C_STRUCTS.emscripten_MouseEvent.button, 'e.button', 'i16') }}}
-      {{{ makeSetValue('eventStruct', C_STRUCTS.emscripten_MouseEvent.buttons, 'e.buttons', 'i16') }}}
-      {{{ makeSetValue('eventStruct', C_STRUCTS.emscripten_MouseEvent.movementX, 'e.movementX', 'i32') }}}
-      {{{ makeSetValue('eventStruct', C_STRUCTS.emscripten_MouseEvent.movementY, 'e.movementY', 'i32') }}}
-      {{{ makeSetValue('eventStruct', C_STRUCTS.emscripten_MouseEvent.canvasX, 'e.clientX - rect.left', 'i32') }}}
-      {{{ makeSetValue('eventStruct', C_STRUCTS.emscripten_MouseEvent.canvasY, 'e.clientY - rect.top', 'i32') }}}
+      {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenMouseEvent.timestamp, 'JSEvents.tick()', 'double') }}}
+      {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenMouseEvent.screenX, 'e.screenX', 'i32') }}}
+      {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenMouseEvent.screenY, 'e.screenY', 'i32') }}}
+      {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenMouseEvent.clientX, 'e.clientX', 'i32') }}}
+      {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenMouseEvent.clientY, 'e.clientY', 'i32') }}}
+      {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenMouseEvent.ctrlKey, 'e.ctrlKey', 'i32') }}}
+      {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenMouseEvent.shiftKey, 'e.shiftKey', 'i32') }}}
+      {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenMouseEvent.altKey, 'e.altKey', 'i32') }}}
+      {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenMouseEvent.metaKey, 'e.metaKey', 'i32') }}}
+      {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenMouseEvent.button, 'e.button', 'i16') }}}
+      {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenMouseEvent.buttons, 'e.buttons', 'i16') }}}
+      {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenMouseEvent.movementX, 'e.movementX', 'i32') }}}
+      {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenMouseEvent.movementY, 'e.movementY', 'i32') }}}
+      {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenMouseEvent.canvasX, 'e.clientX - rect.left', 'i32') }}}
+      {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenMouseEvent.canvasY, 'e.clientY - rect.top', 'i32') }}}
     },
     
     registerMouseEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) {
-      if (!JsEvents.mouseEvent) {
-        JsEvents.mouseEvent = _malloc( {{{ C_STRUCTS.emscripten_MouseEvent.__size__ }}} );
+      if (!JSEvents.mouseEvent) {
+        JSEvents.mouseEvent = _malloc( {{{ C_STRUCTS.EmscriptenMouseEvent.__size__ }}} );
       }
       var handlerFunc = function(event) {
         var e = event || window.event;
-        JsEvents.fillMouseEventData(JsEvents.mouseEvent, e);
-        var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JsEvents.mouseEvent, userData]);
+        JSEvents.fillMouseEventData(JSEvents.mouseEvent, e);
+        var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JSEvents.mouseEvent, userData]);
         if (shouldCancel) {
           e.preventDefault();
         }
       };
 
       var eventHandler = {
-        target: JsEvents.findEventTarget(target),
+        target: JSEvents.findEventTarget(target),
         allowsDeferredCalls: eventTypeString != 'mousemove', // Mouse move events do not allow fullscreen/pointer lock requests to be handled in them!
         eventTypeString: eventTypeString,
         callbackfunc: callbackfunc,
         handlerFunc: handlerFunc,
         useCapture: useCapture
       };
-      JsEvents.registerOrRemoveHandler(eventHandler);
+      JSEvents.registerOrRemoveHandler(eventHandler);
     },
 
     registerWheelEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) {
-      if (!JsEvents.wheelEvent) {
-        JsEvents.wheelEvent = _malloc( {{{ C_STRUCTS.emscripten_WheelEvent.__size__ }}} );
+      if (!JSEvents.wheelEvent) {
+        JSEvents.wheelEvent = _malloc( {{{ C_STRUCTS.EmscriptenWheelEvent.__size__ }}} );
       }
       var handlerFunc = function(event) {
         var e = event || window.event;
-        JsEvents.fillMouseEventData(JsEvents.wheelEvent, e);
-        {{{ makeSetValue('JsEvents.wheelEvent', C_STRUCTS.emscripten_WheelEvent.deltaX, 'e.deltaX', 'double') }}}
-        {{{ makeSetValue('JsEvents.wheelEvent', C_STRUCTS.emscripten_WheelEvent.deltaY, 'e.deltaY', 'double') }}}
-        {{{ makeSetValue('JsEvents.wheelEvent', C_STRUCTS.emscripten_WheelEvent.deltaZ, 'e.deltaZ', 'double') }}}
-        {{{ makeSetValue('JsEvents.wheelEvent', C_STRUCTS.emscripten_WheelEvent.deltaMode, 'e.deltaMode', 'i32') }}}
-        var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JsEvents.wheelEvent, userData]);
+        JSEvents.fillMouseEventData(JSEvents.wheelEvent, e);
+        {{{ makeSetValue('JSEvents.wheelEvent', C_STRUCTS.EmscriptenWheelEvent.deltaX, 'e.deltaX', 'double') }}}
+        {{{ makeSetValue('JSEvents.wheelEvent', C_STRUCTS.EmscriptenWheelEvent.deltaY, 'e.deltaY', 'double') }}}
+        {{{ makeSetValue('JSEvents.wheelEvent', C_STRUCTS.EmscriptenWheelEvent.deltaZ, 'e.deltaZ', 'double') }}}
+        {{{ makeSetValue('JSEvents.wheelEvent', C_STRUCTS.EmscriptenWheelEvent.deltaMode, 'e.deltaMode', 'i32') }}}
+        var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JSEvents.wheelEvent, userData]);
         if (shouldCancel) {
           e.preventDefault();
         }
       };
 
       var eventHandler = {
-        target: JsEvents.findEventTarget(target),
+        target: JSEvents.findEventTarget(target),
         allowsDeferredCalls: true,
         eventTypeString: eventTypeString,
         callbackfunc: callbackfunc,
         handlerFunc: handlerFunc,
         useCapture: useCapture
       };
-      JsEvents.registerOrRemoveHandler(eventHandler);
+      JSEvents.registerOrRemoveHandler(eventHandler);
     },
 
     pageScrollPos: function() {
       if (window.pageXOffset > 0 || window.pageYOffset > 0) {
         return [window.pageXOffset, window.pageYOffset];
       }
-      if (document.documentElement.scrollLeft > 0 || document.documentElement.scrollTop > 0) {
+      if (typeof document.documentElement.scrollLeft !== 'undefined' || typeof document.documentElement.scrollTop !== 'undefined') {
         return [document.documentElement.scrollLeft, document.documentElement.scrollTop];
       }
       return [document.body.scrollLeft|0, document.body.scrollTop|0];
     },
 
     registerUiEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) {
-      if (!JsEvents.uiEvent) {
-        JsEvents.uiEvent = _malloc( {{{ C_STRUCTS.emscripten_UiEvent.__size__ }}} );
+      if (!JSEvents.uiEvent) {
+        JSEvents.uiEvent = _malloc( {{{ C_STRUCTS.EmscriptenUiEvent.__size__ }}} );
       }
 
       if (eventTypeString == "scroll" && !target) {
         target = document; // By default read scroll events on document rather than window.
       } else {
-        target = JsEvents.findEventTarget(target);
+        target = JSEvents.findEventTarget(target);
       }
 
       var handlerFunc = function(event) {
@@ -295,17 +287,17 @@ var LibraryJsEvents = {
           // causing a new scroll, etc..
           return;
         }
-        var scrollPos = JsEvents.pageScrollPos();
-        {{{ makeSetValue('JsEvents.uiEvent', C_STRUCTS.emscripten_UiEvent.detail, 'e.detail', 'i32') }}}
-        {{{ makeSetValue('JsEvents.uiEvent', C_STRUCTS.emscripten_UiEvent.documentBodyClientWidth, 'document.body.clientWidth', 'i32') }}}
-        {{{ makeSetValue('JsEvents.uiEvent', C_STRUCTS.emscripten_UiEvent.documentBodyClientHeight, 'document.body.clientHeight', 'i32') }}}
-        {{{ makeSetValue('JsEvents.uiEvent', C_STRUCTS.emscripten_UiEvent.windowInnerWidth, 'window.innerWidth', 'i32') }}}
-        {{{ makeSetValue('JsEvents.uiEvent', C_STRUCTS.emscripten_UiEvent.windowInnerHeight, 'window.innerHeight', 'i32') }}}
-        {{{ makeSetValue('JsEvents.uiEvent', C_STRUCTS.emscripten_UiEvent.windowOuterWidth, 'window.outerWidth', 'i32') }}}
-        {{{ makeSetValue('JsEvents.uiEvent', C_STRUCTS.emscripten_UiEvent.windowOuterHeight, 'window.outerHeight', 'i32') }}}
-        {{{ makeSetValue('JsEvents.uiEvent', C_STRUCTS.emscripten_UiEvent.scrollTop, 'scrollPos[0]', 'i32') }}}
-        {{{ makeSetValue('JsEvents.uiEvent', C_STRUCTS.emscripten_UiEvent.scrollLeft, 'scrollPos[1]', 'i32') }}}
-        var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JsEvents.uiEvent, userData]);
+        var scrollPos = JSEvents.pageScrollPos();
+        {{{ makeSetValue('JSEvents.uiEvent', C_STRUCTS.EmscriptenUiEvent.detail, 'e.detail', 'i32') }}}
+        {{{ makeSetValue('JSEvents.uiEvent', C_STRUCTS.EmscriptenUiEvent.documentBodyClientWidth, 'document.body.clientWidth', 'i32') }}}
+        {{{ makeSetValue('JSEvents.uiEvent', C_STRUCTS.EmscriptenUiEvent.documentBodyClientHeight, 'document.body.clientHeight', 'i32') }}}
+        {{{ makeSetValue('JSEvents.uiEvent', C_STRUCTS.EmscriptenUiEvent.windowInnerWidth, 'window.innerWidth', 'i32') }}}
+        {{{ makeSetValue('JSEvents.uiEvent', C_STRUCTS.EmscriptenUiEvent.windowInnerHeight, 'window.innerHeight', 'i32') }}}
+        {{{ makeSetValue('JSEvents.uiEvent', C_STRUCTS.EmscriptenUiEvent.windowOuterWidth, 'window.outerWidth', 'i32') }}}
+        {{{ makeSetValue('JSEvents.uiEvent', C_STRUCTS.EmscriptenUiEvent.windowOuterHeight, 'window.outerHeight', 'i32') }}}
+        {{{ makeSetValue('JSEvents.uiEvent', C_STRUCTS.EmscriptenUiEvent.scrollTop, 'scrollPos[0]', 'i32') }}}
+        {{{ makeSetValue('JSEvents.uiEvent', C_STRUCTS.EmscriptenUiEvent.scrollLeft, 'scrollPos[1]', 'i32') }}}
+        var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JSEvents.uiEvent, userData]);
         if (shouldCancel) {
           e.preventDefault();
         }
@@ -319,154 +311,150 @@ var LibraryJsEvents = {
         handlerFunc: handlerFunc,
         useCapture: useCapture
       };
-      JsEvents.registerOrRemoveHandler(eventHandler);
+      JSEvents.registerOrRemoveHandler(eventHandler);
     },
 
     getNodeNameForTarget: function(target) {
-      if (!target) {
-        return '';
-      }
-      if (target == window) {
-        return '#window';
-      }
-      if (target == window.screen) {
-        return '#screen';
-      }
+      if (!target) return '';
+      if (target == window) return '#window';
+      if (target == window.screen) return '#screen';
       return (target && target.nodeName) ? target.nodeName : '';
     },
 
     registerFocusEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) {
-      if (!JsEvents.focusEvent) {
-        JsEvents.focusEvent = _malloc( {{{ C_STRUCTS.emscripten_FocusEvent.__size__ }}} );
+      if (!JSEvents.focusEvent) {
+        JSEvents.focusEvent = _malloc( {{{ C_STRUCTS.EmscriptenFocusEvent.__size__ }}} );
       }
       var handlerFunc = function(event) {
         var e = event || window.event;
 
-        var nodeName = JsEvents.getNodeNameForTarget(e.target);
+        var nodeName = JSEvents.getNodeNameForTarget(e.target);
         var id = e.target.id ? e.target.id : '';
-        writeStringToMemory(nodeName, JsEvents.focusEvent + {{{ C_STRUCTS.emscripten_FocusEvent.nodeName }}} );
-        writeStringToMemory(id, JsEvents.focusEvent + {{{ C_STRUCTS.emscripten_FocusEvent.id }}} );
-        var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JsEvents.focusEvent, userData]);
+        writeStringToMemory(nodeName, JSEvents.focusEvent + {{{ C_STRUCTS.EmscriptenFocusEvent.nodeName }}} );
+        writeStringToMemory(id, JSEvents.focusEvent + {{{ C_STRUCTS.EmscriptenFocusEvent.id }}} );
+        var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JSEvents.focusEvent, userData]);
         if (shouldCancel) {
           e.preventDefault();
         }
       };
 
       var eventHandler = {
-        target: JsEvents.findEventTarget(target),
+        target: JSEvents.findEventTarget(target),
         allowsDeferredCalls: false,
         eventTypeString: eventTypeString,
         callbackfunc: callbackfunc,
         handlerFunc: handlerFunc,
         useCapture: useCapture
       };
-      JsEvents.registerOrRemoveHandler(eventHandler);
+      JSEvents.registerOrRemoveHandler(eventHandler);
     },
 
     tick: function() {
-      if (window['performance'] && window['performance']['now']) {
-        return window['performance']['now']();
-      } else {
-        return Date.now();
-      }
+      if (window['performance'] && window['performance']['now']) return window['performance']['now']();
+      else return Date.now();
     },
 
     registerDeviceOrientationEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) {
-      if (!JsEvents.deviceOrientationEvent) {
-        JsEvents.deviceOrientationEvent = _malloc( {{{ C_STRUCTS.emscripten_DeviceOrientationEvent.__size__ }}} );
+      if (!JSEvents.deviceOrientationEvent) {
+        JSEvents.deviceOrientationEvent = _malloc( {{{ C_STRUCTS.EmscriptenDeviceOrientationEvent.__size__ }}} );
       }
       var handlerFunc = function(event) {
         var e = event || window.event;
 
-        {{{ makeSetValue('JsEvents.deviceOrientationEvent', C_STRUCTS.emscripten_DeviceOrientationEvent.timestamp, 'JsEvents.tick()', 'double') }}}
-        {{{ makeSetValue('JsEvents.deviceOrientationEvent', C_STRUCTS.emscripten_DeviceOrientationEvent.alpha, 'e.alpha', 'double') }}}
-        {{{ makeSetValue('JsEvents.deviceOrientationEvent', C_STRUCTS.emscripten_DeviceOrientationEvent.beta, 'e.beta', 'double') }}}
-        {{{ makeSetValue('JsEvents.deviceOrientationEvent', C_STRUCTS.emscripten_DeviceOrientationEvent.gamma, 'e.gamma', 'double') }}}
-        {{{ makeSetValue('JsEvents.deviceOrientationEvent', C_STRUCTS.emscripten_DeviceOrientationEvent.absolute, 'e.absolute', 'i32') }}}
+        {{{ makeSetValue('JSEvents.deviceOrientationEvent', C_STRUCTS.EmscriptenDeviceOrientationEvent.timestamp, 'JSEvents.tick()', 'double') }}}
+        {{{ makeSetValue('JSEvents.deviceOrientationEvent', C_STRUCTS.EmscriptenDeviceOrientationEvent.alpha, 'e.alpha', 'double') }}}
+        {{{ makeSetValue('JSEvents.deviceOrientationEvent', C_STRUCTS.EmscriptenDeviceOrientationEvent.beta, 'e.beta', 'double') }}}
+        {{{ makeSetValue('JSEvents.deviceOrientationEvent', C_STRUCTS.EmscriptenDeviceOrientationEvent.gamma, 'e.gamma', 'double') }}}
+        {{{ makeSetValue('JSEvents.deviceOrientationEvent', C_STRUCTS.EmscriptenDeviceOrientationEvent.absolute, 'e.absolute', 'i32') }}}
 
-        var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JsEvents.deviceOrientationEvent, userData]);
+        var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JSEvents.deviceOrientationEvent, userData]);
         if (shouldCancel) {
           e.preventDefault();
         }
       };
 
       var eventHandler = {
-        target: JsEvents.findEventTarget(target),
+        target: JSEvents.findEventTarget(target),
         allowsDeferredCalls: false,
         eventTypeString: eventTypeString,
         callbackfunc: callbackfunc,
         handlerFunc: handlerFunc,
         useCapture: useCapture
       };
-      JsEvents.registerOrRemoveHandler(eventHandler);
+      JSEvents.registerOrRemoveHandler(eventHandler);
     },
 
     registerDeviceMotionEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) {
-      if (!JsEvents.deviceMotionEvent) {
-        JsEvents.deviceMotionEvent = _malloc( {{{ C_STRUCTS.emscripten_DeviceMotionEvent.__size__ }}} );
+      if (!JSEvents.deviceMotionEvent) {
+        JSEvents.deviceMotionEvent = _malloc( {{{ C_STRUCTS.EmscriptenDeviceMotionEvent.__size__ }}} );
       }
       var handlerFunc = function(event) {
         var e = event || window.event;
 
-        {{{ makeSetValue('JsEvents.deviceOrientationEvent', C_STRUCTS.emscripten_DeviceMotionEvent.timestamp, 'JsEvents.tick()', 'double') }}}
-        {{{ makeSetValue('JsEvents.deviceMotionEvent', C_STRUCTS.emscripten_DeviceMotionEvent.accelerationX, 'e.acceleration.x', 'double') }}}
-        {{{ makeSetValue('JsEvents.deviceMotionEvent', C_STRUCTS.emscripten_DeviceMotionEvent.accelerationY, 'e.acceleration.y', 'double') }}}
-        {{{ makeSetValue('JsEvents.deviceMotionEvent', C_STRUCTS.emscripten_DeviceMotionEvent.accelerationZ, 'e.acceleration.z', 'double') }}}
-        {{{ makeSetValue('JsEvents.deviceMotionEvent', C_STRUCTS.emscripten_DeviceMotionEvent.accelerationIncludingGravityX, 'e.accelerationIncludingGravity.x', 'double') }}}
-        {{{ makeSetValue('JsEvents.deviceMotionEvent', C_STRUCTS.emscripten_DeviceMotionEvent.accelerationIncludingGravityY, 'e.accelerationIncludingGravity.y', 'double') }}}
-        {{{ makeSetValue('JsEvents.deviceMotionEvent', C_STRUCTS.emscripten_DeviceMotionEvent.accelerationIncludingGravityZ, 'e.accelerationIncludingGravity.z', 'double') }}}
-        {{{ makeSetValue('JsEvents.deviceMotionEvent', C_STRUCTS.emscripten_DeviceMotionEvent.rotationRateAlpha, 'e.rotationRate.alpha', 'double') }}}
-        {{{ makeSetValue('JsEvents.deviceMotionEvent', C_STRUCTS.emscripten_DeviceMotionEvent.rotationRateBeta, 'e.rotationRate.beta', 'double') }}}
-        {{{ makeSetValue('JsEvents.deviceMotionEvent', C_STRUCTS.emscripten_DeviceMotionEvent.rotationRateGamma, 'e.rotationRate.gamma', 'double') }}}
-
-        var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JsEvents.deviceMotionEvent, userData]);
+        {{{ makeSetValue('JSEvents.deviceOrientationEvent', C_STRUCTS.EmscriptenDeviceMotionEvent.timestamp, 'JSEvents.tick()', 'double') }}}
+        {{{ makeSetValue('JSEvents.deviceMotionEvent', C_STRUCTS.EmscriptenDeviceMotionEvent.accelerationX, 'e.acceleration.x', 'double') }}}
+        {{{ makeSetValue('JSEvents.deviceMotionEvent', C_STRUCTS.EmscriptenDeviceMotionEvent.accelerationY, 'e.acceleration.y', 'double') }}}
+        {{{ makeSetValue('JSEvents.deviceMotionEvent', C_STRUCTS.EmscriptenDeviceMotionEvent.accelerationZ, 'e.acceleration.z', 'double') }}}
+        {{{ makeSetValue('JSEvents.deviceMotionEvent', C_STRUCTS.EmscriptenDeviceMotionEvent.accelerationIncludingGravityX, 'e.accelerationIncludingGravity.x', 'double') }}}
+        {{{ makeSetValue('JSEvents.deviceMotionEvent', C_STRUCTS.EmscriptenDeviceMotionEvent.accelerationIncludingGravityY, 'e.accelerationIncludingGravity.y', 'double') }}}
+        {{{ makeSetValue('JSEvents.deviceMotionEvent', C_STRUCTS.EmscriptenDeviceMotionEvent.accelerationIncludingGravityZ, 'e.accelerationIncludingGravity.z', 'double') }}}
+        {{{ makeSetValue('JSEvents.deviceMotionEvent', C_STRUCTS.EmscriptenDeviceMotionEvent.rotationRateAlpha, 'e.rotationRate.alpha', 'double') }}}
+        {{{ makeSetValue('JSEvents.deviceMotionEvent', C_STRUCTS.EmscriptenDeviceMotionEvent.rotationRateBeta, 'e.rotationRate.beta', 'double') }}}
+        {{{ makeSetValue('JSEvents.deviceMotionEvent', C_STRUCTS.EmscriptenDeviceMotionEvent.rotationRateGamma, 'e.rotationRate.gamma', 'double') }}}
+
+        var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JSEvents.deviceMotionEvent, userData]);
         if (shouldCancel) {
           e.preventDefault();
         }
       };
 
       var eventHandler = {
-        target: JsEvents.findEventTarget(target),
+        target: JSEvents.findEventTarget(target),
         allowsDeferredCalls: false,
         eventTypeString: eventTypeString,
         callbackfunc: callbackfunc,
         handlerFunc: handlerFunc,
         useCapture: useCapture
       };
-      JsEvents.registerOrRemoveHandler(eventHandler);
+      JSEvents.registerOrRemoveHandler(eventHandler);
+    },
+
+    screenOrientation: function() {
+      if (!window.screen) return undefined;
+      return window.screen.orientation || window.screen.mozOrientation || window.screen.webkitOrientation || window.screen.msOrientation;
     },
 
     fillOrientationChangeEventData: function(eventStruct, e) {
       var orientations  = ["portrait-primary", "portrait-secondary", "landscape-primary", "landscape-secondary"];
       var orientations2 = ["portrait",         "portrait",           "landscape",         "landscape"];
 
-      var orientationString = window.screen.orientation || window.screen.mozOrientation;
+      var orientationString = JSEvents.screenOrientation();
       var orientation = orientations.indexOf(orientationString);
       if (orientation == -1) {
         orientation = orientations2.indexOf(orientationString);
       }
 
-      {{{ makeSetValue('eventStruct', C_STRUCTS.emscripten_OrientationChangeEvent.orientationIndex, '1 << orientation', 'i32') }}}
-      {{{ makeSetValue('eventStruct', C_STRUCTS.emscripten_OrientationChangeEvent.orientationAngle, 'window.orientation', 'i32') }}}
+      {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenOrientationChangeEvent.orientationIndex, '1 << orientation', 'i32') }}}
+      {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenOrientationChangeEvent.orientationAngle, 'window.orientation', 'i32') }}}
     },
 
     registerOrientationChangeEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) {
-      if (!JsEvents.orientationChangeEvent) {
-        JsEvents.orientationChangeEvent = _malloc( {{{ C_STRUCTS.emscripten_OrientationChangeEvent.__size__ }}} );
+      if (!JSEvents.orientationChangeEvent) {
+        JSEvents.orientationChangeEvent = _malloc( {{{ C_STRUCTS.EmscriptenOrientationChangeEvent.__size__ }}} );
       }
 
       if (!target) {
         target = window.screen; // Orientation events need to be captured from 'window.screen' instead of 'window'
       } else {
-        target = JsEvents.findEventTarget(target);
+        target = JSEvents.findEventTarget(target);
       }
 
       var handlerFunc = function(event) {
         var e = event || window.event;
 
-        JsEvents.fillOrientationChangeEventData(JsEvents.orientationChangeEvent, e);
+        JSEvents.fillOrientationChangeEventData(JSEvents.orientationChangeEvent, e);
 
-        var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JsEvents.orientationChangeEvent, userData]);
+        var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JSEvents.orientationChangeEvent, userData]);
         if (shouldCancel) {
           e.preventDefault();
         }
@@ -484,37 +472,41 @@ var LibraryJsEvents = {
         handlerFunc: handlerFunc,
         useCapture: useCapture
       };
-      JsEvents.registerOrRemoveHandler(eventHandler);
+      JSEvents.registerOrRemoveHandler(eventHandler);
     },
 
+    fullscreenEnabled: function() {
+      return document.fullscreenEnabled || document.mozFullscreenEnabled || document.mozFullScreenEnabled || document.webkitFullscreenEnabled || document.msFullscreenEnabled;
+    },
+    
     fillFullscreenChangeEventData: function(eventStruct, e) {
       var fullscreenElement = document.fullscreenElement || document.mozFullScreenElement || document.webkitFullscreenElement || document.msFullscreenElement;
       var isFullscreen = !!fullscreenElement;
-      {{{ makeSetValue('eventStruct', C_STRUCTS.emscripten_FullscreenChangeEvent.isFullscreen, 'isFullscreen', 'i32') }}}
-      {{{ makeSetValue('eventStruct', C_STRUCTS.emscripten_FullscreenChangeEvent.fullscreenEnabled, 'document.fullscreenEnabled', 'i32') }}}
-      var nodeName = JsEvents.getNodeNameForTarget(fullscreenElement);
+      {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenFullscreenChangeEvent.isFullscreen, 'isFullscreen', 'i32') }}}
+      {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenFullscreenChangeEvent.fullscreenEnabled, 'JSEvents.fullscreenEnabled()', 'i32') }}}
+      var nodeName = JSEvents.getNodeNameForTarget(fullscreenElement);
       var id = (fullscreenElement && fullscreenElement.id) ? fullscreenElement.id : '';
-      writeStringToMemory(nodeName, eventStruct + {{{ C_STRUCTS.emscripten_FullscreenChangeEvent.nodeName }}} );
-      writeStringToMemory(id, eventStruct + {{{ C_STRUCTS.emscripten_FullscreenChangeEvent.id }}} );
+      writeStringToMemory(nodeName, eventStruct + {{{ C_STRUCTS.EmscriptenFullscreenChangeEvent.nodeName }}} );
+      writeStringToMemory(id, eventStruct + {{{ C_STRUCTS.EmscriptenFullscreenChangeEvent.id }}} );
     },
 
     registerFullscreenChangeEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) {
-      if (!JsEvents.fullscreenChangeEvent) {
-        JsEvents.fullscreenChangeEvent = _malloc( {{{ C_STRUCTS.emscripten_FullscreenChangeEvent.__size__ }}} );
+      if (!JSEvents.fullscreenChangeEvent) {
+        JSEvents.fullscreenChangeEvent = _malloc( {{{ C_STRUCTS.EmscriptenFullscreenChangeEvent.__size__ }}} );
       }
 
       if (!target) {
         target = document; // Fullscreen change events need to be captured from 'document' by default instead of 'window'
       } else {
-        target = JsEvents.findEventTarget(target);
+        target = JSEvents.findEventTarget(target);
       }
 
       var handlerFunc = function(event) {
         var e = event || window.event;
 
-        JsEvents.fillFullscreenChangeEventData(JsEvents.fullscreenChangeEvent, e);
+        JSEvents.fillFullscreenChangeEventData(JSEvents.fullscreenChangeEvent, e);
 
-        var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JsEvents.fullscreenChangeEvent, userData]);
+        var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JSEvents.fullscreenChangeEvent, userData]);
         if (shouldCancel) {
           e.preventDefault();
         }
@@ -528,7 +520,7 @@ var LibraryJsEvents = {
         handlerFunc: handlerFunc,
         useCapture: useCapture
       };
-      JsEvents.registerOrRemoveHandler(eventHandler);
+      JSEvents.registerOrRemoveHandler(eventHandler);
     },
 
     requestFullscreen: function(target) {
@@ -538,10 +530,16 @@ var LibraryJsEvents = {
         target.msRequestFullscreen();
       } else if (target.mozRequestFullScreen) {
         target.mozRequestFullScreen();
+      } else if (target.mozRequestFullscreen) {
+        target.mozRequestFullscreen();
       } else if (target.webkitRequestFullscreen) {
         target.webkitRequestFullscreen(Element.ALLOW_KEYBOARD_INPUT);
       } else {
-        return 2 /* Target does not support requesting fullscreen */;
+        if (typeof JSEvents.fullscreenEnabled() === 'undefined') {
+          return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
+        } else {
+          return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_TARGET') }}};
+        }
       }
       return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
     },
@@ -549,30 +547,30 @@ var LibraryJsEvents = {
     fillPointerlockChangeEventData: function(eventStruct, e) {
       var pointerLockElement = document.pointerLockElement || document.mozPointerLockElement || document.webkitPointerLockElement || document.msPointerLockElement;
       var isPointerlocked = !!pointerLockElement;
-      {{{ makeSetValue('eventStruct', C_STRUCTS.emscripten_PointerlockChangeEvent.isActive, 'isPointerlocked', 'i32') }}}
-      var nodeName = JsEvents.getNodeNameForTarget(pointerLockElement);
+      {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenPointerlockChangeEvent.isActive, 'isPointerlocked', 'i32') }}}
+      var nodeName = JSEvents.getNodeNameForTarget(pointerLockElement);
       var id = (pointerLockElement && pointerLockElement.id) ? pointerLockElement.id : '';
-      writeStringToMemory(nodeName, eventStruct + {{{ C_STRUCTS.emscripten_PointerlockChangeEvent.nodeName }}} );
-      writeStringToMemory(id, eventStruct + {{{ C_STRUCTS.emscripten_PointerlockChangeEvent.id }}});
+      writeStringToMemory(nodeName, eventStruct + {{{ C_STRUCTS.EmscriptenPointerlockChangeEvent.nodeName }}} );
+      writeStringToMemory(id, eventStruct + {{{ C_STRUCTS.EmscriptenPointerlockChangeEvent.id }}});
     },
 
     registerPointerlockChangeEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) {
-      if (!JsEvents.pointerlockChangeEvent) {
-        JsEvents.pointerlockChangeEvent = _malloc( {{{ C_STRUCTS.emscripten_PointerlockChangeEvent.__size__ }}} );