zaxis 0.0.2

An event-driven immediate mode GUI for desktop tools
Documentation
//! Pointer presses, capture, dragging, and resizing.

use super::{
    interaction::Capture, Context, HitAction, NumberInputEvent, SliderInput, TextEditInput,
};
use crate::{Rect, Vec2};
use winit::event::ElementState;

impl Context {
    pub(super) fn secondary_button(&mut self, state: ElementState) -> bool {
        if state == ElementState::Released {
            self.input.secondary_down = false;
            self.input.secondary_released = true;
            self.gesture_secondary_release();
            return self.popup.is_some();
        }
        if self.input.secondary_down {
            return self.popup.is_some();
        }
        self.input.secondary_down = true;
        self.input.secondary_pressed = true;
        self.drag_cancel(crate::components::drag_drop::DragReason::Cancelled);
        if self.popup.is_some() {
            self.dismiss_popup(true);
            return true;
        }
        if let Some(pointer) = self.input.pointer {
            if self.tree_context(pointer) {
                return true;
            }
            return self.gesture_secondary_press(pointer);
        }
        false
    }

    pub(super) fn primary_button(&mut self, state: ElementState) -> bool {
        match state {
            ElementState::Pressed => {
                if self.input.primary_down {
                    return self.capture.is_some();
                }
                self.input.primary_down = true;
                self.focus_visible = false;
                self.input.primary_pressed = true;
                self.keyboard_active = None;
                if self.popup.as_ref().is_some_and(|popup| {
                    self.input.pointer.is_some_and(|p| {
                        !popup.rect.contains(p)
                            && (popup.key_target.is_none() || !popup.anchor.contains(p))
                    })
                }) {
                    self.dismiss_popup(true);
                    // Consume the whole gesture; never capture underlying content.
                    return true;
                }
                let hit = self.input.pointer.and_then(|p| self.hit_test(p));
                if hit.is_none_or(|hit| hit.action != HitAction::TextEdit) {
                    self.text_click = None;
                }
                self.drag_press(hit);
                if let Some(hit) = hit {
                    if self.windows.contains_key(&hit.window) {
                        self.raise_window(hit.window);
                    }
                    let focus = match hit.action {
                        HitAction::TreeRow { tree, .. } => Some(tree),
                        _ => hit.action.focusable().then_some(hit.id),
                    };
                    if !(self.is_modal_layer(hit.window) && focus.is_none()) {
                        self.set_focus(focus);
                    }
                    if hit.action != HitAction::Block {
                        self.capture = Some(Capture {
                            hit,
                            pointer: self.input.pointer.unwrap(),
                            rect: self.windows.get(&hit.window).map_or(hit.rect, |w| w.rect),
                        });
                        self.gesture_press(hit, self.input.pointer.unwrap());
                        if let HitAction::ScrollThumb { area, axis } = hit.action {
                            self.begin_scroll_drag(area, axis);
                        }
                        if let HitAction::ColumnResize { table, column } = hit.action {
                            if let Some(state) = self.tables.get_mut(&table) {
                                if let Some(&width) = state.current_widths.get(&column) {
                                    state.drag = Some((column, width));
                                }
                            }
                        }
                        if matches!(hit.action, HitAction::SplitResize { .. }) {
                            self.split_pointer(hit.id, self.input.pointer.unwrap(), 1);
                        }
                        if hit.action == HitAction::TextEdit {
                            let pointer = self.input.pointer.unwrap();
                            let now = std::time::Instant::now();
                            let count = self.text_click.as_ref().map_or(1, |last| {
                                if last.id == hit.id
                                    && now.duration_since(last.time)
                                        <= std::time::Duration::from_millis(500)
                                    && (pointer - last.position).length_squared() <= 16.0
                                    && !self.input.modifiers.shift_key()
                                {
                                    last.count % 3 + 1
                                } else {
                                    1
                                }
                            });
                            self.text_click = Some(super::interaction::ClickSequence {
                                id: hit.id,
                                position: pointer,
                                time: now,
                                count,
                            });
                            self.text_edit_input.entry(hit.id).or_default().push(
                                TextEditInput::Pointer(
                                    pointer,
                                    self.input.modifiers.shift_key(),
                                    count,
                                ),
                            );
                        }
                        if hit.action == HitAction::Slider {
                            self.slider_input
                                .entry(hit.id)
                                .or_default()
                                .push(SliderInput::Pointer(self.input.pointer.unwrap()));
                        }
                        if hit.action == HitAction::DragValue {
                            self.number_input.entry(hit.id).or_default().push(
                                NumberInputEvent::Pointer(
                                    self.input.pointer.unwrap(),
                                    1,
                                    self.input.modifiers,
                                ),
                            );
                        }
                    }
                } else {
                    self.set_focus(None);
                }
                hit.is_some()
            }
            ElementState::Released => {
                self.input.primary_down = false;
                self.input.primary_released = true;
                if self.drag_release() {
                    return true;
                }
                if let Some(capture) = self.capture.take() {
                    if self
                        .input
                        .pointer
                        .and_then(|p| self.hit_test(p))
                        .is_some_and(|h| h.id == capture.hit.id)
                    {
                        self.tree_click(capture.hit);
                    }
                    if matches!(capture.hit.action, HitAction::SplitResize { .. }) {
                        self.split_pointer(
                            capture.hit.id,
                            self.input.pointer.unwrap_or(capture.pointer),
                            2,
                        );
                    }
                    if capture.hit.action == HitAction::DragValue {
                        if let Some(pointer) = self.input.pointer {
                            self.number_input
                                .entry(capture.hit.id)
                                .or_default()
                                .push(NumberInputEvent::Pointer(pointer, 2, self.input.modifiers));
                        }
                    }
                    if let HitAction::ColumnResize { table, column } = capture.hit.action {
                        if let Some(pointer) = self.input.pointer {
                            self.resize_column(table, column, pointer.x - capture.pointer.x);
                        }
                    }
                    if let HitAction::ScrollThumb { area, axis } = capture.hit.action {
                        if let Some(pointer) = self.input.pointer {
                            self.drag_scroll(area, axis, pointer - capture.pointer);
                        }
                    }
                    if capture.hit.action == HitAction::Slider {
                        if let Some(pointer) = self.input.pointer {
                            self.slider_input
                                .entry(capture.hit.id)
                                .or_default()
                                .push(SliderInput::Pointer(pointer));
                        }
                    }
                    self.gesture_release(capture.hit);
                    true
                } else {
                    false
                }
            }
        }
    }

