#![cfg_attr(not(feature = "full"), allow(dead_code, unused_imports))]
use std::{cell::Cell, rc::Rc};
use gpui::{
div, prelude::*, px, relative, App, Corner, Div, ElementId, FocusHandle, Pixels, Point, Window,
};
use super::layer::layer_at_marker;
use crate::motion::{presets, Motion, MotionExt, MotionSide};
use crate::sx::SxStyled;
use crate::{
hooks::{EventHandler, State},
styles,
};
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum Side {
Top,
#[default]
Bottom,
Left,
Right,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum Align {
#[default]
Start,
End,
}
#[doc(hidden)]
#[must_use]
pub fn child_id(parent: &ElementId, part: &'static str) -> ElementId {
ElementId::NamedChild(Box::new(parent.clone()), part.into())
}
#[doc(hidden)]
pub struct OverlayMemory {
pub open: bool,
pub focus_requested: Rc<Cell<bool>>,
pub focus_handle: FocusHandle,
pub trigger_width: Rc<Cell<Pixels>>,
pub open_order: Rc<Cell<u64>>,
}
#[derive(Clone)]
#[doc(hidden)]
pub struct OpenState {
memory: State<OverlayMemory>,
controlled_open: Option<bool>,
on_open_change: Option<EventHandler<bool>>,
}
impl OpenState {
pub fn is_open(&self, cx: &App) -> bool {
self.controlled_open
.unwrap_or_else(|| self.memory.read(cx).open)
}
pub fn set_open(&self, open: bool, window: &mut Window, cx: &mut App) {
if open {
self.memory.read(cx).focus_requested.set(true);
}
self.memory.update(cx, |memory| memory.open = open);
if let Some(handler) = self.on_open_change.as_ref() {
handler(&open, window, cx);
}
}
pub fn focus_handle(&self, cx: &App) -> FocusHandle {
self.memory.read(cx).focus_handle.clone()
}
pub fn trigger_width(&self, cx: &App) -> Rc<Cell<Pixels>> {
self.memory.read(cx).trigger_width.clone()
}
pub fn focus_if_requested(&self, window: &mut Window, cx: &mut App) {
let memory = self.memory.read(cx);
if memory.focus_requested.replace(false) {
let focus_handle = memory.focus_handle.clone();
window.defer(cx, move |window, _| window.focus(&focus_handle));
}
}
}
#[doc(hidden)]
pub fn use_open_state(
id: &ElementId,
controlled_open: Option<bool>,
on_open_change: Option<EventHandler<bool>>,
window: &mut Window,
cx: &mut App,
) -> OpenState {
let memory = window.use_keyed_state(child_id(id, "overlay"), cx, |_, cx| OverlayMemory {
open: false,
focus_requested: Rc::new(Cell::new(controlled_open == Some(true))),
focus_handle: cx.focus_handle(),
trigger_width: Rc::new(Cell::new(px(0.))),
open_order: Rc::new(Cell::new(0)),
});
let memory = State::from_entity(memory);
let open_state = OpenState {
memory,
controlled_open,
on_open_change,
};
if !open_state.is_open(cx) {
open_state.memory.read(cx).open_order.set(0);
}
open_state
}
thread_local! {
static OPEN_COUNTER: Cell<u64> = const { Cell::new(0) };
static CLAIMED_PRESS: Cell<Option<(Point<Pixels>, u64)>> = const { Cell::new(None) };
}
fn next_open_order() -> u64 {
OPEN_COUNTER.with(|counter| {
counter.set(counter.get() + 1);
counter.get()
})
}
#[doc(hidden)]
pub fn floating(side: Side, align: Align, content: impl IntoElement, cx: &mut App) -> Div {
let (side, align) = if super::direction::is_rtl() {
let side = match side {
Side::Left => Side::Right,
Side::Right => Side::Left,
other => other,
};
let align = match align {
Align::Start => Align::End,
Align::End => Align::Start,
};
(side, align)
} else {
(side, align)
};
let gap = px(4.);
let anchor = match (side, align) {
(Side::Bottom | Side::Right, Align::Start) => Corner::TopLeft,
(Side::Bottom, Align::End) | (Side::Left, Align::Start) => Corner::TopRight,
(Side::Top, Align::Start) | (Side::Right, Align::End) => Corner::BottomLeft,
(Side::Top | Side::Left, Align::End) => Corner::BottomRight,
};
let content = div()
.map(|spacer| match side {
Side::Top => spacer.pb(gap),
Side::Bottom => spacer.pt(gap),
Side::Left => spacer.pr(gap),
Side::Right => spacer.pl(gap),
})
.child(
div()
.child(content)
.motion("rok-ui-floating-enter", enter_motion(side)),
);
let layer = layer_at_marker(anchor, content, cx);
let marker = div().absolute().size_0();
let marker = match (side, align) {
(Side::Bottom, Align::Start) => marker.left_0().top(relative(1.)),
(Side::Bottom, Align::End) => marker.right_0().top(relative(1.)),
(Side::Top, Align::Start) => marker.left_0().top_0(),
(Side::Top, Align::End) => marker.right_0().top_0(),
(Side::Right, Align::Start) => marker.left(relative(1.)).top_0(),
(Side::Right, Align::End) => marker.left(relative(1.)).bottom_0(),
(Side::Left, Align::Start) => marker.left_0().top_0(),
(Side::Left, Align::End) => marker.left_0().bottom_0(),
};
marker.child(layer)
}
styles! {
OVERLAY = {
surface: {
text_align: start,
display: flex,
direction: column,
radius: md,
border: 1,
border_color: border,
background: popover,
color: popover_foreground,
font_family: sans,
text: theme,
shadow: md,
},
}
}
#[doc(hidden)]
#[must_use]
pub fn popover_surface() -> Div {
div().sx(&OVERLAY.surface)
}
#[doc(hidden)]
pub fn measure_width(width: Rc<Cell<Pixels>>) -> impl IntoElement {
gpui::canvas(
move |bounds, _, _| width.set(bounds.size.width),
|_, (), _, _| {},
)
.absolute()
.size_full()
}
#[doc(hidden)]
pub fn trigger_wrapper(
id: ElementId,
open_state: &OpenState,
disabled: bool,
cx: &App,
) -> gpui::Stateful<Div> {
let was_open = open_state.is_open(cx);
let mouse_state = open_state.clone();
let key_state = open_state.clone();
div().id(id).relative().when(!disabled, |wrapper| {
wrapper
.on_mouse_down(gpui::MouseButton::Left, move |_, window, cx| {
mouse_state.set_open(!was_open, window, cx);
})
.on_key_down(move |event, window, cx| {
if key_state.focus_handle(cx).contains_focused(window, cx) {
return;
}
let key = event.keystroke.key.as_str();
if matches!(key, "enter" | "space" | "down") && !was_open {
cx.stop_propagation();
key_state.set_open(true, window, cx);
}
})
})
}
#[doc(hidden)]
pub fn dismissable(panel: Div, open_state: &OpenState, window: &mut Window, cx: &mut App) -> Div {
open_state.focus_if_requested(window, cx);
let focus_handle = open_state.focus_handle(cx);
let escape_state = open_state.clone();
let outside_state = open_state.clone();
let order_cell = open_state.memory.read(cx).open_order.clone();
if order_cell.get() == 0 {
order_cell.set(next_open_order());
}
let order = order_cell.get();
panel
.track_focus(&focus_handle)
.occlude()
.on_key_down(move |event, window, cx| {
if event.keystroke.key == "escape" {
cx.stop_propagation();
escape_state.set_open(false, window, cx);
}
})
.capture_any_mouse_down(move |event, window, cx| {
let position = event.position;
CLAIMED_PRESS.with(|claimed| {
let newest = match claimed.get() {
Some((at, claimed_order)) if at == position => claimed_order.max(order),
_ => order,
};
claimed.set(Some((position, newest)));
});
window.defer(cx, |_, _| CLAIMED_PRESS.with(|claimed| claimed.set(None)));
})
.on_mouse_down_out(move |event, window, cx| {
let position = event.position;
let outside_state = outside_state.clone();
window.defer(cx, move |window, cx| {
let claimed_by_newer = CLAIMED_PRESS.with(|claimed| {
claimed
.get()
.is_some_and(|(at, claimed_order)| at == position && claimed_order > order)
});
if !claimed_by_newer {
outside_state.set_open(false, window, cx);
}
});
})
}
#[doc(hidden)]
#[must_use]
pub fn enter_motion(side: Side) -> Motion {
let from = match side {
Side::Bottom => MotionSide::Top,
Side::Top => MotionSide::Bottom,
Side::Left => MotionSide::Right,
Side::Right => MotionSide::Left,
};
presets::slide_in(from, 1.).duration_ms(150)
}