`emscripten_set_mousedown_callback` does not call the callback function from Qt Creator #22133

8Observer8 · 2024-06-22T21:05:43Z

The next example works without problems when I compile and run it from the command line: emcc -g main.cpp -o public/index.html But when I create Empty qmake Project from Qt Creater and run it - it doesn't work - it does not print "Mouse down" to the console:

main.cpp

#include <emscripten.h>
#include <emscripten/html5.h>
#include <iostream>

// https://github.com/emscripten-core/emscripten/issues/19266
int main()
{
    // Mouse Button Down:
    emscripten_set_mousedown_callback(
        EMSCRIPTEN_EVENT_TARGET_WINDOW, nullptr, 0, +[](int eventType,
        const EmscriptenMouseEvent *e, void *userData) -> EM_BOOL
        {
            std::cout << "Mouse down: " << e->button << "\n";
            return EM_FALSE;
        });
}

I create a project in Qt Creator like this:

The text was updated successfully, but these errors were encountered:

sbc100 · 2024-06-22T21:33:33Z

Most likely if you use Qt you probably want to let it handle all the interaction with he mouse etc. Trying to do you own mouse interaction underneath Qt will likely cause confusion or maybe just doesn't work?

8Observer8 · 2024-06-22T21:39:47Z

The contributor of Qt said in the comments: https://bugreports.qt.io/browse/QTBUG-126513 that:

You need to handle this in a javascript mouse event and not a Qt mouse event. Once it gets to Qt mouse handler, the original javascript event handler has passed.

I have tried to use it:

void mousePressEvent(QMouseEvent *event) override
{
    EMSCRIPTEN_RESULT result = emscripten_request_pointerlock(EMSCRIPTEN_EVENT_TARGET_DOCUMENT, false);
    qDebug() << result;
}

It returns EMSCRIPTEN_RESULT_NOT_SUPPORTED

sbc100 · 2024-06-22T22:01:03Z

I see.. they you need to handle the event directly so that you can request the pointer lock.

In that case yes you probably do need to register your own mousedown callback. I'm not sure why shouldn't able to have your one registered alongside the Qt one.. I think they should all fire and we don't use stopPropagation within emscripten so I don't see why you wouldn't get both event.

8Observer8 · 2024-06-26T18:25:20Z

How do you think, guys, is it a bug of Qt or Emscripten? https://bugreports.qt.io/browse/QTBUG-126582

sbc100 · 2024-06-26T18:27:24Z

My guess is that its an emscripten issue, but I'm not sure how this API is supposed to work TBH. Needs more investigation.

8Observer8 · 2024-06-27T09:33:33Z

The main goal is to get movementX and movementY values from this function:

EM_JS(void, requestPointerLock, (), {
    document.body.requestPointerLock();

    document.body.onmousemove = (event) => {
        console.log(event.movementX, event.movementY);
    };
})

And print them here:

    void mouseMoveEvent(QMouseEvent *event) override
    {
        Q_UNUSED(event);

        // qDebug() << movementX << movementY;
    }

sbc100 · 2024-06-27T15:05:17Z

Sorry where are the above code snippets from? is that code from inside of Qt or from your project?

I though that goal here was to be able to call emscripten_request_pointerlock?

8Observer8 · 2024-06-27T16:44:36Z

I try another ways to solve the problem. emscripten_request_pointerlock doesn't work with Qt but this code works:

EM_JS(void, requestPointerLock, (), {
    document.body.requestPointerLock();

    document.body.onmousemove = (event) => {
        console.log(event.movementX, event.movementY);
    };
})

    void mousePressEvent(QMouseEvent *event) override
    {
        Q_UNUSED(event);
        requestPointerLock();
    }

It locks the mouse pointer and prints movementX and movementY to the console when I have the mouse pointer. But I don't know how to get movementX and movementY in C++ code when I move the mouse pointer.

sbc100 · 2024-06-27T17:10:40Z

