Method handle_mouse_event

src/plot_state.rs:494–749

(
        &mut self,
        event: Event,
        cursor: mouse::Cursor,
        widget: &PlotWidget,
        publish_hover_pick: &mut Option<HoverPickEvent>,
        publish_drag_event: &mut Option<

    pub(crate) fn cursor_inside(&self) -> bool {
        self.point_inside(self.cursor_position.x, self.cursor_position.y)
    }

    fn cursor_local_position(&self, cursor: mouse::Cursor, allow_levitating: bool) -> Option<Vec2> {
        let position = match cursor {
            mouse::Cursor::Available(position) => position,
            mouse::Cursor::Levitating(position) if allow_levitating => position,
            mouse::Cursor::Levitating(_) | mouse::Cursor::Unavailable => return None,
        };

        Some(Vec2::new(
            position.x - self.bounds.x,
            position.y - self.bounds.y,
        ))
    }

    fn available_cursor_local_position_inside(&self, cursor: mouse::Cursor) -> Option<Vec2> {
        let position = self.cursor_local_position(cursor, false)?;
        self.point_inside(position.x, position.y)
            .then_some(position)
    }

    pub(crate) fn available_cursor_is_inside(&self, cursor: mouse::Cursor) -> bool {
        self.available_cursor_local_position_inside(cursor)
            .is_some()
    }

    pub(crate) fn drag_in_progress(&self) -> bool {
        self.pan.active || self.selection.active || self.drag.active
    }

    fn drag_in_progress_for(&self, button: mouse::Button) -> bool {
        (self.pan.active && self.pan.button == Some(button))
            || (self.selection.active && self.selection.button == Some(button))
            || (self.drag.active && self.drag.button == Some(button))
    }

    pub(crate) fn handle_mouse_event(
        &mut self,
        event: Event,
        cursor: mouse::Cursor,
        widget: &PlotWidget,
        publish_hover_pick: &mut Option<HoverPickEvent>,
        publish_drag_event: &mut Option<DragEvent>,
    ) -> bool {
        // Only request redraws when something actually changes or when we need
        // to service a picking request for a new cursor position.
        let mut needs_redraw = false;

        let viewport: DVec2 = Vec2::new(self.bounds.width, self.bounds.height).into();

        match event {
            Event::CursorMoved { .. } => {
                let Some(position) = self.cursor_local_position(cursor, self.drag_in_progress())
                else {
                    if self.picking.last_hover_cache.is_some() {
                        self.picking.last_hover_cache = None;
                        needs_redraw = true;