Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
//! This holds the resize logic for picker windows.
//!
//! # Resizing basics:
//! We render a resize handle (`render_resize`) for each side and corner that
//! can be dragged. The `Side` trait implementations (`Left`, `Right`,
//! `Bottom`, `LeftCorner`, `RightCorner`, ...) determine where each handle is
//! placed and how a drag changes the picker's shape.
//!
//! If there is a preview to the right or below there is an additional resize
//! handle on the divider between the results and the preview.
//!
//! The resize's are div's aka rectangles that are "placed" by specifying the
//! position of their sides. When hovering over these the cursor is changed
//! so it is clear you can resize.
//!
//! We set up two callbacks in each
//! - on_drag: fires when the user starts dragging
//! - on_drag_move: runs every frame while the user is dragging
//!
//! The actual shape of the resize is updated in `on_drag_move`. When a preview
//! is active dragging the outside edge modifies the
//!
//! # Resizing persistence
//! Each picker has a 'fixed' size and tracks it's last resize. When manually
//! resized the window size is stored as a percentage of the viewport
//! width/height. The size is serialized as soon as the use lets go of the drag.
//!
//! # Diagrams & Details
//! ```txt
//! ================ CHANGING WIDTH ======================================
//! The picker position stays constant during the drag but it is centered
//! directly after. (when the user lets go)
//! ================ DRAGGING RIGHT ======================================
//!
//! ------------
//! | | | <- dragging this edge right
//! | | |
//! ------------
//! leads to:
//! --------------------
//! | | | <- dragged on this edge
//! | | preview |
//! --------------------
//!
//! self.w_preview = w_preview + drag
//! ================ DRAGGING LEFT =======================================
//!
//! ------------
//! dragging this left -> | | |
//! | | |
//! ------------
//! leads to:
//! -------------------
//! | list | |
//! | | |
//! -------------------
//! ```
use std::{any::type_name, marker::PhantomData};
use gpui::{
ClickEvent, Context, CursorStyle, DragMoveEvent, MouseButton, Point, Stateful, Styled, Window,
};
use ui::prelude::*;
use crate::shape::{Centered, PositionAndShape, Shape, SizeBounds};
use crate::{Picker, PickerDelegate, preview::Layout};
pub struct DragPreview;
impl Render for DragPreview {
fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
div()
}
}
#[derive(Clone, Copy)]
struct ResizeDrag<S> {
shape_before: PositionAndShape,
phantom_data: PhantomData<S>,
mouse_pos_before: Point<Pixels>,
}
pub(crate) trait Side: Copy + 'static {
fn id() -> &'static str {
type_name::<Self>()
}
/// The thickness of the grab strip along the picker's edge.
///
/// Expressed in rems so it scales with the user's UI font size.
fn handle_width(window: &Window) -> Pixels {
rems(0.375).to_pixels(window.rem_size())
}
fn handle_offset(window: &Window) -> Pixels {
Self::handle_width(window) / 2.0
}
/// How far the grab strip is inset from the top and bottom corners so it doesn't overlap the
/// corner resize handles.
fn corner_clearance(window: &Window) -> Pixels {
rems(1.125).to_pixels(window.rem_size())
}
/// The resize cursor for this side's handle.
fn cursor(&self) -> CursorStyle;
/// Places and sizes the grab strip along this side's edge.
fn position(
&self,
div: gpui::Stateful<Div>,
shape: PositionAndShape,
window: &Window,
) -> gpui::Stateful<Div>;
fn current_position_and_shape(
&self,
shape_before: PositionAndShape,
mouse_movement: Point<Pixels>,
) -> PositionAndShape;
fn clamp(
&self,
working: &mut PositionAndShape,
bounds: &SizeBounds,
layout: Option<Layout>,
window: &Window,
);
fn revert_to_default_size(&self, shape: &mut Shape, default: &Centered, window: &Window);
}
#[derive(Clone, Copy)]
pub(crate) struct Left;
impl Side for Left {
fn cursor(&self) -> CursorStyle {
CursorStyle::ResizeColumn
}
fn position(
&self,
div: gpui::Stateful<Div>,
_: PositionAndShape,
window: &Window,
) -> gpui::Stateful<Div> {
div.top_0()
.bottom(Self::corner_clearance(window))
.w(Self::handle_width(window))
.left(-Self::handle_offset(window))
}
fn current_position_and_shape(
&self,
mut shape_before: PositionAndShape,
mouse_movement: Point<Pixels>,
) -> PositionAndShape {
shape_before.left += mouse_movement.x;
shape_before
}
fn clamp(
&self,
working: &mut PositionAndShape,
bounds: &SizeBounds,
layout: Option<Layout>,
window: &Window,
) {
bounds.clamp_left_edge(working, layout, window);
bounds.clamp_divider(working, layout, window);
}
fn revert_to_default_size(&self, shape: &mut Shape, default: &Centered, _window: &Window) {
shape.reset_width(default);
}
}
#[derive(Clone, Copy)]
pub(crate) struct Right(pub(crate) Layout);
impl Side for Right {
fn cursor(&self) -> CursorStyle {
CursorStyle::ResizeColumn
}
fn position(
&self,
div: gpui::Stateful<Div>,
_: PositionAndShape,
window: &Window,
) -> gpui::Stateful<Div> {
div.top_0()
.bottom(Self::corner_clearance(window))
.w(Self::handle_width(window))
.right(-Self::handle_offset(window))
}
fn current_position_and_shape(
&self,
mut shape_before: PositionAndShape,
mouse_movement: Point<Pixels>,
) -> PositionAndShape {
if let Layout::Right = self.0 {
shape_before.preview += mouse_movement.x;
}
shape_before.right += mouse_movement.x;
shape_before
}
fn clamp(
&self,
working: &mut PositionAndShape,
bounds: &SizeBounds,
layout: Option<Layout>,
window: &Window,
) {
bounds.clamp_right_edge(working, layout, window);
bounds.clamp_divider(working, layout, window);
}
fn revert_to_default_size(&self, shape: &mut Shape, default: &Centered, _window: &Window) {
shape.reset_width(default);
}
}
#[derive(Clone, Copy)]
pub(crate) struct Middle(pub(crate) Layout);
impl Side for Middle {
fn cursor(&self) -> CursorStyle {
match self.0 {
Layout::Hidden => {
unreachable!("This resize handle is not drawn when the preview is hidden")
}
Layout::Below => CursorStyle::ResizeRow,
Layout::Right => CursorStyle::ResizeColumn,
}
}
fn position(
&self,
div: gpui::Stateful<Div>,
shape: PositionAndShape,
window: &Window,
) -> gpui::Stateful<Div> {
match self.0 {
Layout::Hidden => {
unreachable!("This resize handle is not drawn when the preview is hidden")
}
Layout::Below => div
.left(Self::corner_clearance(window))
.right(Self::corner_clearance(window))
.h(Self::handle_width(window))
.bottom(shape.preview - Self::handle_offset(window)),
Layout::Right => div
.top_0()
.bottom(Self::corner_clearance(window))
.w(Self::handle_width(window))
.right(shape.preview - Self::handle_offset(window)),
}
}
fn current_position_and_shape(
&self,
mut shape_before: PositionAndShape,
mouse_movement: Point<Pixels>,
) -> PositionAndShape {
match self.0 {
Layout::Hidden => {
unreachable!("This resize handle is not drawn when the preview is hidden")
}
Layout::Below => shape_before.preview -= mouse_movement.y,
Layout::Right => shape_before.preview -= mouse_movement.x,
}
shape_before
}
fn clamp(
&self,
working: &mut PositionAndShape,
bounds: &SizeBounds,
layout: Option<Layout>,
window: &Window,
) {
// The divider only moves the preview; the outer edges are unchanged.
bounds.clamp_divider(working, layout, window);
}
fn revert_to_default_size(&self, shape: &mut Shape, _default: &Centered, window: &Window) {
shape.center_divider(self.0, window);
}
}
#[derive(Clone, Copy)]
pub(crate) struct Bottom(pub(crate) Layout);
impl Side for Bottom {
fn cursor(&self) -> CursorStyle {
CursorStyle::ResizeRow
}
fn position(
&self,
div: gpui::Stateful<Div>,
_: PositionAndShape,
window: &Window,
) -> gpui::Stateful<Div> {
div.left(Self::corner_clearance(window))
.right(Self::corner_clearance(window))
.h(Self::handle_width(window))
.bottom(-Self::handle_offset(window))
}
fn current_position_and_shape(
&self,
mut shape_before: PositionAndShape,
mouse_movement: Point<Pixels>,
) -> PositionAndShape {
if let Layout::Below = self.0 {
shape_before.preview += mouse_movement.y;
}
shape_before.bottom += mouse_movement.y;
shape_before
}
fn clamp(
&self,
working: &mut PositionAndShape,
bounds: &SizeBounds,
layout: Option<Layout>,
window: &Window,
) {
bounds.clamp_bottom_edge(working, layout, window);
bounds.clamp_divider(working, layout, window);
}
fn revert_to_default_size(&self, shape: &mut Shape, default: &Centered, _window: &Window) {
shape.reset_height(default);
}
}
#[derive(Clone, Copy)]
pub(crate) struct LeftCorner(pub(crate) Layout);
impl Side for LeftCorner {
fn cursor(&self) -> CursorStyle {
CursorStyle::ResizeUpRightDownLeft
}
fn position(
&self,
div: gpui::Stateful<Div>,
_: PositionAndShape,
window: &Window,
) -> gpui::Stateful<Div> {
div.w(Self::handle_width(window))
.h(Self::handle_width(window))
.left(-Self::handle_offset(window))
.bottom(-Self::handle_offset(window))
}
fn current_position_and_shape(
&self,
mut shape_before: PositionAndShape,
mouse_movement: Point<Pixels>,
) -> PositionAndShape {
match self.0 {
Layout::Hidden => (),
Layout::Below => shape_before.preview += mouse_movement.y,
Layout::Right => shape_before.preview += mouse_movement.x,
}
shape_before.left += mouse_movement.x;
shape_before.bottom += mouse_movement.y;
shape_before
}
fn clamp(
&self,
working: &mut PositionAndShape,
bounds: &SizeBounds,
layout: Option<Layout>,
window: &Window,
) {
bounds.clamp_left_edge(working, layout, window);
bounds.clamp_bottom_edge(working, layout, window);
bounds.clamp_divider(working, layout, window);
}
fn revert_to_default_size(&self, shape: &mut Shape, default: &Centered, _window: &Window) {
shape.reset_width(default);
shape.reset_height(default);
}
}
#[derive(Clone, Copy)]
pub(crate) struct RightCorner(pub(crate) Layout);
impl Side for RightCorner {
fn cursor(&self) -> CursorStyle {
CursorStyle::ResizeUpLeftDownRight
}
fn position(
&self,
div: gpui::Stateful<Div>,
_: PositionAndShape,
window: &Window,
) -> gpui::Stateful<Div> {
div.w(Self::handle_width(window))
.h(Self::handle_width(window))
.right(-Self::handle_offset(window))
.bottom(-Self::handle_offset(window))
}
fn current_position_and_shape(
&self,
mut shape_before: PositionAndShape,
mouse_movement: Point<Pixels>,
) -> PositionAndShape {
match self.0 {
Layout::Hidden => (),
Layout::Below => shape_before.preview += mouse_movement.y,
Layout::Right => shape_before.preview += mouse_movement.x,
}
shape_before.right += mouse_movement.x;
shape_before.bottom += mouse_movement.y;
shape_before
}
fn clamp(
&self,
working: &mut PositionAndShape,
bounds: &SizeBounds,
layout: Option<Layout>,
window: &Window,
) {
bounds.clamp_right_edge(working, layout, window);
bounds.clamp_bottom_edge(working, layout, window);
bounds.clamp_divider(working, layout, window);
}
fn revert_to_default_size(&self, shape: &mut Shape, default: &Centered, _window: &Window) {
shape.reset_width(default);
shape.reset_height(default);
}
}
impl<S: Side> ResizeDrag<S> {
fn start_new(
shape: Shape,
bounds: &SizeBounds,
layout: Option<Layout>,
window: &mut Window,
) -> Self {
Self {
mouse_pos_before: window.mouse_position(),
// Before rendering we always clamp so the current shape may not be
// within SizeBounds so use a clamped one
shape_before: shape.clamped_position_and_size(layout, bounds, window),
phantom_data: PhantomData,
}
}
}
impl<D: PickerDelegate> Picker<D> {
/// Resizes the picker modal by dragging the handle on the given side or corner
pub(crate) fn render_resize<S: Side>(
&self,
side: S,
window: &mut Window,
cx: &mut Context<Self>,
) -> impl IntoElement {
render_resize_handle(
side,
self.shape,
&self.size_bounds,
self.preview_layout_rendered(window),
window,
)
.on_drag_move::<ResizeDrag<S>>(cx.listener(
move |picker, event: &DragMoveEvent<ResizeDrag<S>>, window, cx| {
let drag = event.drag(cx);
let delta = event.event.position - drag.mouse_pos_before;
let mut working = side.current_position_and_shape(drag.shape_before, delta);
side.clamp(
&mut working,
&picker.size_bounds,
picker.preview_layout_rendered(window),
window,
);
picker.shape = Shape::Resizing(working);
cx.notify();
},
))
.on_click(cx.listener(move |picker, event: &ClickEvent, window, cx| {
picker.reset_size_to_default_on_double_click(side, event, window, cx)
}))
}
fn reset_size_to_default_on_double_click<S: Side>(
&mut self,
side: S,
event: &ClickEvent,
window: &mut Window,
cx: &mut Context<Picker<D>>,
) {
if event.click_count() < 2 {
return;
}
side.revert_to_default_size(&mut self.shape, &self.default_shape, window);
let pos = self.shape.clamped_position_and_size(
self.preview_layout_rendered(window),
&self.size_bounds,
window,
);
self.shape = Shape::Resizing(pos);
cx.notify();
}
}
#[inline(never)]
#[track_caller]
fn render_resize_handle<S: Side>(
side: S,
shape: Shape,
bounds: &SizeBounds,
layout: Option<Layout>,
window: &mut Window,
) -> Stateful<Div> {
div()
.id(S::id())
.absolute()
.cursor(side.cursor())
.map(|handle| {
side.position(
handle,
shape.clamped_position_and_size(layout, bounds, window),
window,
)
})
.block_mouse_except_scroll()
.on_mouse_down(MouseButton::Left, do_nothing)
.on_drag(
ResizeDrag::<S>::start_new(shape, bounds, layout, window),
|_, _, _, cx| cx.new(|_| DragPreview),
)
}
fn do_nothing(_: &gpui::MouseDownEvent, window: &mut Window, cx: &mut App) {
window.prevent_default();
cx.stop_propagation();
}