diff options
| -rw-r--r-- | src/library_events.js | 1241 | ||||
| -rw-r--r-- | src/modules.js | 2 | ||||
| -rw-r--r-- | src/struct_info.json | 184 | ||||
| -rw-r--r-- | system/include/emscripten/events.h | 625 | ||||
| -rw-r--r-- | tests/test_browser.py | 2 | ||||
| -rw-r--r-- | tests/test_events.c | 382 |
6 files changed, 2434 insertions, 2 deletions
diff --git a/src/library_events.js b/src/library_events.js new file mode 100644 index 00000000..d1a86127 --- /dev/null +++ b/src/library_events.js @@ -0,0 +1,1241 @@ +var LibraryJsEvents = { + $JsEvents: { + // pointers to structs malloc()ed to Emscripten HEAP for JS->C interop. + keyEvent: 0, + mouseEvent: 0, + wheelEvent: 0, + uiEvent: 0, + focusEvent: 0, + deviceOrientationEvent: 0, + deviceMotionEvent: 0, + fullscreenChangeEvent: 0, + pointerlockChangeEvent: 0, + visibilityChangeEvent: 0, + touchEvent: 0, + + // When the C runtime exits via exit(), we unregister all event handlers added by this library to be nice and clean. + // Track in this field whether we have yet registered that __ATEXIT__ handler. + removeEventListenersRegistered: false, + + registerRemoveEventListeners: function() { + if (!JsEvents.removeEventListenersRegistered) { + __ATEXIT__.push({ func: function() { + for(var i = JsEvents.eventHandlers.length-1; i >= 0; --i) { + JsEvents._removeHandler(i); + } + } }); + JsEvents.removeEventListenersRegistered = true; + } + }, + + findEventTarget: function(target) { + if (target) { + 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; + } + } else { + // The sensible target varies between events, but use window as the default + // since DOM events mostly can default to that. Specific callback registrations + // override their own defaults. + return window; + } + }, + + deferredCalls: [], + + // Queues the given function call to occur the next time we enter an event handler. + // Existing implementations of pointerlock apis have required that + // the target element is active in fullscreen mode first. Thefefore give + // fullscreen mode request a precedence of 1 and pointer lock a precedence of 2 + // 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; + } + for(var i in arrA) { + 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]; + if (call.targetFunction == targetFunction && arraysHaveEqualContent(call.argsList, argsList)) { + return; + } + } + JsEvents.deferredCalls.push({ + targetFunction: targetFunction, + precedence: precedence, + argsList: argsList + }); + + 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); + --i; + } + } + }, + + canPerformEventHandlerRequests: function() { + return JsEvents.inEventHandler && JsEvents.currentEventHandler.allowsDeferredCalls; + }, + + runDeferredCalls: function() { + if (!JsEvents.canPerformEventHandlerRequests()) { + return; + } + 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); + } + }, + + // If positive, we are currently executing in a JS event handler. + inEventHandler: 0, + // If we are in an event handler, specifies the event handler object from the eventHandlers array that is currently running. + currentEventHandler: null, + + // Stores objects representing each currently registered JS event handler. + eventHandlers: [], + + _removeHandler: function(i) { + 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; + // Process any old deferred calls the user has placed. + 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(); + // Out of event handler - restore nesting count. + --JsEvents.inEventHandler; + } + + if (eventHandler.callbackfunc) { + eventHandler.target.addEventListener(eventHandler.eventTypeString, jsEventHandler, eventHandler.useCapture); + 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--); + } + } + } + }, + + registerKeyEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) { + if (!JsEvents.keyEvent) { + JsEvents.keyEvent = _malloc( {{{ C_STRUCTS.emscripten_KeyboardEvent.__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]); + if (shouldCancel) { + e.preventDefault(); + } + }; + + var eventHandler = { + target: JsEvents.findEventTarget(target), + allowsDeferredCalls: true, + eventTypeString: eventTypeString, + callbackfunc: callbackfunc, + handlerFunc: handlerFunc, + useCapture: useCapture + }; + 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') }}} + }, + + registerMouseEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) { + if (!JsEvents.mouseEvent) { + JsEvents.mouseEvent = _malloc( {{{ C_STRUCTS.emscripten_MouseEvent.__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]); + if (shouldCancel) { + e.preventDefault(); + } + }; + + var eventHandler = { + 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); + }, + + registerWheelEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) { + if (!JsEvents.wheelEvent) { + JsEvents.wheelEvent = _malloc( {{{ C_STRUCTS.emscripten_WheelEvent.__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]); + if (shouldCancel) { + e.preventDefault(); + } + }; + + var eventHandler = { + target: JsEvents.findEventTarget(target), + allowsDeferredCalls: true, + eventTypeString: eventTypeString, + callbackfunc: callbackfunc, + handlerFunc: handlerFunc, + useCapture: useCapture + }; + 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) { + 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 (eventTypeString == "scroll" && !target) { + target = document; // By default read scroll events on document rather than window. + } else { + target = JsEvents.findEventTarget(target); + } + + var handlerFunc = function(event) { + var e = event || window.event; + if (e.target != target) { + // Never take ui events such as scroll via a 'bubbled' route, but always from the direct element that + // was targeted. Otherwise e.g. if app logs a message in response to a page scroll, the Emscripten log + // message box could cause to scroll, generating a new (bubbled) scroll message, causing a new log print, + // 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]); + if (shouldCancel) { + e.preventDefault(); + } + }; + + var eventHandler = { + target: target, + allowsDeferredCalls: false, // Neither scroll or resize events allow running requests inside them. + eventTypeString: eventTypeString, + callbackfunc: callbackfunc, + handlerFunc: handlerFunc, + useCapture: useCapture + }; + JsEvents.registerOrRemoveHandler(eventHandler); + }, + + getNodeNameForTarget: function(target) { + 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__ }}} ); + } + var handlerFunc = function(event) { + var e = event || window.event; + + 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]); + if (shouldCancel) { + e.preventDefault(); + } + }; + + var eventHandler = { + target: JsEvents.findEventTarget(target), + allowsDeferredCalls: false, + eventTypeString: eventTypeString, + callbackfunc: callbackfunc, + handlerFunc: handlerFunc, + useCapture: useCapture + }; + JsEvents.registerOrRemoveHandler(eventHandler); + }, + + tick: function() { + 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__ }}} ); + } + 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') }}} + + var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JsEvents.deviceOrientationEvent, userData]); + if (shouldCancel) { + e.preventDefault(); + } + }; + + var eventHandler = { + target: JsEvents.findEventTarget(target), + allowsDeferredCalls: false, + eventTypeString: eventTypeString, + callbackfunc: callbackfunc, + handlerFunc: handlerFunc, + useCapture: useCapture + }; + JsEvents.registerOrRemoveHandler(eventHandler); + }, + + registerDeviceMotionEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) { + if (!JsEvents.deviceMotionEvent) { + JsEvents.deviceMotionEvent = _malloc( {{{ C_STRUCTS.emscripten_DeviceMotionEvent.__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]); + if (shouldCancel) { + e.preventDefault(); + } + }; + + var eventHandler = { + target: JsEvents.findEventTarget(target), + allowsDeferredCalls: false, + eventTypeString: eventTypeString, + callbackfunc: callbackfunc, + handlerFunc: handlerFunc, + useCapture: useCapture + }; + JsEvents.registerOrRemoveHandler(eventHandler); + }, + + 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 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') }}} + }, + + registerOrientationChangeEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) { + if (!JsEvents.orientationChangeEvent) { + JsEvents.orientationChangeEvent = _malloc( {{{ C_STRUCTS.emscripten_OrientationChangeEvent.__size__ }}} ); + } + + if (!target) { + target = window.screen; // Orientation events need to be captured from 'window.screen' instead of 'window' + } else { + target = JsEvents.findEventTarget(target); + } + + var handlerFunc = function(event) { + var e = event || window.event; + + JsEvents.fillOrientationChangeEventData(JsEvents.orientationChangeEvent, e); + + var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JsEvents.orientationChangeEvent, userData]); + if (shouldCancel) { + e.preventDefault(); + } + }; + + if (eventTypeString == "orientationchange" && window.screen.mozOrientation !== undefined) { + eventTypeString = "mozorientationchange"; + } + + var eventHandler = { + target: target, + allowsDeferredCalls: false, + eventTypeString: eventTypeString, + callbackfunc: callbackfunc, + handlerFunc: handlerFunc, + useCapture: useCapture + }; + JsEvents.registerOrRemoveHandler(eventHandler); + }, + + 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); + var id = (fullscreenElement && fullscreenElement.id) ? fullscreenElement.id : ''; + writeStringToMemory(nodeName, eventStruct + {{{ C_STRUCTS.emscripten_FullscreenChangeEvent.nodeName }}} ); + writeStringToMemory(id, eventStruct + {{{ C_STRUCTS.emscripten_FullscreenChangeEvent.id }}} ); + }, + + registerFullscreenChangeEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) { + if (!JsEvents.fullscreenChangeEvent) { + JsEvents.fullscreenChangeEvent = _malloc( {{{ C_STRUCTS.emscripten_FullscreenChangeEvent.__size__ }}} ); + } + + if (!target) { + target = document; // Fullscreen change events need to be captured from 'document' by default instead of 'window' + } else { + target = JsEvents.findEventTarget(target); + } + + var handlerFunc = function(event) { + var e = event || window.event; + + JsEvents.fillFullscreenChangeEventData(JsEvents.fullscreenChangeEvent, e); + + var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JsEvents.fullscreenChangeEvent, userData]); + if (shouldCancel) { + e.preventDefault(); + } + }; + + var eventHandler = { + target: target, + allowsDeferredCalls: false, + eventTypeString: eventTypeString, + callbackfunc: callbackfunc, + handlerFunc: handlerFunc, + useCapture: useCapture + }; + JsEvents.registerOrRemoveHandler(eventHandler); + }, + + requestFullscreen: function(target) { + if (target.requestFullscreen) { + target.requestFullscreen(); + } else if (target.msRequestFullscreen) { + target.msRequestFullscreen(); + } 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 */; + } + return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}}; + }, + + 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); + var id = (pointerLockElement && pointerLockElement.id) ? pointerLockElement.id : ''; + writeStringToMemory(nodeName, eventStruct + {{{ C_STRUCTS.emscripten_PointerlockChangeEvent.nodeName }}} ); + writeStringToMemory(id, eventStruct + {{{ C_STRUCTS.emscripten_PointerlockChangeEvent.id }}}); + }, + + registerPointerlockChangeEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) { + if (!JsEvents.pointerlockChangeEvent) { + JsEvents.pointerlockChangeEvent = _malloc( {{{ C_STRUCTS.emscripten_PointerlockChangeEvent.__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); + } + + var handlerFunc = function(event) { + var e = event || window.event; + + JsEvents.fillPointerlockChangeEventData(JsEvents.pointerlockChangeEvent, e); + + var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JsEvents.pointerlockChangeEvent, userData]); + if (shouldCancel) { + e.preventDefault(); + } + }; + + var eventHandler = { + target: target, + allowsDeferredCalls: false, + eventTypeString: eventTypeString, + callbackfunc: callbackfunc, + handlerFunc: handlerFunc, + useCapture: useCapture + }; + JsEvents.registerOrRemoveHandler(eventHandler); + }, + + requestPointerLock: function(target) { + if (target.requestPointerLock) { + target.requestPointerLock(); + } else if (target.mozRequestPointerLock) { + target.mozRequestPointerLock(); + } else if (target.webkitRequestPointerLock) { + target.webkitRequestPointerLock(); + } else if (target.msRequestPointerLock) { + target.msRequestPointerLock(); + } else { + return 2 /* Target does not support requesting pointer lock */; + } + return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}}; + }, + + fillVisibilityChangeEventData: function(eventStruct, e) { + 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') }}} + }, + + registerVisibilityChangeEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) { + if (!JsEvents.visibilityChangeEvent) { + JsEvents.visibilityChangeEvent = _malloc( {{{ C_STRUCTS.emscripten_VisibilityChangeEvent.__size__ }}} ); + } + + if (!target) { + target = document; // Visibility change events need to be captured from 'document' by default instead of 'window' + } else { + target = JsEvents.findEventTarget(target); + } + + var handlerFunc = function(event) { + var e = event || window.event; + + JsEvents.fillVisibilityChangeEventData(JsEvents.visibilityChangeEvent, e); + + var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JsEvents.visibilityChangeEvent, userData]); + if (shouldCancel) { + e.preventDefault(); + } + }; + + var eventHandler = { + target: target, + allowsDeferredCalls: false, + eventTypeString: eventTypeString, + callbackfunc: callbackfunc, + handlerFunc: handlerFunc, + useCapture: useCapture + }; + JsEvents.registerOrRemoveHandler(eventHandler); + }, + + registerTouchEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) { + if (!JsEvents.touchEvent) { + JsEvents.touchEvent = _malloc( {{{ C_STRUCTS.emscripten_TouchEvent.__size__ }}} ); + } + + var handlerFunc = function(event) { + var e = event || window.event; + + var touches = {}; + for(var i = 0; i < e.touches.length; ++i) { + var touch = e.touches[i]; + touches[touch.identifier] = touch; + } + for(var i = 0; i < e.changedTouches.length; ++i) { + var touch = e.changedTouches[i]; + touches[touch.identifier] = touch; + touch.changed = true; + } + for(var i = 0; i < e.targetTouches.length; ++i) { + var touch = e.targetTouches[i]; + 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 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__ }}}; + + if (++numTouches >= 32) { + break; + } + } + {{{ makeSetValue('JsEvents.touchEvent', C_STRUCTS.emscripten_TouchEvent.numTouches, 'numTouches', 'i32') }}} + + var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JsEvents.touchEvent, userData]); + if (shouldCancel) { + e.preventDefault(); + } + }; + + var eventHandler = { + target: JsEvents.findEventTarget(target), + allowsDeferredCalls: true, + eventTypeString: eventTypeString, + callbackfunc: callbackfunc, + handlerFunc: handlerFunc, + useCapture: useCapture + }; + JsEvents.registerOrRemoveHandler(eventHandler); + }, + + fillGamepadEventData: function(eventStruct, e) { + {{{ makeSetValue('eventStruct', C_STRUCTS.emscripten_GamepadEvent.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') }}} + } + for(var i = 0; i < e.buttons.length; ++i) { + {{{ makeSetValue('eventStruct+i*8', C_STRUCTS.emscripten_GamepadEvent.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', 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 }}} ); + }, + + registerGamepadEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) { + if (!JsEvents.gamepadEvent) { + JsEvents.gamepadEvent = _malloc( {{{ C_STRUCTS.emscripten_GamepadEvent.__size__ }}} ); + } + + var handlerFunc = function(event) { + var e = event || window.event; + + JsEvents.fillGamepadEventData(JsEvents.gamepadEvent, e.gamepad); + + var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JsEvents.gamepadEvent, userData]); + if (shouldCancel) { + e.preventDefault(); + } + }; + + var eventHandler = { + target: JsEvents.findEventTarget(target), + allowsDeferredCalls: true, + eventTypeString: eventTypeString, + callbackfunc: callbackfunc, + handlerFunc: handlerFunc, + useCapture: useCapture + }; + JsEvents.registerOrRemoveHandler(eventHandler); + }, + + registerBeforeUnloadEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) { + var handlerFunc = function(event) { + var e = event || window.event; + + var confirmationMessage = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, 0, userData]); + + confirmationMessage = Pointer_stringify(confirmationMessage); + if (confirmationMessage) { + e.preventDefault(); + e.returnValue = confirmationMessage; + return confirmationMessage; + } + }; + + var eventHandler = { + target: JsEvents.findEventTarget(target), + allowsDeferredCalls: false, + eventTypeString: eventTypeString, + callbackfunc: callbackfunc, + handlerFunc: handlerFunc, + useCapture: useCapture + }; + 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') }}} + }, + + registerBatteryEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) { + if (!JsEvents.batteryEvent) { + JsEvents.batteryEvent = _malloc( {{{ C_STRUCTS.emscripten_BatteryEvent.__size__ }}} ); + } + + var handlerFunc = function(event) { + var e = event || window.event; + + JsEvents.fillBatteryEventData(JsEvents.batteryEvent, JsEvents.battery()); + + var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, JsEvents.batteryEvent, userData]); + if (shouldCancel) { + e.preventDefault(); + } + }; + + var eventHandler = { + target: JsEvents.findEventTarget(target), + allowsDeferredCalls: false, + eventTypeString: eventTypeString, + callbackfunc: callbackfunc, + handlerFunc: handlerFunc, + useCapture: useCapture + }; + JsEvents.registerOrRemoveHandler(eventHandler); + }, + + registerWebGlEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) { + if (!target) { + target = Module['canvas']; + } + var handlerFunc = function(event) { + var e = event || window.event; + + var shouldCancel = Runtime.dynCall('iiii', callbackfunc, [eventTypeId, 0, userData]); + if (shouldCancel) { + e.preventDefault(); + } + }; + + var eventHandler = { + target: JsEvents.findEventTarget(target), + allowsDeferredCalls: false, + eventTypeString: eventTypeString, + callbackfunc: callbackfunc, + handlerFunc: handlerFunc, + useCapture: useCapture + }; + JsEvents.registerOrRemoveHandler(eventHandler); + }, + }, + + emscripten_set_keypress_callback: function(target, userData, useCapture, callbackfunc) { + 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"); + 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"); + 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"); + 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"); + 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"); + 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"); + 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"); + return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}}; + }, + + emscripten_get_mouse_status: function(mouseState) { + 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); + 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"); + 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"); + 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"); + 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"); + 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"); + 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"); + 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"); + return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}}; + }, + + emscripten_set_deviceorientation_callback: function(userData, useCapture, callbackfunc) { + 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') }}}; + } + // 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); + return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}}; + }, + + emscripten_set_devicemotion_callback: function(userData, useCapture, callbackfunc) { + 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') }}}; + } + // 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); + 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"); + return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}}; + }, + + emscripten_get_orientation_status: function(orientationChangeEvent) { + JsEvents.fillOrientationChangeEventData(orientationChangeEvent); + return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}}; + }, + + emscripten_lock_orientation: function(allowedOrientations) { + var orientations = []; + if (allowedOrientations & 1) orientations.push("portrait-primary"); + if (allowedOrientations & 2) orientations.push("portrait-secondary"); + if (allowedOrientations & 4) orientations.push("landscape-primary"); + if (allowedOrientations & 8) orientations.push("landscape-secondary"); + if (window.screen.lockOrientation) { + window.screen.lockOrientation(orientations); + } else if (window.screen.mozLockOrientation) { + window.screen.mozLockOrientation(orientations); + } else if (window.screen.webkitLockOrientation) { + window.screen.webkitLockOrientation(orientations); + } else if (window.screen.msLockOrientation) { + window.screen.msLockOrientation(orientations); + } else { + return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}}; + } + return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}}; + }, + + emscripten_unlock_orientation: function() { + if (window.screen.unlockOrientation) { + window.screen.unlockOrientation(); + } else if (window.screen.mozUnlockOrientation) { + window.screen.mozUnlockOrientation(); + } else if (window.screen.webkitUnlockOrientation) { + window.screen.webkitUnlockOrientation(); + } else if (window.screen.msUnlockOrientation) { + window.screen.msUnlockOrientation(); + } else { + return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}}; + } + return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}}; + }, + + emscripten_set_fullscreenchange_callback: function(userData, useCapture, callbackfunc) { + JsEvents.registerFullscreenChangeEventCallback(userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_FULLSCREENCHANGE') }}}, "fullscreenchange"); + return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}}; + }, + + emscripten_get_fullscreen_status: function(fullscreenStatus) { + 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 (!target.requestFullscreen && !target.msRequestFullscreen && !target.mozRequestFullScreen && !target.webkitRequestFullscreen) { + return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}}; + } + + 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]); + return {{{ cDefine('EMSCRIPTEN_RESULT_DEFERRED') }}}; + } else { + return {{{ cDefine('EMSCRIPTEN_RESULT_FAILED_NOT_DEFERRED') }}}; + } + } + + return JsEvents.requestFullscreen(target); + }, + + emscripten_exit_fullscreen: function() { + // Make sure no queued up calls will fire after this. + JsEvents.removeDeferredCalls(JsEvents.requestFullscreen); + + if (document.exitFullscreen) { + document.exitFullscreen(); + } else if (document.msExitFullscreen) { + document.msExitFullscreen(); + } else if (document.mozCancelFullScreen) { + document.mozCancelFullScreen(); + } else if (document.webkitExitFullscreen) { + document.webkitExitFullscreen(); + } else { + return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}}; + } + return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}}; + }, + + emscripten_set_pointerlockchange_callback: function(userData, useCapture, callbackfunc) { + JsEvents.registerPointerlockChangeEventCallback(document, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_POINTERLOCKCHANGE') }}}, "pointerlockchange"); + return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}}; + }, + + emscripten_get_pointerlock_status: function(pointerlockStatus) { + 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.requestPointerLock && !target.mozRequestPointerLock && !target.webkitRequestPointerLock && !target.msRequestPointerLock) { + return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}}; + } + + 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]); + return {{{ cDefine('EMSCRIPTEN_RESULT_DEFERRED') }}}; + } else { + return {{{ cDefine('EMSCRIPTEN_RESULT_FAILED_NOT_DEFERRED') }}}; + } + } + + return JsEvents.requestPointerLock(target); + }, + + emscripten_exit_pointerlock: function() { + // Make sure no queued up calls will fire after this. + JsEvents.removeDeferredCalls(JsEvents.requestPointerLock); + + if (document.exitPointerLock) { + document.exitPointerLock(); + } else if (document.msExitPointerLock) { + document.msExitPointerLock(); + } else if (document.mozExitPointerLock) { + document.mozExitPointerLock(); + } else if (document.webkitExitPointerLock) { + document.webkitExitPointerLock(); + } else { + return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}}; + } + return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}}; + }, + + emscripten_vibrate: function(msecs) { + 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') }}}; + } + + var vibrateList = []; + for(var i = 0; i < numEntries; ++i) { + var msecs = {{{ makeGetValue('msecsArray', 'i*4', 'i32') }}} + vibrateList.push(msecs); + } + navigator.vibrate(vibrateList); + return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}}; + }, + + emscripten_set_visibilitychange_callback: function(userData, useCapture, callbackfunc) { + 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); + 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"); + 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"); + 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"); + 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"); + return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}}; + }, + + emscripten_set_gamepadconnected_callback: function(userData, useCapture, callbackfunc) { + 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"); + return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}}; + }, + + emscripten_get_num_gamepads: function() { + 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') }}}; + } + var gamepads = navigator.getGamepads(); + if (index < 0 || index >= gamepads.length) { + return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_PARAM') }}}; + } + 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"); + return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}}; + }, + + emscripten_set_batterychargingchange_callback: function(userData, callbackfunc) { + 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"); + return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}}; + }, + + emscripten_get_battery_status: function(batteryState) { + 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"); + 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"); + return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}}; + }, +}; + +autoAddDeps(LibraryJsEvents, '$JsEvents'); +mergeInto(LibraryManager.library, LibraryJsEvents); diff --git a/src/modules.js b/src/modules.js index ad467ba7..7b267971 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'].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_events.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 a22851b6..ec449097 100644 --- a/src/struct_info.json +++ b/src/struct_info.json @@ -1073,5 +1073,187 @@ "UUID_TYPE_DCE_RANDOM" ], "structs": {} + }, + // =========================================== + // emscripten events library + // =========================================== + { + "file": "emscripten/events.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_INVALID_PARAM", + "EMSCRIPTEN_RESULT_NOT_SUPPORTED", + "EMSCRIPTEN_RESULT_FAILED", + "EMSCRIPTEN_RESULT_NO_DATA" + ], + "structs": { + "emscripten_KeyboardEvent": [ + "key", + "code", + "location", + "ctrlKey", + "shiftKey", + "altKey", + "metaKey", + "repeat", + "locale", + "charValue", + "charCode", + "keyCode", + "which" + ], + "emscripten_MouseEvent": [ + "timestamp", + "screenX", + "screenY", + "clientX", + "clientY", + "ctrlKey", + "shiftKey", + "altKey", + "metaKey", + "button", + "buttons", + "movementX", + "movementY", + "canvasX", + "canvasY" + ], + "emscripten_WheelEvent": [ + "mouse", + "deltaX", + "deltaY", + "deltaZ", + "deltaMode" + ], + "emscripten_UiEvent": [ + "detail", + "documentBodyClientWidth", + "documentBodyClientHeight", + "windowInnerWidth", + "windowInnerHeight", + "windowOuterWidth", + "windowOuterHeight", + "scrollTop", + "scrollLeft" + ], + "emscripten_FocusEvent": [ + "nodeName", + "id" + ], + "emscripten_DeviceOrientationEvent": [ + "timestamp", + "alpha", + "beta", + "gamma", + "absolute" + ], + "emscripten_DeviceMotionEvent": [ + "timestamp", + "accelerationX", + "accelerationY", + "accelerationZ", + "accelerationIncludingGravityX", + "accelerationIncludingGravityY", + "accelerationIncludingGravityZ", + "rotationRateAlpha", + "rotationRateBeta", + "rotationRateGamma" + ], + "emscripten_OrientationChangeEvent": [ + "orientationIndex", + "orientationAngle" + ], + "emscripten_FullscreenChangeEvent": [ + "isFullscreen", + "fullscreenEnabled", + "nodeName", + "id" + ], + "emscripten_PointerlockChangeEvent": [ + "isActive", + "nodeName", + "id" + ], + "emscripten_VisibilityChangeEvent": [ + "hidden", + "visibilityState" + ], + "emscripten_TouchPoint": [ + "identifier", + "screenX", + "screenY", + "clientX", + "clientY", + "pageX", + "pageY", + "isChanged", + "onTarget", + "canvasX", + "canvasY" + ], + "emscripten_TouchEvent": [ + "numTouches", + "ctrlKey", + "shiftKey", + "altKey", + "metaKey", + "touches" + ], + "emscripten_GamepadEvent": [ + "timestamp", + "axis", + "analogButton", + "digitalButton", + "connected", + "index", + "numAxes", + "numButtons", + "id", + "mapping" + ], + "emscripten_BatteryEvent": [ + "chargingTime", + "dischargingTime", + "level", + "charging" + ] + } } -] + ] diff --git a/system/include/emscripten/events.h b/system/include/emscripten/events.h new file mode 100644 index 00000000..4caae3cf --- /dev/null +++ b/system/include/emscripten/events.h @@ -0,0 +1,625 @@ +#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 + +// An invalid parameter was passed to the function. +#define EMSCRIPTEN_RESULT_INVALID_PARAM -4 + +// The operation failed due to some generic reason. +#define EMSCRIPTEN_RESULT_FAILED -5 + +// Operation failed since no data is currently available. +#define EMSCRIPTEN_RESULT_NO_DATA -6 + +#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 emscripten_KeyboardEvent { + // 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; +} emscripten_KeyboardEvent; + +/* + * 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 emscripten_KeyboardEvent *keyEvent, void *userData)); +extern EMSCRIPTEN_RESULT emscripten_set_keydown_callback(const char *target, void *userData, int useCapture, int (*func)(int eventType, const emscripten_KeyboardEvent *keyEvent, void *userData)); +extern EMSCRIPTEN_RESULT emscripten_set_keyup_callback(const char *target, void *userData, int useCapture, int (*func)(int eventType, const emscripten_KeyboardEvent *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 emscripten_MouseEvent { + // 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; +} emscripten_MouseEvent; + +/* + * 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 emscripten_MouseEvent *mouseEvent, void *userData)); +extern EMSCRIPTEN_RESULT emscripten_set_mousedown_callback(const char *target, void *userData, int useCapture, int (*func)(int eventType, const emscripten_MouseEvent *mouseEvent, void *userData)); +extern EMSCRIPTEN_RESULT emscripten_set_mouseup_callback(const char *target, void *userData, int useCapture, int (*func)(int eventType, const emscripten_MouseEvent *mouseEvent, void *userData)); +extern EMSCRIPTEN_RESULT emscripten_set_dblclick_callback(const char *target, void *userData, int useCapture, int (*func)(int eventType, const emscripten_MouseEvent *mouseEvent, void *userData)); +extern EMSCRIPTEN_RESULT emscripten_set_mousemove_callback(const char *target, void *userData, int useCapture, int (*func)(int eventType, const emscripten_MouseEvent *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(emscripten_MouseEvent *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 emscripten_WheelEvent { + // Specifies general mouse information related to this event. + emscripten_MouseEvent 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; +} emscripten_WheelEvent; + +/* + * 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 emscripten_WheelEvent *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 emscripten_UiEvent { + // 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; +} emscripten_UiEvent; + +/* + * 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 emscripten_UiEvent *uiEvent, void *userData)); +extern EMSCRIPTEN_RESULT emscripten_set_scroll_callback(const char *target, void *userData, int useCapture, EM_BOOL (*func)(int eventType, const emscripten_UiEvent *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 emscripten_FocusEvent { + // 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]; +} emscripten_FocusEvent; + +/* + * 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 emscripten_FocusEvent *focusEvent, void *userData)); +extern EMSCRIPTEN_RESULT emscripten_set_focus_callback(const char *target, void *userData, int useCapture, EM_BOOL (*func)(int eventType, const emscripten_FocusEvent *focusEvent, void *userData)); +extern EMSCRIPTEN_RESULT emscripten_set_focusin_callback(const char *target, void *userData, int useCapture, EM_BOOL (*func)(int eventType, const emscripten_FocusEvent *focusEvent, void *userData)); +extern EMSCRIPTEN_RESULT emscripten_set_focusout_callback(const char *target, void *userData, int useCapture, EM_BOOL (*func)(int eventType, const emscripten_FocusEvent *focusEvent, void *userData)); + +/* + * The event structure passed in the deviceorientation event. + * http://dev.w3.org/geo/api/spec-source-orientation.html#deviceorientation + */ +typedef struct emscripten_DeviceOrientationEvent { + // 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; +} emscripten_DeviceOrientationEvent; + +/* + * 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 emscripten_DeviceOrientationEvent *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(emscripten_DeviceOrientationEvent *orientationState); + +/* + * The event structure passed in the devicemotion event. + * http://dev.w3.org/geo/api/spec-source-orientation.html#devicemotion + */ +typedef struct emscripten_DeviceMotionEvent { + // 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; +} emscripten_DeviceMotionEvent; + +/* + * 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 emscripten_DeviceMotionEvent *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(emscripten_DeviceMotionEvent *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 emscripten_OrientationChangeEvent { + // 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; +} emscripten_OrientationChangeEvent; + +/* + * 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 emscripten_OrientationChangeEvent *orientationChangeEvent, void *userData)); +/* + * Returns the current device orientation state. + */ +extern EMSCRIPTEN_RESULT emscripten_get_orientation_status(emscripten_OrientationChangeEvent *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 emscripten_FullscreenChangeEvent { + // 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]; +} emscripten_FullscreenChangeEvent; + +/* + * 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(void *userData, int useCapture, EM_BOOL (*func)(int eventType, const emscripten_FullscreenChangeEvent *fullscreenChangeEvent, void *userData)); +/* + * Returns the current page fullscreen state. + */ +extern EMSCRIPTEN_RESULT emscripten_get_fullscreen_status(emscripten_FullscreenChangeEvent *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 emscripten_PointerlockChangeEvent { + // 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]; +} emscripten_PointerlockChangeEvent; + +/* + * 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(void *userData, int useCapture, EM_BOOL (*func)(int eventType, const emscripten_PointerlockChangeEvent *pointerlockChangeEvent, void *userData)); +/* + * Returns the current page pointerlock state. + */ +extern EMSCRIPTEN_RESULT emscripten_get_pointerlock_status(emscripten_PointerlockChangeEvent *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 emscripten_VisibilityChangeEvent { + // 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; +} emscripten_VisibilityChangeEvent; + +/* + * 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 emscripten_VisibilityChangeEvent *visibilityChangeEvent, void *userData)); +/* + * Returns the current page visibility state. + */ +extern EMSCRIPTEN_RESULT emscripten_get_visibility_status(emscripten_VisibilityChangeEvent *visibilityStatus); + +/* + * Specifies the status of a single touch point on the page. + * See http://www.w3.org/TR/touch-events/#touch-interface + */ +typedef struct emscripten_TouchPoint +{ + // 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; +} emscripten_TouchPoint; + +/* + * Specifies the data of a single touch event. + * See http://www.w3.org/TR/touch-events/#touchevent-interface + */ +typedef struct emscripten_TouchEvent { + // 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. + emscripten_TouchPoint touches[32]; +} emscripten_TouchEvent; + +/* + * 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 emscripten_TouchEvent *touchEvent, void *userData)); +extern EMSCRIPTEN_RESULT emscripten_set_touchend_callback(const char *target, void *userData, int useCapture, EM_BOOL (*func)(int eventType, const emscripten_TouchEvent *touchEvent, void *userData)); +extern EMSCRIPTEN_RESULT emscripten_set_touchmove_callback(const char *target, void *userData, int useCapture, EM_BOOL (*func)(int eventType, const emscripten_TouchEvent *touchEvent, void *userData)); +extern EMSCRIPTEN_RESULT emscripten_set_touchcancel_callback(const char *target, void *userData, int useCapture, EM_BOOL (*func)(int eventType, const emscripten_TouchEvent *touchEvent, void *userData)); + +/* + * Represents the current snapshot state of a gamepad. + * http://www.w3.org/TR/gamepad/#gamepad-interface + */ +typedef struct emscripten_GamepadEvent { + // 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]; +} emscripten_GamepadEvent; + +/* + * 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 emscripten_GamepadEvent *gamepadEvent, void *userData)); +extern EMSCRIPTEN_RESULT emscripten_set_gamepaddisconnected_callback(void *userData, int useCapture, EM_BOOL (*func)(int eventType, const emscripten_GamepadEvent *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, emscripten_GamepadEvent *gamepadState); + +/* + * The event structure passed in the battery chargingchange and levelchange event. + * http://www.w3.org/TR/battery-status/#batterymanager-interface + */ +typedef struct emscripten_BatteryEvent { + double chargingTime; + double dischargingTime; + double level; + EM_BOOL charging; +} emscripten_BatteryEvent; + +/* + * 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 emscripten_BatteryEvent *batteryEvent, void *userData)); +extern EMSCRIPTEN_RESULT emscripten_set_batterylevelchange_callback(void *userData, EM_BOOL (*func)(int eventType, const emscripten_BatteryEvent *batteryEvent, void *userData)); +/* + * Returns the current battery status. + */ +extern EMSCRIPTEN_RESULT emscripten_get_battery_status(emscripten_BatteryEvent *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 diff --git a/tests/test_browser.py b/tests/test_browser.py index 9321f529..e7139f6e 100644 --- a/tests/test_browser.py +++ b/tests/test_browser.py @@ -1768,3 +1768,5 @@ Module["preRun"].push(function () { self.btest('doublestart.c', args=['--pre-js', 'pre.js', '-o', 'test.html'], expected='1') + def test_events(self): + self.btest(path_from_root('tests', 'test_events.c'), expected='0') diff --git a/tests/test_events.c b/tests/test_events.c new file mode 100644 index 00000000..23fa8704 --- /dev/null +++ b/tests/test_events.c @@ -0,0 +1,382 @@ +#include <stdio.h> +#include <emscripten.h> +#include <string.h> +#include <emscripten/events.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]; +} + +// 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 emscripten_KeyboardEvent *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")) { + emscripten_FullscreenChangeEvent fsce; + emscripten_get_fullscreen_status(&fsce); + if (!fsce.isFullscreen) { + emscripten_request_fullscreen(0, 1); + } else { + emscripten_exit_fullscreen(); + } + } + + if (eventType == EMSCRIPTEN_EVENT_KEYPRESS && !strcmp(e->key, "p")) { + emscripten_PointerlockChangeEvent plce; + emscripten_get_pointerlock_status(&plce); + if (!plce.isActive) { + emscripten_request_pointerlock(0, 1); + } else { + emscripten_exit_pointerlock(); + } + } + + return 0; +} + +EM_BOOL mouse_callback(int eventType, const emscripten_MouseEvent *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 emscripten_WheelEvent *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 emscripten_UiEvent *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 emscripten_FocusEvent *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 emscripten_DeviceOrientationEvent *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 emscripten_DeviceMotionEvent *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 emscripten_OrientationChangeEvent *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 emscripten_FullscreenChangeEvent *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 emscripten_PointerlockChangeEvent *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 emscripten_VisibilityChangeEvent *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 emscripten_TouchEvent *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 emscripten_TouchPoint *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 emscripten_GamepadEvent *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 emscripten_BatteryEvent *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; +} + +emscripten_GamepadEvent prevState[32]; +int prevNumGamepads = 0; + +void mainloop() +{ + int numGamepads = emscripten_get_num_gamepads(); + if (numGamepads != prevNumGamepads) + { + printf("Number of connected gamepads: %d\n", numGamepads); + prevNumGamepads = numGamepads; + } + + for(int i = 0; i < numGamepads && i < 32; ++i) + { + emscripten_GamepadEvent 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_set_keypress_callback(0, 0, 1, key_callback); + emscripten_set_keydown_callback(0, 0, 1, key_callback); + emscripten_set_keyup_callback(0, 0, 1, key_callback); + + emscripten_set_click_callback(0, 0, 1, mouse_callback); + emscripten_set_mousedown_callback(0, 0, 1, mouse_callback); + emscripten_set_mouseup_callback(0, 0, 1, mouse_callback); + emscripten_set_dblclick_callback(0, 0, 1, mouse_callback); + emscripten_set_mousemove_callback(0, 0, 1, mouse_callback); + + emscripten_set_wheel_callback(0, 0, 1, wheel_callback); + + emscripten_set_resize_callback(0, 0, 1, uievent_callback); + emscripten_set_scroll_callback(0, 0, 1, uievent_callback); + + emscripten_set_blur_callback(0, 0, 1, focusevent_callback); + emscripten_set_focus_callback(0, 0, 1, focusevent_callback); + emscripten_set_focusin_callback(0, 0, 1, focusevent_callback); + emscripten_set_focusout_callback(0, 0, 1, focusevent_callback); + + emscripten_set_deviceorientation_callback(0, 1, deviceorientation_callback); + emscripten_set_devicemotion_callback(0, 1, devicemotion_callback); + + emscripten_set_orientationchange_callback(0, 1, orientationchange_callback); + + // Test the polling of orientation. + emscripten_OrientationChangeEvent oce; + emscripten_get_orientation_status(&oce); + 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; + printf("Locking orientation to state %d..\n", newOrientation); + // Test locking of orientation. + int failed = emscripten_lock_orientation(newOrientation); + + if (failed) + printf("No support for orientation lock!\n"); + + emscripten_get_orientation_status(&oce); + printf("The current orientation is after locking:\n"); + orientationchange_callback(18, &oce, 0); + + printf("Unlocking orientation..\n"); + emscripten_unlock_orientation(); + + emscripten_FullscreenChangeEvent fsce; + emscripten_get_fullscreen_status(&fsce); + printf("The current fullscreen status is:\n"); + fullscreenchange_callback(EMSCRIPTEN_EVENT_FULLSCREENCHANGE, &fsce, 0); + + emscripten_set_fullscreenchange_callback(0, 1, 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. + failed = emscripten_request_fullscreen(0, 1); + if (failed != 0 && failed != 3) + printf("Fullscreen request failed! (%d)\n", failed); + emscripten_exit_fullscreen(); + + emscripten_PointerlockChangeEvent plce; + emscripten_get_pointerlock_status(&plce); + printf("The current pointerlock status is:\n"); + pointerlockchange_callback(EMSCRIPTEN_EVENT_POINTERLOCKCHANGE, &plce, 0); + + emscripten_set_pointerlockchange_callback(0, 1, 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. + failed = emscripten_request_pointerlock(0, 1); + if (failed != 0 && failed != 3) + printf("Pointer lock request failed! (%d)\n", failed); + emscripten_exit_pointerlock(); + + int vibratePattern[] = { + 150, 500, + 300, 500, + 450 + }; + emscripten_vibrate_pattern(vibratePattern, sizeof(vibratePattern)/sizeof(vibratePattern[0])); + + emscripten_VisibilityChangeEvent vce; + emscripten_get_visibility_status(&vce); + printf("Current visibility status:\n"); + visibilitychange_callback(EMSCRIPTEN_EVENT_VISIBILITYCHANGE, &vce, 0); + + emscripten_set_visibilitychange_callback(0, 1, visibilitychange_callback); + + emscripten_set_touchstart_callback(0, 0, 1, touch_callback); + emscripten_set_touchend_callback(0, 0, 1, touch_callback); + emscripten_set_touchmove_callback(0, 0, 1, touch_callback); + emscripten_set_touchcancel_callback(0, 0, 1, touch_callback); + + emscripten_set_gamepadconnected_callback(0, 1, gamepad_callback); + emscripten_set_gamepaddisconnected_callback(0, 1, gamepad_callback); + + emscripten_set_main_loop(mainloop, 10, 0); + + emscripten_set_beforeunload_callback(0, beforeunload_callback); + + emscripten_set_batterychargingchange_callback(0, battery_callback); + emscripten_set_batterylevelchange_callback(0, battery_callback); + + emscripten_BatteryEvent bs; + failed = emscripten_get_battery_status(&bs); + if (failed) { + printf("Browser can not provide Battery Status information!\n"); + } else { + printf("Current battery status:\n"); + battery_callback(EMSCRIPTEN_EVENT_BATTERYLEVELCHANGE, &bs, 0); + } + + emscripten_set_webglcontextlost_callback(0, 0, 1, webglcontext_callback); + emscripten_set_webglcontextrestored_callback(0, 0, 1, webglcontext_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; +} |