zng_ext_input/

mouse.rs

//! Mouse events and service.
//!
//! # Events
//!
//! Events this extension provides.
//!
//! * [`MOUSE_MOVE_EVENT`]
//! * [`MOUSE_INPUT_EVENT`]
//! * [`MOUSE_CLICK_EVENT`]
//! * [`MOUSE_HOVERED_EVENT`]
//!
//! # Services
//!
//! Services this extension provides.
//!
//! * [`MOUSE`]

use std::{collections::HashMap, mem, num::NonZeroU32, time::*};

use zng_app::{
    DInstant, INSTANT,
    event::{EventPropagationHandle, event, event_args},
    hn,
    shortcut::ModifiersState,
    timer::{DeadlineVar, TIMERS},
    view_process::{
        VIEW_PROCESS_INITED_EVENT,
        raw_device_events::InputDeviceId,
        raw_events::{
            RAW_MOUSE_INPUT_EVENT, RAW_MOUSE_LEFT_EVENT, RAW_MOUSE_MOVED_EVENT, RAW_MOUSE_WHEEL_EVENT,
            RAW_MULTI_CLICK_CONFIG_CHANGED_EVENT, RAW_WINDOW_FOCUS_EVENT,
        },
    },
    widget::{
        WidgetId,
        info::{HitTestInfo, InteractionPath, WIDGET_TREE_CHANGED_EVENT, WidgetInfo, WidgetInfoBuilder},
    },
    window::WindowId,
};
use zng_app_context::app_local;
use zng_ext_window::{NestedWindowWidgetInfoExt, WINDOWS};
use zng_layout::unit::{Dip, DipPoint, DipToPx, Factor, PxPoint, PxToDip};
use zng_state_map::{StateId, state_map, static_id};
use zng_var::{IntoVar, Var, context_var, impl_from_and_into_var, var};
use zng_view_api::touch::TouchPhase;
pub use zng_view_api::{
    config::MultiClickConfig,
    mouse::{ButtonState, MouseButton, MouseScrollDelta},
};

use crate::{
    keyboard::{KEYBOARD, MODIFIERS_CHANGED_EVENT},
    pointer_capture::{CaptureInfo, CaptureMode, POINTER_CAPTURE, POINTER_CAPTURE_EVENT},
};

event_args! {
    /// [`MOUSE_MOVE_EVENT`] arguments.
    pub struct MouseMoveArgs {
        /// Id of window that received the event.
        pub window_id: WindowId,

        /// Id of device that generated the event.
        pub device_id: InputDeviceId,

        /// What modifier keys where pressed when this event happened.
        pub modifiers: ModifiersState,

        /// Positions of the cursor in between the previous event and this one.
        ///
        /// Mouse move events can be coalesced, i.e. multiple moves packed into a single event.
        pub coalesced_pos: Vec<DipPoint>,

        /// Position of the mouse in the window's content area.
        pub position: DipPoint,

        /// Hit-test result for the mouse point in the window.
        pub hits: HitTestInfo,

        /// Full path to the top-most hit in [`hits`](MouseMoveArgs::hits).
        pub target: InteractionPath,

        /// Current pointer capture.
        pub capture: Option<CaptureInfo>,

        ..

        /// if is in [`target`] or [`capture`].
        ///
        /// [`target`]: Self::target
        /// [`capture`]: Self::capture
        fn is_in_target(&self, id: WidgetId) -> bool {
            if self.target.contains(id) {
                return true;
            }

            if let Some(c) = &self.capture {
                return c.target.contains(id);
            }

            false
        }
    }

    /// [`MOUSE_INPUT_EVENT`] arguments.
    pub struct MouseInputArgs {
        /// Id of window that received the event.
        pub window_id: WindowId,

        /// Id of device that generated the event.
        pub device_id: Option<InputDeviceId>,

        /// Which mouse button generated the event.
        pub button: MouseButton,

        /// Position of the mouse in the window's content area.
        pub position: DipPoint,

        /// What modifier keys where pressed when this event happened.
        pub modifiers: ModifiersState,

        /// The state the [`button`] was changed to.
        ///
        /// [`button`]: Self::button
        pub state: ButtonState,

        /// Hit-test result for the mouse point in the window.
        pub hits: HitTestInfo,

        /// Full path to the top-most hit in [`hits`].
        ///
        /// [`hits`]: Self::hits
        pub target: InteractionPath,

        /// Current pointer capture.
        pub capture: Option<CaptureInfo>,

        /// If [`MOUSE_CLICK_EVENT`] will notify because of this input.
        ///
        /// The click event shares the same propagation handle as this event.
        pub is_click: bool,

        ..

        /// If is in [`target`] or [`capture`].
        ///
        /// [`target`]: Self::target
        /// [`capture`]: Self::capture
        fn is_in_target(&self, id: WidgetId) -> bool {
            if self.target.contains(id) {
                return true;
            }

            if let Some(c) = &self.capture {
                return c.target.contains(id);
            }

            false
        }
    }

    /// [`MOUSE_CLICK_EVENT`] arguments.
    pub struct MouseClickArgs {
        /// Id of window that received the event.
        pub window_id: WindowId,

        /// Id of device that generated the event.
        pub device_id: InputDeviceId,

        /// Which mouse button generated the event.
        pub button: MouseButton,

        /// Position of the mouse in the coordinates of [`target`](MouseClickArgs::target).
        pub position: DipPoint,

        /// What modifier keys where pressed when this event happened.
        pub modifiers: ModifiersState,

        /// Count of clicks within the double-click interval. Number `1` is single click, `2` is double click, etc.
        ///
        /// Auto repeated clicks also increment this count.
        pub click_count: NonZeroU32,

        /// If the event was generated by holding the button pressed over a widget with [`ClickMode::repeat`].
        pub is_repeat: bool,

        /// Hit-test result for the mouse point in the window, at the moment the click event
        /// was generated.
        pub hits: HitTestInfo,

        /// Full path to the widget that got clicked.
        ///
        /// A widget is clicked if the [mouse down] and [mouse up] happen
        /// in sequence in the same widget. Subsequent clicks (double, triple)
        /// happen on mouse down.
        ///
        /// If a [mouse down] happen in a child widget and the pointer is dragged
        /// to a larger parent widget and then let go (mouse up), the click target
        /// is the parent widget.
        ///
        /// Multi-clicks ([`click_count`] > 1) only happen to the same target.
        ///
        /// [mouse down]: MouseInputArgs::is_mouse_down
        /// [mouse up]: MouseInputArgs::is_mouse_up
        /// [`click_count`]: MouseClickArgs::click_count
        pub target: InteractionPath,

        ..

        /// If is in [`target`].
        ///
        /// [`target`]: MouseClickArgs::target
        fn is_in_target(&self, id: WidgetId) -> bool {
            self.target.contains(id)
        }
    }

    /// [`MOUSE_HOVERED_EVENT`] arguments.
    pub struct MouseHoverArgs {
        /// Id of window that received the event.
        pub window_id: WindowId,

        /// Id of device that generated the event.
        pub device_id: Option<InputDeviceId>,

        /// Position of the mouse in the window.
        pub position: DipPoint,

        /// Hit-test result for the mouse point in the window.
        pub hits: HitTestInfo,

        /// Previous top-most hit before the mouse moved.
        pub prev_target: Option<InteractionPath>,

        /// Full path to the top-most hit in [`hits`].
        ///
        /// Is `None` when the mouse moves out of a window or the window closes under the mouse
        /// and there was a previous hovered widget.
        ///
        /// [`hits`]: MouseInputArgs::hits
        pub target: Option<InteractionPath>,

        /// Previous pointer capture.
        pub prev_capture: Option<CaptureInfo>,

        /// Current pointer capture.
        pub capture: Option<CaptureInfo>,

        ..

        /// If is in [`target`], [`prev_target`] or [`capture`].
        ///
        /// [`target`]: Self::target
        /// [`prev_target`]: Self::prev_target
        /// [`capture`]: Self::capture
        fn is_in_target(&self, id: WidgetId) -> bool {
            if let Some(t) = &self.target
                && t.contains(id)
            {
                return true;
            }
            if let Some(t) = &self.prev_target
                && t.contains(id)
            {
                return true;
            }

            if let Some(c) = &self.capture {
                return c.target.contains(id);
            }

            false
        }
    }

    /// [`MOUSE_WHEEL_EVENT`] arguments.
    pub struct MouseWheelArgs {
        /// Id of window that received the event.
        pub window_id: WindowId,
        /// Id of device that generated the event.
        pub device_id: InputDeviceId,

        /// Position of the mouse in the coordinates of [`target`](MouseWheelArgs::target).
        pub position: DipPoint,
        /// What modifier keys where pressed when this event happened.
        pub modifiers: ModifiersState,

        /// Wheel motion delta, value is in pixels if the *wheel* is a touchpad.
        pub delta: MouseScrollDelta,

        /// Touch state if the device that generated the event is a touchpad.
        pub phase: TouchPhase,

        /// Hit-test result for the mouse point in the window, at the moment the wheel event
        /// was generated.
        pub hits: HitTestInfo,

        /// Full path to the widget that got scrolled.
        pub target: InteractionPath,

        ..

        /// If is in [`target`].
        ///
        /// [`target`]: MouseWheelArgs::target
        fn is_in_target(&self, id: WidgetId) -> bool {
            self.target.contains(id)
        }
    }
}

