/**

* @license

* Copyright 2014 The Emscripten Authors

* SPDX-License-Identifier: MIT

*/

var LibraryJSEvents = {

$JSEvents: {

/* We do not depend on the exact initial values of falsey member fields - these fields can be populated on-demand

to save code size.

(but still documented here to keep track of what is supposed to be present)

// 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 we transition from fullscreen to windowed mode, we remember here the element that was just in fullscreen mode

// so that we can report information about that element in the event message.

previousFullscreenElement: null,

#if MIN_IE_VERSION != TARGET_NOT_SUPPORTED || MIN_SAFARI_VERSION <= 8 || MIN_EDGE_VERSION <= 12 || MIN_CHROME_VERSION <= 21 // https://caniuse.com/#search=movementX

// Remember the current mouse coordinates in case we need to emulate movementXY generation for browsers that don't support it.

// Some browsers (e.g. Safari 6.0.5) only give movementXY when Pointerlock is active.

previousScreenX: null,

previousScreenY: null,

#endif

// 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,

#if HTML5_SUPPORT_DEFERRING_USER_SENSITIVE_REQUESTS

// If we are in an event handler, specifies the event handler object from the eventHandlers array that is currently running.

currentEventHandler: null,

#endif

*/

// If positive, we are currently executing in a JS event handler.

// (this particular property must be initialized to zero, as we ++/-- it)

inEventHandler: 0,

removeAllEventListeners: function() {

for(var i = JSEvents.eventHandlers.length-1; i >= 0; --i) {

JSEvents._removeHandler(i);

}

JSEvents.eventHandlers = [];

#if HTML5_SUPPORT_DEFERRING_USER_SENSITIVE_REQUESTS

JSEvents.deferredCalls = [];

#endif

},

#if !MINIMAL_RUNTIME || EXIT_RUNTIME // In minimal runtime, there is no concept of the page running vs being closed, and hence __ATEXIT__ is not present

registerRemoveEventListeners: function() {

if (!JSEvents.removeEventListenersRegistered) {

__ATEXIT__.push(JSEvents.removeAllEventListeners);

JSEvents.removeEventListenersRegistered = true;

}

},

#endif

#if HTML5_SUPPORT_DEFERRING_USER_SENSITIVE_REQUESTS

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. Therefore 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(null, call.argsList);

}

},

#endif

// Stores objects representing each currently registered JS event handler.

eventHandlers: [],

#if MIN_IE_VERSION != TARGET_NOT_SUPPORTED

isInternetExplorer: function() { return navigator.userAgent.indexOf('MSIE') !== -1 || navigator.appVersion.indexOf('Trident/') > 0; },

#endif

// Removes all event handlers on the given DOM element of the given type. Pass in eventTypeString == undefined/null to remove all event handlers regardless of the type.

removeAllHandlersOnTarget: function(target, eventTypeString) {

for(var i = 0; i < JSEvents.eventHandlers.length; ++i) {

if (JSEvents.eventHandlers[i].target == target &&

(!eventTypeString || eventTypeString == JSEvents.eventHandlers[i].eventTypeString)) {

JSEvents._removeHandler(i--);

}

}

},

_removeHandler: function(i) {

var h = JSEvents.eventHandlers[i];

h.target.removeEventListener(h.eventTypeString, h.eventListenerFunc, h.useCapture);

JSEvents.eventHandlers.splice(i, 1);

},

registerOrRemoveHandler: function(eventHandler) {

var jsEventHandler = function jsEventHandler(event) {

#if HTML5_SUPPORT_DEFERRING_USER_SENSITIVE_REQUESTS

// Increment nesting count for the event handler.

++JSEvents.inEventHandler;

JSEvents.currentEventHandler = eventHandler;

// Process any old deferred calls the user has placed.

JSEvents.runDeferredCalls();

#endif

// Process the actual event, calls back to user C code handler.

eventHandler.handlerFunc(event);

#if HTML5_SUPPORT_DEFERRING_USER_SENSITIVE_REQUESTS

// 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;

#endif

};

if (eventHandler.callbackfunc) {

eventHandler.eventListenerFunc = jsEventHandler;

eventHandler.target.addEventListener(eventHandler.eventTypeString, jsEventHandler, eventHandler.useCapture);

JSEvents.eventHandlers.push(eventHandler);

#if !MINIMAL_RUNTIME // In minimal runtime, there is no concept of the page running vs being closed, and hence __ATEXIT__ is not present

JSEvents.registerRemoveEventListeners();

#endif

} 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--);

}

}

}

},

#if USE_PTHREADS

queueEventHandlerOnThread_iiii: function(targetThread, eventHandlerFunc, eventTypeId, eventData, userData) {

var stackTop = stackSave();

var varargs = stackAlloc(12);

{{{ makeSetValue('varargs', 0, 'eventTypeId', 'i32') }}};

{{{ makeSetValue('varargs', 4, 'eventData', 'i32') }}};

{{{ makeSetValue('varargs', 8, 'userData', 'i32') }}};

__emscripten_call_on_thread(0, targetThread, {{{ cDefine('EM_FUNC_SIG_IIII') }}}, eventHandlerFunc, eventData, varargs);

stackRestore(stackTop);

},

#endif

#if USE_PTHREADS

getTargetThreadForEventCallback: function(targetThread) {

switch(targetThread) {

case {{{ cDefine('EM_CALLBACK_THREAD_CONTEXT_MAIN_BROWSER_THREAD') }}}: return 0; // The event callback for the current event should be called on the main browser thread. (0 == don't proxy)

case {{{ cDefine('EM_CALLBACK_THREAD_CONTEXT_CALLING_THREAD') }}}: return PThread.currentProxiedOperationCallerThread; // The event callback for the current event should be backproxied to the thread that is registering the event.

default: return targetThread; // The event callback for the current event should be proxied to the given specific thread.

}

},

#endif

getNodeNameForTarget: function(target) {

if (!target) return '';

if (target == window) return '#window';

if (target == screen) return '#screen';

return (target && target.nodeName) ? target.nodeName : '';

},

