Function draw_canvas_pane

src/main.cpp:132–248

Draws the canvas pane's content: the StageView image plus its drag/scroll/key input handling, sized to whatever rect the caller's current ImGui child occupies (ImGui::GetContentRegionAvail()). When link-views is on, the drag/scroll/key input fans out to every buffer's Stage so switching buffers shows them synchronized. Rendering and resize stay on the selected Stage (only it is displayed).

// buffers shows them synchronized. Rendering and resize stay on the
// selected Stage (only it is displayed).
void draw_canvas_pane(oid::host::GlfwCanvas& canvas,
                      oid::host::StageView& view,
                      oid::Stage& sel,
                      const oid::host::UiState& ui,
                      oid::host::StageManager& stages,
                      const oid::host::BufferModel& model,
                      PaneRenderSize& pane_size) {
    // Render the Stage at the canvas PANE's size, in framebuffer pixels, so
    // the offscreen texture's aspect ratio matches the on-screen rect it is
    // displayed in: ImGui::Image stretches the texture to fill the rect, so
    // any texture:rect aspect mismatch visibly distorts the buffer.
    const ImVec2 canvas_size = ImGui::GetContentRegionAvail();
    if (canvas_size.x < 1.0f || canvas_size.y < 1.0f) {
        // Pane not laid out yet (e.g. the first frame, before the child sizes
        // settle). Skip this frame rather than sizing to a degenerate rect.
        return;
    }
    // One uniform DPI scale for BOTH axes (display pixels are square), so
    // cw:ch == canvas_size aspect exactly. A per-axis DisplayFramebufferScale
    // that is briefly non-uniform or unset at startup must never skew it.
    float dpi = ImGui::GetIO().DisplayFramebufferScale.x;
    if (dpi <= 0.0f) {
        dpi = 1.0f;
    }
    const int cw = (std::max)(1, static_cast<int>(canvas_size.x * dpi + 0.5f));
    const int ch = (std::max)(1, static_cast<int>(canvas_size.y * dpi + 0.5f));
    // Logical pane size: the units the camera and mouse math operate in
    // (Qt-native parity, see the PaneRenderSize comment above).
    const int lw = (std::max)(1, static_cast<int>(canvas_size.x + 0.5f));
    const int lh = (std::max)(1, static_cast<int>(canvas_size.y + 0.5f));
    // Publish this frame's logical pane size for GlfwCanvas's SizeProvider
    // before anything below reads canvas.render_width()/render_height()
    // through it.
    pane_size.width = lw;
    pane_size.height = lh;
    // Sync the render target (framebuffer px, for a crisp raster) and the
    // camera projection (logical points, Qt units) to the current pane size
    // every frame -- both are cheap self-guarded no-ops when unchanged.
    // Doing it unconditionally (rather than only on a cached size change)
    // means a first-frame or buffer-switch mismatch self-corrects on the next
    // frame instead of sticking until the user resizes a pane.
    view.ensure_size(cw, ch);
    sel.resize_callback(lw, lh);
    const GLuint tex = view.render(sel);

    ImGui::Image(static_cast<ImTextureID>(tex),
                 canvas_size,
                 ImVec2(0, 1),
                 ImVec2(1, 0)); // flip V (FBO origin is bottom-left)

    // ImGui mouse coordinates are already in screen (logical) points -- the
    // same pane-logical frame the camera operates in (see PaneRenderSize),
    // so positions/deltas below are fed 1:1, exactly like the native Qt
    // canvas (its mouse scale factor render_width()/width() is 1).
    const ImVec2 img_min = ImGui::GetItemRectMin();
    const ImVec2 img_size = ImGui::GetItemRectSize();

    // Overlay an invisible button covering the image so a drag over the