impl MouseHoverArgs {
    /// If [`capture`] is `None` or [`allows`] the `wgt` to receive this event.
    ///
    /// [`capture`]: Self::capture
    /// [`allows`]: CaptureInfo::allows
    pub fn capture_allows(&self, wgt: (WindowId, WidgetId)) -> bool {
        self.capture.as_ref().map(|c| c.allows(wgt)).unwrap_or(true)
    }

    /// Event caused by the mouse position moving over/out of the widget bounds.
    pub fn is_mouse_move(&self) -> bool {
        self.device_id.is_some()
    }

    /// Event caused by the widget moving under/out of the mouse position.
    pub fn is_widget_move(&self) -> bool {
        self.device_id.is_none()
    }

    /// Event caused by a pointer capture change.
    pub fn is_capture_change(&self) -> bool {
        self.prev_capture != self.capture
    }

    /// Returns `true` if the `wgt` was not hovered, but now is.
    pub fn is_mouse_enter(&self, wgt: (WindowId, WidgetId)) -> bool {
        !self.was_over(wgt) && self.is_over(wgt)
    }

    /// Returns `true` if the `wgt` was hovered, but now isn't.
    pub fn is_mouse_leave(&self, wgt: (WindowId, WidgetId)) -> bool {
        self.was_over(wgt) && !self.is_over(wgt)
    }

    /// Returns `true` if the `wgt` was not hovered or was disabled, but now is hovered and enabled.
    pub fn is_mouse_enter_enabled(&self, wgt: (WindowId, WidgetId)) -> bool {
        (!self.was_over(wgt) || self.was_disabled(wgt.1)) && self.is_over(wgt) && self.is_enabled(wgt.1)
    }

    /// Returns `true` if the `wgt` was hovered and enabled, but now is not hovered or is disabled.
    pub fn is_mouse_leave_enabled(&self, wgt: (WindowId, WidgetId)) -> bool {
        self.was_over(wgt) && self.was_enabled(wgt.1) && (!self.is_over(wgt) || self.is_disabled(wgt.1))
    }

    /// Returns `true` if the `wgt` was not hovered or was enabled, but now is hovered and disabled.
    pub fn is_mouse_enter_disabled(&self, wgt: (WindowId, WidgetId)) -> bool {
        (!self.was_over(wgt) || self.was_enabled(wgt.1)) && self.is_over(wgt) && self.is_disabled(wgt.1)
    }

    /// Returns `true` if the `wgt` was hovered and disabled, but now is not hovered or is enabled.
    pub fn is_mouse_leave_disabled(&self, wgt: (WindowId, WidgetId)) -> bool {
        self.was_over(wgt) && self.was_disabled(wgt.1) && (!self.is_over(wgt) || self.is_enabled(wgt.1))
    }

    /// Returns `true` if the `wgt` is in [`prev_target`] and is allowed by the [`prev_capture`].
    ///
    /// [`prev_target`]: Self::prev_target
    /// [`prev_capture`]: Self::prev_capture
    pub fn was_over(&self, wgt: (WindowId, WidgetId)) -> bool {
        if let Some(cap) = &self.prev_capture
            && !cap.allows(wgt)
        {
            return false;
        }

        if let Some(t) = &self.prev_target {
            return t.contains(wgt.1);
        }

        false
    }

    /// Returns `true` if the `wgt` is in [`target`] and is allowed by the current [`capture`].
    ///
    /// [`target`]: Self::target
    /// [`capture`]: Self::capture
    pub fn is_over(&self, wgt: (WindowId, WidgetId)) -> bool {
        if let Some(cap) = &self.capture
            && !cap.allows(wgt)
        {
            return false;
        }

        if let Some(t) = &self.target {
            return t.contains(wgt.1);
        }

        false
    }