fullscreenEnabled: function() {

return document.fullscreenEnabled

#if MIN_FIREFOX_VERSION <= 63

// Firefox 64 shipped unprefixed form of fullscreenEnabled (https://caniuse.com/#feat=mdn-api_document_fullscreenenabled)

|| document.mozFullScreenEnabled

#endif

#if MIN_SAFARI_VERSION != TARGET_NOT_SUPPORTED

// Safari 13.0.3 on macOS Catalina 10.15.1 still ships with prefixed webkitFullscreenEnabled.

// TODO: If Safari at some point ships with unprefixed version, update the version check above.

|| document.webkitFullscreenEnabled

#endif

#if MIN_IE_VERSION != TARGET_NOT_SUPPORTED

// Last IE 11 shipped prefixed msFullscreenEnabled

|| document.msFullscreenEnabled

#endif

;

},

},

_registerKeyEventCallback__deps: ['$JSEvents', '$findEventTarget'],

_registerKeyEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {

#if USE_PTHREADS

targetThread = JSEvents.getTargetThreadForEventCallback(targetThread);

#endif

if (!JSEvents.keyEvent) JSEvents.keyEvent = _malloc( {{{ C_STRUCTS.EmscriptenKeyboardEvent.__size__ }}} );

var keyEventHandlerFunc = function(e) {

#if ASSERTIONS

assert(e);

#endif

#if USE_PTHREADS

var keyEventData = targetThread ? _malloc( {{{ C_STRUCTS.EmscriptenKeyboardEvent.__size__ }}} ) : JSEvents.keyEvent; // This allocated block is passed as satellite data to the proxied function call, so the call frees up the data block when done.

#else

var keyEventData = JSEvents.keyEvent;

#endif

var idx = keyEventData >> 2;

HEAP32[idx + {{{ C_STRUCTS.EmscriptenKeyboardEvent.location / 4}}}] = e.location;

HEAP32[idx + {{{ C_STRUCTS.EmscriptenKeyboardEvent.ctrlKey / 4}}}] = e.ctrlKey;

HEAP32[idx + {{{ C_STRUCTS.EmscriptenKeyboardEvent.shiftKey / 4}}}] = e.shiftKey;

HEAP32[idx + {{{ C_STRUCTS.EmscriptenKeyboardEvent.altKey / 4}}}] = e.altKey;

HEAP32[idx + {{{ C_STRUCTS.EmscriptenKeyboardEvent.metaKey / 4}}}] = e.metaKey;

HEAP32[idx + {{{ C_STRUCTS.EmscriptenKeyboardEvent.repeat / 4}}}] = e.repeat;

HEAP32[idx + {{{ C_STRUCTS.EmscriptenKeyboardEvent.charCode / 4}}}] = e.charCode;

HEAP32[idx + {{{ C_STRUCTS.EmscriptenKeyboardEvent.keyCode / 4}}}] = e.keyCode;

HEAP32[idx + {{{ C_STRUCTS.EmscriptenKeyboardEvent.which / 4}}}] = e.which;

stringToUTF8(e.key || '', keyEventData + {{{ C_STRUCTS.EmscriptenKeyboardEvent.key }}}, {{{ cDefine('EM_HTML5_SHORT_STRING_LEN_BYTES') }}});

stringToUTF8(e.code || '', keyEventData + {{{ C_STRUCTS.EmscriptenKeyboardEvent.code }}}, {{{ cDefine('EM_HTML5_SHORT_STRING_LEN_BYTES') }}});

stringToUTF8(e.char || '', keyEventData + {{{ C_STRUCTS.EmscriptenKeyboardEvent.charValue }}}, {{{ cDefine('EM_HTML5_SHORT_STRING_LEN_BYTES') }}});

stringToUTF8(e.locale || '', keyEventData + {{{ C_STRUCTS.EmscriptenKeyboardEvent.locale }}}, {{{ cDefine('EM_HTML5_SHORT_STRING_LEN_BYTES') }}});

#if USE_PTHREADS

if (targetThread) JSEvents.queueEventHandlerOnThread_iiii(targetThread, callbackfunc, eventTypeId, keyEventData, userData);

else

#endif

if ({{{ makeDynCall('iiii', 'callbackfunc') }}}(eventTypeId, keyEventData, userData)) e.preventDefault();

};

var eventHandler = {

target: findEventTarget(target),

#if HTML5_SUPPORT_DEFERRING_USER_SENSITIVE_REQUESTS

#if MIN_IE_VERSION != TARGET_NOT_SUPPORTED

allowsDeferredCalls: JSEvents.isInternetExplorer() ? false : true, // MSIE doesn't allow fullscreen and pointerlock requests from key handlers, others do.

#else

allowsDeferredCalls: true,

#endif

#endif

eventTypeString: eventTypeString,

callbackfunc: callbackfunc,

handlerFunc: keyEventHandlerFunc,

useCapture: useCapture

};

JSEvents.registerOrRemoveHandler(eventHandler);

},

// In DOM capturing and bubbling sequence, there are two special elements at the top of the event chain that can be of interest

// to register many events to: document and window. These cannot be addressed by using document.querySelector(), so

// a special mechanism to address them is needed. (For any other special object, such as screen.orientation, no general access

// scheme should be needed, but the object-specific event callback registration functions should handle them individually).

//

// Users can also add more special event targets, basically by just doing something like

// specialHTMLTargets["!canvas"] = Module.canvas;

// (that will let !canvas map to the canvas held in Module.canvas).

#if ENVIRONMENT_MAY_BE_WORKER || ENVIRONMENT_MAY_BE_NODE || ENVIRONMENT_MAY_BE_SHELL || USE_PTHREADS

$specialHTMLTargets: "[0, typeof document !== 'undefined' ? document : 0, typeof window !== 'undefined' ? window : 0]",

#else

$specialHTMLTargets: "[0, document, window]",

#endif

#if DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR

$maybeCStringToJsString: function(cString) {

// "cString > 2" checks if the input is a number, and isn't of the special

// values we accept here, EMSCRIPTEN_EVENT_TARGET_* (which map to 0, 1, 2).

// In other words, if cString > 2 then it's a pointer to a valid place in

// memory, and points to a C string.

return cString > 2 ? UTF8ToString(cString) : cString;

},

$findEventTarget__deps: ['$maybeCStringToJsString', '$specialHTMLTargets'],

$findEventTarget: function(target) {

target = maybeCStringToJsString(target);

#if ENVIRONMENT_MAY_BE_WORKER || ENVIRONMENT_MAY_BE_NODE

var domElement = specialHTMLTargets[target] || (typeof document !== 'undefined' ? document.querySelector(target) : undefined);

#else

var domElement = specialHTMLTargets[target] || document.querySelector(target);

#endif

return domElement;

},

