Integrate custom graphics of QGraphicsScene via QPainter

[ubruhin]

Hi,

I have a large C++/QtWidgets application (LibrePCB) making heavy use of QGraphicsScene and am evaluating alternative UI toolkits - in particular QtQuick and Slint. But for a step-by-step migration, I need a way to integrate the already existing QGraphicsScene since a rewrite of it would be too much effort.

In QtQuick I was able to build a PoC using QQuickPaintedItem which provides a QPainter where I can render the scene with QGraphicsScene::render(). Works quite well so far.

If I understand correctly, the Qt backend of Slint uses QPainter for drawing the whole window. So I wonder if it would be possible to draw on the window through this QPainter? Ideally in background, so that Slint controls can be used as overlay on the painted scene.

Is it possible to get access to the QPainter of the Qt backend from C++? Or any other idea how to integrate a QGraphicsScene?

Another story is whether Slint works together with a Qt application at all, as probably I need to run Qt's event loop somehow to get all the events etc. working - or would this even work out of the box with the Qt backend 🤔 EDIT: This seems to work indeed!

Thanks!

[tronical]

At this point we do not expose the QPainter the Qt backend uses. We do expose a QWidget in the C++ API, but that's not something I think we'd like to keep forever. Perhaps you could layer that with translucency on top of a QGraphicsWidget.

Generally speaking, composition of a scene rendered with Slint controls on top of another scene should always be possible one way or another.

[ubruhin]

Oh...hmm... you mean reparenting the QWidget 🤔 That sounds interesting, but I'm a bit concerned that the QWidget will no longer be the root window, which might break some functionality of the Qt backend 🤔

Anyway, I gave it a quick try:

  QMainWindow win;
  win.resize(800, 600);

  QGraphicsView* view = new QGraphicsView(&win);
  view->setScene(...);

  QWidget* widget =
      static_cast<QWidget*>(slint::cbindgen_private::slint_qt_get_widget(
          &ui->window().window_handle()));
  widget->setParent(&win);

It works somehow, with some drawbacks:

• Both widgets need to be resized manually when the window is resized (ok, one of them can be done with Qt layouts).
• Input events are not forwarded to QGraphicsView as transparent background != transparent for input events. Could be worked around by placing a TouchArea over QGraphicsView and manually forwarding the events.
• There's some issue with repainting when switching between transparent and non-transparent content (resizing window removes the artifacts):
  

Overall this way feels very hacky to me, not really viable for a large, professional software. Will need to think about it if and how we could use Slint for the GUI. Thanks anyway for your help so far 👍

[ogoffart]

Another option to look at is QGraphicsProxyWidget to put the Slint layer somehow within the graphicsscene.

Btw, to get the widget, you can use:

QWidget* widget = ui->qwidget();

https://releases.slint.dev/1.7.1/docs/cpp/api/classslint_1_1interpreter_1_1componentinstance#_CPPv4NK5slint11interpreter17ComponentInstance7qwidgetEv

Regarding the resizing, i think this is a bug, maybe #5563 or #3990 or some other.

[ubruhin]

I think QGraphicsProxyWidget can't help us since basically we need to embed a graphics scene (or in fact, multiple graphics scenes) into the Slint UI, not the other way around. Also the graphics scenes are not always there, they will be part of tabs while the outer UI (e.g. the panel on the left in my screenshots above) are static.

I wonder whether it would be possible to extend the RenderingNotifier callback to work also on non-GL backends, to allow native, backend-dependent painting in BeforeRendering or AfterRendering events 🤔 With the Qt backend it could mean to pass the QPainter* to the application so we can draw custom underlays and overlays, the same way as we could do with OpenGL.

Btw, to get the widget, you can use:

QWidget* widget = ui->qwidget();

Ah I didn't find that, thanks for the hint 👍

[ogoffart]

Yes, i think it'd indeed make sense to extend the rendering notifier API to the Qt backend.
(i don't think we need a shared QPainter. You can just pass a QWidget* and one can re-create a QPainter for it)

[ubruhin]

Oh, just for the record, I found another way which could be interesting:

 class EventFilter : public QObject {
  public:
    EventFilter(slint::ComponentHandle<ui::AppWindow> app, GraphicsScene* scene)
      : QObject(), app(app), scene(scene) {}

    virtual bool eventFilter(QObject* watched, QEvent* event) override {
      if (event->type() == QEvent::Paint) {
        QPainter painter(static_cast<QWidget*>(watched));
        myGraphicsScene->render(&painter);
      }
      return QObject::eventFilter(watched, event);
    }
  };

auto app = ui::AppWindow::create();
QWidget* widget =
      static_cast<QWidget*>(slint::cbindgen_private::slint_qt_get_widget(
          &app->window().window_handle()));
widget->installEventFilter(new EventFilter());

This seems to work pretty well as far as I can see.

Btw, for some reason the qwidget() method doesn't exist in my AppWindow class (though I don't understand how it is related to the ComponentInstance class) 🤔 Using Slint 1.7.1 and the Qt backend is obviously there as the code above works fine.