    /// Returns `true` if the widget was enabled in [`prev_target`].
    ///
    /// [`prev_target`]: Self::prev_target
    pub fn was_enabled(&self, widget_id: WidgetId) -> bool {
        match &self.prev_target {
            Some(t) => t.contains_enabled(widget_id),
            None => false,
        }
    }

    /// Returns `true` if the widget was disabled in [`prev_target`].
    ///
    /// [`prev_target`]: Self::prev_target
    pub fn was_disabled(&self, widget_id: WidgetId) -> bool {
        match &self.prev_target {
            Some(t) => t.contains_disabled(widget_id),
            None => false,
        }
    }

    /// Returns `true` if the widget is enabled in [`target`].
    ///
    /// [`target`]: Self::target
    pub fn is_enabled(&self, widget_id: WidgetId) -> bool {
        match &self.target {
            Some(t) => t.contains_enabled(widget_id),
            None => false,
        }
    }

    /// Returns `true` if the widget is disabled in [`target`].
    ///
    /// [`target`]: Self::target
    pub fn is_disabled(&self, widget_id: WidgetId) -> bool {
        match &self.target {
            Some(t) => t.contains_disabled(widget_id),
            None => false,
        }
    }

    /// Gets position in the widget inner bounds.
    pub fn position_wgt(&self, wgt: (WindowId, WidgetId)) -> Option<PxPoint> {
        let tree = WINDOWS.widget_tree(wgt.0)?;
        tree.get(wgt.1)?
            .inner_transform()
            .inverse()?
            .transform_point(self.position.to_px(tree.scale_factor()))
    }
}

impl MouseMoveArgs {
    /// If [`capture`] is `None` or [`allows`] the `wgt` to receive this event.
    ///
    /// [`capture`]: Self::capture
    /// [`allows`]: CaptureInfo::allows
    pub fn capture_allows(&self, wgt: (WindowId, WidgetId)) -> bool {
        self.capture.as_ref().map(|c| c.allows(wgt)).unwrap_or(true)
    }

    /// Gets position in the widget inner bounds.
    pub fn position_wgt(&self, wgt: (WindowId, WidgetId)) -> Option<PxPoint> {
        let tree = WINDOWS.widget_tree(wgt.0)?;
        tree.get(wgt.1)?
            .inner_transform()
            .inverse()?
            .transform_point(self.position.to_px(tree.scale_factor()))
    }
}

impl MouseInputArgs {
    /// If [`capture`] is `None` or [`allows`] the `wgt` to receive this event.
    ///
    /// [`capture`]: Self::capture
    /// [`allows`]: CaptureInfo::allows
    pub fn capture_allows(&self, wgt: (WindowId, WidgetId)) -> bool {
        self.capture.as_ref().map(|c| c.allows(wgt)).unwrap_or(true)
    }

    /// If the `widget_id` is in the [`target`].
    ///
    /// [`target`]: Self::target
    pub fn is_over(&self, widget_id: WidgetId) -> bool {
        self.target.contains(widget_id)
    }

    /// If the [`button`] is the primary.
    ///
    /// [`button`]: Self::button
    pub fn is_primary(&self) -> bool {
        self.button == MouseButton::Left
    }

    /// If the [`button`](Self::button) is the context (right).
    pub fn is_context(&self) -> bool {
        self.button == MouseButton::Right
    }

    /// If the [`state`] is pressed.
    ///
    /// [`state`]: Self::state
    pub fn is_mouse_down(&self) -> bool {
        self.state == ButtonState::Pressed
    }

    /// If the [`state`] is released.
    ///
    /// [`state`]: Self::state
    pub fn is_mouse_up(&self) -> bool {
        self.state == ButtonState::Released
    }

    /// Gets position in the widget inner bounds.
    pub fn position_wgt(&self, wgt: (WindowId, WidgetId)) -> Option<PxPoint> {
        let tree = WINDOWS.widget_tree(wgt.0)?;
        tree.get(wgt.1)?
            .inner_transform()
            .inverse()?
            .transform_point(self.position.to_px(tree.scale_factor()))
    }
}

impl MouseClickArgs {
    /// If the [`button`](Self::button) is the primary.
    pub fn is_primary(&self) -> bool {
        self.button == MouseButton::Left
    }

    /// If the [`button`](Self::button) is the context (right).
    pub fn is_context(&self) -> bool {
        self.button == MouseButton::Right
    }

    /// If the [`click_count`](Self::click_count) is `1`.
    pub fn is_single(&self) -> bool {
        self.click_count.get() == 1
    }

    /// If the [`click_count`](Self::click_count) is `2`.
    pub fn is_double(&self) -> bool {
        self.click_count.get() == 2
    }

    /// If the [`click_count`](Self::click_count) is `3`.
    pub fn is_triple(&self) -> bool {
        self.click_count.get() == 3
    }

    /// Gets position in the widget inner bounds.
    pub fn position_wgt(&self, wgt: (WindowId, WidgetId)) -> Option<PxPoint> {
        let tree = WINDOWS.widget_tree(wgt.0)?;
        tree.get(wgt.1)?
            .inner_transform()
            .inverse()?
            .transform_point(self.position.to_px(tree.scale_factor()))
    }
}

impl MouseWheelArgs {
    /// Swaps the delta axis if [`modifiers`] contains `SHIFT`.
    ///
    /// [`modifiers`]: Self::modifiers
    pub fn shifted_delta(&self) -> MouseScrollDelta {
        if self.modifiers.has_shift() {
            match self.delta {
                MouseScrollDelta::LineDelta(x, y) => MouseScrollDelta::LineDelta(y, x),
                MouseScrollDelta::PixelDelta(x, y) => MouseScrollDelta::PixelDelta(y, x),
                _ => unimplemented!(),
            }
        } else {
            self.delta
        }
    }

    /// If the modifiers allow the event to be used for scrolling.
    ///
    /// Is `true` if only `SHIFT`, `ALT` or none modifiers are pressed. If `true` the
    /// [`scroll_delta`] method returns a value.
    ///
    /// If contextual [`CTRL_SCROLL_VAR`] is `true` the `CTRL` modifier must be pressed for this to be `true`.
    ///
    /// [`scroll_delta`]: Self::scroll_delta
    pub fn is_scroll(&self) -> bool {
        if CTRL_SCROLL_VAR.get() {
            self.modifiers
                .is_only(ModifiersState::CTRL | ModifiersState::SHIFT | ModifiersState::ALT)
        } else {
            self.modifiers.is_empty() || self.modifiers.is_only(ModifiersState::SHIFT | ModifiersState::ALT)
        }
    }