#if OFFSCREENCANVAS_SUPPORT

$findCanvasEventTarget__deps: ['$GL', '$maybeCStringToJsString'],

$findCanvasEventTarget: function(target) {

target = maybeCStringToJsString(target);

// When compiling with OffscreenCanvas support and looking up a canvas to target,

// we first look up if the target Canvas has been transferred to OffscreenCanvas use.

// These transfers are represented/tracked by GL.offscreenCanvases object, which contain

// the OffscreenCanvas element for each regular Canvas element that has been transferred.

// Note that each pthread/worker have their own set of GL.offscreenCanvases. That is,

// when an OffscreenCanvas is transferred from a pthread/main thread to another pthread,

// it will move in the GL.offscreenCanvases array between threads. Hence GL.offscreenCanvases

// represents the set of OffscreenCanvases owned by the current calling thread.

// First check out the list of OffscreenCanvases by CSS selector ID ('#myCanvasID')

return GL.offscreenCanvases[target.substr(1)] // Remove '#' prefix

// If not found, if one is querying by using DOM tag name selector 'canvas', grab the first

// OffscreenCanvas that we can find.

|| (target == 'canvas' && Object.keys(GL.offscreenCanvases)[0])

// If that is not found either, query via the regular DOM selector.

#if USE_PTHREADS

|| (typeof document !== 'undefined' && document.querySelector(target));

#else

|| document.querySelector(target);

#endif

},

#else

$findCanvasEventTarget__deps: ['$findEventTarget'],

$findCanvasEventTarget: function(target) { return findEventTarget(target); },

#endif

#else

// Find a DOM element with the given ID.

$findEventTarget__deps: ['$specialHTMLTargets'],

$findEventTarget: function(target) {

#if ASSERTIONS

warnOnce('Rules for selecting event targets in HTML5 API are changing: instead of using document.getElementById() that only can refer to elements by their DOM ID, new event target selection mechanism uses the more flexible function document.querySelector() that can look up element names, classes, and complex CSS selectors. Build with -s DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR=1 to change to the new lookup rules. See https://github.com/emscripten-core/emscripten/pull/7977 for more details.');

#endif

try {

// The sensible "default" 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.

if (!target) return window;

if (typeof target === "number") target = specialHTMLTargets[target] || UTF8ToString(target);

if (target === '#window') return window;

else if (target === '#document') return document;

else if (target === '#screen') return screen;

else if (target === '#canvas') return Module['canvas'];

return (typeof target === 'string') ? document.getElementById(target) : target;

} catch(e) {

// In Web Workers, some objects above, such as '#document' do not exist. Gracefully

// return null for them.

return null;

}

},

// Like findEventTarget, but looks for OffscreenCanvas elements first

$findCanvasEventTarget__deps: ['$findEventTarget'],

$findCanvasEventTarget: function(target) {

if (typeof target === 'number') target = UTF8ToString(target);

if (!target || target === '#canvas') {

if (typeof GL !== 'undefined' && GL.offscreenCanvases['canvas']) return GL.offscreenCanvases['canvas']; // TODO: Remove this line, target '#canvas' should refer only to Module['canvas'], not to GL.offscreenCanvases['canvas'] - but need stricter tests to be able to remove this line.

return Module['canvas'];

}

if (typeof GL !== 'undefined' && GL.offscreenCanvases[target]) return GL.offscreenCanvases[target];

return findEventTarget(target);

},

#endif

emscripten_set_keypress_callback_on_thread__proxy: 'sync',

emscripten_set_keypress_callback_on_thread__sig: 'iiiiii',

emscripten_set_keypress_callback_on_thread__deps: ['_registerKeyEventCallback'],

emscripten_set_keypress_callback_on_thread: function(target, userData, useCapture, callbackfunc, targetThread) {

__registerKeyEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_KEYPRESS') }}}, "keypress", targetThread);

return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};

},

emscripten_set_keydown_callback_on_thread__proxy: 'sync',

emscripten_set_keydown_callback_on_thread__sig: 'iiiiii',

emscripten_set_keydown_callback_on_thread__deps: ['_registerKeyEventCallback'],

emscripten_set_keydown_callback_on_thread: function(target, userData, useCapture, callbackfunc, targetThread) {

__registerKeyEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_KEYDOWN') }}}, "keydown", targetThread);

return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};

},

emscripten_set_keyup_callback_on_thread__proxy: 'sync',

emscripten_set_keyup_callback_on_thread__sig: 'iiiiii',

emscripten_set_keyup_callback_on_thread__deps: ['_registerKeyEventCallback'],

emscripten_set_keyup_callback_on_thread: function(target, userData, useCapture, callbackfunc, targetThread) {

__registerKeyEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_KEYUP') }}}, "keyup", targetThread);

return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};

},

// Outline access to function .getBoundingClientRect() since it is a long string. Closure compiler does not outline access to it by itself, but it can inline access if

// there is only one caller to this function.

_getBoundingClientRect__deps: ['$specialHTMLTargets'],

_getBoundingClientRect: function(e) {

return specialHTMLTargets.indexOf(e) < 0 ? e.getBoundingClientRect() : {'left':0,'top':0};

},

// Copies mouse event data from the given JS mouse event 'e' to the specified Emscripten mouse event structure in the HEAP.

// eventStruct: the structure to populate.

// e: The JS mouse event to read data from.

// target: Specifies a target DOM element that will be used as the reference to populate targetX and targetY parameters.

_fillMouseEventData__deps: ['$JSEvents', '_getBoundingClientRect', '$specialHTMLTargets'],

