//-----------------------------------------------------------------------------

// The Emscripten-based implementation of platform-dependent GUI functionality.

//

// Copyright 2018 whitequark

//-----------------------------------------------------------------------------

#include <emscripten.h>

#include <emscripten/val.h>

#include <emscripten/html5.h>

#include "config.h"

#include "solvespace.h"

using namespace emscripten;

namespace SolveSpace {

namespace Platform {

//-----------------------------------------------------------------------------

// Emscripten API bridging

//-----------------------------------------------------------------------------

#define sscheck(expr) do { \

EMSCRIPTEN_RESULT emResult = (EMSCRIPTEN_RESULT)(expr); \

if(emResult < 0) \

HandleError(__FILE__, __LINE__, __func__, #expr, emResult); \

} while(0)

static void HandleError(const char *file, int line, const char *function, const char *expr,

EMSCRIPTEN_RESULT emResult) {

const char *error = "Unknown error";

switch(emResult) {

case EMSCRIPTEN_RESULT_DEFERRED: error = "Deferred"; break;

case EMSCRIPTEN_RESULT_NOT_SUPPORTED: error = "Not supported"; break;

case EMSCRIPTEN_RESULT_FAILED_NOT_DEFERRED: error = "Failed (not deferred)"; break;

case EMSCRIPTEN_RESULT_INVALID_TARGET: error = "Invalid target"; break;

case EMSCRIPTEN_RESULT_UNKNOWN_TARGET: error = "Unknown target"; break;

case EMSCRIPTEN_RESULT_INVALID_PARAM: error = "Invalid parameter"; break;

case EMSCRIPTEN_RESULT_FAILED: error = "Failed"; break;

case EMSCRIPTEN_RESULT_NO_DATA: error = "No data"; break;

}

std::string message;

message += ssprintf("File %s, line %u, function %s:\n", file, line, function);

message += ssprintf("Emscripten API call failed: %s.\n", expr);

message += ssprintf("Error: %s\n", error);

FatalError(message);

}

static val Wrap(const std::string& str) {

// FIXME(emscripten): a nicer way to do this?

EM_ASM($Wrap$ret = UTF8ToString($0), str.c_str());

return val::global("window")["$Wrap$ret"];

}

static std::string Unwrap(val emStr) {

// FIXME(emscripten): a nicer way to do this?

val emArray = val::global("window").call<val>("intArrayFromString", emStr, true) ;

val::global("window").set("$Wrap$input", emArray);

char *strC = (char *)EM_ASM_INT(return allocate($Wrap$input, ALLOC_NORMAL));

std::string str(strC, emArray["length"].as<int>());

free(strC);

return str;

}

static void CallStdFunction(void *data) {

std::function<void()> *func = (std::function<void()> *)data;

if(*func) {

(*func)();

}

}

static val Wrap(std::function<void()> *func) {

EM_ASM($Wrap$ret = Module.dynCall_vi.bind(null, $0, $1), CallStdFunction, func);

return val::global("window")["$Wrap$ret"];

}

//-----------------------------------------------------------------------------

// Fatal errors

//-----------------------------------------------------------------------------

void FatalError(const std::string &message) {

dbp("%s", message.c_str());

#ifndef NDEBUG

emscripten_debugger();

#endif

abort();

}

//-----------------------------------------------------------------------------

// Settings

//-----------------------------------------------------------------------------

class SettingsImplHtml : public Settings {

public:

void FreezeInt(const std::string &key, uint32_t value) {

val::global("localStorage").call<void>("setItem", Wrap(key), value);

}

uint32_t ThawInt(const std::string &key, uint32_t defaultValue = 0) {

val value = val::global("localStorage").call<val>("getItem", Wrap(key));

if(value == val::null())

return defaultValue;

return val::global("parseInt")(value, 0).as<int>();

}

void FreezeFloat(const std::string &key, double value) {

val::global("localStorage").call<void>("setItem", Wrap(key), value);

}

double ThawFloat(const std::string &key, double defaultValue = 0.0) {

val value = val::global("localStorage").call<val>("getItem", Wrap(key));

if(value == val::null())

return defaultValue;

return val::global("parseFloat")(value).as<double>();

}

void FreezeString(const std::string &key, const std::string &value) {

val::global("localStorage").call<void>("setItem", Wrap(key), value);

}

std::string ThawString(const std::string &key,

const std::string &defaultValue = "") {

val value = val::global("localStorage").call<val>("getItem", Wrap(key));

if(value == val::null())

return defaultValue;

return Unwrap(value);

}

};

SettingsRef GetSettings() {

return std::make_shared<SettingsImplHtml>();

}

//-----------------------------------------------------------------------------

// Timers

//-----------------------------------------------------------------------------

class TimerImplHtml : public Timer {

public:

static void Callback(void *arg) {

TimerImplHtml *timer = (TimerImplHtml *)arg;

if(timer->onTimeout) {

timer->onTimeout();

}

}

void RunAfter(unsigned milliseconds) override {

emscripten_async_call(TimerImplHtml::Callback, this, milliseconds + 1);

}

void RunAfterNextFrame() override {

emscripten_async_call(TimerImplHtml::Callback, this, 0);

}

void RunAfterProcessingEvents() override {

emscripten_push_uncounted_main_loop_blocker(TimerImplHtml::Callback, this);

}

};

TimerRef CreateTimer() {

return std::unique_ptr<TimerImplHtml>(new TimerImplHtml);

}

//-----------------------------------------------------------------------------

// Menus

//-----------------------------------------------------------------------------

class MenuItemImplHtml : public MenuItem {

public:

val htmlMenuItem;

MenuItemImplHtml() :

htmlMenuItem(val::global("document").call<val>("createElement", val("li")))

{}

void SetAccelerator(KeyboardEvent accel) override {

val htmlAccel = htmlMenuItem.call<val>("querySelector", val(".accel"));

if(htmlAccel.as<bool>()) {

htmlAccel.call<void>("remove");

}

htmlAccel = val::global("document").call<val>("createElement", val("span"));

htmlAccel.call<void>("setAttribute", val("class"), val("accel"));

htmlAccel.set("innerText", AcceleratorDescription(accel));

htmlMenuItem.call<void>("appendChild", htmlAccel);

}

void SetIndicator(Indicator type) override {

val htmlClasses = htmlMenuItem["classList"];

htmlClasses.call<void>("remove", val("check"));

htmlClasses.call<void>("remove", val("radio"));

switch(type) {

case Indicator::NONE:

break;

case Indicator::CHECK_MARK:

htmlClasses.call<void>("add", val("check"));

break;

case Indicator::RADIO_MARK:

htmlClasses.call<void>("add", val("radio"));

break;

}

}

void SetEnabled(bool enabled) override {

if(enabled) {

htmlMenuItem["classList"].call<void>("remove", val("disabled"));

} else {

htmlMenuItem["classList"].call<void>("add", val("disabled"));

}

}

void SetActive(bool active) override {

if(active) {

htmlMenuItem["classList"].call<void>("add", val("active"));

} else {

htmlMenuItem["classList"].call<void>("remove", val("active"));

}

}

};

class MenuImplHtml;

static std::shared_ptr<MenuImplHtml> popupMenuOnScreen;

class MenuImplHtml : public Menu,

public std::enable_shared_from_this<MenuImplHtml> {

public:

val htmlMenu;

std::vector<std::shared_ptr<MenuItemImplHtml>> menuItems;

std::vector<std::shared_ptr<MenuImplHtml>> subMenus;

std::function<void()> popupDismissFunc;

MenuImplHtml() :

htmlMenu(val::global("document").call<val>("createElement", val("ul")))

{

htmlMenu["classList"].call<void>("add", val("menu"));

}

MenuItemRef AddItem(const std::string &label, std::function<void()> onTrigger,

bool mnemonics = true) override {

std::shared_ptr<MenuItemImplHtml> menuItem = std::make_shared<MenuItemImplHtml>();

menuItems.push_back(menuItem);

menuItem->onTrigger = onTrigger;

if(mnemonics) {

val::global("window").call<void>("setLabelWithMnemonic", menuItem->htmlMenuItem,

Wrap(label));

} else {

val htmlLabel = val::global("document").call<val>("createElement", val("span"));

htmlLabel["classList"].call<void>("add", val("label"));

htmlLabel.set("innerText", Wrap(label));

menuItem->htmlMenuItem.call<void>("appendChild", htmlLabel);

}

menuItem->htmlMenuItem.call<void>("addEventListener", val("trigger"),

Wrap(&menuItem->onTrigger));

htmlMenu.call<void>("appendChild", menuItem->htmlMenuItem);

return menuItem;

}

std::shared_ptr<Menu> AddSubMenu(const std::string &label) override {

val htmlMenuItem = val::global("document").call<val>("createElement", val("li"));

val::global("window").call<void>("setLabelWithMnemonic", htmlMenuItem, Wrap(label));

htmlMenuItem["classList"].call<void>("add", val("has-submenu"));

htmlMenu.call<void>("appendChild", htmlMenuItem);

std::shared_ptr<MenuImplHtml> subMenu = std::make_shared<MenuImplHtml>();

subMenus.push_back(subMenu);

htmlMenuItem.call<void>("appendChild", subMenu->htmlMenu);

return subMenu;

}

void AddSeparator() override {

val htmlSeparator = val::global("document").call<val>("createElement", val("li"));

htmlSeparator["classList"].call<void>("add", val("separator"));

htmlMenu.call<void>("appendChild", htmlSeparator);

}

void PopUp() override {

if(popupMenuOnScreen) {

popupMenuOnScreen->htmlMenu.call<void>("remove");

popupMenuOnScreen = NULL;

}

EmscriptenMouseEvent emStatus = {};

sscheck(emscripten_get_mouse_status(&emStatus));

htmlMenu["classList"].call<void>("add", val("popup"));

htmlMenu["style"].set("left", std::to_string(emStatus.clientX) + "px");

htmlMenu["style"].set("top", std::to_string(emStatus.clientY) + "px");

val::global("document")["body"].call<void>("appendChild", htmlMenu);

popupMenuOnScreen = shared_from_this();

}

void Clear() override {

while(htmlMenu["childElementCount"].as<int>() > 0) {

htmlMenu["firstChild"].call<void>("remove");

}

}

};

MenuRef CreateMenu() {

return std::make_shared<MenuImplHtml>();

}

class MenuBarImplHtml final : public MenuBar {

public:

val htmlMenuBar;

std::vector<std::shared_ptr<MenuImplHtml>> subMenus;

MenuBarImplHtml() :

htmlMenuBar(val::global("document").call<val>("createElement", val("ul")))

{

htmlMenuBar["classList"].call<void>("add", val("menu"));

htmlMenuBar["classList"].call<void>("add", val("menubar"));

}

std::shared_ptr<Menu> AddSubMenu(const std::string &label) override {

val htmlMenuItem = val::global("document").call<val>("createElement", val("li"));

val::global("window").call<void>("setLabelWithMnemonic", htmlMenuItem, Wrap(label));

htmlMenuBar.call<void>("appendChild", htmlMenuItem);

std::shared_ptr<MenuImplHtml> subMenu = std::make_shared<MenuImplHtml>();

subMenus.push_back(subMenu);

htmlMenuItem.call<void>("appendChild", subMenu->htmlMenu);

return subMenu;

}

void Clear() override {

while(htmlMenuBar["childElementCount"].as<int>() > 0) {

htmlMenuBar["firstChild"].call<void>("remove");

}

}

};

MenuBarRef GetOrCreateMainMenu(bool *unique) {

*unique = false;

return std::make_shared<MenuBarImplHtml>();

}

//-----------------------------------------------------------------------------

// Windows

//-----------------------------------------------------------------------------

class TouchEventHelper {

public:

// FIXME(emscripten): Workaround. touchstart and touchend repeats two times.

bool touchActionStarted = false;

int previousNumTouches = 0;

double centerX = 0;

double centerY = 0;

// double startPinchDistance = 0;

double previousPinchDistance = 0;

std::function<void(MouseEvent*, void*)> onPointerDown;

std::function<void(MouseEvent*, void*)> onPointerMove;

std::function<void(MouseEvent*, void*)> onPointerUp;

std::function<void(MouseEvent*, void*)> onScroll;

void clear(void) {

touchActionStarted = false;

previousNumTouches = 0;

centerX = 0;

centerY = 0;

// startPinchDistance = 0;

previousPinchDistance = 0;

}

void calculateCenterPosition(const EmscriptenTouchEvent& emEvent, double& dst_x, double& dst_y) {

double x = 0;

double y = 0;

for (int i = 0; i < emEvent.numTouches; i++) {

x += emEvent.touches[i].targetX;

y += emEvent.touches[i].targetY;

}

dst_x = x / emEvent.numTouches;

dst_y = y / emEvent.numTouches;

}

void calculatePinchDistance(const EmscriptenTouchEvent& emEvent, double& dst_distance) {

if (emEvent.numTouches < 2) {

return;

}

double x1 = emEvent.touches[0].targetX;

double y1 = emEvent.touches[0].targetY;

double x2 = emEvent.touches[1].targetX;

double y2 = emEvent.touches[1].targetY;

dst_distance = std::sqrt(std::pow(x1 - x2, 2) + std::pow(y1 - y2, 2));

}

void createMouseEventPRESS(const EmscriptenTouchEvent& emEvent, MouseEvent& dst_mouseevent) {

double x = 0, y = 0;

this->calculateCenterPosition(emEvent, x, y);

this->centerX = x;

this->centerY = y;

this->touchActionStarted = true;

this->previousNumTouches = emEvent.numTouches;

dst_mouseevent.type = MouseEvent::Type::PRESS;

dst_mouseevent.x = x;

dst_mouseevent.y = y;

dst_mouseevent.shiftDown = emEvent.shiftKey;

dst_mouseevent.controlDown = emEvent.ctrlKey;

switch(emEvent.numTouches) {

case 1:

dst_mouseevent.button = MouseEvent::Button::LEFT;

break;

case 2: {

dst_mouseevent.button = MouseEvent::Button::RIGHT;

// double distance = 0;

this->calculatePinchDistance(emEvent, this->previousPinchDistance);

// this->startPinchDistance = distance;

// this->previousPinchDistance = distance;

break;

}

default:

dst_mouseevent.button = MouseEvent::Button::MIDDLE;

break;

}

}

void createMouseEventRELEASE(const EmscriptenTouchEvent& emEvent, MouseEvent& dst_mouseevent) {

this->calculateCenterPosition(emEvent, this->centerX, this->centerY);

this->previousNumTouches = 0;

dst_mouseevent.type = MouseEvent::Type::RELEASE;

dst_mouseevent.x = this->centerX;

dst_mouseevent.y = this->centerY;

dst_mouseevent.shiftDown = emEvent.shiftKey;

dst_mouseevent.controlDown = emEvent.ctrlKey;

switch(this->previousNumTouches) {

case 1:

dst_mouseevent.button = MouseEvent::Button::LEFT;

break;

case 2:

dst_mouseevent.button = MouseEvent::Button::RIGHT;

break;

default:

dst_mouseevent.button = MouseEvent::Button::MIDDLE;

break;

}

}

void createMouseEventMOTION(const EmscriptenTouchEvent& emEvent, MouseEvent& dst_mouseevent) {

dst_mouseevent.type = MouseEvent::Type::MOTION;

this->calculateCenterPosition(emEvent, this->centerX, this->centerY);

dst_mouseevent.x = this->centerX;

dst_mouseevent.y = this->centerY;

dst_mouseevent.shiftDown = emEvent.shiftKey;

dst_mouseevent.controlDown = emEvent.ctrlKey;

switch(emEvent.numTouches) {

case 1:

dst_mouseevent.button = MouseEvent::Button::LEFT;

break;

case 2:

dst_mouseevent.button = MouseEvent::Button::RIGHT;

break;

default:

dst_mouseevent.button = MouseEvent::Button::MIDDLE;

break;

}

}

void createMouseEventSCROLL(const EmscriptenTouchEvent& emEvent, MouseEvent& event) {

event.type = MouseEvent::Type::SCROLL_VERT;

double newDistance = 0;

this->calculatePinchDistance(emEvent, newDistance);

this->calculateCenterPosition(emEvent, this->centerX, this->centerY);

event.x = this->centerX;

event.y = this->centerY;

event.shiftDown = emEvent.shiftKey;

event.controlDown = emEvent.ctrlKey;

// FIXME(emscripten): best value range for scrollDelta ?

event.scrollDelta = (newDistance - this->previousPinchDistance) / 25.0;

if (std::abs(event.scrollDelta) > 2) {

event.scrollDelta = 2;

if (std::signbit(event.scrollDelta)) {

event.scrollDelta *= -1.0;

}

}

this->previousPinchDistance = newDistance;

}

void onTouchStart(const EmscriptenTouchEvent& emEvent, void* callbackParameter) {

if (this->touchActionStarted) {

// dbp("onTouchStart(): Break due to already started.");

return;

}

MouseEvent event;

this->createMouseEventPRESS(emEvent, event);

this->previousNumTouches = emEvent.numTouches;

if (this->onPointerDown) {

// dbp("onPointerDown(): numTouches=%d, timestamp=%f", emEvent.numTouches, emEvent.timestamp);

this->onPointerDown(&event, callbackParameter);

}

}

void onTouchMove(const EmscriptenTouchEvent& emEvent, void* callbackParameter) {

this->calculateCenterPosition(emEvent, this->centerX, this->centerY);

int newNumTouches = emEvent.numTouches;

if (newNumTouches != this->previousNumTouches) {

MouseEvent releaseEvent;

this->createMouseEventRELEASE(emEvent, releaseEvent);

if (this->onPointerUp) {

// dbp("onPointerUp(): numTouches=%d, timestamp=%f", emEvent.numTouches, emEvent.timestamp);

this->onPointerUp(&releaseEvent, callbackParameter);

}

MouseEvent pressEvent;

this->createMouseEventPRESS(emEvent, pressEvent);

if (this->onPointerDown) {

// dbp("onPointerDown(): numTouches=%d, timestamp=%f", emEvent.numTouches, emEvent.timestamp);

this->onPointerDown(&pressEvent, callbackParameter);

}

}

MouseEvent motionEvent = { };

this->createMouseEventMOTION(emEvent, motionEvent);

if (this->onPointerMove) {

// dbp("onPointerMove(): numTouches=%d, timestamp=%f", emEvent.numTouches, emEvent.timestamp);

this->onPointerMove(&motionEvent, callbackParameter);

}

if (emEvent.numTouches == 2) {

MouseEvent scrollEvent;

this->createMouseEventSCROLL(emEvent, scrollEvent);

if (scrollEvent.scrollDelta != 0) {

if (this->onScroll) {

// dbp("Scroll %f", scrollEvent.scrollDelta);

this->onScroll(&scrollEvent, callbackParameter);

}

}

}

this->previousNumTouches = emEvent.numTouches;

}

void onTouchEnd(const EmscriptenTouchEvent& emEvent, void* callbackParameter) {

if (!this->touchActionStarted) {

return;

}

MouseEvent releaseEvent = { };

this->createMouseEventRELEASE(emEvent, releaseEvent);

if (this->onPointerUp) {

// dbp("onPointerUp(): numTouches=%d, timestamp=%d", emEvent.numTouches, emEvent.timestamp);

this->onPointerUp(&releaseEvent, callbackParameter);

}

this->clear();

}

void onTouchCancel(const EmscriptenTouchEvent& emEvent, void* callbackParameter) {

this->onTouchEnd(emEvent, callbackParameter);

}

};

static TouchEventHelper touchEventHelper;

static KeyboardEvent handledKeyboardEvent;

class WindowImplHtml final : public Window {

public:

std::string emCanvasSel;

EMSCRIPTEN_WEBGL_CONTEXT_HANDLE emContext = 0;

val htmlContainer;

val htmlEditor;

val scrollbarHelper;

std::function<void()> editingDoneFunc;

std::shared_ptr<MenuBarImplHtml> menuBar;

WindowImplHtml(val htmlContainer, std::string emCanvasSel) :

emCanvasSel(emCanvasSel),

htmlContainer(htmlContainer),

htmlEditor(val::global("document").call<val>("createElement", val("input")))

{

htmlEditor["classList"].call<void>("add", val("editor"));

htmlEditor["style"].set("display", "none");

editingDoneFunc = [this] {

if(onEditingDone) {

onEditingDone(Unwrap(htmlEditor["value"]));

}

};

htmlEditor.call<void>("addEventListener", val("trigger"), Wrap(&editingDoneFunc));

htmlContainer["parentElement"].call<void>("appendChild", htmlEditor);

std::string scrollbarElementQuery = emCanvasSel + "scrollbar";

dbp("scrollbar element query: \"%s\"", scrollbarElementQuery.c_str());

val scrollbarElement = val::global("document").call<val>("querySelector", val(scrollbarElementQuery));

if (scrollbarElement == val::null()) {

// dbp("scrollbar element is null.");

this->scrollbarHelper = val::null();

} else {

dbp("scrollbar element OK.");

this->scrollbarHelper = val::global("window")["ScrollbarHelper"].new_(val(scrollbarElementQuery));

static std::function<void()> onScrollCallback = [this] {

// dbp("onScrollCallback std::function this=%p", (void*)this);

if (this->onScrollbarAdjusted) {

double newpos = this->scrollbarHelper.call<double>("getScrollbarPosition");

// dbp(" call onScrollbarAdjusted(%f)", newpos);

this->onScrollbarAdjusted(newpos);

}

this->Invalidate();

};

this->scrollbarHelper.set("onScrollCallback", Wrap(&onScrollCallback));

}

sscheck(emscripten_set_resize_callback(

EMSCRIPTEN_EVENT_TARGET_WINDOW, this, /*useCapture=*/false,

WindowImplHtml::ResizeCallback));

sscheck(emscripten_set_resize_callback(

emCanvasSel.c_str(), this, /*useCapture=*/false,

WindowImplHtml::ResizeCallback));

sscheck(emscripten_set_mousemove_callback(

emCanvasSel.c_str(), this, /*useCapture=*/false,

WindowImplHtml::MouseCallback));

sscheck(emscripten_set_mousedown_callback(

emCanvasSel.c_str(), this, /*useCapture=*/false,

WindowImplHtml::MouseCallback));

sscheck(emscripten_set_click_callback(

emCanvasSel.c_str(), this, /*useCapture=*/false,

WindowImplHtml::MouseCallback));

sscheck(emscripten_set_dblclick_callback(

emCanvasSel.c_str(), this, /*useCapture=*/false,

WindowImplHtml::MouseCallback));

sscheck(emscripten_set_mouseup_callback(

emCanvasSel.c_str(), this, /*useCapture=*/false,

WindowImplHtml::MouseCallback));

sscheck(emscripten_set_mouseleave_callback(

emCanvasSel.c_str(), this, /*useCapture=*/false,

WindowImplHtml::MouseCallback));

sscheck(emscripten_set_touchstart_callback(

emCanvasSel.c_str(), this, /*useCapture=*/false,

WindowImplHtml::TouchCallback));

sscheck(emscripten_set_touchmove_callback(

emCanvasSel.c_str(), this, /*useCapture=*/false,

WindowImplHtml::TouchCallback));

sscheck(emscripten_set_touchend_callback(

emCanvasSel.c_str(), this, /*useCapture=*/false,

WindowImplHtml::TouchCallback));

sscheck(emscripten_set_touchcancel_callback(

emCanvasSel.c_str(), this, /*useCapture=*/false,

WindowImplHtml::TouchCallback));

sscheck(emscripten_set_wheel_callback(

emCanvasSel.c_str(), this, /*useCapture=*/false,

WindowImplHtml::WheelCallback));

sscheck(emscripten_set_keydown_callback(

EMSCRIPTEN_EVENT_TARGET_WINDOW, this, /*useCapture=*/false,

WindowImplHtml::KeyboardCallback));

sscheck(emscripten_set_keyup_callback(

EMSCRIPTEN_EVENT_TARGET_WINDOW, this, /*useCapture=*/false,

WindowImplHtml::KeyboardCallback));

sscheck(emscripten_set_webglcontextlost_callback(

emCanvasSel.c_str(), this, /*useCapture=*/false,

WindowImplHtml::ContextLostCallback));

sscheck(emscripten_set_webglcontextrestored_callback(

emCanvasSel.c_str(), this, /*useCapture=*/false,

WindowImplHtml::ContextRestoredCallback));

ResizeCanvasElement();

SetupWebGLContext();

}

~WindowImplHtml() {

if(emContext != 0) {

sscheck(emscripten_webgl_destroy_context(emContext));

}

}

static EM_BOOL ResizeCallback(int emEventType, const EmscriptenUiEvent *emEvent, void *data) {

WindowImplHtml *window = (WindowImplHtml *)data;

window->Invalidate();

return EM_TRUE;

}

static EM_BOOL MouseCallback(int emEventType, const EmscriptenMouseEvent *emEvent,

void *data) {

if(val::global("window").call<bool>("isModal")) return EM_FALSE;

WindowImplHtml *window = (WindowImplHtml *)data;

MouseEvent event = {};

switch(emEventType) {

case EMSCRIPTEN_EVENT_MOUSEMOVE:

event.type = MouseEvent::Type::MOTION;

break;

case EMSCRIPTEN_EVENT_MOUSEDOWN:

event.type = MouseEvent::Type::PRESS;

break;

case EMSCRIPTEN_EVENT_DBLCLICK:

event.type = MouseEvent::Type::DBL_PRESS;

break;

case EMSCRIPTEN_EVENT_MOUSEUP:

event.type = MouseEvent::Type::RELEASE;

break;

case EMSCRIPTEN_EVENT_MOUSELEAVE:

event.type = MouseEvent::Type::LEAVE;

break;

default:

return EM_FALSE;

}

switch(emEventType) {

case EMSCRIPTEN_EVENT_MOUSEMOVE:

if(emEvent->buttons & 1) {

event.button = MouseEvent::Button::LEFT;

} else if(emEvent->buttons & 2) {

event.button = MouseEvent::Button::RIGHT;

} else if(emEvent->buttons & 4) {

event.button = MouseEvent::Button::MIDDLE;

}

break;

case EMSCRIPTEN_EVENT_MOUSEDOWN:

case EMSCRIPTEN_EVENT_DBLCLICK:

case EMSCRIPTEN_EVENT_MOUSEUP:

switch(emEvent->button) {

case 0: event.button = MouseEvent::Button::LEFT; break;

case 1: event.button = MouseEvent::Button::MIDDLE; break;

case 2: event.button = MouseEvent::Button::RIGHT; break;

}

break;

default:

return EM_FALSE;

}

event.x = emEvent->targetX;

event.y = emEvent->targetY;

event.shiftDown = emEvent->shiftKey || emEvent->altKey;

event.controlDown = emEvent->ctrlKey;

if(window->onMouseEvent) {

return window->onMouseEvent(event);

}

return EM_FALSE;

}

static EM_BOOL TouchCallback(int emEventType, const EmscriptenTouchEvent *emEvent,

void *data) {

if(val::global("window").call<bool>("isModal")) return EM_FALSE;

static bool initialized = false;

WindowImplHtml *window = (WindowImplHtml *)data;

if (!initialized) {

touchEventHelper.onPointerDown = [](MouseEvent* event, void* param) -> void {

WindowImplHtml* window = (WindowImplHtml*)param;

if (window->onMouseEvent) {

window->onMouseEvent(*event);

}

};

touchEventHelper.onPointerMove = [](MouseEvent* event, void* param) -> void {

WindowImplHtml* window = (WindowImplHtml*)param;

if (window->onMouseEvent) {

window->onMouseEvent(*event);

}

};

touchEventHelper.onPointerUp = [](MouseEvent* event, void* param) -> void {

WindowImplHtml* window = (WindowImplHtml*)param;

if (window->onMouseEvent) {

window->onMouseEvent(*event);

}

};

touchEventHelper.onScroll = [](MouseEvent* event, void* param) -> void {

WindowImplHtml* window = (WindowImplHtml*)param;

if (window->onMouseEvent) {

window->onMouseEvent(*event);

}

};

initialized = true;

}

switch(emEventType) {

case EMSCRIPTEN_EVENT_TOUCHSTART:

touchEventHelper.onTouchStart(*emEvent, window);

break;

case EMSCRIPTEN_EVENT_TOUCHMOVE:

touchEventHelper.onTouchMove(*emEvent, window);

break;

case EMSCRIPTEN_EVENT_TOUCHEND:

touchEventHelper.onTouchEnd(*emEvent, window);

break;

case EMSCRIPTEN_EVENT_TOUCHCANCEL:

touchEventHelper.onTouchCancel(*emEvent, window);

break;

default:

return EM_FALSE;

}

return true;

}

static EM_BOOL WheelCallback(int emEventType, const EmscriptenWheelEvent *emEvent,

void *data) {

if(val::global("window").call<bool>("isModal")) return EM_FALSE;

WindowImplHtml *window = (WindowImplHtml *)data;

MouseEvent event = {};

if(emEvent->deltaY != 0) {

event.type = MouseEvent::Type::SCROLL_VERT;

// FIXME(emscripten):

// Pay attention to:

// dbp("Mouse wheel delta mode: %lu", emEvent->deltaMode);

// https://emscripten.org/docs/api_reference/html5.h.html#id11

// https://www.w3.org/TR/DOM-Level-3-Events/#dom-wheelevent-deltamode

// and adjust the 0.01 below. deltaMode == 0 on a Firefox on a Windows.

event.scrollDelta = -emEvent->deltaY * 0.01;

} else {

return EM_FALSE;

}

const EmscriptenMouseEvent &emStatus = emEvent->mouse;

event.x = emStatus.targetX;

event.y = emStatus.targetY;

event.shiftDown = emStatus.shiftKey;

event.controlDown = emStatus.ctrlKey;

if(window->onMouseEvent) {

return window->onMouseEvent(event);

}

return EM_FALSE;

}

static EM_BOOL KeyboardCallback(int emEventType, const EmscriptenKeyboardEvent *emEvent,

void *data) {

if(emEvent->altKey) return EM_FALSE;

if(emEvent->repeat) return EM_FALSE;

WindowImplHtml *window = (WindowImplHtml *)data;

KeyboardEvent event = {};

switch(emEventType) {

case EMSCRIPTEN_EVENT_KEYDOWN:

event.type = KeyboardEvent::Type::PRESS;

break;

case EMSCRIPTEN_EVENT_KEYUP:

event.type = KeyboardEvent::Type::RELEASE;

break;

default:

return EM_FALSE;

}

event.shiftDown = emEvent->shiftKey;

event.controlDown = emEvent->ctrlKey;

std::string key = emEvent->key;

if(key[0] == 'F' && isdigit(key[1])) {

event.key = KeyboardEvent::Key::FUNCTION;

event.num = std::stol(key.substr(1));

} else {

event.key = KeyboardEvent::Key::CHARACTER;

auto utf8 = ReadUTF8(key);

if(++utf8.begin() == utf8.end()) {

event.chr = tolower(*utf8.begin());

} else if(key == "Escape") {

event.chr = '\e';

} else if(key == "Tab") {

event.chr = '\t';

} else if(key == "Backspace") {

event.chr = '\b';

} else if(key == "Delete") {

event.chr = '\x7f';

} else {

return EM_FALSE;

}

if(event.chr == '>' && event.shiftDown) {

event.shiftDown = false;

}

}

if(event.Equals(handledKeyboardEvent)) return EM_FALSE;

if(val::global("window").call<bool>("isModal")) {

handledKeyboardEvent = {};

return EM_FALSE;

}

if(window->onKeyboardEvent) {

if(window->onKeyboardEvent(event)) {

handledKeyboardEvent = event;

return EM_TRUE;

}

}

return EM_FALSE;

}

void SetupWebGLContext() {

EmscriptenWebGLContextAttributes emAttribs = {};

emscripten_webgl_init_context_attributes(&emAttribs);

emAttribs.alpha = false;

emAttribs.failIfMajorPerformanceCaveat = true;

sscheck(emContext = emscripten_webgl_create_context(emCanvasSel.c_str(), &emAttribs));

dbp("Canvas %s: got context %d", emCanvasSel.c_str(), emContext);

}

static int ContextLostCallback(int eventType, const void *reserved, void *data) {

WindowImplHtml *window = (WindowImplHtml *)data;

dbp("Canvas %s: context lost", window->emCanvasSel.c_str());

window->emContext = 0;

if(window->onContextLost) {

window->onContextLost();

}

return EM_TRUE;

}

static int ContextRestoredCallback(int eventType, const void *reserved, void *data) {

WindowImplHtml *window = (WindowImplHtml *)data;

dbp("Canvas %s: context restored", window->emCanvasSel.c_str());

window->SetupWebGLContext();

return EM_TRUE;

}

void ResizeCanvasElement() {

double width, height;

std::string htmlContainerSel = "#" + htmlContainer["id"].as<std::string>();

sscheck(emscripten_get_element_css_size(htmlContainerSel.c_str(), &width, &height));

// sscheck(emscripten_get_element_css_size(emCanvasSel.c_str(), &width, &height));

double devicePixelRatio = GetDevicePixelRatio();

width *= devicePixelRatio;

height *= devicePixelRatio;

int currentWidth = 0, currentHeight = 0;

sscheck(emscripten_get_canvas_element_size(emCanvasSel.c_str(), &currentWidth, &currentHeight));

if ((int)width != currentWidth || (int)height != currentHeight) {

// dbp("Canvas %s container current size: (%d, %d)", emCanvasSel.c_str(), (int)currentWidth, (int)currentHeight);

// dbp("Canvas %s: resizing to (%d, %d)", emCanvasSel.c_str(), (int)width, (int)height);

sscheck(emscripten_set_canvas_element_size(emCanvasSel.c_str(), (int)width, (int)height));

}

}

static void RenderCallback(void *data) {

WindowImplHtml *window = (WindowImplHtml *)data;

if(window->emContext == 0) {

dbp("Canvas %s: cannot render: no context", window->emCanvasSel.c_str());

return;

}

window->ResizeCanvasElement();

sscheck(emscripten_webgl_make_context_current(window->emContext));

if(window->onRender) {

window->onRender();

}

}

double GetPixelDensity() override {

return 96.0 * GetDevicePixelRatio();

}

double GetDevicePixelRatio() override {

return emscripten_get_device_pixel_ratio();

}

bool IsVisible() override {

// FIXME(emscripten): implement

return true;

}

void SetVisible(bool visible) override {

// FIXME(emscripten): implement

}

void Focus() override {

// Do nothing, we can't affect focus of browser windows.

}

bool IsFullScreen() override {

EmscriptenFullscreenChangeEvent emEvent = {};

sscheck(emscripten_get_fullscreen_status(&emEvent));

return emEvent.isFullscreen;

}

void SetFullScreen(bool fullScreen) override {

if(fullScreen) {

EmscriptenFullscreenStrategy emStrategy = {};

emStrategy.scaleMode = EMSCRIPTEN_FULLSCREEN_SCALE_STRETCH;

emStrategy.canvasResolutionScaleMode = EMSCRIPTEN_FULLSCREEN_CANVAS_SCALE_HIDEF;

emStrategy.filteringMode = EMSCRIPTEN_FULLSCREEN_FILTERING_DEFAULT;

sscheck(emscripten_request_fullscreen_strategy(

emCanvasSel.c_str(), /*deferUntilInEventHandler=*/true, &emStrategy));

} else {

sscheck(emscripten_exit_fullscreen());

}

}

void SetTitle(const std::string &title) override {