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

3 files changed, 388 insertions, 371 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__ }}} );
+      if (!JSEvents.pointerlockChangeEvent) {
+        JSEvents.pointerlockChangeEvent = _malloc( {{{ C_STRUCTS.EmscriptenPointerlockChangeEvent.__size__ }}} );
       }
 
       if (!target) {
         target = document; // Pointer lock 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.fillPointerlockChangeEventData(JsEvents.pointerlockChangeEvent, e);
+        JSEvents.fillPointerlockChangeEventData(JSEvents.pointerlockChangeEvent, e);
 
-        var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JsEvents.pointerlockChangeEvent, userData]);
+        var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JSEvents.pointerlockChangeEvent, userData]);
         if (shouldCancel) {
           e.preventDefault();
         }
@@ -586,7 +584,7 @@ var LibraryJsEvents = {
         handlerFunc: handlerFunc,
         useCapture: useCapture
       };
-      JsEvents.registerOrRemoveHandler(eventHandler);
+      JSEvents.registerOrRemoveHandler(eventHandler);
     },
 
     requestPointerLock: function(target) {
@@ -599,7 +597,13 @@ var LibraryJsEvents = {
       } else if (target.msRequestPointerLock) {
         target.msRequestPointerLock();
       } else {
-        return 2 /* Target does not support requesting pointer lock */;
+        // document.body is known to accept pointer lock, so use that to differentiate if the user passed a bad element,
+        // or if the whole browser just doesn't support the feature.
+        if (document.body.requestPointerLock || document.body.mozRequestPointerLock || document.body.webkitRequestPointerLock || document.body.msRequestPointerLock) {
+          return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_TARGET') }}};
+        } else {
+          return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
+        }
       }
       return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
     },
@@ -608,27 +612,27 @@ var LibraryJsEvents = {
       var visibilityStates = [ "hidden", "visible", "prerender", "unloaded" ];
       var visibilityState = visibilityStates.indexOf(document.visibilityState);
 
-      {{{ makeSetValue('eventStruct', C_STRUCTS.emscripten_VisibilityChangeEvent.hidden, 'document.hidden', 'i32') }}}
-      {{{ makeSetValue('eventStruct', C_STRUCTS.emscripten_VisibilityChangeEvent.visibilityState, 'visibilityState', 'i32') }}}
+      {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenVisibilityChangeEvent.hidden, 'document.hidden', 'i32') }}}
+      {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenVisibilityChangeEvent.visibilityState, 'visibilityState', 'i32') }}}
     },
 
     registerVisibilityChangeEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) {
-      if (!JsEvents.visibilityChangeEvent) {
-        JsEvents.visibilityChangeEvent = _malloc( {{{ C_STRUCTS.emscripten_VisibilityChangeEvent.__size__ }}} );
+      if (!JSEvents.visibilityChangeEvent) {
+        JSEvents.visibilityChangeEvent = _malloc( {{{ C_STRUCTS.EmscriptenVisibilityChangeEvent.__size__ }}} );
       }
 
       if (!target) {
         target = document; // Visibility 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.fillVisibilityChangeEventData(JsEvents.visibilityChangeEvent, e);
+        JSEvents.fillVisibilityChangeEventData(JSEvents.visibilityChangeEvent, e);
 
-        var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JsEvents.visibilityChangeEvent, userData]);
+        var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JSEvents.visibilityChangeEvent, userData]);
         if (shouldCancel) {
           e.preventDefault();
         }
@@ -642,12 +646,12 @@ var LibraryJsEvents = {
         handlerFunc: handlerFunc,
         useCapture: useCapture
       };