_fillMouseEventData: function(eventStruct, e, target) {

#if ASSERTIONS

assert(eventStruct % 4 == 0);

#endif

var idx = eventStruct >> 2;

HEAP32[idx + {{{ C_STRUCTS.EmscriptenMouseEvent.screenX / 4 }}}] = e.screenX;

HEAP32[idx + {{{ C_STRUCTS.EmscriptenMouseEvent.screenY / 4 }}}] = e.screenY;

HEAP32[idx + {{{ C_STRUCTS.EmscriptenMouseEvent.clientX / 4 }}}] = e.clientX;

HEAP32[idx + {{{ C_STRUCTS.EmscriptenMouseEvent.clientY / 4 }}}] = e.clientY;

HEAP32[idx + {{{ C_STRUCTS.EmscriptenMouseEvent.ctrlKey / 4 }}}] = e.ctrlKey;

HEAP32[idx + {{{ C_STRUCTS.EmscriptenMouseEvent.shiftKey / 4 }}}] = e.shiftKey;

HEAP32[idx + {{{ C_STRUCTS.EmscriptenMouseEvent.altKey / 4 }}}] = e.altKey;

HEAP32[idx + {{{ C_STRUCTS.EmscriptenMouseEvent.metaKey / 4 }}}] = e.metaKey;

HEAP16[idx*2 + {{{ C_STRUCTS.EmscriptenMouseEvent.button / 2 }}}] = e.button;

HEAP16[idx*2 + {{{ C_STRUCTS.EmscriptenMouseEvent.buttons / 2 }}}] = e.buttons;

HEAP32[idx + {{{ C_STRUCTS.EmscriptenMouseEvent.movementX / 4 }}}] = e["movementX"]

#if MIN_FIREFOX_VERSION <= 40

// https://caniuse.com/#feat=mdn-api_mouseevent_movementx

|| e["mozMovementX"]

#endif

#if MIN_CHROME_VERSION <= 36 // || MIN_ANDROID_BROWSER_VERSION <= 4.4.4

|| e["webkitMovementX"]

#endif

#if MIN_IE_VERSION != TARGET_NOT_SUPPORTED || MIN_SAFARI_VERSION <= 80000 || MIN_EDGE_VERSION <= 12 || MIN_CHROME_VERSION <= 21 // https://caniuse.com/#search=movementX

|| (e.screenX-JSEvents.previousScreenX)

#endif

;

HEAP32[idx + {{{ C_STRUCTS.EmscriptenMouseEvent.movementY / 4 }}}] = e["movementY"]

#if MIN_FIREFOX_VERSION <= 40

|| e["mozMovementY"]

#endif

#if MIN_CHROME_VERSION <= 36 // || MIN_ANDROID_BROWSER_VERSION <= 4.4.4

|| e["webkitMovementY"]

#endif

#if MIN_IE_VERSION != TARGET_NOT_SUPPORTED || MIN_SAFARI_VERSION <= 80000 || MIN_EDGE_VERSION <= 12 || MIN_CHROME_VERSION <= 21 // https://caniuse.com/#search=movementX

|| (e.screenY-JSEvents.previousScreenY)

#endif

;

#if !DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR

if (Module['canvas']) {

var rect = __getBoundingClientRect(Module['canvas']);

HEAP32[idx + {{{ C_STRUCTS.EmscriptenMouseEvent.canvasX / 4 }}}] = e.clientX - rect.left;

HEAP32[idx + {{{ C_STRUCTS.EmscriptenMouseEvent.canvasY / 4 }}}] = e.clientY - rect.top;

} else { // Canvas is not initialized, return 0.

HEAP32[idx + {{{ C_STRUCTS.EmscriptenMouseEvent.canvasX / 4 }}}] = 0;

HEAP32[idx + {{{ C_STRUCTS.EmscriptenMouseEvent.canvasY / 4 }}}] = 0;

}

#endif

var rect = __getBoundingClientRect(target);

HEAP32[idx + {{{ C_STRUCTS.EmscriptenMouseEvent.targetX / 4 }}}] = e.clientX - rect.left;

HEAP32[idx + {{{ C_STRUCTS.EmscriptenMouseEvent.targetY / 4 }}}] = e.clientY - rect.top;

#if MIN_IE_VERSION != TARGET_NOT_SUPPORTED || MIN_SAFARI_VERSION <= 80000 || MIN_EDGE_VERSION <= 12 || MIN_CHROME_VERSION <= 21 // https://caniuse.com/#search=movementX

#if MIN_CHROME_VERSION <= 76

// wheel and mousewheel events contain wrong screenX/screenY on chrome/opera <= 76,

// so there we should not record previous screen coordinates on wheel events.

// https://bugs.chromium.org/p/chromium/issues/detail?id=699956

// https://github.com/emscripten-core/emscripten/pull/4997

if (e.type !== 'wheel') {

#endif

JSEvents.previousScreenX = e.screenX;

JSEvents.previousScreenY = e.screenY;

#if MIN_CHROME_VERSION <= 76

}

#endif

#endif

},

_registerMouseEventCallback__deps: ['$JSEvents', '_fillMouseEventData', '$findEventTarget'],

_registerMouseEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {

#if USE_PTHREADS

targetThread = JSEvents.getTargetThreadForEventCallback(targetThread);

#endif

if (!JSEvents.mouseEvent) JSEvents.mouseEvent = _malloc( {{{ C_STRUCTS.EmscriptenMouseEvent.__size__ }}} );

target = findEventTarget(target);

var mouseEventHandlerFunc = function(ev) {

var e = ev || event;

// TODO: Make this access thread safe, or this could update live while app is reading it.

__fillMouseEventData(JSEvents.mouseEvent, e, target);

#if USE_PTHREADS

if (targetThread) {

var mouseEventData = _malloc( {{{ C_STRUCTS.EmscriptenMouseEvent.__size__ }}} ); // This allocated block is passed as satellite data to the proxied function call, so the call frees up the data block when done.

__fillMouseEventData(mouseEventData, e, target);

JSEvents.queueEventHandlerOnThread_iiii(targetThread, callbackfunc, eventTypeId, mouseEventData, userData);

} else

#endif

if ({{{ makeDynCall('iiii', 'callbackfunc') }}}(eventTypeId, JSEvents.mouseEvent, userData)) e.preventDefault();

};

var eventHandler = {

target: target,

#if HTML5_SUPPORT_DEFERRING_USER_SENSITIVE_REQUESTS

allowsDeferredCalls: eventTypeString != 'mousemove' && eventTypeString != 'mouseenter' && eventTypeString != 'mouseleave', // Mouse move events do not allow fullscreen/pointer lock requests to be handled in them!

#endif

eventTypeString: eventTypeString,

callbackfunc: callbackfunc,

handlerFunc: mouseEventHandlerFunc,

useCapture: useCapture

};

#if MIN_IE_VERSION != TARGET_NOT_SUPPORTED && HTML5_SUPPORT_DEFERRING_USER_SENSITIVE_REQUESTS

// In IE, mousedown events don't either allow deferred calls to be run!

if (JSEvents.isInternetExplorer() && eventTypeString == 'mousedown') eventHandler.allowsDeferredCalls = false;

#endif

JSEvents.registerOrRemoveHandler(eventHandler);

},

