Merge pull request #2035 from juj/html5_events

HTML5 Events API.

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'].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++) {
       var filename = libraries[i];
       var src = read(filename);

src/struct_info.json

@@ -1073,5 +1073,188 @@
             "UUID_TYPE_DCE_RANDOM" 
         ],
         "structs": {}
+    },
+    // ===========================================
+    // emscripten html5 library
+    // ===========================================
+    {
+        "file": "emscripten/html5.h",
+        "defines": [
+            "EMSCRIPTEN_EVENT_KEYPRESS",
+            "EMSCRIPTEN_EVENT_KEYDOWN",
+            "EMSCRIPTEN_EVENT_KEYUP",
+            "EMSCRIPTEN_EVENT_CLICK",
+            "EMSCRIPTEN_EVENT_MOUSEDOWN",
+            "EMSCRIPTEN_EVENT_MOUSEUP",
+            "EMSCRIPTEN_EVENT_DBLCLICK",
+            "EMSCRIPTEN_EVENT_MOUSEMOVE",
+            "EMSCRIPTEN_EVENT_WHEEL",
+            "EMSCRIPTEN_EVENT_RESIZE",
+            "EMSCRIPTEN_EVENT_SCROLL",
+            "EMSCRIPTEN_EVENT_BLUR",
+            "EMSCRIPTEN_EVENT_FOCUS",
+            "EMSCRIPTEN_EVENT_FOCUSIN",
+            "EMSCRIPTEN_EVENT_FOCUSOUT",
+            "EMSCRIPTEN_EVENT_DEVICEORIENTATION",
+            "EMSCRIPTEN_EVENT_DEVICEMOTION",
+            "EMSCRIPTEN_EVENT_ORIENTATIONCHANGE",
+            "EMSCRIPTEN_EVENT_FULLSCREENCHANGE",
+            "EMSCRIPTEN_EVENT_POINTERLOCKCHANGE",
+            "EMSCRIPTEN_EVENT_VISIBILITYCHANGE",
+            "EMSCRIPTEN_EVENT_TOUCHSTART",
+            "EMSCRIPTEN_EVENT_TOUCHEND",
+            "EMSCRIPTEN_EVENT_TOUCHMOVE",
+            "EMSCRIPTEN_EVENT_TOUCHCANCEL",
+            "EMSCRIPTEN_EVENT_GAMEPADCONNECTED",
+            "EMSCRIPTEN_EVENT_GAMEPADDISCONNECTED",
+            "EMSCRIPTEN_EVENT_BEFOREUNLOAD",
+            "EMSCRIPTEN_EVENT_BATTERYCHARGINGCHANGE",
+            "EMSCRIPTEN_EVENT_BATTERYLEVELCHANGE",
+            "EMSCRIPTEN_EVENT_WEBGLCONTEXTLOST",
+            "EMSCRIPTEN_EVENT_WEBGLCONTEXTRESTORED",
+
+            "EMSCRIPTEN_RESULT_SUCCESS",
+            "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": {
+            "EmscriptenKeyboardEvent": [
+              "key",
+              "code",
+              "location",
+              "ctrlKey",
+              "shiftKey",
+              "altKey",
+              "metaKey",
+              "repeat",
+              "locale",
+              "charValue",
+              "charCode",
+              "keyCode",
+              "which"
+            ],
+            "EmscriptenMouseEvent": [
+              "timestamp",
+              "screenX",
+              "screenY",
+              "clientX",
+              "clientY",
+              "ctrlKey",
+              "shiftKey",
+              "altKey",
+              "metaKey",
+              "button",
+              "buttons",
+              "movementX",
+              "movementY",
+              "canvasX",
+              "canvasY"
+            ],
+            "EmscriptenWheelEvent": [
+              "mouse",
+              "deltaX",
+              "deltaY",
+              "deltaZ",
+              "deltaMode"
+            ],
+            "EmscriptenUiEvent": [
+              "detail",
+              "documentBodyClientWidth",
+              "documentBodyClientHeight",
+              "windowInnerWidth",
+              "windowInnerHeight",
+              "windowOuterWidth",
+              "windowOuterHeight",
+              "scrollTop",
+              "scrollLeft"
+            ],
+            "EmscriptenFocusEvent": [
+              "nodeName",
+              "id"
+            ],
+            "EmscriptenDeviceOrientationEvent": [
+              "timestamp",
+              "alpha",
+              "beta",
+              "gamma",
+              "absolute"
+            ],
+            "EmscriptenDeviceMotionEvent": [
+              "timestamp",
+              "accelerationX",
+              "accelerationY",
+              "accelerationZ",
+              "accelerationIncludingGravityX",
+              "accelerationIncludingGravityY",
+              "accelerationIncludingGravityZ",
+              "rotationRateAlpha",
+              "rotationRateBeta",
+              "rotationRateGamma"
+            ],
+            "EmscriptenOrientationChangeEvent": [
+              "orientationIndex",
+              "orientationAngle"
+            ],
+            "EmscriptenFullscreenChangeEvent": [
+              "isFullscreen",
+              "fullscreenEnabled",
+              "nodeName",
+              "id"
+            ],
+            "EmscriptenPointerlockChangeEvent": [
+              "isActive",
+              "nodeName",
+              "id"
+            ],
+            "EmscriptenVisibilityChangeEvent": [
+              "hidden",
+              "visibilityState"
+            ],
+            "EmscriptenTouchPoint": [
+              "identifier",
+              "screenX",
+              "screenY",
+              "clientX",
+              "clientY",
+              "pageX",
+              "pageY",
+              "isChanged",
+              "onTarget",
+              "canvasX",
+              "canvasY"
+            ],
+            "EmscriptenTouchEvent": [
+              "numTouches",
+              "ctrlKey",
+              "shiftKey",
+              "altKey",
+              "metaKey",
+              "touches"
+            ],
+            "EmscriptenGamepadEvent": [
+              "timestamp",
+              "axis",
+              "analogButton",
+              "digitalButton",
+              "connected",
+              "index",
+              "numAxes",
+              "numButtons",
+              "id",
+              "mapping"
+            ],
+            "EmscriptenBatteryEvent": [
+              "chargingTime",
+              "dischargingTime",
+              "level",
+              "charging"
+            ]
+        }
     }
-]
+ ]

system/include/emscripten/html5.h