I try another ways to solve the problem. emscripten_request_pointerlock doesn't work with Qt but this code works:
EM_JS(void, requestPointerLock, (), {
    document.body.requestPointerLock();

    document.body.onmousemove = (event) => {
        console.log(event.movementX, event.movementY);
    };
})
    void mousePressEvent(QMouseEvent *event) override
    {
        Q_UNUSED(event);
        requestPointerLock();
    }
It locks the mouse pointer and prints movementX and movementY to the console when I have the mouse pointer. But I don't know how to get movementX and movementY in C++ code when I move the mouse pointer.

I'm not sure that is the right solution.. but if you want to go that route that is certainly questions for Qt. You would need to look at how to create/injext new Qt events, mostly likely take a look at the Qt emscripten implemenation.

However, I a little confused because your requestPointerLock above is still not running inside an event handler.. how is it working in that case?

sbc100 · 2024-06-27T17:13:56Z

Oh wait.. did you try passing true as the second argument (deferUntilInEventHandler) to emscripten_request_pointerlock ?

8Observer8 · 2024-06-27T17:24:32Z

Oh wait.. did you try passing true as the second argument (deferUntilInEventHandler) to emscripten_request_pointerlock ?

I tried. The mouse pointer is not locked. It prints -1 to the console when I click. This is the WASM output: dist.zip

#include <QtGui/QMouseEvent>
#include <QtGui/QOpenGLFunctions>
#include <QtOpenGL/QOpenGLWindow>
#include <QtWidgets/QApplication>

#ifdef Q_OS_WASM
#include <emscripten.h>
#include <emscripten/html5.h>
#endif

class OpenGLWindow : public QOpenGLWindow, private QOpenGLFunctions
{

public:

    OpenGLWindow()
    {
        setTitle("OpenGL ES 2.0, Qt6, C++");
        resize(350, 350);
    }

private:

    void mousePressEvent(QMouseEvent *event) override
    {
        Q_UNUSED(event);

        EMSCRIPTEN_RESULT result = emscripten_request_pointerlock(
            EMSCRIPTEN_EVENT_TARGET_DOCUMENT, true);
        qDebug() << result;
    }

    virtual void initializeGL() override
    {
        initializeOpenGLFunctions();
        glClearColor(0.2f, 0.2f, 0.2f, 1.f);
    }

    virtual void paintGL() override
    {
        glClear(GL_COLOR_BUFFER_BIT);
    }
};

int main(int argc, char *argv[])
{
    QApplication::setAttribute(Qt::ApplicationAttribute::AA_UseDesktopOpenGL);
    QApplication app(argc, argv);
    OpenGLWindow w;
    w.show();
    return app.exec();
}

pro

QT += core gui openglwidgets

win32: LIBS += -lopengl32

CONFIG += c++17

wasm: INCLUDEPATH += "C:\emsdk\upstream\emscripten\cache\sysroot\include"

SOURCES += \
    main.cpp

8Observer8 · 2024-06-27T17:31:31Z

However, I a little confused because your requestPointerLock above is still not running inside an event handler.. how is it working in that case?

I don't know but the mouse cursor was locked and the movementX and movementY values was printed to the console:

#include <QtGui/QMouseEvent>
#include <QtGui/QOpenGLFunctions>
#include <QtOpenGL/QOpenGLWindow>
#include <QtWidgets/QApplication>

#ifdef Q_OS_WASM
#include <emscripten.h>
#include <emscripten/html5.h>
#endif

#ifdef Q_OS_WASM
EM_JS(void, requestPointerLock, (), {
    document.body.requestPointerLock();

    document.body.onmousemove = (event) => {
        console.log(event.movementX, event.movementY);
    };
})
#endif

class OpenGLWindow : public QOpenGLWindow, private QOpenGLFunctions
{

public:

    OpenGLWindow()
    {
        setTitle("OpenGL ES 2.0, Qt6, C++");
        resize(350, 350);
    }

private:

    void mousePressEvent(QMouseEvent *event) override
    {
        Q_UNUSED(event);
        requestPointerLock();
    }

    virtual void initializeGL() override
    {
        initializeOpenGLFunctions();
        glClearColor(0.2f, 0.2f, 0.2f, 1.f);
    }