emscripten_set_click_callback_on_thread__proxy: 'sync',

emscripten_set_click_callback_on_thread__sig: 'iiiiii',

emscripten_set_click_callback_on_thread__deps: ['_registerMouseEventCallback'],

emscripten_set_click_callback_on_thread: function(target, userData, useCapture, callbackfunc, targetThread) {

__registerMouseEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_CLICK') }}}, "click", targetThread);

return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};

},

emscripten_set_mousedown_callback_on_thread__proxy: 'sync',

emscripten_set_mousedown_callback_on_thread__sig: 'iiiiii',

emscripten_set_mousedown_callback_on_thread__deps: ['_registerMouseEventCallback'],

emscripten_set_mousedown_callback_on_thread: function(target, userData, useCapture, callbackfunc, targetThread) {

__registerMouseEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_MOUSEDOWN') }}}, "mousedown", targetThread);

return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};

},

emscripten_set_mouseup_callback_on_thread__proxy: 'sync',

emscripten_set_mouseup_callback_on_thread__sig: 'iiiiii',

emscripten_set_mouseup_callback_on_thread__deps: ['_registerMouseEventCallback'],

emscripten_set_mouseup_callback_on_thread: function(target, userData, useCapture, callbackfunc, targetThread) {

__registerMouseEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_MOUSEUP') }}}, "mouseup", targetThread);

return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};

},

emscripten_set_dblclick_callback_on_thread__proxy: 'sync',

emscripten_set_dblclick_callback_on_thread__sig: 'iiiiii',

emscripten_set_dblclick_callback_on_thread__deps: ['_registerMouseEventCallback'],

emscripten_set_dblclick_callback_on_thread: function(target, userData, useCapture, callbackfunc, targetThread) {

__registerMouseEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_DBLCLICK') }}}, "dblclick", targetThread);

return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};

},

emscripten_set_mousemove_callback_on_thread__proxy: 'sync',

emscripten_set_mousemove_callback_on_thread__sig: 'iiiiii',

emscripten_set_mousemove_callback_on_thread__deps: ['_registerMouseEventCallback'],

emscripten_set_mousemove_callback_on_thread: function(target, userData, useCapture, callbackfunc, targetThread) {

__registerMouseEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_MOUSEMOVE') }}}, "mousemove", targetThread);

return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};

},

emscripten_set_mouseenter_callback_on_thread__proxy: 'sync',

emscripten_set_mouseenter_callback_on_thread__sig: 'iiiiii',

emscripten_set_mouseenter_callback_on_thread__deps: ['_registerMouseEventCallback'],

emscripten_set_mouseenter_callback_on_thread: function(target, userData, useCapture, callbackfunc, targetThread) {

__registerMouseEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_MOUSEENTER') }}}, "mouseenter", targetThread);

return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};

},

emscripten_set_mouseleave_callback_on_thread__proxy: 'sync',

emscripten_set_mouseleave_callback_on_thread__sig: 'iiiiii',

emscripten_set_mouseleave_callback_on_thread__deps: ['_registerMouseEventCallback'],

emscripten_set_mouseleave_callback_on_thread: function(target, userData, useCapture, callbackfunc, targetThread) {

__registerMouseEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_MOUSELEAVE') }}}, "mouseleave", targetThread);

return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};

},

emscripten_set_mouseover_callback_on_thread__proxy: 'sync',

emscripten_set_mouseover_callback_on_thread__sig: 'iiiiii',

emscripten_set_mouseover_callback_on_thread__deps: ['_registerMouseEventCallback'],

emscripten_set_mouseover_callback_on_thread: function(target, userData, useCapture, callbackfunc, targetThread) {

__registerMouseEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_MOUSEOVER') }}}, "mouseover", targetThread);

return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};

},

emscripten_set_mouseout_callback_on_thread__proxy: 'sync',

emscripten_set_mouseout_callback_on_thread__sig: 'iiiiii',

emscripten_set_mouseout_callback_on_thread__deps: ['_registerMouseEventCallback'],

emscripten_set_mouseout_callback_on_thread: function(target, userData, useCapture, callbackfunc, targetThread) {

__registerMouseEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_MOUSEOUT') }}}, "mouseout", targetThread);

return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};

},

emscripten_get_mouse_status__proxy: 'sync',

emscripten_get_mouse_status__sig: 'ii',

emscripten_get_mouse_status__deps: ['$JSEvents'],

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.

HEAP8.set(HEAP8.subarray(JSEvents.mouseEvent, JSEvents.mouseEvent + {{{ C_STRUCTS.EmscriptenMouseEvent.__size__ }}}), mouseState);

return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};

},

_registerWheelEventCallback__deps: ['$JSEvents', '_fillMouseEventData', '$findEventTarget'],

_registerWheelEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {

#if USE_PTHREADS

targetThread = JSEvents.getTargetThreadForEventCallback(targetThread);

#endif

if (!JSEvents.wheelEvent) JSEvents.wheelEvent = _malloc( {{{ C_STRUCTS.EmscriptenWheelEvent.__size__ }}} );

// The DOM Level 3 events spec event 'wheel'

var wheelHandlerFunc = function(ev) {

var e = ev || event;

#if USE_PTHREADS

var wheelEvent = targetThread ? _malloc( {{{ C_STRUCTS.EmscriptenWheelEvent.__size__ }}} ) : JSEvents.wheelEvent; // This allocated block is passed as satellite data to the proxied function call, so the call frees up the data block when done.

#else

var wheelEvent = JSEvents.wheelEvent;

#endif

__fillMouseEventData(wheelEvent, e, target);

{{{ makeSetValue('wheelEvent', C_STRUCTS.EmscriptenWheelEvent.deltaX, 'e["deltaX"]', 'double') }}};

{{{ makeSetValue('wheelEvent', C_STRUCTS.EmscriptenWheelEvent.deltaY, 'e["deltaY"]', 'double') }}};

{{{ makeSetValue('wheelEvent', C_STRUCTS.EmscriptenWheelEvent.deltaZ, 'e["deltaZ"]', 'double') }}};

{{{ makeSetValue('wheelEvent', C_STRUCTS.EmscriptenWheelEvent.deltaMode, 'e["deltaMode"]', 'i32') }}};

#if USE_PTHREADS

if (targetThread) JSEvents.queueEventHandlerOnThread_iiii(targetThread, callbackfunc, eventTypeId, wheelEvent, userData);

else

#endif

if ({{{ makeDynCall('iiii', 'callbackfunc') }}}(eventTypeId, wheelEvent, userData)) e.preventDefault();

};

#if MIN_IE_VERSION <= 8 || MIN_SAFARI_VERSION < 60100 // Browsers that do not support https://caniuse.com/#feat=mdn-api_wheelevent

// The 'mousewheel' event as implemented in Safari 6.0.5

var mouseWheelHandlerFunc = function(ev) {

var e = ev || event;

__fillMouseEventData(JSEvents.wheelEvent, e, target);

{{{ makeSetValue('JSEvents.wheelEvent', C_STRUCTS.EmscriptenWheelEvent.deltaX, 'e["wheelDeltaX"] || 0', 'double') }}};

/* 1. Invert to unify direction with the DOM Level 3 wheel event. 2. MSIE does not provide wheelDeltaY, so wheelDelta is used as a fallback. */

var wheelDeltaY = -(e["wheelDeltaY"] || e["wheelDelta"])

{{{ makeSetValue('JSEvents.wheelEvent', C_STRUCTS.EmscriptenWheelEvent.deltaY, 'wheelDeltaY', 'double') }}};

{{{ makeSetValue('JSEvents.wheelEvent', C_STRUCTS.EmscriptenWheelEvent.deltaZ, '0 /* Not available */', 'double') }}};

{{{ makeSetValue('JSEvents.wheelEvent', C_STRUCTS.EmscriptenWheelEvent.deltaMode, '0 /* DOM_DELTA_PIXEL */', 'i32') }}};

var shouldCancel = {{{ makeDynCall('iiii', 'callbackfunc') }}}( eventTypeId, JSEvents.wheelEvent, userData);

if (shouldCancel) {

e.preventDefault();

}

};

#endif

var eventHandler = {

target: target,

#if HTML5_SUPPORT_DEFERRING_USER_SENSITIVE_REQUESTS

allowsDeferredCalls: true,

#endif

eventTypeString: eventTypeString,

callbackfunc: callbackfunc,

#if MIN_IE_VERSION <= 8 || MIN_SAFARI_VERSION < 60100 // Browsers that do not support https://caniuse.com/#feat=mdn-api_wheelevent

handlerFunc: (eventTypeString == 'wheel') ? wheelHandlerFunc : mouseWheelHandlerFunc,

#else

handlerFunc: wheelHandlerFunc,

#endif

useCapture: useCapture

};

JSEvents.registerOrRemoveHandler(eventHandler);

},

emscripten_set_wheel_callback_on_thread__proxy: 'sync',

emscripten_set_wheel_callback_on_thread__sig: 'iiiiii',

emscripten_set_wheel_callback_on_thread__deps: ['$JSEvents', '_registerWheelEventCallback', '$findEventTarget'],

emscripten_set_wheel_callback_on_thread: function(target, userData, useCapture, callbackfunc, targetThread) {

target = findEventTarget(target);

if (typeof target.onwheel !== 'undefined') {

__registerWheelEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_WHEEL') }}}, "wheel", targetThread);

return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};

#if MIN_IE_VERSION <= 8 || MIN_SAFARI_VERSION < 60100 // Browsers that do not support https://caniuse.com/#feat=mdn-api_wheelevent

} else if (typeof target.onmousewheel !== 'undefined') {

__registerWheelEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_WHEEL') }}}, "mousewheel", targetThread);

return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};

#endif

} else {

return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};

}

},

_registerUiEventCallback__deps: ['$JSEvents', '$findEventTarget'],

_registerUiEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {

#if USE_PTHREADS

targetThread = JSEvents.getTargetThreadForEventCallback(targetThread);

#endif

if (!JSEvents.uiEvent) JSEvents.uiEvent = _malloc( {{{ C_STRUCTS.EmscriptenUiEvent.__size__ }}} );

#if DISABLE_DEPRECATED_FIND_EVENT_TARGET_BEHAVIOR

target = findEventTarget(target);

#else

if (eventTypeString == "scroll" && !target) {

target = document; // By default read scroll events on document rather than window.

} else {

target = findEventTarget(target);

}

#else

#endif

var uiEventHandlerFunc = function(ev) {

var e = ev || 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 b = document.body; // Take document.body to a variable, Closure compiler does not outline access to it on its own.

if (!b) {

// During a page unload 'body' can be null, with "Cannot read property 'clientWidth' of null" being thrown

return;

}

#if USE_PTHREADS

var uiEvent = targetThread ? _malloc( {{{ C_STRUCTS.EmscriptenUiEvent.__size__ }}} ) : JSEvents.uiEvent;

#else

var uiEvent = JSEvents.uiEvent;

#endif

{{{ makeSetValue('uiEvent', C_STRUCTS.EmscriptenUiEvent.detail, 'e.detail', 'i32') }}};

{{{ makeSetValue('uiEvent', C_STRUCTS.EmscriptenUiEvent.documentBodyClientWidth, 'b.clientWidth', 'i32') }}};

{{{ makeSetValue('uiEvent', C_STRUCTS.EmscriptenUiEvent.documentBodyClientHeight, 'b.clientHeight', 'i32') }}};

{{{ makeSetValue('uiEvent', C_STRUCTS.EmscriptenUiEvent.windowInnerWidth, 'innerWidth', 'i32') }}};

{{{ makeSetValue('uiEvent', C_STRUCTS.EmscriptenUiEvent.windowInnerHeight, 'innerHeight', 'i32') }}};

{{{ makeSetValue('uiEvent', C_STRUCTS.EmscriptenUiEvent.windowOuterWidth, 'outerWidth', 'i32') }}};

{{{ makeSetValue('uiEvent', C_STRUCTS.EmscriptenUiEvent.windowOuterHeight, 'outerHeight', 'i32') }}};

{{{ makeSetValue('uiEvent', C_STRUCTS.EmscriptenUiEvent.scrollTop, 'pageXOffset', 'i32') }}};

{{{ makeSetValue('uiEvent', C_STRUCTS.EmscriptenUiEvent.scrollLeft, 'pageYOffset', 'i32') }}};

#if USE_PTHREADS

if (targetThread) JSEvents.queueEventHandlerOnThread_iiii(targetThread, callbackfunc, eventTypeId, uiEvent, userData);

else

#endif

if ({{{ makeDynCall('iiii', 'callbackfunc') }}}(eventTypeId, uiEvent, userData)) e.preventDefault();

};

var eventHandler = {

target: target,

eventTypeString: eventTypeString,

callbackfunc: callbackfunc,

handlerFunc: uiEventHandlerFunc,

useCapture: useCapture

};

JSEvents.registerOrRemoveHandler(eventHandler);

},