    /// Returns the delta for a scrolling operation, depending on the [`modifiers`].
    ///
    /// If [`is_scroll`] scales the delta by `alt_factor`, then, if no more modifiers are pressed returns
    /// the scaled delta, if only `SHIFT` is pressed returns the swapped delta, otherwise returns `None`.
    ///
    /// [`is_scroll`]: Self::is_scroll
    /// [`modifiers`]: Self::modifiers
    pub fn scroll_delta(&self, alt_factor: impl Into<Factor>) -> Option<MouseScrollDelta> {
        let mut modifiers = self.modifiers;
        if CTRL_SCROLL_VAR.get() && !modifiers.take_ctrl() {
            return None;
        }
        let mut delta = self.delta;
        if modifiers.take_alt() {
            let alt_factor = alt_factor.into();
            delta = match delta {
                MouseScrollDelta::LineDelta(x, y) => MouseScrollDelta::LineDelta(x * alt_factor.0, y * alt_factor.0),
                MouseScrollDelta::PixelDelta(x, y) => MouseScrollDelta::PixelDelta(x * alt_factor.0, y * alt_factor.0),
                _ => return None,
            };
        }

        if modifiers.is_empty() {
            Some(delta)
        } else if modifiers.is_only_shift() {
            Some(match delta {
                MouseScrollDelta::LineDelta(x, y) => MouseScrollDelta::LineDelta(y, x),
                MouseScrollDelta::PixelDelta(x, y) => MouseScrollDelta::PixelDelta(y, x),
                _ => return None,
            })
        } else {
            None
        }
    }

    /// If the modifiers allow the event to be used for zooming.
    ///
    /// Is `true` if only `CTRL` is pressed. If `true` the [`zoom_delta`] method returns a value.
    ///
    /// If contextual [`CTRL_SCROLL_VAR`] is `true` no modifiers must be pressed for this to be `true`.
    ///
    /// [`zoom_delta`]: Self::zoom_delta
    pub fn is_zoom(&self) -> bool {
        if CTRL_SCROLL_VAR.get() {
            self.modifiers.is_empty()
        } else {
            self.modifiers.is_only_ctrl()
        }
    }

    /// Returns the delta for a zoom-in/out operation, depending on the [`modifiers`].
    ///
    /// If [`is_zoom`] returns the scroll delta, otherwise returns `None`.
    ///
    /// [`is_zoom`]: Self::is_zoom
    /// [`modifiers`]: Self::modifiers
    pub fn zoom_delta(&self) -> Option<MouseScrollDelta> {
        if self.is_zoom() { Some(self.delta) } else { None }
    }

    /// Gets position in the widget inner bounds.
    pub fn position_wgt(&self, wgt: (WindowId, WidgetId)) -> Option<PxPoint> {
        let tree = WINDOWS.widget_tree(wgt.0)?;
        tree.get(wgt.1)?
            .inner_transform()
            .inverse()?
            .transform_point(self.position.to_px(tree.scale_factor()))
    }
}

context_var! {
    /// Defines if [`MouseWheelArgs`] gesture is [`is_scroll`] when `CTRL` is pressed and [`is_zoom`] when no modifier is pressed.
    ///
    /// Is `false` by default.
    ///
    /// [`is_scroll`]: MouseWheelArgs::is_scroll
    /// [`is_zoom`]: MouseWheelArgs::is_zoom
    pub static CTRL_SCROLL_VAR: bool = false;
}

event! {
    /// Mouse move event.
    pub static MOUSE_MOVE_EVENT: MouseMoveArgs {
        let _ = MOUSE_SV.read();
    };

    /// Mouse down or up event.
    pub static MOUSE_INPUT_EVENT: MouseInputArgs {
        let _ = MOUSE_SV.read();
    };

    /// Mouse click event, any [`click_count`](MouseClickArgs::click_count).
    pub static MOUSE_CLICK_EVENT: MouseClickArgs {
        let _ = MOUSE_SV.read();
    };

    /// The top-most hovered widget changed or pointer capture changed.
    pub static MOUSE_HOVERED_EVENT: MouseHoverArgs {
        let _ = MOUSE_SV.read();
    };

    /// Mouse wheel scroll event.
    pub static MOUSE_WHEEL_EVENT: MouseWheelArgs {
        let _ = MOUSE_SV.read();
    };
}

/// Represents mouse gestures that can initiate a click.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
pub enum ClickTrigger {
    /// Widget is clicked when the same mouse button is pressed and released on it.
    PressRelease,
    /// Widget is clicked when a mouse button is pressed on it.
    Press,
    /// Widget is clicked when a mouse button is released on it, even if not pressed on it.
    Release,
}

/// Defines how click events are generated for a widget.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
pub struct ClickMode {
    /// Gesture that causes the *first* click, that is a click that is not in the double-click interval.
    pub single: ClickTrigger,

    /// Gesture that causes the subsequent clicks, if done within the double-click interval.
    pub double: ClickTrigger,

    /// If a mouse button is held pressed after a delay generate repeat clicks on an interval.
    pub repeat: bool,
}
impl Default for ClickMode {
    /// First `PressRelease`, double `Press` and no repeat.
    fn default() -> Self {
        Self {
            single: ClickTrigger::PressRelease,
            double: ClickTrigger::Press,
            repeat: false,
        }
    }
}
impl IntoVar<Option<ClickMode>> for ClickTrigger {
    fn into_var(self) -> Var<Option<ClickMode>> {
        Some(ClickMode::from(self)).into_var()
    }
}
impl_from_and_into_var! {
    fn from(gesture: ClickTrigger) -> ClickMode {
        ClickMode {
            single: gesture,
            double: gesture,
            repeat: false,
        }
    }

    fn from(some: ClickMode) -> Option<ClickMode>;
}
impl ClickMode {
    /// Click on [`ClickTrigger::Press`].
    pub fn press() -> Self {
        Self {
            single: ClickTrigger::Press,
            double: ClickTrigger::Press,
            repeat: false,
        }
    }

    /// Click on release.
    pub fn release() -> Self {
        Self {
            single: ClickTrigger::Release,
            double: ClickTrigger::Release,
            repeat: false,
        }
    }