-      JsEvents.registerOrRemoveHandler(eventHandler);
+      JSEvents.registerOrRemoveHandler(eventHandler);
     },
 
     registerTouchEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) {
-      if (!JsEvents.touchEvent) {
-        JsEvents.touchEvent = _malloc( {{{ C_STRUCTS.emscripten_TouchEvent.__size__ }}} );
+      if (!JSEvents.touchEvent) {
+        JSEvents.touchEvent = _malloc( {{{ C_STRUCTS.EmscriptenTouchEvent.__size__ }}} );
       }
 
       var handlerFunc = function(event) {
@@ -668,96 +672,96 @@ var LibraryJsEvents = {
           touches[touch.identifier].onTarget = true;
         }
         
-        var ptr = JsEvents.touchEvent;
-        {{{ makeSetValue('ptr', C_STRUCTS.emscripten_TouchEvent.ctrlKey, 'e.ctrlKey', 'i32') }}}
-        {{{ makeSetValue('ptr', C_STRUCTS.emscripten_TouchEvent.shiftKey, 'e.shiftKey', 'i32') }}}
-        {{{ makeSetValue('ptr', C_STRUCTS.emscripten_TouchEvent.altKey, 'e.altKey', 'i32') }}}
-        {{{ makeSetValue('ptr', C_STRUCTS.emscripten_TouchEvent.metaKey, 'e.metaKey', 'i32') }}}
-        ptr += {{{ C_STRUCTS.emscripten_TouchEvent.touches }}}; // Advance to the start of the touch array.
+        var ptr = JSEvents.touchEvent;
+        {{{ makeSetValue('ptr', C_STRUCTS.EmscriptenTouchEvent.ctrlKey, 'e.ctrlKey', 'i32') }}}
+        {{{ makeSetValue('ptr', C_STRUCTS.EmscriptenTouchEvent.shiftKey, 'e.shiftKey', 'i32') }}}
+        {{{ makeSetValue('ptr', C_STRUCTS.EmscriptenTouchEvent.altKey, 'e.altKey', 'i32') }}}
+        {{{ makeSetValue('ptr', C_STRUCTS.EmscriptenTouchEvent.metaKey, 'e.metaKey', 'i32') }}}
+        ptr += {{{ C_STRUCTS.EmscriptenTouchEvent.touches }}}; // Advance to the start of the touch array.
         var rect = Module['canvas'].getBoundingClientRect();
         var numTouches = 0;
         for(var i in touches) {
           var t = touches[i];
-          {{{ makeSetValue('ptr', C_STRUCTS.emscripten_TouchPoint.identifier, 't.identifier', 'i32') }}}
-          {{{ makeSetValue('ptr', C_STRUCTS.emscripten_TouchPoint.screenX, 't.screenX', 'i32') }}}
-          {{{ makeSetValue('ptr', C_STRUCTS.emscripten_TouchPoint.screenY, 't.screenY', 'i32') }}}
-          {{{ makeSetValue('ptr', C_STRUCTS.emscripten_TouchPoint.clientX, 't.clientX', 'i32') }}}
-          {{{ makeSetValue('ptr', C_STRUCTS.emscripten_TouchPoint.clientY, 't.clientY', 'i32') }}}
-          {{{ makeSetValue('ptr', C_STRUCTS.emscripten_TouchPoint.pageX, 't.pageX', 'i32') }}}
-          {{{ makeSetValue('ptr', C_STRUCTS.emscripten_TouchPoint.pageY, 't.pageY', 'i32') }}}
-          {{{ makeSetValue('ptr', C_STRUCTS.emscripten_TouchPoint.isChanged, 't.changed', 'i32') }}}
-          {{{ makeSetValue('ptr', C_STRUCTS.emscripten_TouchPoint.onTarget, 't.onTarget', 'i32') }}}
-          {{{ makeSetValue('ptr', C_STRUCTS.emscripten_TouchPoint.canvasX, 't.clientX - rect.left', 'i32') }}}
-          {{{ makeSetValue('ptr', C_STRUCTS.emscripten_TouchPoint.canvasY, 't.clientY - rect.top', 'i32') }}}
-          ptr += {{{ C_STRUCTS.emscripten_TouchPoint.__size__ }}};
+          {{{ makeSetValue('ptr', C_STRUCTS.EmscriptenTouchPoint.identifier, 't.identifier', 'i32') }}}
+          {{{ makeSetValue('ptr', C_STRUCTS.EmscriptenTouchPoint.screenX, 't.screenX', 'i32') }}}
+          {{{ makeSetValue('ptr', C_STRUCTS.EmscriptenTouchPoint.screenY, 't.screenY', 'i32') }}}
+          {{{ makeSetValue('ptr', C_STRUCTS.EmscriptenTouchPoint.clientX, 't.clientX', 'i32') }}}
+          {{{ makeSetValue('ptr', C_STRUCTS.EmscriptenTouchPoint.clientY, 't.clientY', 'i32') }}}
+          {{{ makeSetValue('ptr', C_STRUCTS.EmscriptenTouchPoint.pageX, 't.pageX', 'i32') }}}
+          {{{ makeSetValue('ptr', C_STRUCTS.EmscriptenTouchPoint.pageY, 't.pageY', 'i32') }}}
+          {{{ makeSetValue('ptr', C_STRUCTS.EmscriptenTouchPoint.isChanged, 't.changed', 'i32') }}}
+          {{{ makeSetValue('ptr', C_STRUCTS.EmscriptenTouchPoint.onTarget, 't.onTarget', 'i32') }}}
+          {{{ makeSetValue('ptr', C_STRUCTS.EmscriptenTouchPoint.canvasX, 't.clientX - rect.left', 'i32') }}}
+          {{{ makeSetValue('ptr', C_STRUCTS.EmscriptenTouchPoint.canvasY, 't.clientY - rect.top', 'i32') }}}
+          ptr += {{{ C_STRUCTS.EmscriptenTouchPoint.__size__ }}};
 
           if (++numTouches >= 32) {
             break;
           }
         }
-        {{{ makeSetValue('JsEvents.touchEvent', C_STRUCTS.emscripten_TouchEvent.numTouches, 'numTouches', 'i32') }}}
+        {{{ makeSetValue('JSEvents.touchEvent', C_STRUCTS.EmscriptenTouchEvent.numTouches, 'numTouches', 'i32') }}}
 
-        var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JsEvents.touchEvent, userData]);
+        var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JSEvents.touchEvent, 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);
     },
 
     fillGamepadEventData: function(eventStruct, e) {
-      {{{ makeSetValue('eventStruct', C_STRUCTS.emscripten_GamepadEvent.timestamp, 'e.timestamp', 'double') }}}
+      {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenGamepadEvent.timestamp, 'e.timestamp', 'double') }}}
       for(var i = 0; i < e.axes.length; ++i) {
-        {{{ makeSetValue('eventStruct+i*8', C_STRUCTS.emscripten_GamepadEvent.axis, 'e.axes[i]', 'double') }}}
+        {{{ makeSetValue('eventStruct+i*8', C_STRUCTS.EmscriptenGamepadEvent.axis, 'e.axes[i]', 'double') }}}
       }
       for(var i = 0; i < e.buttons.length; ++i) {
-        {{{ makeSetValue('eventStruct+i*8', C_STRUCTS.emscripten_GamepadEvent.analogButton, 'e.buttons[i].value', 'double') }}}
+        {{{ makeSetValue('eventStruct+i*8', C_STRUCTS.EmscriptenGamepadEvent.analogButton, 'e.buttons[i].value', 'double') }}}
       }
       for(var i = 0; i < e.buttons.length; ++i) {
-        {{{ makeSetValue('eventStruct+i*4', C_STRUCTS.emscripten_GamepadEvent.digitalButton, 'e.buttons[i].pressed', 'i32') }}}
+        {{{ makeSetValue('eventStruct+i*4', C_STRUCTS.EmscriptenGamepadEvent.digitalButton, 'e.buttons[i].pressed', 'i32') }}}
       }
