feat(qt6): QOpenGLWidget-based plot widget and demo

adapters/qt6/CMakeLists.txt

@@ -0,0 +1,37 @@
+# The Qt6 adapter: a QOpenGLWidget that renders a plot into its own framebuffer
+# and drives it from Qt's events. It is the third host, and the first whose
+# toolkit already owns a GL widget -- so the interesting parts are the surface
+# format the application must have set before the widget exists (documented on
+# the class) and the device-pixel-ratio mapping between Qt's logical coordinates
+# and the framebuffer pixels the library speaks.
+#
+# Unlike the GLFW and ImGui adapters this one is not fetched: Qt is a system SDK,
+# and a project that enables this target is asking for the installed one.
+find_package(Qt6 QUIET COMPONENTS Core Gui Widgets OpenGLWidgets)
+
+if(NOT Qt6_FOUND)
+  message(FATAL_ERROR
+    "plot: PLOT_BUILD_QT6 is ON but Qt6 was not found (need the Core, Gui, Widgets"
+    " and OpenGLWidgets components). Install Qt6 -- on Arch, qt6-base -- or"
+    " configure with -DPLOT_BUILD_QT6=OFF, or point CMAKE_PREFIX_PATH at the Qt6"
+    " installation.")
+endif()
+
+add_library(plot_qt6 STATIC qt_plot_widget.cpp qt_plot_widget.hpp)
+add_library(plot::qt6 ALIAS plot_qt6)
+# The public include root is `adapters/`, so the header is reached as
+# <qt6/qt_plot_widget.hpp> -- the toolkit's name first, like every other adapter's.
+target_include_directories(plot_qt6 PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/..")
+# Qt is PUBLIC, unlike GLFW and ImGui: the widget's header derives from
+# QOpenGLWidget, so a consumer needs Qt's headers and libraries to use it at all.
+target_link_libraries(plot_qt6 PUBLIC
+  plot::core
+  Qt6::Core
+  Qt6::Gui
+  Qt6::Widgets
+  Qt6::OpenGLWidgets)
+# The widget declares Q_OBJECT, so its header has to go through moc. The property
+# is set on this target rather than globally: no other target in the project has a
+# Qt class in it, and AUTOMOC scans every source of a target it is set on.
+set_target_properties(plot_qt6 PROPERTIES AUTOMOC ON)
+plot_apply_warnings(plot_qt6)

adapters/qt6/qt_plot_widget.cpp

@@ -0,0 +1,291 @@
+#include <qt6/qt_plot_widget.hpp>
+
+#include <plot/gl/loader.hpp>
+
+#include <QKeyEvent>
+#include <QMouseEvent>
+#include <QOpenGLContext>
+#include <QPointF>
+#include <QWheelEvent>
+
+#include <chrono>
+#include <cmath>
+#include <cstdio>
+#include <cstring>
+
+namespace plot::qt {
+namespace {
+
+/// The entry points `QOpenGLContext::getProcAddress()` could not provide, as
+/// passed to `plot::gl::load()`. `load()` may still resolve them through its
+/// dlsym fallback, but only the context-aware resolver is guaranteed to return
+/// pointers valid for the current context, so a fallback is worth reporting.
+/// Process-global and written only from the context's owning thread, which is the
+/// only thread `initializeGL()` runs on.
+constexpr u32 kMaxUnresolved = 16;
+const char* g_unresolved[kMaxUnresolved] = {};
+u32 g_unresolved_count = 0;
+
+/// Qt's own resolver for the current context, as `plot::gl::ProcLoader`.
+///
+/// `getProcAddress()` returns Qt's `QFunctionPointer` (`void (*)()`), the loader
+/// wants `void*`: a function pointer respelled as an object pointer. POSIX
+/// guarantees the two have the same representation, and the bit copy states that
+/// where a `reinterpret_cast` is merely conditionally supported -- the same
+/// reasoning the GLFW adapter uses for `glfwGetProcAddress`.
+void* resolve_via_qt(const char* name) noexcept {
+  QOpenGLContext* context = QOpenGLContext::currentContext();
+  if (context == nullptr) return nullptr;
+  const QFunctionPointer proc = context->getProcAddress(name);
+  void* out = nullptr;
+  static_assert(sizeof(out) == sizeof(proc), "function and object pointers must match");
+  std::memcpy(&out, &proc, sizeof(out));
+  if (out == nullptr && g_unresolved_count < kMaxUnresolved) {
+    g_unresolved[g_unresolved_count++] = name;
+  }
+  return out;
+}
+
+/// Qt's modifier flags as the controller's translatable mask. Unlike GLFW's
+/// GLFW_MOD_* these are Qt's own bits, so this is a genuine translation and not
+/// the reinterpretation the GLFW adapter gets away with.
+u32 mods_from(Qt::KeyboardModifiers mods) noexcept {
+  u32 out = 0;
+  if (mods.testFlag(Qt::ShiftModifier)) out |= static_cast<u32>(input::Mod::Shift);
+  if (mods.testFlag(Qt::ControlModifier)) out |= static_cast<u32>(input::Mod::Ctrl);
+  if (mods.testFlag(Qt::AltModifier)) out |= static_cast<u32>(input::Mod::Alt);
+  if (mods.testFlag(Qt::MetaModifier)) out |= static_cast<u32>(input::Mod::Super);
+  return out;
+}
+
+/// The controller has no gesture for the auxiliary buttons, and Qt always names
+/// one of the three on a press or a release -- the only events whose button is
+/// read. A move's `Qt::NoButton` maps to Left, which nothing looks at.
+input::Button button_from(Qt::MouseButton button) noexcept {
+  switch (button) {
+    case Qt::MiddleButton: return input::Button::Middle;
+    case Qt::RightButton: return input::Button::Right;
+    default: return input::Button::Left;
+  }
+}
+
+/// True while any button the controller has a gesture for is held.
+bool any_plot_button(Qt::MouseButtons buttons) noexcept {
+  return buttons.testFlag(Qt::LeftButton) || buttons.testFlag(Qt::MiddleButton) ||
+         buttons.testFlag(Qt::RightButton);
+}
+
+f64 now_s() noexcept {
+  return std::chrono::duration<f64>(std::chrono::steady_clock::now().time_since_epoch()).count();
+}
+
+}  // namespace
+
+PlotWidget::PlotWidget(Plot& plot, QWidget* parent)
+    : QOpenGLWidget(parent), plot_(&plot), controller_(plot) {
+  // Hover has to reach the plot: the controller's cursor hit test reads the last
+  // pointer position even while no button is down.
+  setMouseTracking(true);
+  // The controller's keys (+, - and f) are input to the plot, and a widget without
+  // a focus policy never receives a key event.
+  setFocusPolicy(Qt::StrongFocus);
+}
+
+PlotWidget::~PlotWidget() {
+  // The renderer's RAII handles call glDelete*, which needs the context current
+  // and alive. This body runs before ~QOpenGLWidget tears the context down, which
+  // is what makes makeCurrent() valid here -- and `renderer_` is engaged only if
+  // initializeGL() ran, so there is a context to make current.
+  if (renderer_) {
+    makeCurrent();
+    renderer_.reset();
+    doneCurrent();
+  }
+}
+
+void PlotWidget::initializeGL() {
+  initializeOpenGLFunctions();
+
+  // A second call means Qt recreated the context (the widget moved to another
+  // screen or window): the names the renderer holds belonged to the old context,
+  // and nothing here may outlive it. This runs before anything of ours is created
+  // on the new context, so the deletes it issues can only name objects that are
+  // not there.
+  renderer_.reset();
+
+  g_unresolved_count = 0;
+  if (!plot::gl::load(&resolve_via_qt)) {
+    init_status_ = Status{ErrorCode::Unsupported,
+                          "plot::gl::load() failed: the current context is missing a required"
+                          " OpenGL 3.3 entry point"};
+    std::fprintf(stderr, "[plot::qt6] %s\n", init_status_.message);
+    return;
+  }
+  if (g_unresolved_count > 0) {
+    std::fprintf(stderr,
+                 "[plot::qt6] QOpenGLContext::getProcAddress() did not resolve %u required"
+                 " entry point(s); plot::gl::load() used its dlsym fallback for:",
+                 g_unresolved_count);
+    for (u32 i = 0; i < g_unresolved_count; ++i) std::fprintf(stderr, " %s", g_unresolved[i]);
+    std::fprintf(stderr, "\n");
+  }
+
+  renderer_.emplace();
+  Status status;
+  if (!renderer_->init(&status)) {
+    init_status_ = status.code != ErrorCode::Ok
+                       ? status
+                       : Status{ErrorCode::GLFailure, "Renderer::init() failed"};
+    // Leave the renderer engaged: its destructor is what releases whatever the
+    // partial init did build, and it runs with the context current.
+    std::fprintf(stderr, "[plot::qt6] Renderer::init(): %s: %s\n", to_string(init_status_.code),
+                 init_status_.message);
+    return;
+  }
+  init_status_ = Status{};
+  refresh_viewport();
+}
+
+void PlotWidget::resizeGL(int w, int h) {
+  (void)w;
+  (void)h;
+  // Nothing about the size is cached: `paintGL()` derives the viewport from the
+  // live geometry every frame, so a frame can never be drawn at a stale size.
+  // Refreshing it here as well means a gesture that arrives between the resize and
+  // the next paint maps against the new geometry rather than the old one.
+  refresh_viewport();
+}
+
+void PlotWidget::paintGL() {
+  if (!renderer_ || !renderer_->ready()) return;
+
+  const Rect viewport = device_viewport();
+  if (viewport.w < 1.0f || viewport.h < 1.0f) return;  // nothing to draw into
+
+  // The controller owns no viewport: this hands it to the plot (which re-lays the
+  // chrome out with it) and refreshes the layout, so every frame is laid out for
+  // the geometry of *this* frame. A resize changes the layout; it never scales a
+  // stale one.
+  controller_.set_viewport(viewport);
+
+  const f64 started = now_s();
+  const f64 dt = last_paint_s_ >= 0.0 ? started - last_paint_s_ : 0.0;
+  last_paint_s_ = started;
+  if (frame_) frame_(*plot_, dt);
+
+  renderer_->begin_frame(static_cast<u32>(viewport.w), static_cast<u32>(viewport.h), viewport);
+  renderer_->draw(*plot_);
+  renderer_->end_frame();
+  const f32 frame_ms = static_cast<f32>((now_s() - started) * 1.0e3);
+  last_frame_ms_ = frame_ms;
+  // Seeded by the first frame rather than started at zero, so the mean is the mean
+  // of the frames that ran from the first one.
+  mean_frame_ms_ = frames_ == 0 ? frame_ms : mean_frame_ms_ + 0.1f * (frame_ms - mean_frame_ms_);
+  last_viewport_ = viewport;
+  ++frames_;
+}
+
+Rect PlotWidget::device_viewport() const noexcept {
+  // Logical -> device pixels, rounded: at 1.25 a 1023-pixel-wide widget is
+  // 1278.75 device pixels, which must cover 1279 framebuffer columns or the last
+  // one is left outside the plot (and outside the renderer's clear).
+  const f64 dpr = static_cast<f64>(devicePixelRatioF());
+  const long w = std::lround(static_cast<f64>(width()) * dpr);
+  const long h = std::lround(static_cast<f64>(height()) * dpr);
+  return Rect{0.0f, 0.0f, static_cast<f32>(w), static_cast<f32>(h)};
+}
+
+Vec2 PlotWidget::to_device(const QPointF& p) const noexcept {
+  // The same factor `device_viewport()` scales the widget by, applied to a
+  // position and to the deltas derived from two of them. One convention on both
+  // sides is what makes a gesture land on the data under the cursor.
+  const f64 dpr = static_cast<f64>(devicePixelRatioF());
+  return Vec2{static_cast<f32>(p.x() * dpr), static_cast<f32>(p.y() * dpr)};
+}
+
+void PlotWidget::refresh_viewport() { controller_.set_viewport(device_viewport()); }
+
+void PlotWidget::forward_pointer(QMouseEvent* event, bool pressed, bool released) {
+  const Vec2 p = to_device(event->position());
+  input::PointerEvent e;
+  e.x = p.x;
+  e.y = p.y;
+  if (have_pointer_) {
+    e.dx = p.x - last_x_;
+    e.dy = p.y - last_y_;
+  }
+  // A press is also a pointer sample: the next move's delta starts here, or the
+  // first motion of a drag would include the jump to the click.
+  last_x_ = p.x;
+  last_y_ = p.y;
+  have_pointer_ = true;
+  e.button = button_from(event->button());
+  e.mods = mods_from(event->modifiers());
+  e.down = any_plot_button(event->buttons());
+  e.pressed = pressed;
+  e.released = released;
+  controller_.on_pointer(e);
+  event->accept();
+  update();
+}
+
+void PlotWidget::mousePressEvent(QMouseEvent* event) { forward_pointer(event, true, false); }
+
+void PlotWidget::mouseMoveEvent(QMouseEvent* event) { forward_pointer(event, false, false); }
+
+void PlotWidget::mouseReleaseEvent(QMouseEvent* event) { forward_pointer(event, false, true); }
+void PlotWidget::mouseDoubleClickEvent(QMouseEvent* event) { forward_pointer(event, true, false); }
+
+void PlotWidget::wheelEvent(QWheelEvent* event) {
+  // Qt reports eighths of a degree, 120 to a notch; the controller takes notches,
+  // positive = zoom in, which is Qt's positive angleDelta().y() as well (the wheel
+  // pushed away from the user). Passing the raw delta would zoom 120x too far.
+  const f32 notches = static_cast<f32>(event->angleDelta().y()) / 120.0f;
+  if (notches == 0.0f) {
+    // A horizontal-only wheel is not a zoom, and it must not reach the controller:
+    // a zero-notch zoom changes no range but still runs the range setters, which
+    // clear auto scale -- so a stray horizontal scroll would silently stop a live
+    // axis from following its stream. Ignored, so an enclosing scroll area may
+    // still act on it.
+    event->ignore();
+    return;
+  }
+  const Vec2 p = to_device(event->position());
+  input::WheelEvent e;
+  e.x = p.x;
+  e.y = p.y;
+  e.dx = static_cast<f32>(event->angleDelta().x()) / 120.0f;
+  e.dy = notches;
+  e.mods = mods_from(event->modifiers());
+  controller_.on_wheel(e);
+  event->accept();
+  update();
+}
+
+void PlotWidget::keyPressEvent(QKeyEvent* event) {
+  int mapped = 0;
+  switch (event->key()) {
+    // The controller zooms on '+', which on most layouts is shift+'='; '=' is
+    // mapped to it as well, so both spellings zoom in -- the pair the GLFW adapter
+    // maps. Shift+'-' arrives as its own key, and zooms out like '-'.
+    case Qt::Key_Plus:
+    case Qt::Key_Equal: mapped = input::kKeyZoomIn; break;
+    case Qt::Key_Minus:
+    case Qt::Key_Underscore: mapped = input::kKeyZoomOut; break;
+    case Qt::Key_F: mapped = input::kKeyFit; break;
+    default:
+      QOpenGLWidget::keyPressEvent(event);  // not a plot key: nobody else wants it
+      return;
+  }
+  input::KeyEvent e;
+  e.key = mapped;
+  e.mods = mods_from(event->modifiers());
+  // Qt reports a held key as repeated presses and sends no release until the key
+  // is physically released, so the repeat is what makes a held key keep acting.
+  e.down = true;
+  controller_.on_key(e);
+  event->accept();
+  update();
+}
+
+}  // namespace plot::qt

adapters/qt6/qt_plot_widget.hpp

@@ -0,0 +1,208 @@
+#pragma once
+
+// The plot headers come first, and must. Qt's <QOpenGLWidget> reaches
+// <QtGui/qopengl.h>, which on a desktop platform includes the system <GL/gl.h>;
+// that header defines GL_TRUE, GL_COLOR_BUFFER_BIT, GL_TEXTURE_2D and the rest as
+// preprocessor macros, and those are exactly the names plot/gl/api.hpp declares as
+// enumerators -- a macro rewrite turns each definition into nonsense. Parsing
+// api.hpp before the macros exist is what lets the two coexist (the GLFW adapter
+// sidesteps the same clash with GLFW_INCLUDE_NONE, which Qt offers no equivalent
+// of). A translation unit that uses this widget must keep the same order for
+// anything it includes itself, and must not name a `plot::gl::GL_*` enumerator
+// after a Qt header that reaches GL has been included: the macro rewrites that
+// token wherever it appears, namespace and all.
+#include <plot/core/rect.hpp>
+#include <plot/core/status.hpp>
+#include <plot/core/types.hpp>
+#include <plot/input/controller.hpp>
+#include <plot/math/vec2.hpp>
+#include <plot/plot/plot.hpp>
+#include <plot/render/renderer.hpp>
+
+#include <QOpenGLFunctions>
+#include <QOpenGLWidget>
+
+#include <functional>
+#include <optional>
+#include <utility>
+
+class QKeyEvent;
+class QMouseEvent;
+class QPointF;
+class QWheelEvent;
+
+namespace plot::qt {
+
+/// Embeds a `Plot` in a Qt widget: a `QOpenGLWidget` whose framebuffer the plot
+/// is rendered into, with Qt's own input events translated into `plot::input`
+/// ones.
+///
+/// `QOpenGLWidget` renders into an FBO of its own, which it binds before calling
+/// `paintGL()` -- exactly the "currently bound framebuffer" `Renderer` documents
+/// it draws into. The widget therefore never creates a target of its own, and the
+/// renderer's scissor-cleared viewport is the widget's whole rectangle. Nothing is
+/// rendered to a texture or through a second pass: the plot is what Qt composes,
+/// and the widget's other content (Qt draws none; a `QOpenGLWidget` is opaque)
+/// would be drawn around it.
+///
+/// ## The surface format is a precondition, not a setting
+///
+/// This widget cannot ask for a context version: Qt hands a widget the
+/// *application default* `QSurfaceFormat` at the moment its context is created,
+/// and a context cannot be renegotiated afterwards. An embedding application must
+/// therefore have done this before the widget exists:
+///
+///     QSurfaceFormat fmt;
+///     fmt.setVersion(3, 3);
+///     fmt.setProfile(QSurfaceFormat::CoreProfile);
+///     fmt.setSwapBehavior(QSurfaceFormat::DoubleBuffer);
+///     fmt.setDepthBufferSize(0);
+///     fmt.setStencilBufferSize(0);
+///     QSurfaceFormat::setDefaultFormat(fmt);
+///     QCoreApplication::setAttribute(Qt::AA_UseDesktopOpenGL);  // before QApplication
+///
+/// The last line matters as much as the rest: an ES or ANGLE backend has no 3.3
+/// core profile to give, and this library's loader resolves desktop entry points.
+/// `initializeGL()` reports the failure through `init_status()` rather than
+/// asserting, but it cannot repair a format that was already decided.
+///
+/// ## The coordinate convention: device pixels, both sides
+///
+/// Two pixel spaces meet here, exactly as they do in the GLFW and ImGui adapters.
+/// Qt reports widget geometry and mouse positions in **logical** pixels
+/// (`width()`, `QMouseEvent::position()`), while the widget's framebuffer -- what
+/// `Renderer::begin_frame()` takes and what every `Rect` in this library speaks --
+/// is in **device** pixels, `devicePixelRatioF()` times as large on a scaled
+/// display.
+///
+/// This widget converts everything into device pixels and keeps it there:
+///
+///   * the viewport handed to the plot is `round(width() * dpr)` x
+///     `round(height() * dpr)` (rounded, not truncated, so the last column of the
+///     FBO is inside the plot), and
+///   * every pointer, wheel and key anchor is multiplied by the same
+///     `devicePixelRatioF()` before it reaches the controller, deltas included.
+///
+/// `device_viewport()` and `to_device()` are the only two places that mapping
+/// exists, so the viewport and the input cannot disagree -- and they must not: a
+/// mismatch renders correctly but pans by the wrong amount, which is invisible on
+/// an unscaled display and wrong on every other one.
+///
+/// ## Input
+///
+/// Qt reports levels and edges directly (`QMouseEvent` press/release are edges,
+/// `buttons()` is the state after the event), so the translation is a
+/// reinterpretation rather than the edge synthesis the ImGui adapter needs.
+/// Wheel input is the one unit conversion: Qt's `angleDelta()` is in eighths of a
+/// degree, 120 to a notch, while `Controller::on_wheel()` takes notches, positive
+/// = zoom in -- which is Qt's positive `angleDelta().y()` too. A wheel event with
+/// no vertical component is refused before it reaches the controller, because a
+/// zero-notch zoom changes no range but still runs the range setters, which clear
+/// auto scale: a horizontal scroll must not silently stop a live axis following.
+///
+/// ## Threading
+///
+/// Qt widgets live on the GUI thread, and so does everything here: `initializeGL`,
+/// `paintGL` and the event handlers all run there, which is the thread that owns
+/// the context. A host that feeds the plot from a producer thread acquires its
+/// data on this thread (see the frame callback).
+class PlotWidget : public QOpenGLWidget, protected QOpenGLFunctions {
+  Q_OBJECT
+
+ public:
+  /// One frame of host code, run by `paintGL()` after the viewport is set and
+  /// before the frame is staged. It is where data is refreshed -- acquiring a
+  /// `data::StreamSeries`, re-fitting a live axis, moving cursors -- and `dt` is
+  /// the wall time since the previous call, in seconds. Optional; a widget with
+  /// no callback just re-draws the plot as it stands.
+  using FrameFn = std::function<void(Plot&, f64)>;
+
+  /// Renders and drives `plot`, which must outlive this widget.
+  explicit PlotWidget(Plot& plot, QWidget* parent = nullptr);
+  ~PlotWidget() override;
+
+  PlotWidget(const PlotWidget&) = delete;
+  PlotWidget& operator=(const PlotWidget&) = delete;
+
+  void set_frame_callback(FrameFn frame) { frame_ = std::move(frame); }
+
+  /// The plot this widget renders. Valid for the widget's whole life.
+  Plot& plot() noexcept { return *plot_; }
+  const Plot& plot() const noexcept { return *plot_; }
+  /// The controller the widget feeds, bound to `plot()`.
+  input::Controller& controller() noexcept { return controller_; }
+  const input::Controller& controller() const noexcept { return controller_; }
+
+  /// The renderer, or null until a successful `initializeGL()`. Valid from the
+  /// corresponding `paintGL()` onwards, and after the widget's context exists.
+  Renderer* renderer() noexcept { return renderer_ ? &*renderer_ : nullptr; }
+  const Renderer* renderer() const noexcept { return renderer_ ? &*renderer_ : nullptr; }
+
+  /// What `initializeGL()` made of the context: `Ok`, or the failure that left
+  /// the widget drawing nothing. A `QOpenGLWidget` virtual cannot return a
+  /// `Status`, and a widget must not throw across Qt's callback, so the outcome
+  /// is recorded here instead.
+  const Status& init_status() const noexcept { return init_status_; }
+
+  /// Frames actually staged, and the frame time of the last one (ms). The mean is
+  /// an exponential moving average seeded by the first frame, of the same
+  /// render-only span: the frame callback, `begin_frame`, `draw` and `end_frame`.
+  u64 frames_painted() const noexcept { return frames_; }
+  f32 last_frame_ms() const noexcept { return last_frame_ms_; }
+  f32 mean_frame_ms() const noexcept { return mean_frame_ms_; }
+
+  /// The region the last frame was drawn into, in device pixels -- the rect
+  /// `begin_frame()` was handed. Zero-sized before the first frame.
+  Rect last_device_viewport() const noexcept { return last_viewport_; }
+
+ protected:
+  void initializeGL() override;
+  void resizeGL(int w, int h) override;
+  void paintGL() override;
+
+  void mousePressEvent(QMouseEvent* event) override;
+  void mouseMoveEvent(QMouseEvent* event) override;
+  void mouseReleaseEvent(QMouseEvent* event) override;
+  /// Qt reports the second press of a double click as this event and not as a
+  /// press, so without it a drag that began with a double click would have no
+  /// press to start from. Forwarded as one.
+  void mouseDoubleClickEvent(QMouseEvent* event) override;
+  void wheelEvent(QWheelEvent* event) override;
+  void keyPressEvent(QKeyEvent* event) override;
+
+ private:
+  /// The widget's rectangle in device pixels: the plot's viewport, and the size
+  /// of the framebuffer the frame is drawn into.
+  Rect device_viewport() const noexcept;
+  /// A Qt position (logical widget pixels) in device pixels. The one place the
+  /// input mapping exists, so every event is scaled by the same factor the
+  /// viewport is.
+  Vec2 to_device(const QPointF& p) const noexcept;
+  /// Translates one mouse event and hands it to the controller. `pressed` and
+  /// `released` are the transitions Qt reports on the event itself.
+  void forward_pointer(QMouseEvent* event, bool pressed, bool released);
+  /// Sets the plot's viewport to the current device rect (through the controller,
+  /// which refreshes the layout with it).
+  void refresh_viewport();
+
+  Plot* plot_ = nullptr;  ///< declared first: the controller is built over it
+  input::Controller controller_;
+  std::optional<Renderer> renderer_;
+  FrameFn frame_;
+  Status init_status_;
+
+  /// Last pointer position in device pixels: the deltas the controller pans with
+  /// are the movement since the previous event, which Qt does not report.
+  bool have_pointer_ = false;
+  f32 last_x_ = 0.0f;
+  f32 last_y_ = 0.0f;
+
+  u64 frames_ = 0;
+  f32 last_frame_ms_ = 0.0f;
+  f32 mean_frame_ms_ = 0.0f;
+  /// Wall clock at the last `paintGL()` start, or negative before the first one.
+  f64 last_paint_s_ = -1.0;
+  Rect last_viewport_{};
+};
+
+}  // namespace plot::qt