    /// Click on press and repeat.
    pub fn repeat() -> Self {
        Self {
            single: ClickTrigger::Press,
            double: ClickTrigger::Press,
            repeat: true,
        }
    }

    /// Click on press+release or repeat.
    pub fn mixed_repeat() -> Self {
        Self {
            single: ClickTrigger::PressRelease,
            double: ClickTrigger::Press,
            repeat: true,
        }
    }
}

/// Mouse config methods.
pub trait WidgetInfoMouseExt {
    /// Gets the click mode of the widget.
    fn click_mode(&self) -> ClickMode;
}
impl WidgetInfoMouseExt for WidgetInfo {
    fn click_mode(&self) -> ClickMode {
        for w in self.self_and_ancestors() {
            if let Some(m) = w.meta().get_clone(*CLICK_MODE_ID).flatten() {
                return m;
            }
        }
        ClickMode::default()
    }
}

/// Mouse config builder methods.
pub trait WidgetInfoBuilderMouseExt {
    /// Sets the click mode of the widget.
    ///
    /// Setting this to `None` will cause the widget to inherit the click mode.
    fn set_click_mode(&mut self, mode: Option<ClickMode>);
}
impl WidgetInfoBuilderMouseExt for WidgetInfoBuilder {
    fn set_click_mode(&mut self, mode: Option<ClickMode>) {
        self.with_meta(|mut m| match m.entry(*CLICK_MODE_ID) {
            state_map::StateMapEntry::Occupied(mut e) => *e.get_mut() = mode,
            state_map::StateMapEntry::Vacant(e) => {
                if mode.is_some() {
                    e.insert(mode);
                }
            }
        })
    }
}

static_id! {
    static ref CLICK_MODE_ID: StateId<Option<ClickMode>>;
}

/// Settings that define the mouse button pressed repeat.
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub struct ButtonRepeatConfig {
    /// Delay before repeat starts.
    pub start_delay: Duration,
    /// Delay before each repeat event after the first.
    pub interval: Duration,
}
impl Default for ButtonRepeatConfig {
    /// 600ms, 100ms.
    fn default() -> Self {
        Self {
            start_delay: Duration::from_millis(600),
            interval: Duration::from_millis(100),
        }
    }
}

/// Mouse service.
///
/// # Mouse Capture
///
/// Mouse capture is integrated with touch capture in the [`POINTER_CAPTURE`] service.
///
/// [`POINTER_CAPTURE`]: crate::pointer_capture::POINTER_CAPTURE
pub struct MOUSE;
impl MOUSE {
    /// Returns a read-only variable that tracks the [buttons] that are currently pressed.
    ///
    /// [buttons]: MouseButton
    pub fn buttons(&self) -> Var<Vec<MouseButton>> {
        MOUSE_SV.read().buttons.read_only()
    }

    /// Variable that defines the click-count increment time and area, a.k.a. the double-click config.
    ///
    /// Repeated clicks with an interval less then this time and within the distance of the first click increment the click count.
    ///
    /// The value is the same as [`sys_multi_click_config`], if set the variable disconnects from system config.
    ///
    /// [`sys_multi_click_config`]: Self::sys_multi_click_config
    pub fn multi_click_config(&self) -> Var<MultiClickConfig> {
        MOUSE_SV.read().multi_click_config.clone()
    }

    /// Variable that tracks the system click-count increment time and area, a.k.a. the double-click config.
    ///
    /// # Value Source
    ///
    /// The value comes from the operating system settings, the variable
    /// updates with a new value if the system setting is changed and on view-process (re)init.
    ///
    /// In headless apps the default is [`MultiClickConfig::default`] and does not change.
    pub fn sys_multi_click_config(&self) -> Var<MultiClickConfig> {
        MOUSE_SV.read().sys_multi_click_config.read_only()
    }

    /// Variable that gets and sets the config for [`ClickMode::repeat`] clicks.
    ///
    /// Note that this variable is linked with [`KEYBOARD.repeat_config`] until it is set, so if it is never set
    /// it will update with the keyboard value.
    ///
    /// [`KEYBOARD.repeat_config`]: KEYBOARD::repeat_config
    pub fn repeat_config(&self) -> Var<ButtonRepeatConfig> {
        MOUSE_SV.read().repeat_config.clone()
    }

    /// Variable that gets current hovered window and cursor point over that window.
    pub fn position(&self) -> Var<Option<MousePosition>> {
        MOUSE_SV.read().position.read_only()
    }

    /// Variable that gets the current hovered window and widgets.
    pub fn hovered(&self) -> Var<Option<InteractionPath>> {
        MOUSE_SV.read().hovered.read_only()
    }
}

/// Mouse cursor position.
///
/// Tracked in [`MOUSE.position`].
///
/// [`MOUSE.position`]: MOUSE::position
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct MousePosition {
    /// Window the mouse is hovering.
    pub window_id: WindowId,
    /// Mouse position in the window.
    pub position: DipPoint,
    /// Timestamp of the mouse move.
    pub timestamp: DInstant,
}

app_local! {
    static MOUSE_SV: MouseService = {
        hooks();
        let sys_multi_click_config = var(MultiClickConfig::default());
        MouseService {
            multi_click_config: sys_multi_click_config.cow(),
            sys_multi_click_config,
            repeat_config: KEYBOARD
                .repeat_config()
                .map(|c| ButtonRepeatConfig {
                    start_delay: c.start_delay,
                    interval: c.interval,
                })
                .cow(),
            buttons: var(vec![]),
            hovered: var(None),
            position: var(None),

            pos: DipPoint::zero(),
            pos_window: None,
            pos_device: None,
            hits: None,

            modifiers: ModifiersState::default(),

            hovered_value: None,
            clicking: HashMap::default(),
        }
    };
}
struct MouseService {
    multi_click_config: Var<MultiClickConfig>,
    sys_multi_click_config: Var<MultiClickConfig>,
    repeat_config: Var<ButtonRepeatConfig>,
    buttons: Var<Vec<MouseButton>>,
    hovered: Var<Option<InteractionPath>>,
    position: Var<Option<MousePosition>>,

    // last cursor move position (scaled).
    pos: DipPoint,
    // last cursor move over `pos_window` and source device.
    pos_window: Option<WindowId>,
    pos_device: Option<InputDeviceId>,
    // last cursor move hit-test (on the pos_window or a nested window).
    hits: Option<HitTestInfo>,

    /// last modifiers.
    modifiers: ModifiersState,

    hovered_value: Option<InteractionPath>,
    clicking: HashMap<MouseButton, ClickingInfo>,
}