-      {{{ makeSetValue('eventStruct', C_STRUCTS.emscripten_GamepadEvent.connected, 'e.connected', 'i32') }}}
-      {{{ makeSetValue('eventStruct', C_STRUCTS.emscripten_GamepadEvent.index, 'e.index', 'i32') }}}
-      {{{ makeSetValue('eventStruct', C_STRUCTS.emscripten_GamepadEvent.numAxes, 'e.axes.length', 'i32') }}}
-      {{{ makeSetValue('eventStruct', C_STRUCTS.emscripten_GamepadEvent.numButtons, 'e.buttons.length', 'i32') }}}
-      writeStringToMemory(e.id, eventStruct + {{{ C_STRUCTS.emscripten_GamepadEvent.id }}} );
-      writeStringToMemory(e.mapping, eventStruct + {{{ C_STRUCTS.emscripten_GamepadEvent.mapping }}} );
+      {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenGamepadEvent.connected, 'e.connected', 'i32') }}}
+      {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenGamepadEvent.index, 'e.index', 'i32') }}}
+      {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenGamepadEvent.numAxes, 'e.axes.length', 'i32') }}}
+      {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenGamepadEvent.numButtons, 'e.buttons.length', 'i32') }}}
+      writeStringToMemory(e.id, eventStruct + {{{ C_STRUCTS.EmscriptenGamepadEvent.id }}} );
+      writeStringToMemory(e.mapping, eventStruct + {{{ C_STRUCTS.EmscriptenGamepadEvent.mapping }}} );
     },
 
     registerGamepadEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) {
-      if (!JsEvents.gamepadEvent) {
-        JsEvents.gamepadEvent = _malloc( {{{ C_STRUCTS.emscripten_GamepadEvent.__size__ }}} );
+      if (!JSEvents.gamepadEvent) {
+        JSEvents.gamepadEvent = _malloc( {{{ C_STRUCTS.EmscriptenGamepadEvent.__size__ }}} );
       }
 
       var handlerFunc = function(event) {
         var e = event || window.event;
 
-        JsEvents.fillGamepadEventData(JsEvents.gamepadEvent, e.gamepad);
+        JSEvents.fillGamepadEventData(JSEvents.gamepadEvent, e.gamepad);
 
-        var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JsEvents.gamepadEvent, userData]);
+        var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JSEvents.gamepadEvent, 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);
     },
 
     registerBeforeUnloadEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) {
@@ -775,50 +779,50 @@ var LibraryJsEvents = {
       };
 
       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);
     },
 
     battery: function() { return navigator.battery || navigator.mozBattery || navigator.webkitBattery; },
 
     fillBatteryEventData: function(eventStruct, e) {
-      {{{ makeSetValue('eventStruct', C_STRUCTS.emscripten_BatteryEvent.chargingTime, 'e.chargingTime', 'double') }}}
-      {{{ makeSetValue('eventStruct', C_STRUCTS.emscripten_BatteryEvent.dischargingTime, 'e.dischargingTime', 'double') }}}
-      {{{ makeSetValue('eventStruct', C_STRUCTS.emscripten_BatteryEvent.level, 'e.level', 'double') }}}
-      {{{ makeSetValue('eventStruct', C_STRUCTS.emscripten_BatteryEvent.charging, 'e.charging', 'i32') }}}
+      {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenBatteryEvent.chargingTime, 'e.chargingTime', 'double') }}}
+      {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenBatteryEvent.dischargingTime, 'e.dischargingTime', 'double') }}}
+      {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenBatteryEvent.level, 'e.level', 'double') }}}
+      {{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenBatteryEvent.charging, 'e.charging', 'i32') }}}
     },
     
     registerBatteryEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) {
-      if (!JsEvents.batteryEvent) {
-        JsEvents.batteryEvent = _malloc( {{{ C_STRUCTS.emscripten_BatteryEvent.__size__ }}} );
+      if (!JSEvents.batteryEvent) {
+        JSEvents.batteryEvent = _malloc( {{{ C_STRUCTS.EmscriptenBatteryEvent.__size__ }}} );
       }
 
       var handlerFunc = function(event) {
         var e = event || window.event;
 
-        JsEvents.fillBatteryEventData(JsEvents.batteryEvent, JsEvents.battery());
+        JSEvents.fillBatteryEventData(JSEvents.batteryEvent, JSEvents.battery());
 
-        var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JsEvents.batteryEvent, userData]);
+        var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JSEvents.batteryEvent, 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);
     },
 
     registerWebGlEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) {
@@ -835,145 +839,138 @@ var LibraryJsEvents = {
       };
 
       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);
     },
   },
 
   emscripten_set_keypress_callback: function(target, userData, useCapture, callbackfunc) {
-    JsEvents.registerKeyEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_KEYPRESS') }}}, "keypress");
+    JSEvents.registerKeyEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_KEYPRESS') }}}, "keypress");
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
   emscripten_set_keydown_callback: function(target, userData, useCapture, callbackfunc) {
-    JsEvents.registerKeyEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_KEYDOWN') }}}, "keydown");
+    JSEvents.registerKeyEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_KEYDOWN') }}}, "keydown");
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
   emscripten_set_keyup_callback: function(target, userData, useCapture, callbackfunc) {
-    JsEvents.registerKeyEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_KEYUP') }}}, "keyup");
+    JSEvents.registerKeyEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_KEYUP') }}}, "keyup");
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
   emscripten_set_click_callback: function(target, userData, useCapture, callbackfunc) {
-    JsEvents.registerMouseEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_CLICK') }}}, "click");
+    JSEvents.registerMouseEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_CLICK') }}}, "click");
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
   emscripten_set_mousedown_callback: function(target, userData, useCapture, callbackfunc) {
-    JsEvents.registerMouseEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_MOUSEDOWN') }}}, "mousedown");
+    JSEvents.registerMouseEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_MOUSEDOWN') }}}, "mousedown");
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
   emscripten_set_mouseup_callback: function(target, userData, useCapture, callbackfunc) {
-    JsEvents.registerMouseEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_MOUSEUP') }}}, "mouseup");
+    JSEvents.registerMouseEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_MOUSEUP') }}}, "mouseup");
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
   emscripten_set_dblclick_callback: function(target, userData, useCapture, callbackfunc) {
-    JsEvents.registerMouseEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_DBLCLICK') }}}, "dblclick");
+    JSEvents.registerMouseEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_DBLCLICK') }}}, "dblclick");
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
   emscripten_set_mousemove_callback: function(target, userData, useCapture, callbackfunc) {
-    JsEvents.registerMouseEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_MOUSEMOVE') }}}, "mousemove");
+    JSEvents.registerMouseEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_MOUSEMOVE') }}}, "mousemove");
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
   emscripten_get_mouse_status: function(mouseState) {
-    if (!JsEvents.mouseEvent) {
-      return {{{ cDefine('EMSCRIPTEN_RESULT_NO_DATA') }}};
-    }
+    if (!JSEvents.mouseEvent) return {{{ cDefine('EMSCRIPTEN_RESULT_NO_DATA') }}};
     // HTML5 does not really have a polling API for mouse events, so implement one manually by
     // returning the data from the most recently received event. This requires that user has registered
     // at least some no-op function as an event handler to any of the mouse function.
-    HEAP32.set(HEAP32.subarray(JsEvents.mouseEvent, {{{ C_STRUCTS.emscripten_MouseEvent.__size__ }}}), mouseState);
+    HEAP32.set(HEAP32.subarray(JSEvents.mouseEvent, {{{ C_STRUCTS.EmscriptenMouseEvent.__size__ }}}), mouseState);
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
   emscripten_set_wheel_callback: function(target, userData, useCapture, callbackfunc) {
-    JsEvents.registerWheelEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_WHEEL') }}}, "wheel");
+    JSEvents.registerWheelEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_WHEEL') }}}, "wheel");
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
   emscripten_set_resize_callback: function(target, userData, useCapture, callbackfunc) {
-    JsEvents.registerUiEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_RESIZE') }}}, "resize");
+    JSEvents.registerUiEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_RESIZE') }}}, "resize");
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
   emscripten_set_scroll_callback: function(target, userData, useCapture, callbackfunc) {
-    JsEvents.registerUiEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_SCROLL') }}}, "scroll");
+    JSEvents.registerUiEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_SCROLL') }}}, "scroll");
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
   emscripten_set_blur_callback: function(target, userData, useCapture, callbackfunc) {
-    JsEvents.registerFocusEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_BLUR') }}}, "blur");
+    JSEvents.registerFocusEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_BLUR') }}}, "blur");
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
   emscripten_set_focus_callback: function(target, userData, useCapture, callbackfunc) {
-    JsEvents.registerFocusEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_FOCUS') }}}, "focus");
+    JSEvents.registerFocusEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_FOCUS') }}}, "focus");
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
   emscripten_set_focusin_callback: function(target, userData, useCapture, callbackfunc) {
-    JsEvents.registerFocusEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_FOCUSIN') }}}, "focusin");
+    JSEvents.registerFocusEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_FOCUSIN') }}}, "focusin");
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
   emscripten_set_focusout_callback: function(target, userData, useCapture, callbackfunc) {
-    JsEvents.registerFocusEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_FOCUSOUT') }}}, "focusout");
+    JSEvents.registerFocusEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_FOCUSOUT') }}}, "focusout");
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
   emscripten_set_deviceorientation_callback: function(userData, useCapture, callbackfunc) {
-    JsEvents.registerDeviceOrientationEventCallback(window, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_DEVICEORIENTATION') }}}, "deviceorientation");
+    JSEvents.registerDeviceOrientationEventCallback(window, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_DEVICEORIENTATION') }}}, "deviceorientation");
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
   emscripten_get_deviceorientation_status: function(orientationState) {
-    if (!JsEvents.deviceOrientationEvent) {
-      return {{{ cDefine('EMSCRIPTEN_RESULT_NO_DATA') }}};
-    }
+    if (!JSEvents.deviceOrientationEvent) return {{{ cDefine('EMSCRIPTEN_RESULT_NO_DATA') }}};
     // HTML5 does not really have a polling API for device orientation events, so implement one manually by
     // returning the data from the most recently received event. This requires that user has registered
     // at least some no-op function as an event handler.
-    HEAP32.set(HEAP32.subarray(JsEvents.deviceOrientationEvent, {{{ C_STRUCTS.emscripten_DeviceOrientationEvent.__size__ }}}), orientationState);
+    HEAP32.set(HEAP32.subarray(JSEvents.deviceOrientationEvent, {{{ C_STRUCTS.EmscriptenDeviceOrientationEvent.__size__ }}}), orientationState);
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
   emscripten_set_devicemotion_callback: function(userData, useCapture, callbackfunc) {
-    JsEvents.registerDeviceMotionEventCallback(window, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_DEVICEMOTION') }}}, "devicemotion");
+    JSEvents.registerDeviceMotionEventCallback(window, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_DEVICEMOTION') }}}, "devicemotion");
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
   emscripten_get_devicemotion_status: function(motionState) {
-    if (!JsEvents.deviceMotionEvent) {
-      return {{{ cDefine('EMSCRIPTEN_RESULT_NO_DATA') }}};
-    }
+    if (!JSEvents.deviceMotionEvent) return {{{ cDefine('EMSCRIPTEN_RESULT_NO_DATA') }}};
     // HTML5 does not really have a polling API for device motion events, so implement one manually by
     // returning the data from the most recently received event. This requires that user has registered
     // at least some no-op function as an event handler.
-    HEAP32.set(HEAP32.subarray(JsEvents.deviceMotionEvent, {{{ C_STRUCTS.emscripten_DeviceMotionEvent.__size__ }}}), motionState);
+    HEAP32.set(HEAP32.subarray(JSEvents.deviceMotionEvent, {{{ C_STRUCTS.EmscriptenDeviceMotionEvent.__size__ }}}), motionState);
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
   emscripten_set_orientationchange_callback: function(userData, useCapture, callbackfunc) {
-    if (!window.screen || !window.screen.addEventListener) {
-      return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
-    }
-    JsEvents.registerOrientationChangeEventCallback(window.screen, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_ORIENTATIONCHANGE') }}}, "orientationchange");
+    if (!window.screen || !window.screen.addEventListener) return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
+    JSEvents.registerOrientationChangeEventCallback(window.screen, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_ORIENTATIONCHANGE') }}}, "orientationchange");
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
   
   emscripten_get_orientation_status: function(orientationChangeEvent) {
-    JsEvents.fillOrientationChangeEventData(orientationChangeEvent);
+    if (!JSEvents.screenOrientation() && typeof window.orientation === 'undefined') return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
+    JSEvents.fillOrientationChangeEventData(orientationChangeEvent);
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
@@ -1012,48 +1009,57 @@ var LibraryJsEvents = {
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
-  emscripten_set_fullscreenchange_callback: function(userData, useCapture, callbackfunc) {
-    JsEvents.registerFullscreenChangeEventCallback(userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_FULLSCREENCHANGE') }}}, "fullscreenchange");
+  emscripten_set_fullscreenchange_callback: function(target, userData, useCapture, callbackfunc) {
+    if (typeof JSEvents.fullscreenEnabled() === 'undefined') return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
+    if (!target) target = document;
+    else {
+      target = JSEvents.findEventTarget(target);
+      if (!target) return {{{ cDefine('EMSCRIPTEN_RESULT_UNKNOWN_TARGET') }}};
+    }
+    JSEvents.registerFullscreenChangeEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_FULLSCREENCHANGE') }}}, "fullscreenchange");
+    JSEvents.registerFullscreenChangeEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_FULLSCREENCHANGE') }}}, "mozfullscreenchange");
+    JSEvents.registerFullscreenChangeEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_FULLSCREENCHANGE') }}}, "webkitfullscreenchange");
+    JSEvents.registerFullscreenChangeEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_FULLSCREENCHANGE') }}}, "msfullscreenchange");
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
   emscripten_get_fullscreen_status: function(fullscreenStatus) {
-    JsEvents.fillFullscreenChangeEventData(fullscreenStatus);
+    if (typeof JSEvents.fullscreenEnabled() === 'undefined') return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
+    JSEvents.fillFullscreenChangeEventData(fullscreenStatus);
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
   // https://developer.mozilla.org/en-US/docs/Web/Guide/API/DOM/Using_full_screen_mode
   emscripten_request_fullscreen: function(target, deferUntilInEventHandler) {
-    if (!target) {
-      target = '#canvas';
-    }
-    target = JsEvents.findEventTarget(target);
-    if (!target) {
-      return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_TARGET') }}};
-    }
+    if (typeof JSEvents.fullscreenEnabled() === 'undefined') return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
+    if (!JSEvents.fullscreenEnabled()) return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_TARGET') }}};
+    if (!target) target = '#canvas';
+    target = JSEvents.findEventTarget(target);
+    if (!target) return {{{ cDefine('EMSCRIPTEN_RESULT_UNKNOWN_TARGET') }}};
 
-    if (!target.requestFullscreen && !target.msRequestFullscreen && !target.mozRequestFullScreen && !target.webkitRequestFullscreen) {
-      return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
+    if (!target.requestFullscreen && !target.msRequestFullscreen && !target.mozRequestFullScreen && !target.mozRequestFullscreen && !target.webkitRequestFullscreen) {
+      return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_TARGET') }}};
     }
 
-    var canPerformRequests = JsEvents.canPerformEventHandlerRequests();
+    var canPerformRequests = JSEvents.canPerformEventHandlerRequests();
 
     // Queue this function call if we're not currently in an event handler and the user saw it appropriate to do so.
     if (!canPerformRequests) {
       if (deferUntilInEventHandler) {
-        JsEvents.deferCall(JsEvents.requestFullscreen, 1 /* priority over pointer lock */, [target]);
+        JSEvents.deferCall(JSEvents.requestFullscreen, 1 /* priority over pointer lock */, [target]);
         return {{{ cDefine('EMSCRIPTEN_RESULT_DEFERRED') }}};
       } else {
         return {{{ cDefine('EMSCRIPTEN_RESULT_FAILED_NOT_DEFERRED') }}};
       }
     }
 
-    return JsEvents.requestFullscreen(target);
+    return JSEvents.requestFullscreen(target);
   },
   
   emscripten_exit_fullscreen: function() {
+    if (typeof JSEvents.fullscreenEnabled() === 'undefined') return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
     // Make sure no queued up calls will fire after this.
-    JsEvents.removeDeferredCalls(JsEvents.requestFullscreen);
+    JSEvents.removeDeferredCalls(JSEvents.requestFullscreen);
 
     if (document.exitFullscreen) {
       document.exitFullscreen();
@@ -1069,46 +1075,56 @@ var LibraryJsEvents = {
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
-  emscripten_set_pointerlockchange_callback: function(userData, useCapture, callbackfunc) {
-    JsEvents.registerPointerlockChangeEventCallback(document, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_POINTERLOCKCHANGE') }}}, "pointerlockchange");
+  emscripten_set_pointerlockchange_callback: function(target, userData, useCapture, callbackfunc) {
+    if (!document.body.requestPointerLock && !document.body.mozRequestPointerLock && !document.body.webkitRequestPointerLock && !document.body.msRequestPointerLock) {
+      return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
+    }
+    if (!target) target = document;
+    else {
+      target = JSEvents.findEventTarget(target);
+      if (!target) return {{{ cDefine('EMSCRIPTEN_RESULT_UNKNOWN_TARGET') }}};
+    }
+    JSEvents.registerPointerlockChangeEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_POINTERLOCKCHANGE') }}}, "pointerlockchange");
+    JSEvents.registerPointerlockChangeEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_POINTERLOCKCHANGE') }}}, "mozpointerlockchange");
+    JSEvents.registerPointerlockChangeEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_POINTERLOCKCHANGE') }}}, "webkitpointerlockchange");
+    JSEvents.registerPointerlockChangeEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_POINTERLOCKCHANGE') }}}, "mspointerlockchange");
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
   emscripten_get_pointerlock_status: function(pointerlockStatus) {
-    JsEvents.fillPointerlockChangeEventData(pointerlockStatus);  
+    if (!document.body.requestPointerLock && !document.body.mozRequestPointerLock && !document.body.webkitRequestPointerLock && !document.body.msRequestPointerLock) {
+      return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
+    }
+    JSEvents.fillPointerlockChangeEventData(pointerlockStatus);  
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
   emscripten_request_pointerlock: function(target, deferUntilInEventHandler) {
-    if (!target) {
-      target = '#canvas';
-    }
-    target = JsEvents.findEventTarget(target);
-    if (!target) {
-      return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_TARGET') }}};
-    }
+    if (!target) target = '#canvas';
+    target = JSEvents.findEventTarget(target);
+    if (!target) return {{{ cDefine('EMSCRIPTEN_RESULT_UNKNOWN_TARGET') }}};
     if (!target.requestPointerLock && !target.mozRequestPointerLock && !target.webkitRequestPointerLock && !target.msRequestPointerLock) {
       return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
     }
 
-    var canPerformRequests = JsEvents.canPerformEventHandlerRequests();
+    var canPerformRequests = JSEvents.canPerformEventHandlerRequests();
 
     // Queue this function call if we're not currently in an event handler and the user saw it appropriate to do so.
     if (!canPerformRequests) {
       if (deferUntilInEventHandler) {
-        JsEvents.deferCall(JsEvents.requestPointerLock, 2 /* priority below fullscreen */, [target]);
+        JSEvents.deferCall(JSEvents.requestPointerLock, 2 /* priority below fullscreen */, [target]);
         return {{{ cDefine('EMSCRIPTEN_RESULT_DEFERRED') }}};
       } else {
         return {{{ cDefine('EMSCRIPTEN_RESULT_FAILED_NOT_DEFERRED') }}};
       }
     }
 
-    return JsEvents.requestPointerLock(target);
+    return JSEvents.requestPointerLock(target);
   },
 
   emscripten_exit_pointerlock: function() {
     // Make sure no queued up calls will fire after this.
-    JsEvents.removeDeferredCalls(JsEvents.requestPointerLock);
+    JSEvents.removeDeferredCalls(JSEvents.requestPointerLock);
 
     if (document.exitPointerLock) {
       document.exitPointerLock();
@@ -1125,18 +1141,13 @@ var LibraryJsEvents = {
   },
   
   emscripten_vibrate: function(msecs) {
-    if (!navigator.vibrate) {
-      return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
-    }
-    
+    if (!navigator.vibrate) return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};    
     navigator.vibrate(msecs);
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
   
   emscripten_vibrate_pattern: function(msecsArray, numEntries) {
-    if (!navigator.vibrate) {
-      return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
-    }
+    if (!navigator.vibrate) return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
 
     var vibrateList = [];
     for(var i = 0; i < numEntries; ++i) {
@@ -1148,94 +1159,99 @@ var LibraryJsEvents = {
   },
 
   emscripten_set_visibilitychange_callback: function(userData, useCapture, callbackfunc) {
-    JsEvents.registerVisibilityChangeEventCallback(document, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_VISIBILITYCHANGE') }}}, "visibilitychange");
+    JSEvents.registerVisibilityChangeEventCallback(document, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_VISIBILITYCHANGE') }}}, "visibilitychange");
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
   emscripten_get_visibility_status: function(visibilityStatus) {
-    JsEvents.fillVisibilityChangeEventData(visibilityStatus);  
+    if (typeof document.visibilityState === 'undefined' && typeof document.hidden === 'undefined') {
+      return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
+    }
+    JSEvents.fillVisibilityChangeEventData(visibilityStatus);  
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
   
   emscripten_set_touchstart_callback: function(target, userData, useCapture, callbackfunc) {
-    JsEvents.registerTouchEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_TOUCHSTART') }}}, "touchstart");
+    JSEvents.registerTouchEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_TOUCHSTART') }}}, "touchstart");
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
   
   emscripten_set_touchend_callback: function(target, userData, useCapture, callbackfunc) {
-    JsEvents.registerTouchEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_TOUCHEND') }}}, "touchend");
+    JSEvents.registerTouchEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_TOUCHEND') }}}, "touchend");
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
   
   emscripten_set_touchmove_callback: function(target, userData, useCapture, callbackfunc) {
-    JsEvents.registerTouchEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_TOUCHMOVE') }}}, "touchmove");
+    JSEvents.registerTouchEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_TOUCHMOVE') }}}, "touchmove");
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
   
   emscripten_set_touchcancel_callback: function(target, userData, useCapture, callbackfunc) {
-    JsEvents.registerTouchEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_TOUCHCANCEL') }}}, "touchcancel");
+    JSEvents.registerTouchEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_TOUCHCANCEL') }}}, "touchcancel");
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
   
   emscripten_set_gamepadconnected_callback: function(userData, useCapture, callbackfunc) {
-    JsEvents.registerGamepadEventCallback(window, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_GAMEPADCONNECTED') }}}, "gamepadconnected");
+    if (!navigator.getGamepads) return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
+    JSEvents.registerGamepadEventCallback(window, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_GAMEPADCONNECTED') }}}, "gamepadconnected");
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
   
   emscripten_set_gamepaddisconnected_callback: function(userData, useCapture, callbackfunc) {
-    JsEvents.registerGamepadEventCallback(window, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_GAMEPADDISCONNECTED') }}}, "gamepaddisconnected");
+    if (!navigator.getGamepads) return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
+    JSEvents.registerGamepadEventCallback(window, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_GAMEPADDISCONNECTED') }}}, "gamepaddisconnected");
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
  },
   
   emscripten_get_num_gamepads: function() {
-    if (!navigator.getGamepads) {
-      return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
-    }
+    if (!navigator.getGamepads) return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
     return navigator.getGamepads().length;
   },
   
   emscripten_get_gamepad_status: function(index, gamepadState) {
-    if (!navigator.getGamepads) {
-      return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
-    }
+    if (!navigator.getGamepads) return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
     var gamepads = navigator.getGamepads();
     if (index < 0 || index >= gamepads.length) {
       return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_PARAM') }}};
     }
-    JsEvents.fillGamepadEventData(gamepadState, gamepads[index]);
+    JSEvents.fillGamepadEventData(gamepadState, gamepads[index]);
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
   
   emscripten_set_beforeunload_callback: function(userData, callbackfunc) {
-    JsEvents.registerBeforeUnloadEventCallback(window, userData, true, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_BEFOREUNLOAD') }}}, "beforeunload"); 
+    if (typeof window.onbeforeunload === 'undefined') return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
+    JSEvents.registerBeforeUnloadEventCallback(window, userData, true, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_BEFOREUNLOAD') }}}, "beforeunload"); 
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
   
   emscripten_set_batterychargingchange_callback: function(userData, callbackfunc) {
-    JsEvents.registerBatteryEventCallback(JsEvents.battery(), userData, true, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_BATTERYCHARGINGCHANGE') }}}, "chargingchange");
+    if (!JSEvents.battery()) return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}}; 
+    JSEvents.registerBatteryEventCallback(JSEvents.battery(), userData, true, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_BATTERYCHARGINGCHANGE') }}}, "chargingchange");
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
   emscripten_set_batterylevelchange_callback: function(userData, callbackfunc) {
-    JsEvents.registerBatteryEventCallback(JsEvents.battery(), userData, true, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_BATTERYLEVELCHANGE') }}}, "levelchange");
+    if (!JSEvents.battery()) return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}}; 
+    JSEvents.registerBatteryEventCallback(JSEvents.battery(), userData, true, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_BATTERYLEVELCHANGE') }}}, "levelchange");
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
   
   emscripten_get_battery_status: function(batteryState) {
-    JsEvents.fillBatteryEventData(batteryState, JsEvents.battery());
+    if (!JSEvents.battery()) return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}}; 
+    JSEvents.fillBatteryEventData(batteryState, JSEvents.battery());
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
   
   emscripten_set_webglcontextlost_callback: function(target, userData, useCapture, callbackfunc) {
-    JsEvents.registerWebGlEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_WEBGLCONTEXTLOST') }}}, "webglcontextlost");
+    JSEvents.registerWebGlEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_WEBGLCONTEXTLOST') }}}, "webglcontextlost");
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 
   emscripten_set_webglcontextrestored_callback: function(target, userData, useCapture, callbackfunc) {
-    JsEvents.registerWebGlEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_WEBGLCONTEXTRESTORED') }}}, "webglcontextrestored");
+    JSEvents.registerWebGlEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_WEBGLCONTEXTRESTORED') }}}, "webglcontextrestored");
     return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
   },
 };
 
-autoAddDeps(LibraryJsEvents, '$JsEvents');
-mergeInto(LibraryManager.library, LibraryJsEvents);
+autoAddDeps(LibraryJSEvents, '$JSEvents');
+mergeInto(LibraryManager.library, LibraryJSEvents);
diff --git a/src/modules.js b/src/modules.js
index 7b267971..ea1509e9 100644
--- a/src/modules.js
+++ b/src/modules.js
@@ -424,7 +424,7 @@ var LibraryManager = {
   load: function() {
     if (this.library) return;
 
-    var libraries = ['library.js', 'library_path.js', 'library_fs.js', 'library_idbfs.js', 'library_memfs.js', 'library_nodefs.js', 'library_sockfs.js', 'library_tty.js', 'library_browser.js', 'library_sdl.js', 'library_gl.js', 'library_glut.js', 'library_xlib.js', 'library_egl.js', 'library_gc.js', 'library_jansson.js', 'library_openal.js', 'library_glfw.js', 'library_uuid.js', 'library_glew.js', 'library_events.js'].concat(additionalLibraries);
+    var libraries = ['library.js', 'library_path.js', 'library_fs.js', 'library_idbfs.js', 'library_memfs.js', 'library_nodefs.js', 'library_sockfs.js', 'library_tty.js', 'library_browser.js', 'library_sdl.js', 'library_gl.js', 'library_glut.js', 'library_xlib.js', 'library_egl.js', 'library_gc.js', 'library_jansson.js', 'library_openal.js', 'library_glfw.js', 'library_uuid.js', 'library_glew.js', 'library_html5.js'].concat(additionalLibraries);
     for (var i = 0; i < libraries.length; i++) {
       eval(processMacros(preprocess(read(libraries[i]))));
     }
diff --git a/src/struct_info.json b/src/struct_info.json
index ec449097..32261c0a 100644
--- a/src/struct_info.json
+++ b/src/struct_info.json
@@ -1075,10 +1075,10 @@
         "structs": {}
     },
     // ===========================================
-    // emscripten events library
+    // emscripten html5 library
     // ===========================================
     {
-        "file": "emscripten/events.h",
+        "file": "emscripten/html5.h",
         "defines": [
             "EMSCRIPTEN_EVENT_KEYPRESS",
             "EMSCRIPTEN_EVENT_KEYDOWN",
@@ -1117,13 +1117,14 @@
             "EMSCRIPTEN_RESULT_DEFERRED",
             "EMSCRIPTEN_RESULT_FAILED_NOT_DEFERRED",
             "EMSCRIPTEN_RESULT_INVALID_TARGET",
+            "EMSCRIPTEN_RESULT_UNKNOWN_TARGET",
             "EMSCRIPTEN_RESULT_INVALID_PARAM",
             "EMSCRIPTEN_RESULT_NOT_SUPPORTED",
             "EMSCRIPTEN_RESULT_FAILED",
             "EMSCRIPTEN_RESULT_NO_DATA"
         ],
         "structs": {
-            "emscripten_KeyboardEvent": [
+            "EmscriptenKeyboardEvent": [
               "key",
               "code",
               "location",
@@ -1138,7 +1139,7 @@
               "keyCode",
               "which"
             ],
-            "emscripten_MouseEvent": [
+            "EmscriptenMouseEvent": [
               "timestamp",
               "screenX",
               "screenY",
@@ -1155,14 +1156,14 @@
               "canvasX",
               "canvasY"
             ],
-            "emscripten_WheelEvent": [
+            "EmscriptenWheelEvent": [
               "mouse",
               "deltaX",
               "deltaY",
               "deltaZ",
               "deltaMode"
             ],
-            "emscripten_UiEvent": [
+            "EmscriptenUiEvent": [
               "detail",
               "documentBodyClientWidth",
               "documentBodyClientHeight",
@@ -1173,18 +1174,18 @@
               "scrollTop",
               "scrollLeft"
             ],
-            "emscripten_FocusEvent": [
+            "EmscriptenFocusEvent": [
               "nodeName",
               "id"
             ],
-            "emscripten_DeviceOrientationEvent": [
+            "EmscriptenDeviceOrientationEvent": [
               "timestamp",
               "alpha",
               "beta",
               "gamma",
               "absolute"
             ],
-            "emscripten_DeviceMotionEvent": [
+            "EmscriptenDeviceMotionEvent": [
               "timestamp",
               "accelerationX",
               "accelerationY",
@@ -1196,26 +1197,26 @@
               "rotationRateBeta",
               "rotationRateGamma"
             ],
-            "emscripten_OrientationChangeEvent": [
+            "EmscriptenOrientationChangeEvent": [
               "orientationIndex",
               "orientationAngle"
             ],
-            "emscripten_FullscreenChangeEvent": [
+            "EmscriptenFullscreenChangeEvent": [
               "isFullscreen",
               "fullscreenEnabled",
               "nodeName",
               "id"
             ],
-            "emscripten_PointerlockChangeEvent": [
+            "EmscriptenPointerlockChangeEvent": [
               "isActive",
               "nodeName",
               "id"
             ],
-            "emscripten_VisibilityChangeEvent": [
+            "EmscriptenVisibilityChangeEvent": [
               "hidden",
               "visibilityState"
             ],
-            "emscripten_TouchPoint": [
+            "EmscriptenTouchPoint": [
               "identifier",
               "screenX",
               "screenY",
@@ -1228,7 +1229,7 @@
               "canvasX",
               "canvasY"
             ],
-            "emscripten_TouchEvent": [
+            "EmscriptenTouchEvent": [
               "numTouches",
               "ctrlKey",
               "shiftKey",
@@ -1236,7 +1237,7 @@
               "metaKey",
               "touches"
             ],
-            "emscripten_GamepadEvent": [
+            "EmscriptenGamepadEvent": [
               "timestamp",
               "axis",
               "analogButton",
@@ -1248,7 +1249,7 @@
               "id",
               "mapping"
             ],
-            "emscripten_BatteryEvent": [
+            "EmscriptenBatteryEvent": [
               "chargingTime",
               "dischargingTime",
               "level",