    virtual void paintGL() override
    {
        glClear(GL_COLOR_BUFFER_BIT);
    }
};

int main(int argc, char *argv[])
{
    QApplication::setAttribute(Qt::ApplicationAttribute::AA_UseDesktopOpenGL);
    QApplication app(argc, argv);
    OpenGLWindow w;
    w.show();
    return app.exec();
}

pro

QT += core gui openglwidgets

win32: LIBS += -lopengl32

CONFIG += c++17

wasm: INCLUDEPATH += "C:\emsdk\upstream\emscripten\cache\sysroot\include"

SOURCES += \
    main.cpp

sbc100 · 2024-06-27T17:38:25Z

Oh wait.. did you try passing true as the second argument (deferUntilInEventHandler) to emscripten_request_pointerlock ?

I tried. The mouse pointer is not locked. It prints -1 to the console when I click. This is the WASM output: dist.zip

#include <QtGui/QMouseEvent>
#include <QtGui/QOpenGLFunctions>
#include <QtOpenGL/QOpenGLWindow>
#include <QtWidgets/QApplication>

#ifdef Q_OS_WASM
#include <emscripten.h>
#include <emscripten/html5.h>
#endif

class OpenGLWindow : public QOpenGLWindow, private QOpenGLFunctions
{

public:

    OpenGLWindow()
    {
        setTitle("OpenGL ES 2.0, Qt6, C++");
        resize(350, 350);
    }

private:

    void mousePressEvent(QMouseEvent *event) override
    {
        Q_UNUSED(event);

        EMSCRIPTEN_RESULT result = emscripten_request_pointerlock(
            EMSCRIPTEN_EVENT_TARGET_DOCUMENT, true);
        qDebug() << result;
    }

    virtual void initializeGL() override
    {
        initializeOpenGLFunctions();
        glClearColor(0.2f, 0.2f, 0.2f, 1.f);
    }

    virtual void paintGL() override
    {
        glClear(GL_COLOR_BUFFER_BIT);
    }
};

int main(int argc, char *argv[])
{
    QApplication::setAttribute(Qt::ApplicationAttribute::AA_UseDesktopOpenGL);
    QApplication app(argc, argv);
    OpenGLWindow w;
    w.show();
    return app.exec();
}

pro

QT += core gui openglwidgets

win32: LIBS += -lopengl32

CONFIG += c++17

wasm: INCLUDEPATH += "C:\emsdk\upstream\emscripten\cache\sysroot\include"

SOURCES += \
    main.cpp

Can you step into the code for emscripten_request_pointerlock and see why its returning -1? It should be returning EMSCRIPTEN_RESULT_DEFERRED (1)

8Observer8 · 2024-06-27T18:38:06Z

Can you step into the code for emscripten_request_pointerlock and see why its returning -1? It should be returning EMSCRIPTEN_RESULT_DEFERRED (1)

It returns EMSCRIPTEN_RESULT_NOT_SUPPORTED (-1):

#define EMSCRIPTEN_RESULT_SUCCESS              0
#define EMSCRIPTEN_RESULT_DEFERRED             1
#define EMSCRIPTEN_RESULT_NOT_SUPPORTED       -1

I cannot set a breakpoint at the emscripten_request_pointerlock line because Qt Creator doesn't allow it:

But I can click on this link:

Result:

sbc100 · 2024-06-27T18:40:38Z

You should be able to set a breakpoint in devtools once you have your app running in chrome. You should be able to then step through the emscripten_request_pointerlock in devtools.

8Observer8 · 2024-06-27T19:01:45Z

A target is the document but target.requestPointerLock is undefined:

8Observer8 · 2024-06-28T09:17:30Z

I have reproduced the problem above in pure Emscripten from CMD: emcc -g main.cpp -o public/index.html

It returns -1 because target.requestPointerLock is undefined:

#include <emscripten.h>
#include <emscripten/html5.h>
#include <iostream>