@@ -0,0 +1,628 @@
+#ifndef __emscripten_events_h__
+#define __emscripten_events_h__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* This file defines Emscripten low-level glue bindings for interfacing with the following HTML5 APIs:
+ *    - DOM Level 3 Events: Keyboard, Mouse, Mouse Wheel, Resize, Scroll, Focus. See https://dvcs.w3.org/hg/dom3events/raw-file/tip/html/DOM3-Events.html
+ *    - DeviceOrientation Events for gyro and accelerometer. See http://www.w3.org/TR/orientation-event/
+ *    - Screen Orientation Events for portrait/landscape handling. See https://dvcs.w3.org/hg/screen-orientation/raw-file/tip/Overview.html
+ *    - Fullscreen Events for browser canvas fullscreen modes transitioning. See https://dvcs.w3.org/hg/fullscreen/raw-file/tip/Overview.html
+ *    - Pointer Lock Events for relative-mode mouse motion control. See http://www.w3.org/TR/pointerlock/
+ *    - Vibration API for mobile device haptic vibration feedback control. See http://dev.w3.org/2009/dap/vibration/
+ *    - Page Visibility Events for power management control. See http://www.w3c-test.org/webperf/specs/PageVisibility/
+ *    - Touch Events. See http://www.w3.org/TR/touch-events/
+ *    - Gamepad API. See http://www.w3.org/TR/gamepad/
+ *    - Beforeunload event. See http://www.whatwg.org/specs/web-apps/current-work/multipage/history.html#beforeunloadevent
+ *    - WebGL context events. See http://www.khronos.org/registry/webgl/specs/latest/1.0/#5.15.2
+ *
+ * Most web APIs are event-based, which means that the functionality is accessed by registering a callback function to be called when the event occurs. The
+ * Gamepad API is currently an exception, for which only a polling API is available. For some APIs, both an event-based and a polling-based API is exposed.
+ *
+ * Calling a callback registration function with a null pointer function causes an unregistration of that callback from the given target element. All event
+ * handlers are also automatically unregistered when the C exit() function is invoked during the atexit handler pass. Use either the function 
+ * emscripten_set_main_loop() or set Module.noExitRuntime = true; to make sure that leaving main() will not immediately cause an exit() and clean up the
+ * event handlers.
+ *
+ * Throughout this file, the function signatures have a 'target' parameter. This parameter allows specifying the HTML Element ID to which the callback
+ * registration is to be applied to. This field has the following special meanings:
+ *    - 0 or NULL: A default element is chosen automatically based on the event type, which should be reasonable most of the time.
+ *    - "#window": The event listener is applied to the JS 'window' object.
+ *    - "#document": The event listener is applied to the JS 'document' object.
+ *    - "#screen": The event listener is applied to the JS 'window.screen' object.
+ *    - "#canvas": The event listener is applied to the Emscripten default WebGL canvas element.
+ *    - Any other string without a leading hash "#" sign: The event listener is applied to the element by the given ID on the page.
+ *
+ * The callback hook functions also take in a 'userData' parameter. This is a custom user-defineable value that will be carried through unchanged to all 
+ * invocations of the registered event callback. Use this e.g. to pass a pointer to a C++ class or similar to enclose the C API in a clean object-oriented manner.
+ *
+ * Callback handlers that return an EM_BOOL may return nonzero to signal that the default action for that event is to be suppressed. This will call 
+ * the .preventDefault(); member on the event. Returning zero will cause the default browser event action to be carried out.
+ *
+ * Most functions return the result using the type EMSCRIPTEN_RESULT. Nonzero and positive values denote success. Negative values
+ * signal failure. None of the functions fail or abort by throwing a JS or C++ exception. If a particular browser does not support the given feature,
+ * the value EMSCRIPTEN_RESULT_NOT_SUPPORTED will be returned at the time the callback is registered.
+ *
+ * Due to web security purposes, the pointer lock and fullscreen requests can only be invoked from inside an user-originated event handler. Such requests
+ * are automatically deferred until the user presses a keyboard or mouse button the next time.
+ */
+
+#define EMSCRIPTEN_EVENT_KEYPRESS               1
+#define EMSCRIPTEN_EVENT_KEYDOWN                2
+#define EMSCRIPTEN_EVENT_KEYUP                  3
+#define EMSCRIPTEN_EVENT_CLICK                  4
+#define EMSCRIPTEN_EVENT_MOUSEDOWN              5
+#define EMSCRIPTEN_EVENT_MOUSEUP                6
+#define EMSCRIPTEN_EVENT_DBLCLICK               7
+#define EMSCRIPTEN_EVENT_MOUSEMOVE              8
+#define EMSCRIPTEN_EVENT_WHEEL                  9
+#define EMSCRIPTEN_EVENT_RESIZE                10
+#define EMSCRIPTEN_EVENT_SCROLL                11
+#define EMSCRIPTEN_EVENT_BLUR                  12
+#define EMSCRIPTEN_EVENT_FOCUS                 13
+#define EMSCRIPTEN_EVENT_FOCUSIN               14
+#define EMSCRIPTEN_EVENT_FOCUSOUT              15
+#define EMSCRIPTEN_EVENT_DEVICEORIENTATION     16
+#define EMSCRIPTEN_EVENT_DEVICEMOTION          17
+#define EMSCRIPTEN_EVENT_ORIENTATIONCHANGE     18
+#define EMSCRIPTEN_EVENT_FULLSCREENCHANGE      19
+#define EMSCRIPTEN_EVENT_POINTERLOCKCHANGE     20
+#define EMSCRIPTEN_EVENT_VISIBILITYCHANGE      21
+#define EMSCRIPTEN_EVENT_TOUCHSTART            22
+#define EMSCRIPTEN_EVENT_TOUCHEND              23
+#define EMSCRIPTEN_EVENT_TOUCHMOVE             24
+#define EMSCRIPTEN_EVENT_TOUCHCANCEL           25
+#define EMSCRIPTEN_EVENT_GAMEPADCONNECTED      26
+#define EMSCRIPTEN_EVENT_GAMEPADDISCONNECTED   27
+#define EMSCRIPTEN_EVENT_BEFOREUNLOAD          28
+#define EMSCRIPTEN_EVENT_BATTERYCHARGINGCHANGE 29
+#define EMSCRIPTEN_EVENT_BATTERYLEVELCHANGE    30
+#define EMSCRIPTEN_EVENT_WEBGLCONTEXTLOST      31
+#define EMSCRIPTEN_EVENT_WEBGLCONTEXTRESTORED  32
+
+#define EMSCRIPTEN_RESULT int
+
+// The operation succeeded
+#define EMSCRIPTEN_RESULT_SUCCESS              0
+
+// For web security reasons, the requested operation cannot be completed now, but was deferred for completion in the next event handler.
+#define EMSCRIPTEN_RESULT_DEFERRED             1
+
+// The given operation is not supported by this browser or the target element.
+#define EMSCRIPTEN_RESULT_NOT_SUPPORTED       -1
+
+// For web security reasons, the requested operation could not be completed now, and it failed since the user requested the operation to not be deferred.
+#define EMSCRIPTEN_RESULT_FAILED_NOT_DEFERRED -2
+
+// The given target element for the operation is invalid.
+#define EMSCRIPTEN_RESULT_INVALID_TARGET      -3
+
+// The given target element for the operation was not found.
+#define EMSCRIPTEN_RESULT_UNKNOWN_TARGET      -4
+
+// An invalid parameter was passed to the function.
+#define EMSCRIPTEN_RESULT_INVALID_PARAM       -5
+
+// The operation failed due to some generic reason.
+#define EMSCRIPTEN_RESULT_FAILED              -6
+
+// Operation failed since no data is currently available.
+#define EMSCRIPTEN_RESULT_NO_DATA             -7
+
+#define EM_BOOL int
+#define EM_UTF8 char
+
+#define DOM_KEY_LOCATION int
+#define DOM_KEY_LOCATION_STANDARD 0x00
+#define DOM_KEY_LOCATION_LEFT     0x01
+#define DOM_KEY_LOCATION_RIGHT    0x02
+#define DOM_KEY_LOCATION_NUMPAD   0x03
+
+/*
+ * The event structure passed in keyboard events keypress, keydown and keyup.
+ * https://dvcs.w3.org/hg/dom3events/raw-file/tip/html/DOM3-Events.html#keys
+ */
+typedef struct EmscriptenKeyboardEvent {
+  // The printed representation of the pressed key.
+  EM_UTF8 key[32];
+  // A string that identifies the physical key being pressed. The value is not affected by the current keyboard
+  // layout or modifier state, so a particular key will always return the same value.
+  EM_UTF8 code[32];
+  // Indicates the location of the key on the keyboard. One of the DOM_KEY_LOCATION_ values.
+  unsigned long location;
+  // Specifies which modifiers were active during the key event.
+  EM_BOOL ctrlKey;
+  EM_BOOL shiftKey;
+  EM_BOOL altKey;
+  EM_BOOL metaKey;
+  // Specifies if this keyboard event represents a repeated press.
+  EM_BOOL repeat;
+  // A locale string indicating the locale the keyboard is configured for. This may be the empty string if the
+  // browser or device doesn't know the keyboard's locale.
+  EM_UTF8 locale[32];
+  // The following fields are values from previous versions of the DOM key events specifications.
+  // See https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent?redirectlocale=en-US&redirectslug=DOM%2FKeyboardEvent
+  // The character representation of the key.
+  EM_UTF8 charValue[32];
+  // The Unicode reference number of the key; this attribute is used only by the keypress event. For keys whose char attribute
+  // contains multiple characters, this is the Unicode value of the first character in that attribute.
+  unsigned long charCode;
+  // A system and implementation dependent numerical code identifying the unmodified value of the pressed key.
+  unsigned long keyCode;
+  // A system and implementation dependent numeric code identifying the unmodified value of the pressed key; this is usually the same as keyCode.
+  unsigned long which;
+} EmscriptenKeyboardEvent;
+
+/*
+ * Registers a callback function for receiving browser-generated keyboard input events.
+ * See https://developer.mozilla.org/en/DOM/Event/UIEvent/KeyEvent
+ * and http://www.javascriptkit.com/jsref/eventkeyboardmouse.shtml
+ */
+extern EMSCRIPTEN_RESULT emscripten_set_keypress_callback(const char *target, void *userData, int useCapture, int (*func)(int eventType, const EmscriptenKeyboardEvent *keyEvent, void *userData));
+extern EMSCRIPTEN_RESULT emscripten_set_keydown_callback(const char *target, void *userData, int useCapture, int (*func)(int eventType, const EmscriptenKeyboardEvent *keyEvent, void *userData));
+extern EMSCRIPTEN_RESULT emscripten_set_keyup_callback(const char *target, void *userData, int useCapture, int (*func)(int eventType, const EmscriptenKeyboardEvent *keyEvent, void *userData));
+
+/*
+ * The event structure passed in mouse events click, mousedown, mouseup, dblclick and mousemove.
+ * https://dvcs.w3.org/hg/dom3events/raw-file/tip/html/DOM3-Events.html#interface-MouseEvent
+ */
+typedef struct EmscriptenMouseEvent {
+  // A timestamp of when this data was generated by the browser. This is an absolute wallclock time in milliseconds.
+  double timestamp;
+  // The coordinate relative to the browser screen coordinate system.
+  long screenX;
+  long screenY;
+  // The coordinate relative to the viewport associate with the event.
+  long clientX;
+  long clientY;
+  // Specifies which modifiers were active during the mouse event.
+  EM_BOOL ctrlKey;
+  EM_BOOL shiftKey;
+  EM_BOOL altKey;
+  EM_BOOL metaKey;
+  // Which pointer device button changed state.
+  unsigned short button;
+  // A bitmask that indicates which combinations of mouse buttons were being held down at the time of the event.
+  unsigned short buttons;
+  // If pointer lock is active, these two extra fields give relative mouse movement since the last event.
+  long movementX;
+  long movementY;
+  // Emscripten-specific extension: These fields give the mouse coordinates mapped to the Emscripten canvas client area.
+  long canvasX;
+  long canvasY;
+  // Pad this struct to multiple of 8 bytes to make WheelEvent unambiguously align to 8 bytes.
+  long padding;
+} EmscriptenMouseEvent;
+
+/*
+ * Registers a callback function for receiving browser-generated mouse input events.
+ * See https://developer.mozilla.org/en/DOM/MouseEvent
+ */
+extern EMSCRIPTEN_RESULT emscripten_set_click_callback(const char *target, void *userData, int useCapture, int (*func)(int eventType, const EmscriptenMouseEvent *mouseEvent, void *userData));
+extern EMSCRIPTEN_RESULT emscripten_set_mousedown_callback(const char *target, void *userData, int useCapture, int (*func)(int eventType, const EmscriptenMouseEvent *mouseEvent, void *userData));
+extern EMSCRIPTEN_RESULT emscripten_set_mouseup_callback(const char *target, void *userData, int useCapture, int (*func)(int eventType, const EmscriptenMouseEvent *mouseEvent, void *userData));
+extern EMSCRIPTEN_RESULT emscripten_set_dblclick_callback(const char *target, void *userData, int useCapture, int (*func)(int eventType, const EmscriptenMouseEvent *mouseEvent, void *userData));
+extern EMSCRIPTEN_RESULT emscripten_set_mousemove_callback(const char *target, void *userData, int useCapture, int (*func)(int eventType, const EmscriptenMouseEvent *mouseEvent, void *userData));
+/*
+ * Returns the most recently received mouse event state. Note that for this function call to succeed, emscripten_set_xx_callback must have first
+ * been called with one of the mouse event types and a non-zero callback function pointer to enable the Mouse state capture.
+ */
+extern EMSCRIPTEN_RESULT emscripten_get_mouse_status(EmscriptenMouseEvent *mouseState);
+
+#define DOM_DELTA_PIXEL 0x00
+#define DOM_DELTA_LINE  0x01
+#define DOM_DELTA_PAGE  0x02
+
+/*
+ * The event structure passed in mouse wheelevent.
+ * https://dvcs.w3.org/hg/dom3events/raw-file/tip/html/DOM3-Events.html#interface-WheelEvent
+ */
+typedef struct EmscriptenWheelEvent {
+  // Specifies general mouse information related to this event.
+  EmscriptenMouseEvent mouse;
+  // Measures along different axes the movement of the wheel.
+  double deltaX;
+  double deltaY;
+  double deltaZ;
+  // One of the DOM_DELTA_ values that indicates the units of measurement for the delta values.
+  unsigned long deltaMode;
+} EmscriptenWheelEvent;
+
+/*
+ * Registers a callback function for receiving browser-generated mouse wheel events.
+ * See http://www.w3.org/TR/DOM-Level-3-Events/#event-type-wheel
+ */
+extern EMSCRIPTEN_RESULT emscripten_set_wheel_callback(const char *target, void *userData, int useCapture, EM_BOOL (*func)(int eventType, const EmscriptenWheelEvent *wheelEvent, void *userData));
+
+/*
+ * The event structure passed in DOM element resize and scroll events.
+ * https://dvcs.w3.org/hg/dom3events/raw-file/tip/html/DOM3-Events.html#interface-UIEvent
+ */
+typedef struct EmscriptenUiEvent {
+  // Specifies detail information about this event.
+  long detail;
+  // The clientWidth/clientHeight of the document.body element.
+  int documentBodyClientWidth;
+  int documentBodyClientHeight;
+  // The innerWidth/innerHeight of the window element.
+  int windowInnerWidth;
+  int windowInnerHeight;
+  // The outerWidth/outerHeight of the window element.
+  int windowOuterWidth;
+  int windowOuterHeight;
+  // The page scroll position.
+  int scrollTop;
+  int scrollLeft;
+} EmscriptenUiEvent;
+
+/*
+ * Registers a callback function for receiving DOM element resize and scroll events.
+ * See https://dvcs.w3.org/hg/dom3events/raw-file/tip/html/DOM3-Events.html#event-type-resize
+ */
+extern EMSCRIPTEN_RESULT emscripten_set_resize_callback(const char *target, void *userData, int useCapture, EM_BOOL (*func)(int eventType, const EmscriptenUiEvent *uiEvent, void *userData));
+extern EMSCRIPTEN_RESULT emscripten_set_scroll_callback(const char *target, void *userData, int useCapture, EM_BOOL (*func)(int eventType, const EmscriptenUiEvent *uiEvent, void *userData));
+
+/*
+ * The event structure passed in DOM element blur, focus, focusin and focusout events.
+ * https://dvcs.w3.org/hg/dom3events/raw-file/tip/html/DOM3-Events.html#interface-FocusEvent
+ */
+typedef struct EmscriptenFocusEvent {
+  // The nodeName of the target HTML Element. See https://developer.mozilla.org/en-US/docs/Web/API/Node.nodeName
+  EM_UTF8 nodeName[128];
+  // The HTML Element ID of the target element.
+  EM_UTF8 id[128];
+} EmscriptenFocusEvent;
+
+/*
+ * Registers a callback function for receiving DOM element blur, focus, focusin and focusout events.
+ * See https://dvcs.w3.org/hg/dom3events/raw-file/tip/html/DOM3-Events.html#event-type-blur
+ */
+extern EMSCRIPTEN_RESULT emscripten_set_blur_callback(const char *target, void *userData, int useCapture, EM_BOOL (*func)(int eventType, const EmscriptenFocusEvent *focusEvent, void *userData));
+extern EMSCRIPTEN_RESULT emscripten_set_focus_callback(const char *target, void *userData, int useCapture, EM_BOOL (*func)(int eventType, const EmscriptenFocusEvent *focusEvent, void *userData));
+extern EMSCRIPTEN_RESULT emscripten_set_focusin_callback(const char *target, void *userData, int useCapture, EM_BOOL (*func)(int eventType, const EmscriptenFocusEvent *focusEvent, void *userData));
+extern EMSCRIPTEN_RESULT emscripten_set_focusout_callback(const char *target, void *userData, int useCapture, EM_BOOL (*func)(int eventType, const EmscriptenFocusEvent *focusEvent, void *userData));
+
+/*
+ * The event structure passed in the deviceorientation event.
+ * http://dev.w3.org/geo/api/spec-source-orientation.html#deviceorientation
+ */
+typedef struct EmscriptenDeviceOrientationEvent {
+  // Absolute wallclock time in msec units of when the event occurred.
+  double timestamp;
+  // The orientation of the device in terms of the transformation from a coordinate frame fixed on the Earth to a coordinate frame fixed in the device. 
+  double alpha;
+  double beta;
+  double gamma;
+  // If false, the orientation is only relative to some other bas orinetation, not to the fixed coordinate frame.
+  EM_BOOL absolute;
+} EmscriptenDeviceOrientationEvent;
+
+/*
+ * Registers a callback function for receiving the deviceorientation event.
+ * See http://dev.w3.org/geo/api/spec-source-orientation.html
+ */
+extern EMSCRIPTEN_RESULT emscripten_set_deviceorientation_callback(void *userData, int useCapture, EM_BOOL (*func)(int eventType, const EmscriptenDeviceOrientationEvent *orientationEvent, void *userData));
+/*
+ * Returns the most recently received deviceorientation event state. Note that for this function call to succeed, emscripten_set_deviceorientation_callback
+ * must have first been called with one of the mouse event types and a non-zero callback function pointer to enable the Device Orientation state capture.
+ */
+extern EMSCRIPTEN_RESULT emscripten_get_deviceorientation_status(EmscriptenDeviceOrientationEvent *orientationState);
+
+/*
+ * The event structure passed in the devicemotion event.
+ * http://dev.w3.org/geo/api/spec-source-orientation.html#devicemotion
+ */
+typedef struct EmscriptenDeviceMotionEvent {
+  // Absolute wallclock time in msec units of when the event occurred.
+  double timestamp;
+  // Acceleration of the device excluding gravity.
+  double accelerationX;
+  double accelerationY;
+  double accelerationZ;
+  // Acceleration of the device including gravity.
+  double accelerationIncludingGravityX;
+  double accelerationIncludingGravityY;
+  double accelerationIncludingGravityZ;
+  // The rotational delta of the device.
+  double rotationRateAlpha;
+  double rotationRateBeta;
+  double rotationRateGamma;
+} EmscriptenDeviceMotionEvent;
+
+/*
+ * Registers a callback function for receiving the devicemotion event.
+ * See http://dev.w3.org/geo/api/spec-source-orientation.html
+ */
+extern EMSCRIPTEN_RESULT emscripten_set_devicemotion_callback(void *userData, int useCapture, EM_BOOL (*func)(int eventType, const EmscriptenDeviceMotionEvent *motionEvent, void *userData));
+/*
+ * Returns the most recently received deviceomotion event state. Note that for this function call to succeed, emscripten_set_devicemotion_callback
+ * must have first been called with one of the mouse event types and a non-zero callback function pointer to enable the Device Motion state capture.
+ */
+extern EMSCRIPTEN_RESULT emscripten_get_devicemotion_status(EmscriptenDeviceMotionEvent *motionState);
+
+#define EMSCRIPTEN_ORIENTATION_PORTRAIT_PRIMARY    1
+#define EMSCRIPTEN_ORIENTATION_PORTRAIT_SECONDARY  2
+#define EMSCRIPTEN_ORIENTATION_LANDSCAPE_PRIMARY   4
+#define EMSCRIPTEN_ORIENTATION_LANDSCAPE_SECONDARY 8
+
+/*
+ * The event structure passed in the orientationchange event.
+ * https://dvcs.w3.org/hg/screen-orientation/raw-file/tip/Overview.html
+ */
+typedef struct EmscriptenOrientationChangeEvent {
+  // One of EM_ORIENTATION_PORTRAIT_xx fields, or -1 if unknown.
+  int orientationIndex;
+  // Emscripten-specific extension: Some browsers refer to 'window.orientation', so report that as well.
+  // Orientation angle in degrees. 0: "default orientation", i.e. default upright orientation to hold the mobile device in. Could be either landscape or portrait.
+  int orientationAngle;
+} EmscriptenOrientationChangeEvent;
+
+/*
+ * Registers a callback function for receiving the orientationchange event.
+ * https://dvcs.w3.org/hg/screen-orientation/raw-file/tip/Overview.html
+ */
+extern EMSCRIPTEN_RESULT emscripten_set_orientationchange_callback(void *userData, int useCapture, EM_BOOL (*func)(int eventType, const EmscriptenOrientationChangeEvent *orientationChangeEvent, void *userData));
+/*
+ * Returns the current device orientation state.
+ */
+extern EMSCRIPTEN_RESULT emscripten_get_orientation_status(EmscriptenOrientationChangeEvent *orientationStatus);
+/*
+ * Locks the screen orientation to the given set of allowed orientations.
+ * allowedOrientations: A bitfield set of EM_ORIENTATION_xx flags.
+ */
+extern EMSCRIPTEN_RESULT emscripten_lock_orientation(int allowedOrientations);
+/*
+ * Allows the screen to turn again into any orientation.
+ */
+extern EMSCRIPTEN_RESULT emscripten_unlock_orientation();
+
+/*
+ * The event structure passed in the fullscreenchange event.
+ * https://dvcs.w3.org/hg/fullscreen/raw-file/tip/Overview.html
+ */
+typedef struct EmscriptenFullscreenChangeEvent {
+  // Specifies whether an element on the browser page is currently fullscreen.
+  EM_BOOL isFullscreen;
+  // Specifies if the current page has the ability to display elements fullscreen.
+  EM_BOOL fullscreenEnabled;
+  // The nodeName of the target HTML Element that is in full screen mode. See https://developer.mozilla.org/en-US/docs/Web/API/Node.nodeName
+  EM_UTF8 nodeName[128];
+  // The HTML Element ID of the target HTML element that is in full screen mode.
+  EM_UTF8 id[128];
+} EmscriptenFullscreenChangeEvent;
+
+/*
+ * Registers a callback function for receiving the fullscreenchange event.
+ * https://dvcs.w3.org/hg/screen-orientation/raw-file/tip/Overview.html
+ */
+extern EMSCRIPTEN_RESULT emscripten_set_fullscreenchange_callback(const char *target, void *userData, int useCapture, EM_BOOL (*func)(int eventType, const EmscriptenFullscreenChangeEvent *fullscreenChangeEvent, void *userData));
+/*
+ * Returns the current page fullscreen state.
+ */
+extern EMSCRIPTEN_RESULT emscripten_get_fullscreen_status(EmscriptenFullscreenChangeEvent *fullscreenStatus);
+/*
+ * Requests the given target element to transition to full screen mode.
+ * Note: This function can only run inside a user-generated JavaScript event handler.
+ * deferUntilInEventHandler: If true and you called this function outside an event callback, this request will
+ *                           be queued to be executed the next time a JS event handler runs. If false, this
+ *                           function will instead fail if not running inside a JS event handler.
+ */
+extern EMSCRIPTEN_RESULT emscripten_request_fullscreen(const char *target, int deferUntilInEventHandler);
+/*
+ * Returns back to windowed browsing mode.
+ */
+extern EMSCRIPTEN_RESULT emscripten_exit_fullscreen();
+
+/*
+ * The event structure passed in the pointerlockchange event.
+ * http://www.w3.org/TR/pointerlock/
+ */
+typedef struct EmscriptenPointerlockChangeEvent {
+  // Specifies whether an element on the browser page currently has pointer lock enabled.
+  EM_BOOL isActive;
+  // The nodeName of the target HTML Element that has the pointer lock active. See https://developer.mozilla.org/en-US/docs/Web/API/Node.nodeName
+  EM_UTF8 nodeName[128];
+  // The HTML Element ID of the target HTML element that has the pointer lock active.
+  EM_UTF8 id[128];
+} EmscriptenPointerlockChangeEvent;
+
+/*
+ * Registers a callback function for receiving the pointerlockchange event.
+ * Pointer lock hides the mouse cursor and exclusively gives the target element relative mouse movement events via the mousemove event.
+ * http://www.w3.org/TR/pointerlock/
+ */
+extern EMSCRIPTEN_RESULT emscripten_set_pointerlockchange_callback(const char *target, void *userData, int useCapture, EM_BOOL (*func)(int eventType, const EmscriptenPointerlockChangeEvent *pointerlockChangeEvent, void *userData));
+/*
+ * Returns the current page pointerlock state.
+ */
+extern EMSCRIPTEN_RESULT emscripten_get_pointerlock_status(EmscriptenPointerlockChangeEvent *pointerlockStatus);
+/*
+ * Requests the given target element to grab pointerlock.
+ * Note: This function can only run inside a user-generated JavaScript event handler.
+ * deferUntilInEventHandler: If true and you called this function outside an event callback, this request will
+ *                           be queued to be executed the next time a JS event handler runs. If false, this
+ *                           function will instead fail if not running inside a JS event handler.
+ */
+extern EMSCRIPTEN_RESULT emscripten_request_pointerlock(const char *target, int deferUntilInEventHandler);
+/*
+ * Exits pointer lock state and restores the mouse cursor to be visible again.
+ */
+extern EMSCRIPTEN_RESULT emscripten_exit_pointerlock();
+
+#define EMSCRIPTEN_VISIBILITY_HIDDEN    0
+#define EMSCRIPTEN_VISIBILITY_VISIBLE   1
+#define EMSCRIPTEN_VISIBILITY_PRERENDER 2
+#define EMSCRIPTEN_VISIBILITY_UNLOADED  3
+
+/*
+ * The event structure passed in the visibilitychange event.
+ * http://www.w3c-test.org/webperf/specs/PageVisibility/
+ */
+typedef struct EmscriptenVisibilityChangeEvent {
+  // If true, the current browser page is now hidden.
+  EM_BOOL hidden;
+  // Specifies a more fine-grained state of the current page visibility status. One of the EMSCRIPTEN_VISIBILITY_ values.
+  int visibilityState;
+} EmscriptenVisibilityChangeEvent;
+
+/*
+ * Registers a callback function for receiving the visibilitychange event.
+ * http://www.w3c-test.org/webperf/specs/PageVisibility/
+ */
+extern EMSCRIPTEN_RESULT emscripten_set_visibilitychange_callback(void *userData, int useCapture, EM_BOOL (*func)(int eventType, const EmscriptenVisibilityChangeEvent *visibilityChangeEvent, void *userData));
+/*
+ * Returns the current page visibility state.
+ */
+extern EMSCRIPTEN_RESULT emscripten_get_visibility_status(EmscriptenVisibilityChangeEvent *visibilityStatus);
+
+/*
+ * Specifies the status of a single touch point on the page.
+ * See http://www.w3.org/TR/touch-events/#touch-interface
+ */
+typedef struct EmscriptenTouchPoint
+{
+  // An identification number for each touch point.
+  long identifier;
+  // The touch coordinate relative to the whole screen origin, in pixels.
+  long screenX;
+  long screenY;
+  // The touch coordinate relative to the viewport, in pixels.
+  long clientX;
+  long clientY;
+  // The touch coordinate relative to the viewport, in pixels, and including any scroll offset.
+  long pageX;
+  long pageY;
+  // Specifies whether this touch point changed during this event.
+  EM_BOOL isChanged;
+  // Specifies whether this touch point is still above the original target on which it was initially pressed against.
+  EM_BOOL onTarget;
+  // The touch coordinates mapped to the Emscripten canvas client area, in pixels.
+  long canvasX;
+  long canvasY;
+} EmscriptenTouchPoint;
+
+/*
+ * Specifies the data of a single touch event.
+ * See http://www.w3.org/TR/touch-events/#touchevent-interface
+ */
+typedef struct EmscriptenTouchEvent {
+  // The number of valid elements in the touches array.
+  int numTouches;
+  // Specifies which modifiers were active during the key event.
+  EM_BOOL ctrlKey;
+  EM_BOOL shiftKey;
+  EM_BOOL altKey;
+  EM_BOOL metaKey;
+  // An array of currently active touches, one for each finger.
+  EmscriptenTouchPoint touches[32];
+} EmscriptenTouchEvent;
+
+/*
+ * Registers a callback function for receiving the touchstart, touchend, touchmove and touchcancel events.
+ * http://www.w3.org/TR/touch-events/
+ */
+extern EMSCRIPTEN_RESULT emscripten_set_touchstart_callback(const char *target, void *userData, int useCapture, EM_BOOL (*func)(int eventType, const EmscriptenTouchEvent *touchEvent, void *userData));
+extern EMSCRIPTEN_RESULT emscripten_set_touchend_callback(const char *target, void *userData, int useCapture, EM_BOOL (*func)(int eventType, const EmscriptenTouchEvent *touchEvent, void *userData));
+extern EMSCRIPTEN_RESULT emscripten_set_touchmove_callback(const char *target, void *userData, int useCapture, EM_BOOL (*func)(int eventType, const EmscriptenTouchEvent *touchEvent, void *userData));
+extern EMSCRIPTEN_RESULT emscripten_set_touchcancel_callback(const char *target, void *userData, int useCapture, EM_BOOL (*func)(int eventType, const EmscriptenTouchEvent *touchEvent, void *userData));
+
+/*
+ * Represents the current snapshot state of a gamepad.
+ * http://www.w3.org/TR/gamepad/#gamepad-interface
+ */
+typedef struct EmscriptenGamepadEvent {
+  // Absolute wallclock time in msec units of when the data was recorded.
+  double timestamp;
+  // The number of valid axes entries in the axis array.
+  int numAxes;
+  // The number of valid button entries in the analogButton and digitalButton arrays.
+  int numButtons;
+  // The analog state of the gamepad axes, in the range [-1, 1].
+  double axis[64];
+  // The analog state of the gamepad buttons, in the range [0, 1].
+  double analogButton[64];
+  // The digital state of the gamepad buttons, either 0 or 1.
+  EM_BOOL digitalButton[64];
+  // Specifies whether this gamepad is connected to the browser page.
+  EM_BOOL connected;
+  // An ordinal associated with this gamepad, zero-based.
+  long index;
+  // An ID for the brand or style of the connected gamepad device. Typically, this will include the USB vendor and a product ID.
+  EM_UTF8 id[64];
+  // A string that identifies the layout or control mapping of this device.
+  EM_UTF8 mapping[64];
+} EmscriptenGamepadEvent;
+
+/*
+ * Registers a callback function for receiving the gamepadconnected and gamepaddisconnected events.
+ * http://www.w3.org/TR/gamepad/
+ */
+extern EMSCRIPTEN_RESULT emscripten_set_gamepadconnected_callback(void *userData, int useCapture, EM_BOOL (*func)(int eventType, const EmscriptenGamepadEvent *gamepadEvent, void *userData));
+extern EMSCRIPTEN_RESULT emscripten_set_gamepaddisconnected_callback(void *userData, int useCapture, EM_BOOL (*func)(int eventType, const EmscriptenGamepadEvent *gamepadEvent, void *userData));
+
+/*
+ * Returns the number of gamepads connected to the system or EMSCRIPTEN_RESULT_NOT_SUPPORTED if the current browser does not support gamepads.
+ * Note: A gamepad does not show up as connected until a button on it is pressed.
+ */
+extern int emscripten_get_num_gamepads();
+/*
+ * Returns a snapshot of the current gamepad state.
+ */
+extern EMSCRIPTEN_RESULT emscripten_get_gamepad_status(int index, EmscriptenGamepadEvent *gamepadState);
+
+/*
+ * The event structure passed in the battery chargingchange and levelchange event.
+ * http://www.w3.org/TR/battery-status/#batterymanager-interface
+ */
+typedef struct EmscriptenBatteryEvent {
+  double chargingTime;
+  double dischargingTime;
+  double level;
+  EM_BOOL charging;
+} EmscriptenBatteryEvent;
+
+/*
+ * Registers a callback function for receiving the battery chargingchange and levelchange events.
+ * http://www.w3.org/TR/battery-status/
+ */
+extern EMSCRIPTEN_RESULT emscripten_set_batterychargingchange_callback(void *userData, EM_BOOL (*func)(int eventType, const EmscriptenBatteryEvent *batteryEvent, void *userData));
+extern EMSCRIPTEN_RESULT emscripten_set_batterylevelchange_callback(void *userData, EM_BOOL (*func)(int eventType, const EmscriptenBatteryEvent *batteryEvent, void *userData));
+/*
+ * Returns the current battery status.
+ */
+extern EMSCRIPTEN_RESULT emscripten_get_battery_status(EmscriptenBatteryEvent *batteryState);
+
+/*
+ * Produces a vibration feedback for given msecs.
+ * http://dev.w3.org/2009/dap/vibration/
+ */
+extern EMSCRIPTEN_RESULT emscripten_vibrate(int msecs);
+/*
+ * Produces a complex vibration feedback pattern.
+ * msecsArray: An array of timing entries [on, off, on, off, on, off, ...] where every second one specifies a duration of vibration, and 
+ *             every other one specifies a duration of silence.
+ * numEntries: The number of integers in the array msecsArray.
+ */
+extern EMSCRIPTEN_RESULT emscripten_vibrate_pattern(int *msecsArray, int numEntries);
+
+/*
+ * Registers a callback function for receiving the page beforeunload event.
+ * Hook onto this event to perform process right prior to page close, and/or display a confirmation notification asking if the user really wants to leave the page.
+ * http://www.whatwg.org/specs/web-apps/current-work/multipage/history.html#beforeunloadevent
+ */
+extern EMSCRIPTEN_RESULT emscripten_set_beforeunload_callback(void *userData, const char *(*func)(int eventType, const void *reserved, void *userData));
+
+/*
+ * Registers a callback function for the canvas webgl context webglcontextlost and webglcontextrestored events.
+ * See http://www.khronos.org/registry/webgl/specs/latest/1.0/#5.15.2
+ */
+extern EMSCRIPTEN_RESULT emscripten_set_webglcontextlost_callback(const char *target, void *userData, int useCapture, EM_BOOL (*func)(int eventType, const void *reserved, void *userData));
+extern EMSCRIPTEN_RESULT emscripten_set_webglcontextrestored_callback(const char *target, void *userData, int useCapture, EM_BOOL (*func)(int eventType, const void *reserved, void *userData));
+
+#ifdef __cplusplus
+} // ~extern "C"
+#endif
+
+#endif