emscripten_set_resize_callback_on_thread__proxy: 'sync',

emscripten_set_resize_callback_on_thread__sig: 'iiiiii',

emscripten_set_resize_callback_on_thread__deps: ['_registerUiEventCallback'],

emscripten_set_resize_callback_on_thread: function(target, userData, useCapture, callbackfunc, targetThread) {

__registerUiEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_RESIZE') }}}, "resize", targetThread);

return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};

},

emscripten_set_scroll_callback_on_thread__proxy: 'sync',

emscripten_set_scroll_callback_on_thread__sig: 'iiiiii',

emscripten_set_scroll_callback_on_thread__deps: ['_registerUiEventCallback'],

emscripten_set_scroll_callback_on_thread: function(target, userData, useCapture, callbackfunc, targetThread) {

__registerUiEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_SCROLL') }}}, "scroll", targetThread);

return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};

},

_registerFocusEventCallback__deps: ['$JSEvents', '$findEventTarget'],

_registerFocusEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {

#if USE_PTHREADS

targetThread = JSEvents.getTargetThreadForEventCallback(targetThread);

#endif

if (!JSEvents.focusEvent) JSEvents.focusEvent = _malloc( {{{ C_STRUCTS.EmscriptenFocusEvent.__size__ }}} );

var focusEventHandlerFunc = function(ev) {

var e = ev || event;

var nodeName = JSEvents.getNodeNameForTarget(e.target);

var id = e.target.id ? e.target.id : '';

#if USE_PTHREADS

var focusEvent = targetThread ? _malloc( {{{ C_STRUCTS.EmscriptenFocusEvent.__size__ }}} ) : JSEvents.focusEvent;

#else

var focusEvent = JSEvents.focusEvent;

#endif

stringToUTF8(nodeName, focusEvent + {{{ C_STRUCTS.EmscriptenFocusEvent.nodeName }}}, {{{ cDefine('EM_HTML5_LONG_STRING_LEN_BYTES') }}});

stringToUTF8(id, focusEvent + {{{ C_STRUCTS.EmscriptenFocusEvent.id }}}, {{{ cDefine('EM_HTML5_LONG_STRING_LEN_BYTES') }}});

#if USE_PTHREADS

if (targetThread) JSEvents.queueEventHandlerOnThread_iiii(targetThread, callbackfunc, eventTypeId, focusEvent, userData);

else

#endif

if ({{{ makeDynCall('iiii', 'callbackfunc') }}}(eventTypeId, focusEvent, userData)) e.preventDefault();

};

var eventHandler = {

target: findEventTarget(target),

eventTypeString: eventTypeString,

callbackfunc: callbackfunc,

handlerFunc: focusEventHandlerFunc,

useCapture: useCapture

};

JSEvents.registerOrRemoveHandler(eventHandler);

},

emscripten_set_blur_callback_on_thread__proxy: 'sync',

emscripten_set_blur_callback_on_thread__sig: 'iiiiii',

emscripten_set_blur_callback_on_thread__deps: ['_registerFocusEventCallback'],

emscripten_set_blur_callback_on_thread: function(target, userData, useCapture, callbackfunc, targetThread) {

__registerFocusEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_BLUR') }}}, "blur", targetThread);

return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};

},

emscripten_set_focus_callback_on_thread__proxy: 'sync',

emscripten_set_focus_callback_on_thread__sig: 'iiiiii',

emscripten_set_focus_callback_on_thread__deps: ['_registerFocusEventCallback'],

emscripten_set_focus_callback_on_thread: function(target, userData, useCapture, callbackfunc, targetThread) {

__registerFocusEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_FOCUS') }}}, "focus", targetThread);

return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};

},

emscripten_set_focusin_callback_on_thread__proxy: 'sync',

emscripten_set_focusin_callback_on_thread__sig: 'iiiiii',

emscripten_set_focusin_callback_on_thread__deps: ['_registerFocusEventCallback'],

emscripten_set_focusin_callback_on_thread: function(target, userData, useCapture, callbackfunc, targetThread) {

__registerFocusEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_FOCUSIN') }}}, "focusin", targetThread);

return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};

},

emscripten_set_focusout_callback_on_thread__proxy: 'sync',

emscripten_set_focusout_callback_on_thread__sig: 'iiiiii',

emscripten_set_focusout_callback_on_thread__deps: ['_registerFocusEventCallback'],

emscripten_set_focusout_callback_on_thread: function(target, userData, useCapture, callbackfunc, targetThread) {

__registerFocusEventCallback(target, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_FOCUSOUT') }}}, "focusout", targetThread);

return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};

},

_fillDeviceOrientationEventData__deps: ['$JSEvents'],

_fillDeviceOrientationEventData: function(eventStruct, e, target) {

{{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenDeviceOrientationEvent.alpha, 'e.alpha', 'double') }}};

{{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenDeviceOrientationEvent.beta, 'e.beta', 'double') }}};

{{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenDeviceOrientationEvent.gamma, 'e.gamma', 'double') }}};

{{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenDeviceOrientationEvent.absolute, 'e.absolute', 'i32') }}};

},

_registerDeviceOrientationEventCallback__deps: ['$JSEvents', '_fillDeviceOrientationEventData', '$findEventTarget'],

_registerDeviceOrientationEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {

#if USE_PTHREADS

targetThread = JSEvents.getTargetThreadForEventCallback(targetThread);

#endif

if (!JSEvents.deviceOrientationEvent) JSEvents.deviceOrientationEvent = _malloc( {{{ C_STRUCTS.EmscriptenDeviceOrientationEvent.__size__ }}} );

var deviceOrientationEventHandlerFunc = function(ev) {

var e = ev || event;

__fillDeviceOrientationEventData(JSEvents.deviceOrientationEvent, e, target); // TODO: Thread-safety with respect to emscripten_get_deviceorientation_status()

#if USE_PTHREADS

if (targetThread) {

var deviceOrientationEvent = _malloc( {{{ C_STRUCTS.EmscriptenDeviceOrientationEvent.__size__ }}} );

__fillDeviceOrientationEventData(deviceOrientationEvent, e, target);

JSEvents.queueEventHandlerOnThread_iiii(targetThread, callbackfunc, eventTypeId, deviceOrientationEvent, userData);

} else

#endif

if ({{{ makeDynCall('iiii', 'callbackfunc') }}}(eventTypeId, JSEvents.deviceOrientationEvent, userData)) e.preventDefault();

};

var eventHandler = {

target: findEventTarget(target),

eventTypeString: eventTypeString,

callbackfunc: callbackfunc,

handlerFunc: deviceOrientationEventHandlerFunc,

useCapture: useCapture

};

JSEvents.registerOrRemoveHandler(eventHandler);

},