struct ClickingInfo {
    path: InteractionPath,
    press_stop_handle: EventPropagationHandle,

    pressed: bool,
    last_pos: DipPoint,
    last_click: DInstant,
    click_count: u32,

    repeat_timer: Option<DeadlineVar>,
    repeat_count: u32,
}

fn hooks() {
    WIDGET_TREE_CHANGED_EVENT
        .hook(|args| {
            MOUSE_SV.write().continue_hovered(args.tree.window_id());
            true
        })
        .perm();

    RAW_MOUSE_MOVED_EVENT
        .hook(|args| {
            MOUSE_SV
                .write()
                .on_cursor_moved(args.window_id, args.device_id, args.coalesced_pos.clone(), args.position);
            true
        })
        .perm();

    RAW_MOUSE_WHEEL_EVENT
        .hook(|args| {
            MOUSE_SV.read().on_scroll(args.window_id, args.device_id, args.delta, args.phase);
            true
        })
        .perm();

    RAW_MOUSE_INPUT_EVENT
        .hook(|args| {
            MOUSE_SV
                .write()
                .on_mouse_input(args.window_id, args.device_id, args.state, args.button);
            true
        })
        .perm();

    MODIFIERS_CHANGED_EVENT
        .hook(|args| {
            MOUSE_SV.write().modifiers = args.modifiers;
            true
        })
        .perm();

    RAW_MOUSE_LEFT_EVENT
        .hook(|args| {
            MOUSE_SV.write().on_cursor_left_window(args.window_id, args.device_id);
            true
        })
        .perm();

    RAW_WINDOW_FOCUS_EVENT
        .hook(|args| {
            if let Some(window_id) = args.prev_focus {
                MOUSE_SV.write().on_window_blur(window_id, args.new_focus);
            }
            true
        })
        .perm();

    RAW_MULTI_CLICK_CONFIG_CHANGED_EVENT
        .hook(|args| {
            let mut s = MOUSE_SV.write();
            s.multi_click_config.set(args.config);
            s.clicking.clear();
            true
        })
        .perm();

    VIEW_PROCESS_INITED_EVENT
        .hook(|args| {
            if args.is_respawn {
                MOUSE_SV.write().clean_all_state();
            }
            true
        })
        .perm();

    POINTER_CAPTURE_EVENT
        .on_event(
            true,
            hn!(|a| {
                MOUSE_SV.write().on_pointer_capture(&a.prev_capture, &a.new_capture);
            }),
        )
        .perm();
}
impl MouseService {
    fn on_mouse_input(&mut self, mut window_id: WindowId, device_id: InputDeviceId, state: ButtonState, button: MouseButton) {
        let mut position = if self.pos_window == Some(window_id) {
            self.pos
        } else {
            DipPoint::default()
        };

        let hits = self.hits.clone().unwrap_or_else(|| HitTestInfo::no_hits(window_id));

        let wgt_tree = match WINDOWS.widget_tree(hits.window_id()) {
            Some(t) => t,
            None => {
                tracing::error!("cannot find clicked window, {}", hits.window_id());
                return;
            }
        };

        if hits.window_id() != window_id {
            // is over nested window
            window_id = hits.window_id();
            position = hits.point().to_dip(wgt_tree.scale_factor());
        }

        let (wgt_path, click_mode) = hits
            .target()
            .and_then(|t| wgt_tree.get(t.widget_id).map(|w| (w.interaction_path(), w.click_mode())))
            .unwrap_or_else(|| (wgt_tree.root().interaction_path(), wgt_tree.root().click_mode()));

        let wgt_path = match wgt_path.unblocked() {
            Some(p) => p,
            None => return, // entire window blocked
        };

        match state {
            ButtonState::Pressed => {
                self.buttons.modify(move |btns| {
                    if !btns.contains(&button) {
                        btns.push(button);
                    }
                });
            }
            ButtonState::Released => {
                self.buttons.modify(move |btns| {
                    if let Some(i) = btns.iter().position(|k| *k == button) {
                        btns.swap_remove(i);
                    }
                });
            }
        }

        let stop_handle = EventPropagationHandle::new();

        let entry = self.clicking.entry(button).or_insert_with(|| ClickingInfo {
            path: wgt_path.clone(),
            press_stop_handle: stop_handle.clone(),
            last_click: DInstant::EPOCH,
            last_pos: position,
            pressed: false,
            click_count: 0,
            repeat_timer: None,
            repeat_count: 0,
        });

        if entry.path != wgt_path {
            let actual_change = entry.path.as_path() != wgt_path.as_path();
            // else only interactivity change mid-click

            entry.path = wgt_path.clone();
            if actual_change {
                entry.press_stop_handle = stop_handle.clone();
                entry.pressed = false;
                entry.click_count = 0;
                entry.repeat_timer = None;
                entry.repeat_count = 0;
            }
        }

        let multi_click_cfg = self.multi_click_config.get();

        let double_allowed = entry.last_click.elapsed() <= multi_click_cfg.time && {
            let dist = (entry.last_pos.to_vector() - position.to_vector()).abs();
            let area = multi_click_cfg.area;
            dist.x <= area.width && dist.y <= area.height
        };

        let click_trigger = if entry.click_count == 0 || !double_allowed {
            entry.click_count = 0;
            click_mode.single
        } else {
            click_mode.double
        };

        let click = match state {
            ButtonState::Pressed => {
                entry.pressed = true;
                entry.press_stop_handle = stop_handle.clone();
                matches!(click_trigger, ClickTrigger::Press)
            }
            ButtonState::Released => {
                entry.repeat_count = 0;
                entry.repeat_timer = None;
                if mem::take(&mut entry.pressed) && !entry.press_stop_handle.is_stopped() {
                    matches!(click_trigger, ClickTrigger::PressRelease | ClickTrigger::Release)
                } else {
                    matches!(click_trigger, ClickTrigger::Release)
                }
            }
        };

        if click_mode.repeat {
            if click {
                let t = self.repeat_config.get().start_delay;
                let t = TIMERS.deadline(t);
                t.hook(|t| {
                    let elapsed = t.value().has_elapsed();
                    if elapsed {
                        MOUSE_SV.write().on_repeat_timer_elapsed();
                    }
                    !elapsed
                })
                .perm();
                entry.repeat_timer = Some(t);
                entry.repeat_count = 0;
            }
        } else {
            entry.repeat_timer = None;
            entry.repeat_count = 0;
        }

        let capture_info = POINTER_CAPTURE.current_capture().get();

        let now = INSTANT.now();
        let args = MouseInputArgs::new(
            now,
            stop_handle.clone(),
            window_id,
            device_id,
            button,
            position,
            self.modifiers,
            state,
            hits.clone(),
            wgt_path.clone(),
            capture_info,
            click,
        );

        // on_mouse_input
        MOUSE_INPUT_EVENT.notify(args);

        if click {
            if double_allowed {
                entry.click_count += 1;
            } else {
                entry.click_count = 1;
            }

            entry.last_click = now;
            entry.last_pos = position;

            let args = MouseClickArgs::new(
                now,
                stop_handle,
                window_id,
                device_id,
                button,
                position,
                self.modifiers,
                NonZeroU32::new(entry.click_count).unwrap(),
                false,
                hits,
                wgt_path,
            );

            // on_mouse_click
            MOUSE_CLICK_EVENT.notify(args);
        }
    }