    pub(super) fn move_pointer(&mut self, pointer: Vec2) {
        self.input.pointer = Some(pointer);
        self.update_auto_scroll_pointer(pointer);
        self.drag_move(pointer);
        if let Some(capture) = self.capture {
            self.gesture_move(pointer);
            if matches!(capture.hit.action, HitAction::SplitResize { .. }) {
                self.split_pointer(capture.hit.id, pointer, 0);
            }
            if capture.hit.action == HitAction::DragValue {
                self.number_input
                    .entry(capture.hit.id)
                    .or_default()
                    .push(NumberInputEvent::Pointer(pointer, 0, self.input.modifiers));
            }
            if let HitAction::ColumnResize { table, column } = capture.hit.action {
                self.resize_column(table, column, pointer.x - capture.pointer.x);
            }
            if let HitAction::ScrollThumb { area, axis } = capture.hit.action {
                self.drag_scroll(area, axis, pointer - capture.pointer);
            }
            if capture.hit.action == HitAction::TextEdit {
                if (pointer - capture.pointer).length_squared() > 16.0 {
                    self.text_click = None;
                }
                self.text_edit_input
                    .entry(capture.hit.id)
                    .or_default()
                    .push(TextEditInput::Pointer(pointer, true, 0));
            }
            if capture.hit.action == HitAction::Slider {
                self.slider_input
                    .entry(capture.hit.id)
                    .or_default()
                    .push(SliderInput::Pointer(pointer));
            }
            if let Some(window) = self.windows.get_mut(&capture.hit.window) {
                let delta = pointer - capture.pointer;
                match capture.hit.action {
                    HitAction::Move => {
                        let max = (self.logical_size - Vec2::new(48.0, 32.0)).max(Vec2::ZERO);
                        window.rect = Rect::from_min_size(
                            (capture.rect.min + delta).clamp(Vec2::ZERO, max),
                            capture.rect.size(),
                        );
                    }
                    HitAction::Resize => {
                        window.rect = Rect::from_min_size(
                            capture.rect.min,
                            (capture.rect.size() + delta).max(window.min_size),
                        )
                    }
                    _ => {}
                }
            }
        }
    }
    fn resize_column(&mut self, table: super::Id, column: super::Id, delta: f32) {
        if let Some((dragged, width)) = self.tables.get(&table).and_then(|state| state.drag) {
            if dragged == column {
                self.column_resize
                    .insert((table, column), (width + delta).max(0.0));
            }
        }
    }
}