tests/test_browser.py

@@ -1813,3 +1813,5 @@ Module["preRun"].push(function () {
 
     self.btest('doublestart.c', args=['--pre-js', 'pre.js', '-o', 'test.html'], expected='1')
 
+  def test_html5(self):
+    self.btest(path_from_root('tests', 'test_html5.c'), expected='0')

tests/test_html5.c

@@ -0,0 +1,474 @@
+#include <stdio.h>
+#include <emscripten.h>
+#include <string.h>
+#include <emscripten/html5.h>
+
+static inline const char *emscripten_event_type_to_string(int eventType) {
+  const char *events[] = { "(invalid)", "(none)", "keypress", "keydown", "keyup", "click", "mousedown", "mouseup", "dblclick", "mousemove", "wheel", "resize", 
+    "scroll", "blur", "focus", "focusin", "focusout", "deviceorientation", "devicemotion", "orientationchange", "fullscreenchange", "pointerlockchange", 
+    "visibilitychange", "touchstart", "touchend", "touchmove", "touchcancel", "gamepadconnected", "gamepaddisconnected", "beforeunload", 
+    "batterychargingchange", "batterylevelchange", "webglcontextlost", "webglcontextrestored", "(invalid)" };
+  ++eventType;
+  if (eventType < 0) eventType = 0;
+  if (eventType >= sizeof(events)/sizeof(events[0])) eventType = sizeof(events)/sizeof(events[0])-1;
+  return events[eventType];
+}
+
+const char *emscripten_result_to_string(EMSCRIPTEN_RESULT result) {
+  if (result == EMSCRIPTEN_RESULT_SUCCESS) return "EMSCRIPTEN_RESULT_SUCCESS";
+  if (result == EMSCRIPTEN_RESULT_DEFERRED) return "EMSCRIPTEN_RESULT_DEFERRED";
+  if (result == EMSCRIPTEN_RESULT_NOT_SUPPORTED) return "EMSCRIPTEN_RESULT_NOT_SUPPORTED";
+  if (result == EMSCRIPTEN_RESULT_FAILED_NOT_DEFERRED) return "EMSCRIPTEN_RESULT_FAILED_NOT_DEFERRED";
+  if (result == EMSCRIPTEN_RESULT_INVALID_TARGET) return "EMSCRIPTEN_RESULT_INVALID_TARGET";
+  if (result == EMSCRIPTEN_RESULT_UNKNOWN_TARGET) return "EMSCRIPTEN_RESULT_UNKNOWN_TARGET";
+  if (result == EMSCRIPTEN_RESULT_INVALID_PARAM) return "EMSCRIPTEN_RESULT_INVALID_PARAM";
+  if (result == EMSCRIPTEN_RESULT_FAILED) return "EMSCRIPTEN_RESULT_FAILED";
+  if (result == EMSCRIPTEN_RESULT_NO_DATA) return "EMSCRIPTEN_RESULT_NO_DATA";
+  return "Unknown EMSCRIPTEN_RESULT!";
+}
+
+#define TEST_RESULT(x) if (ret != EMSCRIPTEN_RESULT_SUCCESS) printf("%s returned %s.\n", #x, emscripten_result_to_string(ret));
+
+// The event handler functions can return 1 to suppress the event and disable the default action. That calls event.preventDefault();
+// Returning 0 signals that the event was not consumed by the code, and will allow the event to pass on and bubble up normally.
+EM_BOOL key_callback(int eventType, const EmscriptenKeyboardEvent *e, void *userData)
+{
+  printf("%s, key: \"%s\", code: \"%s\", location: %lu,%s%s%s%s repeat: %d, locale: \"%s\", char: \"%s\", charCode: %lu, keyCode: %lu, which: %lu\n",
+    emscripten_event_type_to_string(eventType), e->key, e->code, e->location, 
+    e->ctrlKey ? " CTRL" : "", e->shiftKey ? " SHIFT" : "", e->altKey ? " ALT" : "", e->metaKey ? " META" : "", 
+    e->repeat, e->locale, e->charValue, e->charCode, e->keyCode, e->which);
+
+  if (eventType == EMSCRIPTEN_EVENT_KEYPRESS && (!strcmp(e->key, "f") || e->which == 102)) {
+    EmscriptenFullscreenChangeEvent fsce;
+    EMSCRIPTEN_RESULT ret = emscripten_get_fullscreen_status(&fsce);
+    TEST_RESULT(emscripten_get_fullscreen_status);
+    if (!fsce.isFullscreen) {
+      printf("Requesting fullscreen..\n");
+      ret = emscripten_request_fullscreen(0, 1);
+      TEST_RESULT(emscripten_request_fullscreen);
+    } else {
+      printf("Exiting fullscreen..\n");
+      ret = emscripten_exit_fullscreen();
+      TEST_RESULT(emscripten_exit_fullscreen);
+      ret = emscripten_get_fullscreen_status(&fsce);
+      TEST_RESULT(emscripten_get_fullscreen_status);
+      if (fsce.isFullscreen) {
+        fprintf(stderr, "Fullscreen exit did not work!\n");
+      }
+    }
+  }
+
+  if (eventType == EMSCRIPTEN_EVENT_KEYPRESS && (!strcmp(e->key, "p") || e->which == 112)) {
+    EmscriptenPointerlockChangeEvent plce;
+    EMSCRIPTEN_RESULT ret = emscripten_get_pointerlock_status(&plce);
+    TEST_RESULT(emscripten_get_pointerlock_status);
+    if (!plce.isActive) {
+      printf("Requesting pointer lock..\n");
+      ret = emscripten_request_pointerlock(0, 1);
+      TEST_RESULT(emscripten_request_pointerlock);
+    } else {
+      printf("Exiting pointer lock..\n");
+      ret = emscripten_exit_pointerlock();
+      TEST_RESULT(emscripten_exit_pointerlock);
+      ret = emscripten_get_pointerlock_status(&plce);
+      TEST_RESULT(emscripten_get_pointerlock_status);
+      if (plce.isActive) {
+        fprintf(stderr, "Pointer lock exit did not work!\n");
+      }
+    }
+  }
+
+  return 0;
+}
+
+EM_BOOL mouse_callback(int eventType, const EmscriptenMouseEvent *e, void *userData)
+{
+  printf("%s, screen: (%ld,%ld), client: (%ld,%ld),%s%s%s%s button: %hu, buttons: %hu, movement: (%ld,%ld), canvas: (%ld,%ld)\n",
+    emscripten_event_type_to_string(eventType), e->screenX, e->screenY, e->clientX, e->clientY,
+    e->ctrlKey ? " CTRL" : "", e->shiftKey ? " SHIFT" : "", e->altKey ? " ALT" : "", e->metaKey ? " META" : "", 
+    e->button, e->buttons, e->movementX, e->movementY, e->canvasX, e->canvasY);
+
+  return 0;
+}
+
+EM_BOOL wheel_callback(int eventType, const EmscriptenWheelEvent *e, void *userData)
+{
+  printf("%s, screen: (%ld,%ld), client: (%ld,%ld),%s%s%s%s button: %hu, buttons: %hu, canvas: (%ld,%ld), delta:(%g,%g,%g), deltaMode:%lu\n",
+    emscripten_event_type_to_string(eventType), e->mouse.screenX, e->mouse.screenY, e->mouse.clientX, e->mouse.clientY,
+    e->mouse.ctrlKey ? " CTRL" : "", e->mouse.shiftKey ? " SHIFT" : "", e->mouse.altKey ? " ALT" : "", e->mouse.metaKey ? " META" : "", 
+    e->mouse.button, e->mouse.buttons, e->mouse.canvasX, e->mouse.canvasY,
+    (float)e->deltaX, (float)e->deltaY, (float)e->deltaZ, e->deltaMode);
+
+  return 0;
+}
+
+EM_BOOL uievent_callback(int eventType, const EmscriptenUiEvent *e, void *userData)
+{
+  printf("%s, detail: %ld, document.body.client size: (%d,%d), window.inner size: (%d,%d), scrollPos: (%d, %d)\n",
+    emscripten_event_type_to_string(eventType), e->detail, e->documentBodyClientWidth, e->documentBodyClientHeight,
+    e->windowInnerWidth, e->windowInnerHeight, e->scrollTop, e->scrollLeft);
+
+  return 0;
+}
+
+EM_BOOL focusevent_callback(int eventType, const EmscriptenFocusEvent *e, void *userData)
+{
+  printf("%s, nodeName: \"%s\", id: \"%s\"\n", emscripten_event_type_to_string(eventType), e->nodeName, e->id[0] == '\0' ? "(empty string)" : e->id);
+
+  return 0;
+}
+
+EM_BOOL deviceorientation_callback(int eventType, const EmscriptenDeviceOrientationEvent *e, void *userData)
+{
+  printf("%s, (%g, %g, %g)\n", emscripten_event_type_to_string(eventType), e->alpha, e->beta, e->gamma);
+
+  return 0;
+}
+
+EM_BOOL devicemotion_callback(int eventType, const EmscriptenDeviceMotionEvent *e, void *userData)
+{
+  printf("%s, accel: (%g, %g, %g), accelInclGravity: (%g, %g, %g), rotationRate: (%g, %g, %g)\n", 
+    emscripten_event_type_to_string(eventType), 
+    e->accelerationX, e->accelerationY, e->accelerationZ,
+    e->accelerationIncludingGravityX, e->accelerationIncludingGravityY, e->accelerationIncludingGravityZ,
+    e->rotationRateAlpha, e->rotationRateBeta, e->rotationRateGamma);
+
+  return 0;
+}
+
+EM_BOOL orientationchange_callback(int eventType, const EmscriptenOrientationChangeEvent *e, void *userData)
+{
+  printf("%s, orientationAngle: %d, orientationIndex: %d\n", emscripten_event_type_to_string(eventType), e->orientationAngle, e->orientationIndex);
+
+  return 0;
+}
+
+EM_BOOL fullscreenchange_callback(int eventType, const EmscriptenFullscreenChangeEvent *e, void *userData)
+{
+  printf("%s, isFullscreen: %d, fullscreenEnabled: %d, fs element nodeName: \"%s\", fs element id: \"%s\"\n",
+    emscripten_event_type_to_string(eventType), e->isFullscreen, e->fullscreenEnabled, e->nodeName, e->id);
+
+  return 0;
+}
+
+EM_BOOL pointerlockchange_callback(int eventType, const EmscriptenPointerlockChangeEvent *e, void *userData)
+{
+  printf("%s, isActive: %d, pointerlock element nodeName: \"%s\", id: \"%s\"\n",
+    emscripten_event_type_to_string(eventType), e->isActive, e->nodeName, e->id);
+
+  return 0;
+}
+
+EM_BOOL visibilitychange_callback(int eventType, const EmscriptenVisibilityChangeEvent *e, void *userData)
+{
+  printf("%s, hidden: %d, visibilityState: %d\n", emscripten_event_type_to_string(eventType), e->hidden, e->visibilityState);
+
+  return 0;
+}
+
+EM_BOOL touch_callback(int eventType, const EmscriptenTouchEvent *e, void *userData)
+{
+  printf("%s, numTouches: %d %s%s%s%s\n",
+    emscripten_event_type_to_string(eventType), e->numTouches,
+    e->ctrlKey ? " CTRL" : "", e->shiftKey ? " SHIFT" : "", e->altKey ? " ALT" : "", e->metaKey ? " META" : "");
+  for(int i = 0; i < e->numTouches; ++i)
+  {
+    const EmscriptenTouchPoint *t = &e->touches[i];
+    printf("  %ld: screen: (%ld,%ld), client: (%ld,%ld), page: (%ld,%ld), isChanged: %d, onTarget: %d, canvas: (%ld, %ld)\n",
+      t->identifier, t->screenX, t->screenY, t->clientX, t->clientY, t->pageX, t->pageY, t->isChanged, t->onTarget, t->canvasX, t->canvasY);
+  }
+  
+  return 0;
+}
+
+EM_BOOL gamepad_callback(int eventType, const EmscriptenGamepadEvent *e, void *userData)
+{
+  printf("%s: timeStamp: %g, connected: %d, index: %ld, numAxes: %d, numButtons: %d, id: \"%s\", mapping: \"%s\"\n",
+    eventType != 0 ? emscripten_event_type_to_string(eventType) : "Gamepad state", e->timestamp, e->connected, e->index, 
+    e->numAxes, e->numButtons, e->id, e->mapping);
+
+  if (e->connected)
+  {
+    for(int i = 0; i < e->numAxes; ++i)
+      printf("Axis %d: %g\n", i, e->axis[i]);
+
+    for(int i = 0; i < e->numButtons; ++i)
+      printf("Button %d: Digital: %d, Analog: %g\n", i, e->digitalButton[i], e->analogButton[i]);
+  }
+
+  return 0;
+}
+
+const char *beforeunload_callback(int eventType, const void *reserved, void *userData)
+{
+#ifdef REPORT_RESULT
+  return ""; // For test harness, don't show a confirmation dialog to not block and keep the test runner automated.
+#else
+  return "Do you really want to leave the page?";
+#endif
+}
+
+void formatTime(char *str, int seconds)
+{
+  int h = seconds / (60*60);
+  seconds -= h*60*60;
+  int m = seconds / 60;
+  seconds -= m*60;
+  if (h > 0)
+  {
+    sprintf(str, "%dh:%02dm:%02ds", h, m, seconds);
+  }
+  else
+  {
+    sprintf(str, "%02dm:%02ds", m, seconds);
+  }
+}
+
+EM_BOOL battery_callback(int eventType, const EmscriptenBatteryEvent *e, void *userData)
+{
+  char t1[64];
+  formatTime(t1, (int)e->chargingTime);
+  char t2[64];
+  formatTime(t2, (int)e->dischargingTime);
+  printf("%s: chargingTime: %s, dischargingTime: %s, level: %g%%, charging: %d\n",
+    emscripten_event_type_to_string(eventType), t1, t2, e->level*100, e->charging);
+
+  return 0;
+}
+
+EM_BOOL webglcontext_callback(int eventType, const void *reserved, void *userData)
+{
+  printf("%s.\n", emscripten_event_type_to_string(eventType));
+
+  return 0;
+}
+
+EmscriptenGamepadEvent prevState[32];
+int prevNumGamepads = 0;
+
+void mainloop()
+{
+  int numGamepads = emscripten_get_num_gamepads();
+  if (numGamepads != prevNumGamepads)
+  {
+    if (numGamepads == EMSCRIPTEN_RESULT_NOT_SUPPORTED) {
+      printf("emscripten_get_num_gamepads returned EMSCRIPTEN_RESULT_NOT_SUPPORTED.\n");
+      emscripten_cancel_main_loop();
+      return;
+    } else {
+      printf("Number of connected gamepads: %d\n", numGamepads);
+    }
+    prevNumGamepads = numGamepads;
+  }
+
+  for(int i = 0; i < numGamepads && i < 32; ++i)
+  {
+    EmscriptenGamepadEvent ge;
+    int failed = emscripten_get_gamepad_status(i, &ge);
+    if (!failed)
+    {
+      int g = ge.index;
+      for(int j = 0; j < ge.numAxes; ++j)
+      {
+        if (ge.axis[j] != prevState[g].axis[j])
+          printf("Gamepad %d, axis %d: %g\n", g, j, ge.axis[j]);
+      }
+
+      for(int j = 0; j < ge.numButtons; ++j)
+      {
+        if (ge.analogButton[j] != prevState[g].analogButton[j] || ge.digitalButton[j] != prevState[g].digitalButton[j])
+          printf("Gamepad %d, button %d: Digital: %d, Analog: %g\n", g, j, ge.digitalButton[j], ge.analogButton[j]);
+      }
+      prevState[g] = ge;
+    }
+  }
+
+}
+
+#ifdef REPORT_RESULT
+void report_result(void *arg)
+{
+  int result = 0;
+  REPORT_RESULT();
+}
+#endif
+
+int main()
+{
+
+  EMSCRIPTEN_RESULT ret = emscripten_set_keypress_callback(0, 0, 1, key_callback);
+  TEST_RESULT(emscripten_set_keypress_callback);
+  ret = emscripten_set_keydown_callback(0, 0, 1, key_callback);
+  TEST_RESULT(emscripten_set_keydown_callback);
+  ret = emscripten_set_keyup_callback(0, 0, 1, key_callback);
+  TEST_RESULT(emscripten_set_keyup_callback);
+
+  ret = emscripten_set_click_callback(0, 0, 1, mouse_callback);
+  TEST_RESULT(emscripten_set_click_callback);
+  ret = emscripten_set_mousedown_callback(0, 0, 1, mouse_callback);
+  TEST_RESULT(emscripten_set_mousedown_callback);
+  ret = emscripten_set_mouseup_callback(0, 0, 1, mouse_callback);
+  TEST_RESULT(emscripten_set_mouseup_callback);
+  ret = emscripten_set_dblclick_callback(0, 0, 1, mouse_callback);
+  TEST_RESULT(emscripten_set_dblclick_callback);
+  ret = emscripten_set_mousemove_callback(0, 0, 1, mouse_callback);
+  TEST_RESULT(emscripten_set_mousemove_callback);
+
+  ret = emscripten_set_wheel_callback(0, 0, 1, wheel_callback);
+  TEST_RESULT(emscripten_set_wheel_callback);
+
+  ret = emscripten_set_resize_callback(0, 0, 1, uievent_callback);
+  TEST_RESULT(emscripten_set_resize_callback);
+  ret = emscripten_set_scroll_callback(0, 0, 1, uievent_callback);
+  TEST_RESULT(emscripten_set_scroll_callback);
+
+  ret = emscripten_set_blur_callback(0, 0, 1, focusevent_callback);
+  TEST_RESULT(emscripten_set_blur_callback);
+  ret = emscripten_set_focus_callback(0, 0, 1, focusevent_callback);
+  TEST_RESULT(emscripten_set_focus_callback);
+  ret = emscripten_set_focusin_callback(0, 0, 1, focusevent_callback);
+  TEST_RESULT(emscripten_set_focusin_callback);
+  ret = emscripten_set_focusout_callback(0, 0, 1, focusevent_callback);
+  TEST_RESULT(emscripten_set_focusout_callback);
+
+  ret = emscripten_set_deviceorientation_callback(0, 1, deviceorientation_callback);
+  TEST_RESULT(emscripten_set_deviceorientation_callback);
+  ret = emscripten_set_devicemotion_callback(0, 1, devicemotion_callback);
+  TEST_RESULT(emscripten_set_devicemotion_callback);
+
+  ret = emscripten_set_orientationchange_callback(0, 1, orientationchange_callback);
+  TEST_RESULT(emscripten_set_orientationchange_callback);
+
+  // Test the polling of orientation.
+  EmscriptenOrientationChangeEvent oce;
+  ret = emscripten_get_orientation_status(&oce);
+  TEST_RESULT(emscripten_get_orientation_status);
+  if (ret == EMSCRIPTEN_RESULT_SUCCESS) {
+    printf("The current orientation is:\n");
+    orientationchange_callback(EMSCRIPTEN_EVENT_ORIENTATIONCHANGE, &oce, 0);
+  }
+
+  int newOrientation = (oce.orientationIndex == EMSCRIPTEN_ORIENTATION_PORTRAIT_PRIMARY 
+  || oce.orientationIndex == EMSCRIPTEN_ORIENTATION_PORTRAIT_SECONDARY) ? EMSCRIPTEN_ORIENTATION_LANDSCAPE_PRIMARY : EMSCRIPTEN_ORIENTATION_PORTRAIT_PRIMARY;
+  // Test locking of orientation.
+  ret = emscripten_lock_orientation(newOrientation);
+  TEST_RESULT(emscripten_lock_orientation);
+  if (ret == EMSCRIPTEN_RESULT_SUCCESS) {
+    printf("Locked orientation to state %d.\n", newOrientation);
+  }
+
+  ret = emscripten_get_orientation_status(&oce);
+  TEST_RESULT(emscripten_get_orientation_status);
+  if (ret == EMSCRIPTEN_RESULT_SUCCESS) {
+    printf("The current orientation is after locking:\n");
+    orientationchange_callback(18, &oce, 0);
+  }
+
+  ret = emscripten_unlock_orientation();
+  TEST_RESULT(emscripten_unlock_orientation);
+  if (ret == EMSCRIPTEN_RESULT_SUCCESS) {
+    printf("Unlocked orientation.\n");
+  }
+
+  EmscriptenFullscreenChangeEvent fsce;
+  ret = emscripten_get_fullscreen_status(&fsce);
+  TEST_RESULT(emscripten_get_fullscreen_status);
+  if (ret == EMSCRIPTEN_RESULT_SUCCESS) {
+    printf("The current fullscreen status is:\n");
+    fullscreenchange_callback(EMSCRIPTEN_EVENT_FULLSCREENCHANGE, &fsce, 0);
+  }
+
+  ret = emscripten_set_fullscreenchange_callback(0, 0, 1, fullscreenchange_callback);
+  TEST_RESULT(emscripten_set_fullscreenchange_callback);
+
+  // These won't do anything, since fullscreen must be requested in an event handler,
+  // but call these anyways to confirm that they don't crash in an exception in the test suite.
+  ret = emscripten_request_fullscreen(0, 1);
+  TEST_RESULT(emscripten_request_fullscreen);
+  ret = emscripten_exit_fullscreen();
+  TEST_RESULT(emscripten_exit_fullscreen);
+
+  EmscriptenPointerlockChangeEvent plce;
+  ret = emscripten_get_pointerlock_status(&plce);
+  TEST_RESULT(emscripten_get_pointerlock_status);
+  if (ret == EMSCRIPTEN_RESULT_SUCCESS) {
+    printf("The current pointerlock status is:\n");
+    pointerlockchange_callback(EMSCRIPTEN_EVENT_POINTERLOCKCHANGE, &plce, 0);
+  }
+
+  ret = emscripten_set_pointerlockchange_callback(0, 0, 1, pointerlockchange_callback);
+  TEST_RESULT(emscripten_set_pointerlockchange_callback);
+
+  // These won't do anything, since pointer lock must be requested in an event handler,
+  // but call these anyways to confirm that they don't crash in an exception in the test suite.
+  ret = emscripten_request_pointerlock(0, 1);
+  TEST_RESULT(emscripten_request_pointerlock);
+  ret = emscripten_exit_pointerlock();
+  TEST_RESULT(emscripten_exit_pointerlock);
+
+  int vibratePattern[] = {
+    150, 500, 
+    300, 500, 
+    450
+  };
+  ret = emscripten_vibrate_pattern(vibratePattern, sizeof(vibratePattern)/sizeof(vibratePattern[0]));
+  TEST_RESULT(emscripten_vibrate_pattern);
+
+  EmscriptenVisibilityChangeEvent vce;
+  ret = emscripten_get_visibility_status(&vce);
+  TEST_RESULT(emscripten_get_visibility_status);
+  if (ret == EMSCRIPTEN_RESULT_SUCCESS) {
+    printf("Current visibility status:\n");
+    visibilitychange_callback(EMSCRIPTEN_EVENT_VISIBILITYCHANGE, &vce, 0);
+  }
+
+  ret = emscripten_set_visibilitychange_callback(0, 1, visibilitychange_callback);
+  TEST_RESULT(emscripten_set_visibilitychange_callback);
+
+  ret = emscripten_set_touchstart_callback(0, 0, 1, touch_callback);
+  TEST_RESULT(emscripten_set_touchstart_callback);
+  ret = emscripten_set_touchend_callback(0, 0, 1, touch_callback);
+  TEST_RESULT(emscripten_set_touchend_callback);
+  ret = emscripten_set_touchmove_callback(0, 0, 1, touch_callback);
+  TEST_RESULT(emscripten_set_touchmove_callback);
+  ret = emscripten_set_touchcancel_callback(0, 0, 1, touch_callback);
+  TEST_RESULT(emscripten_set_touchcancel_callback);
+
+  ret = emscripten_set_gamepadconnected_callback(0, 1, gamepad_callback);
+  TEST_RESULT(emscripten_set_gamepadconnected_callback);
+  ret = emscripten_set_gamepaddisconnected_callback(0, 1, gamepad_callback);
+  TEST_RESULT(emscripten_set_gamepaddisconnected_callback);
+
+  emscripten_set_main_loop(mainloop, 10, 0);
+
+  ret = emscripten_set_beforeunload_callback(0, beforeunload_callback);
+  TEST_RESULT(emscripten_set_beforeunload_callback);
+
+  ret = emscripten_set_batterychargingchange_callback(0, battery_callback);
+  TEST_RESULT(emscripten_set_batterychargingchange_callback);
+  ret = emscripten_set_batterylevelchange_callback(0, battery_callback);
+  TEST_RESULT(emscripten_set_batterylevelchange_callback);
+
+  EmscriptenBatteryEvent bs;
+  ret = emscripten_get_battery_status(&bs);
+  TEST_RESULT(emscripten_get_battery_status);
+  if (ret == EMSCRIPTEN_RESULT_SUCCESS) {
+    printf("Current battery status:\n");
+    battery_callback(EMSCRIPTEN_EVENT_BATTERYLEVELCHANGE, &bs, 0);
+  }
+
+  ret = emscripten_set_webglcontextlost_callback(0, 0, 1, webglcontext_callback);
+  TEST_RESULT(emscripten_set_webglcontextlost_callback);
+  ret = emscripten_set_webglcontextrestored_callback(0, 0, 1, webglcontext_callback);
+  TEST_RESULT(emscripten_set_webglcontextrestored_callback);
+
+  /* For the events to function, one must either call emscripten_set_main_loop or enable Module.noExitRuntime by some other means. 
+     Otherwise the application will exit after leaving main(), and the atexit handlers will clean up all event hooks (by design). */
+  EM_ASM(Module['noExitRuntime'] = true);
+  
+#ifdef REPORT_RESULT
+  // Keep the page running for a moment.
+  emscripten_async_call(report_result, 0, 5000);
+#endif
+  return 0;
+}

tools/shared.py

@@ -345,7 +345,7 @@ def find_temp_directory():
 # we re-check sanity when the settings are changed)
 # We also re-check sanity and clear the cache when the version changes
 
-EMSCRIPTEN_VERSION = '1.9.3'
+EMSCRIPTEN_VERSION = '1.9.4'
 
 def generate_sanity():
   return EMSCRIPTEN_VERSION + '|' + get_llvm_target() + '|' + LLVM_ROOT + '|' + get_clang_version()