    fn on_cursor_moved(&mut self, window_id: WindowId, device_id: InputDeviceId, coalesced_pos: Vec<DipPoint>, mut position: DipPoint) {
        let mut moved = Some(window_id) != self.pos_window || Some(device_id) != self.pos_device;

        if moved {
            // if is over another window now.
            self.pos_window = Some(window_id);
            self.pos_device = Some(device_id);
        }

        moved |= position != self.pos;

        if moved {
            // if moved to another window or within the same window.

            self.pos = position;

            // mouse_move data
            let mut frame_info = match WINDOWS.widget_tree(window_id) {
                Some(f) => f,
                None => {
                    // window not found
                    if let Some(hovered) = self.hovered_value.take() {
                        let capture = POINTER_CAPTURE.current_capture().get();
                        let args = MouseHoverArgs::now(
                            window_id,
                            device_id,
                            position,
                            HitTestInfo::no_hits(window_id),
                            Some(hovered),
                            None,
                            capture.clone(),
                            capture,
                        );
                        MOUSE_HOVERED_EVENT.notify(args);
                    }
                    return;
                }
            };

            let mut pos_hits = frame_info.root().hit_test(position.to_px(frame_info.scale_factor()));

            let target = if let Some(t) = pos_hits.target() {
                if let Some(w) = frame_info.get(t.widget_id) {
                    if let Some(f) = w.nested_window_tree() {
                        // nested window hit
                        frame_info = f;
                        let factor = frame_info.scale_factor();
                        let pos = position.to_px(factor);
                        let pos = w.inner_transform().inverse().and_then(|t| t.transform_point(pos)).unwrap_or(pos);
                        pos_hits = frame_info.root().hit_test(pos);
                        position = pos.to_dip(factor);
                        pos_hits
                            .target()
                            .and_then(|h| frame_info.get(h.widget_id))
                            .map(|w| w.interaction_path())
                            .unwrap_or_else(|| frame_info.root().interaction_path())
                    } else {
                        w.interaction_path()
                    }
                } else {
                    tracing::error!("hits target `{}` not found", t.widget_id);
                    frame_info.root().interaction_path()
                }
            } else {
                frame_info.root().interaction_path()
            }
            .unblocked();

            self.position.set(Some(MousePosition {
                window_id: frame_info.window_id(),
                position,
                timestamp: INSTANT.now(),
            }));

            self.hits = Some(pos_hits.clone());

            let capture = POINTER_CAPTURE.current_capture().get();

            // mouse_enter/mouse_leave.
            let hovered_args = if self.hovered_value != target {
                self.hovered.set(target.clone());
                let prev_target = mem::replace(&mut self.hovered_value, target.clone());
                let args = MouseHoverArgs::now(
                    frame_info.window_id(),
                    device_id,
                    position,
                    pos_hits.clone(),
                    prev_target,
                    target.clone(),
                    capture.clone(),
                    capture.clone(),
                );
                Some(args)
            } else {
                None
            };

            // mouse_move
            if let Some(target) = target {
                let args = MouseMoveArgs::now(
                    frame_info.window_id(),
                    device_id,
                    self.modifiers,
                    coalesced_pos,
                    position,
                    pos_hits,
                    target,
                    capture,
                );
                MOUSE_MOVE_EVENT.notify(args);
            }

            if let Some(args) = hovered_args {
                MOUSE_HOVERED_EVENT.notify(args);
            }
        } else if coalesced_pos.is_empty() {
            tracing::debug!("RawCursorMoved did not actually move")
        }
    }

    fn on_scroll(&self, window_id: WindowId, device_id: InputDeviceId, delta: MouseScrollDelta, phase: TouchPhase) {
        let position = if self.pos_window == Some(window_id) {
            self.pos
        } else {
            DipPoint::default()
        };

        let hits = self.hits.clone().unwrap_or_else(|| HitTestInfo::no_hits(window_id));

        let frame_info = WINDOWS.widget_tree(hits.window_id()).unwrap();

        let target = hits
            .target()
            .and_then(|t| frame_info.get(t.widget_id).map(|w| w.interaction_path()))
            .unwrap_or_else(|| frame_info.root().interaction_path());

        if let Some(target) = target.unblocked() {
            let args = MouseWheelArgs::now(hits.window_id(), device_id, position, self.modifiers, delta, phase, hits, target);
            MOUSE_WHEEL_EVENT.notify(args);
        }
    }

    fn on_cursor_left_window(&mut self, window_id: WindowId, device_id: InputDeviceId) {
        if Some(window_id) == self.pos_window.take() {
            self.position.set(None);
            if let Some(path) = self.hovered_value.take() {
                self.hovered.set(None);
                let capture = POINTER_CAPTURE.current_capture().get();
                let args = MouseHoverArgs::now(
                    window_id,
                    device_id,
                    self.pos,
                    HitTestInfo::no_hits(window_id),
                    Some(path),
                    None,
                    capture.clone(),
                    capture,
                );
                MOUSE_HOVERED_EVENT.notify(args);
            }
        }
    }

    fn on_window_blur(&mut self, prev_window: WindowId, new_window: Option<WindowId>) {
        if new_window.is_some() {
            if let Some(p) = self.pos_window {
                // last hovered window losing focus, and is not just focusing a nested window
                if p == prev_window && (new_window.is_none() || new_window != self.hits.as_ref().map(|h| h.window_id())) {
                    self.clean_all_state();
                }
            }
        } else {
            self.clean_all_state();
        }
    }