emscripten_set_deviceorientation_callback_on_thread__proxy: 'sync',

emscripten_set_deviceorientation_callback_on_thread__sig: 'iiiii',

emscripten_set_deviceorientation_callback_on_thread__deps: ['_registerDeviceOrientationEventCallback'],

emscripten_set_deviceorientation_callback_on_thread: function(userData, useCapture, callbackfunc, targetThread) {

__registerDeviceOrientationEventCallback({{{ cDefine('EMSCRIPTEN_EVENT_TARGET_WINDOW') }}}, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_DEVICEORIENTATION') }}}, "deviceorientation", targetThread);

return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};

},

emscripten_get_deviceorientation_status__proxy: 'sync',

emscripten_get_deviceorientation_status__sig: 'ii',

emscripten_get_deviceorientation_status__deps: ['$JSEvents', '_registerDeviceOrientationEventCallback'],

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.EmscriptenDeviceOrientationEvent.__size__ }}}), orientationState);

return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};

},

_fillDeviceMotionEventData__deps: ['$JSEvents'],

_fillDeviceMotionEventData: function(eventStruct, e, target) {

var supportedFields = 0;

var a = e['acceleration'];

supportedFields |= a && {{{ cDefine('EMSCRIPTEN_DEVICE_MOTION_EVENT_SUPPORTS_ACCELERATION') }}};

var ag = e['accelerationIncludingGravity'];

supportedFields |= ag && {{{ cDefine('EMSCRIPTEN_DEVICE_MOTION_EVENT_SUPPORTS_ACCELERATION_INCLUDING_GRAVITY') }}};

var rr = e['rotationRate'];

supportedFields |= rr && {{{ cDefine('EMSCRIPTEN_DEVICE_MOTION_EVENT_SUPPORTS_ROTATION_RATE') }}};

a = a || {};

ag = ag || {};

rr = rr || {};

{{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenDeviceMotionEvent.accelerationX, 'a["x"]', 'double') }}};

{{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenDeviceMotionEvent.accelerationY, 'a["y"]', 'double') }}};

{{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenDeviceMotionEvent.accelerationZ, 'a["z"]', 'double') }}};

{{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenDeviceMotionEvent.accelerationIncludingGravityX, 'ag["x"]', 'double') }}};

{{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenDeviceMotionEvent.accelerationIncludingGravityY, 'ag["y"]', 'double') }}};

{{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenDeviceMotionEvent.accelerationIncludingGravityZ, 'ag["z"]', 'double') }}};

{{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenDeviceMotionEvent.rotationRateAlpha, 'rr["alpha"]', 'double') }}};

{{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenDeviceMotionEvent.rotationRateBeta, 'rr["beta"]', 'double') }}};

{{{ makeSetValue('eventStruct', C_STRUCTS.EmscriptenDeviceMotionEvent.rotationRateGamma, 'rr["gamma"]', 'double') }}};

},

_registerDeviceMotionEventCallback__deps: ['$JSEvents', '_fillDeviceMotionEventData', '$findEventTarget'],

_registerDeviceMotionEventCallback: function(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {

#if USE_PTHREADS

targetThread = JSEvents.getTargetThreadForEventCallback(targetThread);

#endif

if (!JSEvents.deviceMotionEvent) JSEvents.deviceMotionEvent = _malloc( {{{ C_STRUCTS.EmscriptenDeviceMotionEvent.__size__ }}} );

var deviceMotionEventHandlerFunc = function(ev) {

var e = ev || event;

__fillDeviceMotionEventData(JSEvents.deviceMotionEvent, e, target); // TODO: Thread-safety with respect to emscripten_get_devicemotion_status()

#if USE_PTHREADS

if (targetThread) {

var deviceMotionEvent = _malloc( {{{ C_STRUCTS.EmscriptenDeviceMotionEvent.__size__ }}} );

__fillDeviceMotionEventData(deviceMotionEvent, e, target);

JSEvents.queueEventHandlerOnThread_iiii(targetThread, callbackfunc, eventTypeId, deviceMotionEvent, userData);

} else

#endif

if ({{{ makeDynCall('iiii', 'callbackfunc') }}}(eventTypeId, JSEvents.deviceMotionEvent, userData)) e.preventDefault();

};

var eventHandler = {

target: findEventTarget(target),

eventTypeString: eventTypeString,

callbackfunc: callbackfunc,

handlerFunc: deviceMotionEventHandlerFunc,

useCapture: useCapture

};

JSEvents.registerOrRemoveHandler(eventHandler);

},

emscripten_set_devicemotion_callback_on_thread__proxy: 'sync',

emscripten_set_devicemotion_callback_on_thread__sig: 'iiiii',

emscripten_set_devicemotion_callback_on_thread__deps: ['_registerDeviceMotionEventCallback'],

emscripten_set_devicemotion_callback_on_thread: function(userData, useCapture, callbackfunc, targetThread) {

__registerDeviceMotionEventCallback({{{ cDefine('EMSCRIPTEN_EVENT_TARGET_WINDOW') }}}, userData, useCapture, callbackfunc, {{{ cDefine('EMSCRIPTEN_EVENT_DEVICEMOTION') }}}, "devicemotion", targetThread);

return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};

},

emscripten_get_devicemotion_status__proxy: 'sync',

emscripten_get_devicemotion_status__sig: 'ii',

emscripten_get_devicemotion_status__deps: ['$JSEvents'],

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.EmscriptenDeviceMotionEvent.__size__ }}}), motionState);

return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};

},

_screenOrientation: function() {

if (!screen) return undefined;

return screen.orientation || screen.mozOrientation || screen.webkitOrientation || screen.msOrientation;

},

_fillOrientationChangeEventData__deps: ['_screenOrientation'],

_fillOrientationChangeEventData: function(eventStruct) {

var orientations = ["portrait-primary", "portrait-secondary", "landscape-primary", "landscape-secondary"];