int main()
{
    // Mouse Button Down:
    emscripten_set_mousedown_callback(
        "#canvas", nullptr, 0, +[](int eventType,
            const EmscriptenMouseEvent *e, void *userData) -> EM_BOOL
        {
            EMSCRIPTEN_RESULT result = emscripten_request_pointerlock(
                EMSCRIPTEN_EVENT_TARGET_DOCUMENT, true);
            std::cout << result << std::endl;
            return EM_FALSE;
        });

    return 0;
}

8Observer8 · 2024-06-28T09:22:51Z

document doesn't have requestPointerLock:

8Observer8 · 2024-06-28T09:56:45Z

I have replaced EMSCRIPTEN_EVENT_TARGET_DOCUMENT with #canvas and the example above works without the problem: emcc -g main.cpp -o public/index.html

main.cpp

#include <emscripten.h>
#include <emscripten/html5.h>
#include <iostream>

int main()
{
    // Mouse Button Down:
    emscripten_set_mousedown_callback(
        "#canvas", nullptr, 0, +[](int eventType,
            const EmscriptenMouseEvent *e, void *userData) -> EM_BOOL
        {
            EMSCRIPTEN_RESULT result = emscripten_request_pointerlock("#canvas", true);
            std::cout << result << std::endl;
            return EM_FALSE;
        });

    return 0;
}

But I cannot reproduce this solution for Qt because when I replace EMSCRIPTEN_EVENT_TARGET_DOCUMENT with #canvas the target is null:

It is because the Qt's canvas doesn't have id="canvas" for the <canvas> element:

8Observer8 · 2024-06-28T10:12:31Z

I have tried to replace EMSCRIPTEN_EVENT_TARGET_DOCUMENT with EMSCRIPTEN_EVENT_TARGET_SCREEN. I works for pure Emscripten: emcc -g main.cpp -o public/index.html

main.cpp

#include <emscripten.h>
#include <emscripten/html5.h>
#include <iostream>

int main()
{
    // Mouse Button Down:
    emscripten_set_mousedown_callback(
        "#canvas", nullptr, 0, +[](int eventType,
            const EmscriptenMouseEvent *e, void *userData) -> EM_BOOL
        {
            EMSCRIPTEN_RESULT result = emscripten_request_pointerlock(
                EMSCRIPTEN_EVENT_TARGET_SCREEN, true);
            std::cout << result << std::endl;
            return EM_FALSE;
        });

    return 0;
}

But why doesn't EMSCRIPTEN_EVENT_TARGET_SCREEN works in Qt?

#include <QtGui/QMouseEvent>
#include <QtGui/QOpenGLFunctions>
#include <QtOpenGL/QOpenGLWindow>
#include <QtWidgets/QApplication>

#ifdef Q_OS_WASM
#include <emscripten.h>
#include <emscripten/html5.h>
#endif

class OpenGLWindow : public QOpenGLWindow, private QOpenGLFunctions
{

public:

    OpenGLWindow()
    {
        setTitle("OpenGL ES 2.0, Qt6, C++");
        resize(350, 350);
    }

private:

    void mousePressEvent(QMouseEvent *event) override
    {
        Q_UNUSED(event);

        EMSCRIPTEN_RESULT result = emscripten_request_pointerlock(
            EMSCRIPTEN_EVENT_TARGET_SCREEN, true);
        qDebug() << result;
    }

    virtual void initializeGL() override
    {
        initializeOpenGLFunctions();
        glClearColor(0.2f, 0.2f, 0.2f, 1.f);
    }

    virtual void paintGL() override
    {
        glClear(GL_COLOR_BUFFER_BIT);
    }
};

int main(int argc, char *argv[])
{
    QApplication::setAttribute(Qt::ApplicationAttribute::AA_UseDesktopOpenGL);
    QApplication app(argc, argv);
    OpenGLWindow w;
    w.show();
    return app.exec();
}

8Observer8 · 2024-06-28T10:18:50Z

maybeCStringToJsString returns something wrong:

8Observer8 · 2024-06-28T10:24:29Z

I have tried EMSCRIPTEN_EVENT_TARGET_SCREEN again but it doesn't work now: emcc -g main.cpp -o public/index.html It has the same error as Qt's build. I don't know why it worked before. Maybe I have made something wrong.