    /// Call after a frame or info rebuild.
    fn continue_hovered(&mut self, mut window_id: WindowId) {
        if self.pos_window == Some(window_id) {
            // update hovered if widgets moved under the cursor position.
            let mut frame_info = match WINDOWS.widget_tree(window_id) {
                Some(f) => f,
                None => {
                    self.clean_all_state();
                    return;
                }
            };
            let mut pos_hits = frame_info.root().hit_test(self.pos.to_px(frame_info.scale_factor()));
            let mut position = self.pos;
            let target = if let Some(t) = pos_hits.target() {
                if let Some(w) = frame_info.get(t.widget_id) {
                    if let Some(f) = w.nested_window_tree() {
                        frame_info = f;
                        let factor = frame_info.scale_factor();
                        let pos = self.pos.to_px(factor);
                        let pos = w.inner_transform().inverse().and_then(|t| t.transform_point(pos)).unwrap_or(pos);
                        pos_hits = frame_info.root().hit_test(pos);
                        window_id = frame_info.window_id();
                        position = pos.to_dip(factor);
                        pos_hits
                            .target()
                            .and_then(|h| frame_info.get(h.widget_id))
                            .map(|w| w.interaction_path())
                            .unwrap_or_else(|| frame_info.root().interaction_path())
                    } else {
                        w.interaction_path()
                    }
                } else {
                    tracing::error!("hits target `{}` not found", t.widget_id);
                    frame_info.root().interaction_path()
                }
            } else {
                frame_info.root().interaction_path()
            }
            .unblocked();
            self.hits = Some(pos_hits.clone());

            if self.hovered_value != target {
                let capture = POINTER_CAPTURE.current_capture().get();
                let prev = mem::replace(&mut self.hovered_value, target.clone());
                let args = MouseHoverArgs::now(window_id, None, position, pos_hits, prev, target, capture.clone(), capture);
                MOUSE_HOVERED_EVENT.notify(args);
            }
        }
    }

    fn clean_all_state(&mut self) {
        if self.pos_window.take().is_some()
            && let Some(path) = self.hovered_value.take()
        {
            let window_id = path.window_id();
            self.buttons.with(|b| {
                for btn in b {
                    let args = MouseInputArgs::now(
                        window_id,
                        None,
                        *btn,
                        DipPoint::new(Dip::new(-1), Dip::new(-1)),
                        ModifiersState::empty(),
                        ButtonState::Released,
                        HitTestInfo::no_hits(window_id),
                        path.clone(),
                        None,
                        false,
                    );
                    MOUSE_INPUT_EVENT.notify(args);
                }
            });

            let args = MouseHoverArgs::now(
                window_id,
                None,
                DipPoint::new(Dip::new(-1), Dip::new(-1)),
                HitTestInfo::no_hits(window_id),
                Some(path),
                None,
                None,
                None,
            );
            MOUSE_HOVERED_EVENT.notify(args);
        }
        self.buttons.set(vec![]);
        self.clicking.clear();
        self.pos_device = None;
        self.pos_window = None;
        self.hits = None;
        self.position.set(None);
        self.hovered.set(None);
    }

    fn on_pointer_capture(&mut self, prev_capture: &Option<CaptureInfo>, new_capture: &Option<CaptureInfo>) {
        if let Some(path) = &self.hovered_value
            && self.pos_window.is_some()
        {
            let window_id = path.window_id();
            let hover_args = MouseHoverArgs::now(
                window_id,
                self.pos_device.unwrap(),
                self.pos,
                self.hits.clone().unwrap_or_else(|| HitTestInfo::no_hits(window_id)),
                Some(path.clone()),
                Some(path.clone()),
                prev_capture.clone(),
                new_capture.clone(),
            );
            MOUSE_HOVERED_EVENT.notify(hover_args);
        }
    }
}
impl MouseService {
    fn on_repeat_timer_elapsed(&mut self) {
        // update pressed repeat clicks
        for (btn, info) in self.clicking.iter_mut() {
            if let Some(timer) = info.repeat_timer.take() {
                // is repeat mode
                if timer.with_new(|t| t.has_elapsed()).unwrap_or(false) {
                    // time to repeat
                    info.repeat_count = info.repeat_count.saturating_add(1);

                    if let Some(dv) = self.pos_device
                        && let Some(tree) = WINDOWS.widget_tree(info.path.window_id())
                    {
                        // probably still valid

                        let hit_test = tree.root().hit_test(self.pos.to_px(tree.scale_factor()));

                        // get the hit target, constrained by capture
                        let mut target = None;
                        if let Some(hit) = hit_test.target().map(|t| tree.get(t.widget_id).unwrap()) {
                            target = hit.path().shared_ancestor(info.path.as_path()).map(|c| c.into_owned());
                        }
                        if let Some(c) = POINTER_CAPTURE.current_capture().get() {
                            match c.mode {
                                CaptureMode::Window => {
                                    if let Some(t) = &target {
                                        if t.window_id() != c.target.window_id() {
                                            target = None; // captured in other window, cancel repeat
                                        }
                                    } else {
                                        // no hit, but window capture
                                        target = Some(tree.root().path());
                                    }
                                }
                                CaptureMode::Subtree => {
                                    if let Some(t) = &target {
                                        target = c.target.shared_ancestor(t).map(|c| c.into_owned());
                                    } else {
                                        target = Some(c.target);
                                    }
                                }
                                CaptureMode::Widget => {
                                    target = Some(c.target);
                                }
                            }
                        }

                        if let Some(target) = target {
                            // if still has a target
                            if let Some(target) = tree.get(target.widget_id()).and_then(|w| w.interaction_path().unblocked()) {
                                // and it is unblocked

                                // notify repeat
                                let args = MouseClickArgs::now(
                                    target.window_id(),
                                    dv,
                                    *btn,
                                    self.pos,
                                    self.modifiers,
                                    NonZeroU32::new(info.repeat_count).unwrap(),
                                    true,
                                    hit_test,
                                    target,
                                );
                                MOUSE_CLICK_EVENT.notify(args);

                                // continue timer
                                let t = MOUSE.repeat_config().get().interval;
                                let t = TIMERS.deadline(t);
                                t.hook(|t| {
                                    let elapsed = t.value().has_elapsed();
                                    if elapsed {
                                        MOUSE_SV.write().on_repeat_timer_elapsed();
                                    }
                                    !elapsed
                                })
                                .perm();
                                info.repeat_timer = Some(t);
                            }
                        }
                    }
                } else {
                    // not time to repeat
                    info.repeat_timer = Some(timer);
                }
            }
        }
    }
}