gpui_liveplot/gpui_backend/
view.rs

1use std::sync::{Arc, RwLock};
2use std::time::{Duration, Instant};
3
4use gpui::prelude::*;
5use gpui::{
6    MouseButton, MouseDownEvent, MouseMoveEvent, MouseUpEvent, Pixels, Point, ScrollWheelEvent,
7    Window, canvas, div, px,
8};
9
10use crate::geom::{Point as DataPoint, ScreenPoint, ScreenRect};
11use crate::interaction::{
12    HitRegion, pan_viewport, toggle_pin, zoom_factor_from_drag, zoom_to_rect, zoom_viewport,
13};
14use crate::plot::Plot;
15use crate::transform::Transform;
16use crate::view::{Range, Viewport};
17
18use super::config::PlotViewConfig;
19use super::constants::DOUBLE_CLICK_PIN_GRACE_MS;
20use super::frame::build_frame;
21use super::geometry::{distance_sq, normalized_rect};
22use super::hover::{compute_hover_target, hover_target_within_threshold};
23use super::link::{LinkBinding, PlotLinkGroup, PlotLinkOptions, ViewSyncKind};
24use super::paint::{paint_frame, to_hsla};
25use super::state::{ClickState, DragMode, DragState, PinToggle, PlotUiState};
26
27/// A GPUI view that renders a [`Plot`] with interactive controls.
28///
29/// This view handles pan/zoom/box-zoom, hover readouts, and pin interactions
30/// while delegating data management to the underlying [`Plot`].
31#[derive(Clone)]
32pub struct GpuiPlotView {
33    plot: Arc<RwLock<Plot>>,
34    state: Arc<RwLock<PlotUiState>>,
35    config: PlotViewConfig,
36    link: Option<LinkBinding>,
37}
38
39impl GpuiPlotView {
40    /// Create a new GPUI plot view for the given plot.
41    ///
42    /// Uses the default [`PlotViewConfig`].
43    pub fn new(plot: Plot) -> Self {
44        Self {
45            plot: Arc::new(RwLock::new(plot)),
46            state: Arc::new(RwLock::new(PlotUiState::default())),
47            config: PlotViewConfig::default(),
48            link: None,
49        }
50    }
51
52    /// Create a new GPUI plot view with a custom configuration.
53    pub fn with_config(plot: Plot, config: PlotViewConfig) -> Self {
54        Self {
55            plot: Arc::new(RwLock::new(plot)),
56            state: Arc::new(RwLock::new(PlotUiState::default())),
57            config,
58            link: None,
59        }
60    }
61
62    /// Attach this view to a multi-plot link group.
63    ///
64    /// Link groups synchronize viewport/cursor/brush state between views.
65    pub fn with_link_group(mut self, group: PlotLinkGroup, options: PlotLinkOptions) -> Self {
66        self.link = Some(LinkBinding {
67            member_id: group.register_member(),
68            group,
69            options,
70        });
71        self
72    }
73
74    /// Get a handle for mutating the underlying plot.
75    ///
76    /// This is useful for streaming updates from async tasks.
77    pub fn plot_handle(&self) -> PlotHandle {
78        PlotHandle {
79            plot: Arc::clone(&self.plot),
80        }
81    }
82
83    fn publish_manual_view_link(&self, viewport: Viewport) {
84        let Some(link) = self.link.as_ref() else {
85            return;
86        };
87        link.group.publish_manual_view(
88            link.member_id,
89            viewport,
90            link.options.link_x,
91            link.options.link_y,
92        );
93    }
94
95    fn publish_reset_link(&self) {
96        let Some(link) = self.link.as_ref() else {
97            return;
98        };
99        if link.options.link_reset {
100            link.group.publish_reset(link.member_id);
101        }
102    }
103
104    fn publish_cursor_link(&self, x: Option<f64>) {
105        let Some(link) = self.link.as_ref() else {
106            return;
107        };
108        if link.options.link_cursor {
109            link.group.publish_cursor_x(link.member_id, x);
110        }
111    }
112
113    fn publish_brush_link(&self, x_range: Option<Range>) {
114        let Some(link) = self.link.as_ref() else {
115            return;
116        };
117        if link.options.link_brush {
118            link.group.publish_brush_x(link.member_id, x_range);
119        }
120    }
121
122    fn apply_manual_view_with_link(
123        &self,
124        plot: &mut Plot,
125        state: &mut PlotUiState,
126        rect: ScreenRect,
127        viewport: Viewport,
128    ) {
129        apply_manual_view(plot, state, rect, viewport);
130        state.linked_brush_x = None;
131        self.publish_manual_view_link(viewport);
132        self.publish_brush_link(None);
133    }
134
135    fn on_mouse_down(&mut self, ev: &MouseDownEvent, cx: &mut Context<Self>) {
136        let pos = screen_point(ev.position);
137        let mut state = self.state.write().expect("plot state lock");
138        state.last_cursor = Some(pos);
139
140        if let Some(series_id) = state.legend_hit(pos) {
141            if ev.button == MouseButton::Left && ev.click_count == 1 {
142                if let Ok(mut plot) = self.plot.write() {
143                    if let Some(series) = plot
144                        .series_mut()
145                        .iter_mut()
146                        .find(|series| series.id() == series_id)
147                    {
148                        series.set_visible(!series.is_visible());
149                    }
150                }
151            }
152            state.clear_interaction();
153            state.hover = None;
154            state.hover_target = None;
155            cx.notify();
156            return;
157        }
158
159        let region = state.regions.hit_test(pos);
160        if ev.button == MouseButton::Left && ev.click_count >= 2 && region == HitRegion::Plot {
161            let last_toggle = state.last_pin_toggle.take();
162            if let Ok(mut plot) = self.plot.write() {
163                if let Some(last_toggle) = last_toggle {
164                    if last_toggle.at.elapsed() <= Duration::from_millis(DOUBLE_CLICK_PIN_GRACE_MS)
165                        && distance_sq(last_toggle.screen_pos, pos)
166                            <= self.config.pin_threshold_px.powi(2)
167                    {
168                        revert_pin_toggle(&mut plot, last_toggle);
169                    }
170                }
171                plot.reset_view();
172                state.linked_brush_x = None;
173                self.publish_reset_link();
174                self.publish_brush_link(None);
175            }
176            state.clear_interaction();
177            cx.notify();
178            return;
179        }
180
181        state.pending_click = Some(ClickState {
182            region,
183            button: ev.button,
184        });
185
186        match (ev.button, region) {
187            (MouseButton::Left, HitRegion::XAxis) => {
188                state.drag = Some(DragState::new(DragMode::ZoomX, pos, true));
189            }
190            (MouseButton::Left, HitRegion::YAxis) => {
191                state.drag = Some(DragState::new(DragMode::ZoomY, pos, true));
192            }
193            (MouseButton::Left, HitRegion::Plot) => {
194                state.drag = Some(DragState::new(DragMode::Pan, pos, false));
195            }
196            (MouseButton::Right, HitRegion::Plot) => {
197                state.drag = Some(DragState::new(DragMode::ZoomRect, pos, true));
198                state.selection_rect = Some(ScreenRect::new(pos, pos));
199            }
200            _ => {}
201        }
202
203        cx.notify();
204    }
205
206    fn on_mouse_move(&mut self, ev: &MouseMoveEvent, cx: &mut Context<Self>) {
207        let pos = screen_point(ev.position);
208        let mut state = self.state.write().expect("plot state lock");
209        state.last_cursor = Some(pos);
210
211        if state.legend_hit(pos).is_some() {
212            state.hover = None;
213        } else if state.regions.hit_test(pos) == HitRegion::Plot {
214            state.hover = Some(pos);
215        } else {
216            state.hover = None;
217        }
218        let linked_cursor_x = state.hover.and_then(|_| {
219            state
220                .transform
221                .as_ref()
222                .and_then(|transform| transform.screen_to_data(pos))
223                .map(|point| point.x)
224        });
225        self.publish_cursor_link(linked_cursor_x);
226
227        let Some(mut drag) = state.drag.clone() else {
228            cx.notify();
229            return;
230        };
231
232        if !is_drag_button_held(drag.mode, ev.pressed_button) {
233            state.clear_interaction();
234            self.publish_cursor_link(None);
235            cx.notify();
236            return;
237        }
238
239        let moved_sq = distance_sq(drag.start, pos);
240        if !drag.active && moved_sq > self.config.drag_threshold_px.powi(2) {
241            drag.active = true;
242        }
243
244        if !drag.active {
245            state.drag = Some(drag);
246            cx.notify();
247            return;
248        }
249
250        let delta = ScreenPoint::new(pos.x - drag.last.x, pos.y - drag.last.y);
251        let plot_rect = state.plot_rect;
252        let transform = state.transform.clone();
253
254        match drag.mode {
255            DragMode::Pan => {
256                if let (Some(rect), Some(transform)) = (plot_rect, transform) {
257                    if let Ok(mut plot) = self.plot.write() {
258                        if let Some(viewport) = plot.viewport() {
259                            if let Some(next) = pan_viewport(viewport, delta, &transform) {
260                                self.apply_manual_view_with_link(&mut plot, &mut state, rect, next);
261                            }
262                        }
263                    }
264                }
265            }
266            DragMode::ZoomRect => {
267                state.selection_rect = Some(ScreenRect::new(drag.start, pos));
268            }
269            DragMode::ZoomX => {
270                if let (Some(rect), Some(transform)) = (plot_rect, transform) {
271                    let axis_pixels = rect.width().max(1.0);
272                    let factor = zoom_factor_from_drag(delta.x, axis_pixels);
273                    if let Ok(mut plot) = self.plot.write() {
274                        if let Some(viewport) = plot.viewport() {
275                            let center = transform
276                                .screen_to_data(pos)
277                                .unwrap_or_else(|| viewport.x_center());
278                            let next = zoom_viewport(viewport, center, factor, 1.0);
279                            self.apply_manual_view_with_link(&mut plot, &mut state, rect, next);
280                        }
281                    }
282                }
283            }
284            DragMode::ZoomY => {
285                if let (Some(rect), Some(transform)) = (plot_rect, transform) {
286                    let axis_pixels = rect.height().max(1.0);
287                    let factor = zoom_factor_from_drag(-delta.y, axis_pixels);
288                    if let Ok(mut plot) = self.plot.write() {
289                        if let Some(viewport) = plot.viewport() {
290                            let center = transform
291                                .screen_to_data(pos)
292                                .unwrap_or_else(|| viewport.y_center());
293                            let next = zoom_viewport(viewport, center, 1.0, factor);
294                            self.apply_manual_view_with_link(&mut plot, &mut state, rect, next);
295                        }
296                    }
297                }
298            }
299        }
300
301        drag.last = pos;
302        state.drag = Some(drag);
303        state.pending_click = None;
304        cx.notify();
305    }
306
307    fn on_mouse_up(&mut self, ev: &MouseUpEvent, cx: &mut Context<Self>) {
308        let pos = screen_point(ev.position);
309        let mut state = self.state.write().expect("plot state lock");
310        let drag = state.drag.clone();
311
312        if let Some(drag_state) = drag.as_ref() {
313            if drag_state.active && drag_state.mode == DragMode::ZoomRect {
314                if let (Some(rect), Some(transform)) =
315                    (state.selection_rect.take(), state.transform.clone())
316                {
317                    let rect = normalized_rect(rect);
318                    if let Ok(mut plot) = self.plot.write() {
319                        if let Some(viewport) = plot.viewport() {
320                            if let Some(next) = zoom_to_rect(viewport, rect, &transform) {
321                                self.apply_manual_view_with_link(
322                                    &mut plot,
323                                    &mut state,
324                                    transform.screen(),
325                                    next,
326                                );
327                                self.publish_brush_link(Some(next.x));
328                            }
329                        }
330                    }
331                }
332            }
333        }
334
335        let click = state.pending_click.take();
336        let should_toggle = click.as_ref().is_some_and(|click| {
337            click.button == MouseButton::Left && click.region == HitRegion::Plot
338        }) && drag.as_ref().is_none_or(|drag| !drag.active)
339            && ev.click_count == 1;
340
341        if should_toggle {
342            if let Some(transform) = state.transform.clone() {
343                if let Ok(mut plot) = self.plot.write() {
344                    let target = state
345                        .hover_target
346                        .filter(|target| hover_target_within_threshold(target, pos, &self.config))
347                        .or_else(|| {
348                            compute_hover_target(
349                                &plot,
350                                &transform,
351                                pos,
352                                state.plot_rect,
353                                self.config.pin_threshold_px,
354                                self.config.unpin_threshold_px,
355                            )
356                        });
357
358                    if let Some(target) = target {
359                        let added = toggle_pin(plot.pins_mut(), target.pin);
360                        let now = Instant::now();
361                        state.last_pin_toggle = Some(PinToggle {
362                            pin: target.pin,
363                            added,
364                            at: now,
365                            screen_pos: target.screen,
366                        });
367                    }
368                }
369            }
370        } else if ev.click_count > 1 {
371            state.last_pin_toggle = None;
372        }
373
374        state.drag = None;
375        state.selection_rect = None;
376        self.publish_cursor_link(None);
377        cx.notify();
378    }
379
380    fn on_mouse_up_out(&mut self, _ev: &MouseUpEvent, cx: &mut Context<Self>) {
381        let mut state = self.state.write().expect("plot state lock");
382        state.clear_interaction();
383        self.publish_cursor_link(None);
384        cx.notify();
385    }
386
387    fn on_scroll(&mut self, ev: &ScrollWheelEvent, _window: &Window, cx: &mut Context<Self>) {
388        let pos = screen_point(ev.position);
389        let mut state = self.state.write().expect("plot state lock");
390        if state.legend_hit(pos).is_some() {
391            return;
392        }
393        let region = state.regions.hit_test(pos);
394        let Some(transform) = state.transform.clone() else {
395            return;
396        };
397
398        let line_height = px(16.0);
399        let delta = ev.delta.pixel_delta(line_height);
400        let zoom_delta = -f32::from(delta.y);
401        if zoom_delta.abs() < 0.01 {
402            return;
403        }
404        let factor = (1.0 - (zoom_delta as f64 * 0.002)).clamp(0.1, 10.0);
405
406        if let Ok(mut plot) = self.plot.write() {
407            if let Some(viewport) = plot.viewport() {
408                let center = transform
409                    .screen_to_data(pos)
410                    .unwrap_or_else(|| viewport.center());
411                let (factor_x, factor_y) = match region {
412                    HitRegion::XAxis => (factor, 1.0),
413                    HitRegion::YAxis => (1.0, factor),
414                    HitRegion::Plot => (factor, factor),
415                    HitRegion::Outside => (1.0, 1.0),
416                };
417                if factor_x != 1.0 || factor_y != 1.0 {
418                    let next = zoom_viewport(viewport, center, factor_x, factor_y);
419                    if let Some(rect) = state.plot_rect {
420                        self.apply_manual_view_with_link(&mut plot, &mut state, rect, next);
421                    }
422                }
423            }
424        }
425
426        cx.notify();
427    }
428}
429
430impl Render for GpuiPlotView {
431    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
432        let plot = Arc::clone(&self.plot);
433        let state = Arc::clone(&self.state);
434        let config = self.config.clone();
435        let link = self.link.clone();
436        let theme = plot.read().expect("plot lock").theme().clone();
437
438        div()
439            .size_full()
440            .bg(to_hsla(theme.background))
441            .child(
442                canvas(
443                    move |bounds, window, _| {
444                        let mut plot = plot.write().expect("plot lock");
445                        let mut state = state.write().expect("plot state lock");
446                        if let Some(link) = &link {
447                            apply_link_updates(link, &mut plot, &mut state);
448                        }
449                        build_frame(&mut plot, &mut state, &config, bounds, window)
450                    },
451                    move |_, frame, window, cx| {
452                        paint_frame(&frame, window, cx);
453                    },
454                )
455                .size_full(),
456            )
457            .on_mouse_down(
458                MouseButton::Left,
459                cx.listener(|this, ev, _, cx| {
460                    this.on_mouse_down(ev, cx);
461                }),
462            )
463            .on_mouse_down(
464                MouseButton::Right,
465                cx.listener(|this, ev, _, cx| {
466                    this.on_mouse_down(ev, cx);
467                }),
468            )
469            .on_mouse_move(cx.listener(|this, ev, _, cx| {
470                this.on_mouse_move(ev, cx);
471            }))
472            .on_mouse_up(
473                MouseButton::Left,
474                cx.listener(|this, ev, _, cx| {
475                    this.on_mouse_up(ev, cx);
476                }),
477            )
478            .on_mouse_up(
479                MouseButton::Right,
480                cx.listener(|this, ev, _, cx| {
481                    this.on_mouse_up(ev, cx);
482                }),
483            )
484            .on_mouse_up_out(
485                MouseButton::Left,
486                cx.listener(|this, ev, _, cx| {
487                    this.on_mouse_up_out(ev, cx);
488                }),
489            )
490            .on_mouse_up_out(
491                MouseButton::Right,
492                cx.listener(|this, ev, _, cx| {
493                    this.on_mouse_up_out(ev, cx);
494                }),
495            )
496            .on_scroll_wheel(cx.listener(|this, ev, window, cx| {
497                this.on_scroll(ev, window, cx);
498            }))
499    }
500}
501
502/// A handle for mutating a [`Plot`] held inside a `GpuiPlotView`.
503///
504/// The handle clones cheaply and can be moved into async tasks.
505#[derive(Clone)]
506pub struct PlotHandle {
507    plot: Arc<RwLock<Plot>>,
508}
509
510impl PlotHandle {
511    /// Read the plot state.
512    ///
513    /// The plot is locked for the duration of the callback.
514    pub fn read<R>(&self, f: impl FnOnce(&Plot) -> R) -> R {
515        let plot = self.plot.read().expect("plot lock");
516        f(&plot)
517    }
518
519    /// Mutate the plot state.
520    ///
521    /// The plot is locked for the duration of the callback.
522    pub fn write<R>(&self, f: impl FnOnce(&mut Plot) -> R) -> R {
523        let mut plot = self.plot.write().expect("plot lock");
524        f(&mut plot)
525    }
526}
527
528fn apply_link_updates(link: &LinkBinding, plot: &mut Plot, state: &mut PlotUiState) {
529    if let Some(update) = link.group.latest_view_update()
530        && update.seq > state.link_view_seq
531    {
532        state.link_view_seq = update.seq;
533        if update.source != link.member_id {
534            match update.kind {
535                ViewSyncKind::Reset => {
536                    if link.options.link_reset {
537                        plot.reset_view();
538                        state.viewport = None;
539                        state.transform = None;
540                        state.linked_brush_x = None;
541                    }
542                }
543                ViewSyncKind::Manual {
544                    viewport,
545                    sync_x,
546                    sync_y,
547                } => {
548                    let mut next = plot
549                        .viewport()
550                        .or_else(|| plot.data_bounds())
551                        .unwrap_or(viewport);
552                    let mut changed = false;
553                    if sync_x && link.options.link_x {
554                        next.x = viewport.x;
555                        changed = true;
556                    }
557                    if sync_y && link.options.link_y {
558                        next.y = viewport.y;
559                        changed = true;
560                    }
561                    if changed {
562                        plot.set_manual_view(next);
563                        state.viewport = Some(next);
564                        if let Some(rect) = state.plot_rect {
565                            state.transform = Transform::new(next, rect);
566                        }
567                    }
568                }
569            }
570        }
571    }
572
573    if let Some(update) = link.group.latest_cursor_update()
574        && update.seq > state.link_cursor_seq
575    {
576        state.link_cursor_seq = update.seq;
577        if update.source != link.member_id && link.options.link_cursor {
578            state.linked_cursor_x = update.x;
579        }
580    }
581
582    if let Some(update) = link.group.latest_brush_update()
583        && update.seq > state.link_brush_seq
584    {
585        state.link_brush_seq = update.seq;
586        if update.source != link.member_id && link.options.link_brush {
587            state.linked_brush_x = update.x_range;
588            if let Some(x_range) = update.x_range {
589                let y_range = plot
590                    .viewport()
591                    .or_else(|| plot.data_bounds())
592                    .map(|viewport| viewport.y)
593                    .unwrap_or_else(|| Range::new(0.0, 1.0));
594                let next = Viewport::new(x_range, y_range);
595                plot.set_manual_view(next);
596                state.viewport = Some(next);
597                if let Some(rect) = state.plot_rect {
598                    state.transform = Transform::new(next, rect);
599                }
600            }
601        }
602    }
603}
604
605fn screen_point(point: Point<Pixels>) -> ScreenPoint {
606    ScreenPoint::new(f32::from(point.x), f32::from(point.y))
607}
608
609fn apply_manual_view(
610    plot: &mut Plot,
611    state: &mut PlotUiState,
612    rect: ScreenRect,
613    viewport: Viewport,
614) {
615    plot.set_manual_view(viewport);
616    state.viewport = Some(viewport);
617    state.transform = Transform::new(viewport, rect);
618}
619
620fn revert_pin_toggle(plot: &mut Plot, toggle: PinToggle) {
621    let pins = plot.pins_mut();
622    if toggle.added {
623        if let Some(index) = pins.iter().position(|pin| *pin == toggle.pin) {
624            pins.swap_remove(index);
625        }
626    } else if !pins.contains(&toggle.pin) {
627        pins.push(toggle.pin);
628    }
629}
630
631fn is_drag_button_held(mode: DragMode, pressed_button: Option<MouseButton>) -> bool {
632    let expected = match mode {
633        DragMode::ZoomRect => MouseButton::Right,
634        DragMode::Pan | DragMode::ZoomX | DragMode::ZoomY => MouseButton::Left,
635    };
636    pressed_button == Some(expected)
637}
638
639trait ViewportCenter {
640    fn center(&self) -> DataPoint;
641    fn x_center(&self) -> DataPoint;
642    fn y_center(&self) -> DataPoint;
643}
644
645impl ViewportCenter for Viewport {
646    fn center(&self) -> DataPoint {
647        DataPoint::new(
648            (self.x.min + self.x.max) * 0.5,
649            (self.y.min + self.y.max) * 0.5,
650        )
651    }
652
653    fn x_center(&self) -> DataPoint {
654        DataPoint::new(
655            (self.x.min + self.x.max) * 0.5,
656            (self.y.min + self.y.max) * 0.5,
657        )
658    }
659
660    fn y_center(&self) -> DataPoint {
661        DataPoint::new(
662            (self.x.min + self.x.max) * 0.5,
663            (self.y.min + self.y.max) * 0.5,
664        )
665    }
666}
667
668#[cfg(test)]
669mod tests {
670    use super::{DragMode, MouseButton, is_drag_button_held};
671
672    #[test]
673    fn drag_requires_matching_button() {
674        assert!(is_drag_button_held(DragMode::Pan, Some(MouseButton::Left)));
675        assert!(is_drag_button_held(
676            DragMode::ZoomX,
677            Some(MouseButton::Left)
678        ));
679        assert!(is_drag_button_held(
680            DragMode::ZoomY,
681            Some(MouseButton::Left)
682        ));
683        assert!(is_drag_button_held(
684            DragMode::ZoomRect,
685            Some(MouseButton::Right)
686        ));
687        assert!(!is_drag_button_held(
688            DragMode::Pan,
689            Some(MouseButton::Right)
690        ));
691        assert!(!is_drag_button_held(DragMode::ZoomRect, None));
692    }
693}
gpui_liveplot/gpui_backend/view.rs

gpui_liveplot/gpui_backend/
view.rs