main.cpp

#include <emscripten.h>
#include <emscripten/html5.h>
#include <iostream>

int main()
{
    // Mouse Button Down:
    emscripten_set_mousedown_callback(
        "#canvas", nullptr, 0, +[](int eventType,
            const EmscriptenMouseEvent *e, void *userData) -> EM_BOOL
        {
            EMSCRIPTEN_RESULT result = emscripten_request_pointerlock(
                EMSCRIPTEN_EVENT_TARGET_SCREEN, true);
            std::cout << result << std::endl;
            return EM_FALSE;
        });

    return 0;
}

8Observer8 · 2024-06-28T10:35:05Z

Another trying. Qt has a div element with id="screen". The emscripten_request_pointerlock returns EMSCRIPTEN_RESULT_DEFERRED (1):

main.cpp

#include <QtGui/QMouseEvent>
#include <QtGui/QOpenGLFunctions>
#include <QtOpenGL/QOpenGLWindow>
#include <QtWidgets/QApplication>

#ifdef Q_OS_WASM
#include <emscripten.h>
#include <emscripten/html5.h>
#endif

class OpenGLWindow : public QOpenGLWindow, private QOpenGLFunctions
{

public:

    OpenGLWindow()
    {
        setTitle("OpenGL ES 2.0, Qt6, C++");
        resize(350, 350);
    }

private:

    void mousePressEvent(QMouseEvent *event) override
    {
        Q_UNUSED(event);

        EMSCRIPTEN_RESULT result = emscripten_request_pointerlock("#screen", true);
        qDebug() << result;
    }

    virtual void initializeGL() override
    {
        initializeOpenGLFunctions();
        glClearColor(0.2f, 0.2f, 0.2f, 1.f);
    }

    virtual void paintGL() override
    {
        glClear(GL_COLOR_BUFFER_BIT);
    }
};

int main(int argc, char *argv[])
{
    QApplication::setAttribute(Qt::ApplicationAttribute::AA_UseDesktopOpenGL);
    QApplication app(argc, argv);
    OpenGLWindow w;
    w.show();
    return app.exec();
}

8Observer8 · 2024-06-28T10:39:38Z

I have tried to replace the second argument of emscripten_request_pointerlock from true to false but emscripten_request_pointerlock returns EMSCRIPTEN_RESULT_FAILED_NOT_DEFERRED (-2):

main.cpp

#include <QtGui/QMouseEvent>
#include <QtGui/QOpenGLFunctions>
#include <QtOpenGL/QOpenGLWindow>
#include <QtWidgets/QApplication>

#ifdef Q_OS_WASM
#include <emscripten.h>
#include <emscripten/html5.h>
#endif

class OpenGLWindow : public QOpenGLWindow, private QOpenGLFunctions
{

public:

    OpenGLWindow()
    {
        setTitle("OpenGL ES 2.0, Qt6, C++");
        resize(350, 350);
    }

private:

    void mousePressEvent(QMouseEvent *event) override
    {
        Q_UNUSED(event);

        EMSCRIPTEN_RESULT result = emscripten_request_pointerlock("#screen", false);
        qDebug() << result;
    }

    virtual void initializeGL() override
    {
        initializeOpenGLFunctions();
        glClearColor(0.2f, 0.2f, 0.2f, 1.f);
    }

    virtual void paintGL() override
    {
        glClear(GL_COLOR_BUFFER_BIT);
    }
};

int main(int argc, char *argv[])
{
    QApplication::setAttribute(Qt::ApplicationAttribute::AA_UseDesktopOpenGL);
    QApplication app(argc, argv);
    OpenGLWindow w;
    w.show();
    return app.exec();
}

8Observer8 · 2024-06-28T10:49:30Z

Here is the true case:

        EMSCRIPTEN_RESULT result = emscripten_request_pointerlock("#screen", true);
        qDebug() << result;

The problem is here:

var canPerformRequests = JSEvents.canPerformEventHandlerRequests();

canPerformRequests returns 0. How do you think why JSEvents.inEventHandler is 0:

and JSEvents.currentEventHandler is undefined:

8Observer8 · 2024-06-28T10:57:37Z

But when I pass false here:

        EMSCRIPTEN_RESULT result = emscripten_request_pointerlock("#screen", false);
        qDebug() << result;

the JSEvents.currentEventHandler is not undefined:

but SEvents.inEventHandler is 0:

and JSEvents.currentEventHandler.allowsDeferredCalls is undefined:

sbc100 · 2024-06-28T16:56:59Z

I have tried to replace the second argument of emscripten_request_pointerlock from true to false

Why? Leaving it as true and having EMSCRIPTEN_RESULT_DEFERRED seems like it is working as intended? What is wrong in that case?

8Observer8 · 2024-06-28T18:44:24Z

Why? Leaving it as true and having EMSCRIPTEN_RESULT_DEFERRED seems like it is working as intended? What is wrong in that case?

I have tried both case: true and false in two posts above. You can see the true case in this post You can see the result there.

sbc100 · 2024-06-28T18:54:53Z

You said in #22133 (comment) that is returns EMSCRIPTEN_RESULT_DEFERRED.. which would be the correct/working/expected result I think.

sbc100 · 2024-06-28T20:44:38Z

In deferred mode you don't want to be calling requestPointerLock during the call itself. Instead the call to requestPointerLock is "deffered" until later when will succeed.

Does the differed mode not work for for some reason?

8Observer8 · 2024-06-28T21:06:55Z

Locking doesn't work. I click in the client area and see 1 in the console every time when I click.

sbc100 · 2024-06-28T21:24:07Z

I think with the differed mode the actual locking won't happen until the next event. If you click again does the lock take effect?

sbc100 · 2024-06-28T21:25:17Z

BTW, 1 means EMSCRIPTEN_RESULT_DEFERRED mean the locking will occur on the next event.. so that is form of success.

8Observer8 · 2024-06-28T23:14:55Z

If you click again does the lock take effect?

No:

I have uploaded the result build to the free hosting: https://667f439855614296d369a205--small-opengles2-examples-qt6-cpp.netlify.app/

main.cpp

#include <QtGui/QMouseEvent>
#include <QtGui/QOpenGLFunctions>
#include <QtOpenGL/QOpenGLWindow>
#include <QtWidgets/QApplication>

#ifdef Q_OS_WASM
#include <emscripten.h>
#include <emscripten/html5.h>
#endif

class OpenGLWindow : public QOpenGLWindow, private QOpenGLFunctions
{

public:

    OpenGLWindow()
    {
        setTitle("OpenGL ES 2.0, Qt6, C++");
        resize(350, 350);
    }

private:

    void mousePressEvent(QMouseEvent *event) override
    {
        Q_UNUSED(event);

        EMSCRIPTEN_RESULT result = emscripten_request_pointerlock("#screen", true);
        qDebug() << result;
    }

    virtual void initializeGL() override
    {
        initializeOpenGLFunctions();
        glClearColor(0.2f, 0.2f, 0.2f, 1.f);
    }

    virtual void paintGL() override
    {
        glClear(GL_COLOR_BUFFER_BIT);
    }
};

int main(int argc, char *argv[])
{
    QApplication::setAttribute(Qt::ApplicationAttribute::AA_UseDesktopOpenGL);
    QApplication app(argc, argv);
    OpenGLWindow w;
    w.show();
    return app.exec();
}

pro

QT += core gui openglwidgets

win32: LIBS += -lopengl32

CONFIG += c++17

wasm: INCLUDEPATH += "C:\emsdk\upstream\emscripten\cache\sysroot\include"

SOURCES += \
    main.cpp

sbc100 · 2024-06-28T23:20:18Z

So the problem here seems to be that the differed action is not working?

I guess we need to looking to the call to JSEvents.deferCall to see why the deferred call the requestPointerLock is not being made at some later time.

Can you set a breakpoint in the runDeferredCalls function or add some logging there to see why its not being run?

8Observer8 · 2024-06-28T23:47:10Z

My steps:

I have opened the link: https://667f439855614296d369a205--small-opengles2-examples-qt6-cpp.netlify.app/
I have opened the "Source" tab
I have found runDeferredCalls
I have set a breakpoint inside of runDeferredCalls
I have run an application and make clicks in the client area of the browser but nothing happens (the application is not stopped):

8Observer8 · 2024-07-02T17:59:08Z

The application is not stopped inside of the runDeferredCalls function:

sbc100 · 2024-07-02T18:14:03Z

Sounds like perhaps a bug in the differed call mechanism. I'm not very familiar with that or if/how it gets tested I'm afraid.

emscripten_set_mousedown_callback does not call the callback function from Qt Creator #22133

emscripten_set_mousedown_callback does not call the callback function from Qt Creator #22133

Comments

8Observer8 commented Jun 22, 2024 • edited Loading

sbc100 commented Jun 22, 2024

8Observer8 commented Jun 22, 2024

sbc100 commented Jun 22, 2024

8Observer8 commented Jun 26, 2024 • edited Loading

sbc100 commented Jun 26, 2024

8Observer8 commented Jun 27, 2024 • edited Loading

sbc100 commented Jun 27, 2024

8Observer8 commented Jun 27, 2024 • edited Loading

sbc100 commented Jun 27, 2024

sbc100 commented Jun 27, 2024

8Observer8 commented Jun 27, 2024 • edited Loading

8Observer8 commented Jun 27, 2024

sbc100 commented Jun 27, 2024

8Observer8 commented Jun 27, 2024 • edited Loading

sbc100 commented Jun 27, 2024

8Observer8 commented Jun 27, 2024 • edited Loading

8Observer8 commented Jun 28, 2024 • edited Loading

8Observer8 commented Jun 28, 2024 • edited Loading

8Observer8 commented Jun 28, 2024 • edited Loading

8Observer8 commented Jun 28, 2024

8Observer8 commented Jun 28, 2024

8Observer8 commented Jun 28, 2024

8Observer8 commented Jun 28, 2024

8Observer8 commented Jun 28, 2024

8Observer8 commented Jun 28, 2024 • edited Loading

8Observer8 commented Jun 28, 2024

sbc100 commented Jun 28, 2024

8Observer8 commented Jun 28, 2024 • edited Loading

sbc100 commented Jun 28, 2024

sbc100 commented Jun 28, 2024

8Observer8 commented Jun 28, 2024 • edited Loading

sbc100 commented Jun 28, 2024

sbc100 commented Jun 28, 2024

8Observer8 commented Jun 28, 2024 • edited Loading

sbc100 commented Jun 28, 2024

8Observer8 commented Jun 28, 2024 • edited Loading

8Observer8 commented Jul 2, 2024 • edited Loading

sbc100 commented Jul 2, 2024

`emscripten_set_mousedown_callback` does not call the callback function from Qt Creator #22133

`emscripten_set_mousedown_callback` does not call the callback function from Qt Creator #22133

8Observer8 commented Jun 22, 2024 •

edited

Loading

8Observer8 commented Jun 26, 2024 •

edited

Loading

8Observer8 commented Jun 27, 2024 •

edited

Loading

8Observer8 commented Jun 27, 2024 •

edited

Loading

8Observer8 commented Jun 27, 2024 •

edited

Loading

8Observer8 commented Jun 27, 2024 •

edited

Loading

8Observer8 commented Jun 27, 2024 •

edited

Loading

8Observer8 commented Jun 28, 2024 •

edited

Loading

8Observer8 commented Jun 28, 2024 •

edited

Loading

8Observer8 commented Jun 28, 2024 •

edited

Loading

8Observer8 commented Jun 28, 2024 •

edited

Loading

8Observer8 commented Jun 28, 2024 •

edited

Loading

8Observer8 commented Jun 28, 2024 •

edited

Loading

8Observer8 commented Jun 28, 2024 •

edited

Loading

8Observer8 commented Jun 28, 2024 •

edited

Loading

8Observer8 commented Jul 2, 2024 •

edited

Loading