Yehowshua/ZIm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Refactor to make ModalLayer a View

Browse source
This commit is contained in:
Conrad Irwin 2023-11-09 22:11:11 -07:00
parent d4b1d1b528
commit 5a711886d4
3 changed files with 162 additions and 185 deletions
Download patch file Download diff file Expand all files Collapse all files

244
crates/command_palette2/src/command_palette.rs
View file

@ -1,10 +1,9 @@
use anyhow::anyhow;
use collections::{CommandPaletteFilter, HashMap}; use collections::{CommandPaletteFilter, HashMap};
use fuzzy::{StringMatch, StringMatchCandidate}; use fuzzy::{StringMatch, StringMatchCandidate};
use gpui::{ use gpui::{
actions, div, Action, AnyElement, AnyWindowHandle, AppContext, BorrowWindow, Component, Div, actions, div, Action, AppContext, Component, Div, EventEmitter, FocusHandle, Keystroke,
Element, EventEmitter, FocusHandle, Keystroke, ParentElement, Render, StatelessInteractive, ParentElement, Render, StatelessInteractive, Styled, View, ViewContext, VisualContext,
Styled, View, ViewContext, VisualContext, WeakView, WindowContext, WeakView, WindowContext,
}; };
use picker::{Picker, PickerDelegate}; use picker::{Picker, PickerDelegate};
use std::cmp::{self, Reverse}; use std::cmp::{self, Reverse};
@ -60,7 +59,7 @@ impl CommandPalette {
.collect(); .collect();
let delegate = let delegate =
CommandPaletteDelegate::new(cx.view().downgrade(), commands, previous_focus_handle, cx); CommandPaletteDelegate::new(cx.view().downgrade(), commands, previous_focus_handle);
let picker = cx.build_view(|cx| Picker::new(delegate, cx)); let picker = cx.build_view(|cx| Picker::new(delegate, cx));
Self { picker } Self { picker }
@ -125,17 +124,20 @@ impl CommandPaletteDelegate {
command_palette: WeakView<CommandPalette>, command_palette: WeakView<CommandPalette>,
commands: Vec<Command>, commands: Vec<Command>,
previous_focus_handle: FocusHandle, previous_focus_handle: FocusHandle,
cx: &ViewContext<CommandPalette>,
) -> Self { ) -> Self {
Self { Self {
command_palette, command_palette,
matches: commands
.iter()
.enumerate()
.map(|(i, command)| StringMatch {
candidate_id: i,
string: command.name.clone(),
positions: Vec::new(),
score: 0.0,
})
.collect(),
commands, commands,
matches: vec![StringMatch {
candidate_id: 0,
score: 0.,
positions: vec![],
string: "Foo my bar".into(),
}],
selected_ix: 0, selected_ix: 0,
previous_focus_handle, previous_focus_handle,
} }
@ -405,129 +407,129 @@ impl std::fmt::Debug for Command {
} }
} }
#[cfg(test)] // #[cfg(test)]
mod tests { // mod tests {
use std::sync::Arc; // use std::sync::Arc;
use super::*; // use super::*;
use editor::Editor; // use editor::Editor;
use gpui::{executor::Deterministic, TestAppContext}; // use gpui::{executor::Deterministic, TestAppContext};
use project::Project; // use project::Project;
use workspace::{AppState, Workspace}; // use workspace::{AppState, Workspace};
#[test] // #[test]
fn test_humanize_action_name() { // fn test_humanize_action_name() {
assert_eq!( // assert_eq!(
humanize_action_name("editor::GoToDefinition"), // humanize_action_name("editor::GoToDefinition"),
"editor: go to definition" // "editor: go to definition"
); // );
assert_eq!( // assert_eq!(
humanize_action_name("editor::Backspace"), // humanize_action_name("editor::Backspace"),
"editor: backspace" // "editor: backspace"
); // );
assert_eq!( // assert_eq!(
humanize_action_name("go_to_line::Deploy"), // humanize_action_name("go_to_line::Deploy"),
"go to line: deploy" // "go to line: deploy"
); // );
} // }
#[gpui::test] // #[gpui::test]
async fn test_command_palette(deterministic: Arc<Deterministic>, cx: &mut TestAppContext) { // async fn test_command_palette(deterministic: Arc<Deterministic>, cx: &mut TestAppContext) {
let app_state = init_test(cx); // let app_state = init_test(cx);
let project = Project::test(app_state.fs.clone(), [], cx).await; // let project = Project::test(app_state.fs.clone(), [], cx).await;
let window = cx.add_window(|cx| Workspace::test_new(project.clone(), cx)); // let window = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));
let workspace = window.root(cx); // let workspace = window.root(cx);
let editor = window.add_view(cx, |cx| { // let editor = window.add_view(cx, |cx| {
let mut editor = Editor::single_line(None, cx); // let mut editor = Editor::single_line(None, cx);
editor.set_text("abc", cx); // editor.set_text("abc", cx);
editor // editor
}); // });
workspace.update(cx, |workspace, cx| { // workspace.update(cx, |workspace, cx| {
cx.focus(&editor); // cx.focus(&editor);
workspace.add_item(Box::new(editor.clone()), cx) // workspace.add_item(Box::new(editor.clone()), cx)
}); // });
workspace.update(cx, |workspace, cx| { // workspace.update(cx, |workspace, cx| {
toggle_command_palette(workspace, &Toggle, cx); // toggle_command_palette(workspace, &Toggle, cx);
}); // });
let palette = workspace.read_with(cx, |workspace, _| { // let palette = workspace.read_with(cx, |workspace, _| {
workspace.modal::<CommandPalette>().unwrap() // workspace.modal::<CommandPalette>().unwrap()
}); // });
palette // palette
.update(cx, |palette, cx| { // .update(cx, |palette, cx| {
// Fill up palette's command list by running an empty query; // // Fill up palette's command list by running an empty query;
// we only need it to subsequently assert that the palette is initially // // we only need it to subsequently assert that the palette is initially
// sorted by command's name. // // sorted by command's name.
palette.delegate_mut().update_matches("".to_string(), cx) // palette.delegate_mut().update_matches("".to_string(), cx)
}) // })
.await; // .await;
palette.update(cx, |palette, _| { // palette.update(cx, |palette, _| {
let is_sorted = // let is_sorted =
|actions: &[Command]| actions.windows(2).all(|pair| pair[0].name <= pair[1].name); // |actions: &[Command]| actions.windows(2).all(|pair| pair[0].name <= pair[1].name);
assert!(is_sorted(&palette.delegate().actions)); // assert!(is_sorted(&palette.delegate().actions));
}); // });
palette // palette
.update(cx, |palette, cx| { // .update(cx, |palette, cx| {
palette // palette
.delegate_mut() // .delegate_mut()
.update_matches("bcksp".to_string(), cx) // .update_matches("bcksp".to_string(), cx)
}) // })
.await; // .await;
palette.update(cx, |palette, cx| { // palette.update(cx, |palette, cx| {
assert_eq!(palette.delegate().matches[0].string, "editor: backspace"); // assert_eq!(palette.delegate().matches[0].string, "editor: backspace");
palette.confirm(&Default::default(), cx); // palette.confirm(&Default::default(), cx);
}); // });
deterministic.run_until_parked(); // deterministic.run_until_parked();
editor.read_with(cx, |editor, cx| { // editor.read_with(cx, |editor, cx| {
assert_eq!(editor.text(cx), "ab"); // assert_eq!(editor.text(cx), "ab");
}); // });
// Add namespace filter, and redeploy the palette // // Add namespace filter, and redeploy the palette
cx.update(|cx| { // cx.update(|cx| {
cx.update_default_global::<CommandPaletteFilter, _, _>(|filter, _| { // cx.update_default_global::<CommandPaletteFilter, _, _>(|filter, _| {
filter.filtered_namespaces.insert("editor"); // filter.filtered_namespaces.insert("editor");
}) // })
}); // });
workspace.update(cx, |workspace, cx| { // workspace.update(cx, |workspace, cx| {
toggle_command_palette(workspace, &Toggle, cx); // toggle_command_palette(workspace, &Toggle, cx);
}); // });
// Assert editor command not present // // Assert editor command not present
let palette = workspace.read_with(cx, |workspace, _| { // let palette = workspace.read_with(cx, |workspace, _| {
workspace.modal::<CommandPalette>().unwrap() // workspace.modal::<CommandPalette>().unwrap()
}); // });
palette // palette
.update(cx, |palette, cx| { // .update(cx, |palette, cx| {
palette // palette
.delegate_mut() // .delegate_mut()
.update_matches("bcksp".to_string(), cx) // .update_matches("bcksp".to_string(), cx)
}) // })
.await; // .await;
palette.update(cx, |palette, _| { // palette.update(cx, |palette, _| {
assert!(palette.delegate().matches.is_empty()) // assert!(palette.delegate().matches.is_empty())
}); // });
} // }
fn init_test(cx: &mut TestAppContext) -> Arc<AppState> { // fn init_test(cx: &mut TestAppContext) -> Arc<AppState> {
cx.update(|cx| { // cx.update(|cx| {
let app_state = AppState::test(cx); // let app_state = AppState::test(cx);
theme::init(cx); // theme::init(cx);
language::init(cx); // language::init(cx);
editor::init(cx); // editor::init(cx);
workspace::init(app_state.clone(), cx); // workspace::init(app_state.clone(), cx);
init(cx); // init(cx);
Project::init_settings(cx); // Project::init_settings(cx);
app_state // app_state
}) // })
} // }
} // }

94
crates/workspace2/src/modal_layer.rs
View file

@ -1,10 +1,7 @@
use crate::Workspace;
use gpui::{ use gpui::{
div, px, AnyView, Component, Div, EventEmitter, FocusHandle, ParentElement, Render, div, px, AnyView, Div, EventEmitter, FocusHandle, ParentElement, Render, StatelessInteractive,
StatefulInteractivity, StatelessInteractive, Styled, Subscription, View, ViewContext, Styled, Subscription, View, ViewContext, VisualContext, WindowContext,
VisualContext, WindowContext,
}; };
use std::{any::TypeId, sync::Arc};
use ui::v_stack; use ui::v_stack;
pub struct ActiveModal { pub struct ActiveModal {
@ -31,7 +28,7 @@ impl ModalLayer {
Self { active_modal: None } Self { active_modal: None }
} }
pub fn toggle_modal<V, B>(&mut self, cx: &mut ViewContext<Workspace>, build_view: B) pub fn toggle_modal<V, B>(&mut self, cx: &mut ViewContext<Self>, build_view: B)
where where
V: Modal, V: Modal,
B: FnOnce(&mut ViewContext<V>) -> V, B: FnOnce(&mut ViewContext<V>) -> V,
@ -48,14 +45,14 @@ impl ModalLayer {
self.show_modal(new_modal, cx); self.show_modal(new_modal, cx);
} }
pub fn show_modal<V>(&mut self, new_modal: View<V>, cx: &mut ViewContext<Workspace>) pub fn show_modal<V>(&mut self, new_modal: View<V>, cx: &mut ViewContext<Self>)
where where
V: Modal, V: Modal,
{ {
self.active_modal = Some(ActiveModal { self.active_modal = Some(ActiveModal {
modal: new_modal.clone().into(), modal: new_modal.clone().into(),
subscription: cx.subscribe(&new_modal, |workspace, modal, e, cx| match e { subscription: cx.subscribe(&new_modal, |this, modal, e, cx| match e {
ModalEvent::Dismissed => workspace.modal_layer.hide_modal(cx), ModalEvent::Dismissed => this.hide_modal(cx),
}), }),
previous_focus_handle: cx.focused(), previous_focus_handle: cx.focused(),
focus_handle: cx.focus_handle(), focus_handle: cx.focus_handle(),
@ -64,7 +61,7 @@ impl ModalLayer {
cx.notify(); cx.notify();
} }
pub fn hide_modal(&mut self, cx: &mut ViewContext<Workspace>) { pub fn hide_modal(&mut self, cx: &mut ViewContext<Self>) {
if let Some(active_modal) = self.active_modal.take() { if let Some(active_modal) = self.active_modal.take() {
if let Some(previous_focus) = active_modal.previous_focus_handle { if let Some(previous_focus) = active_modal.previous_focus_handle {
if active_modal.focus_handle.contains_focused(cx) { if active_modal.focus_handle.contains_focused(cx) {
@ -75,57 +72,34 @@ impl ModalLayer {
cx.notify(); cx.notify();
} }
pub fn wrapper_element(
&self,
cx: &ViewContext<Workspace>,
) -> Div<Workspace, StatefulInteractivity<Workspace>> {
let parent = div().id("boop");
parent.when_some(self.active_modal.as_ref(), |parent, open_modal| {
let container1 = div()
.absolute()
.flex()
.flex_col()
.items_center()
.size_full()
.top_0()
.left_0()
.z_index(400);
let container2 = v_stack()
.h(px(0.0))
.relative()
.top_20()
.track_focus(&open_modal.focus_handle)
.on_mouse_down_out(|workspace: &mut Workspace, event, cx| {
workspace.modal_layer.hide_modal(cx);
});
parent.child(container1.child(container2.child(open_modal.modal.clone())))
})
}
} }
// impl Render for ModalLayer { impl Render for ModalLayer {
// type Element = Div<Self>; type Element = Div<Self>;
// fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element { fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
// let mut div = div(); let Some(active_modal) = &self.active_modal else {
// for (type_id, build_view) in cx.global::<ModalRegistry>().registered_modals { return div();
// div = div.useful_on_action( };
// type_id,
// Box::new(|this, _: dyn Any, phase, cx: &mut ViewContext<Self>| {
// if phase == DispatchPhase::Capture {
// return;
// }
// self.workspace.update(cx, |workspace, cx| {
// self.open_modal = Some(build_view(workspace, cx));
// });
// cx.notify();
// }),
// )
// }
// div div()
// } .absolute()
// } .flex()
.flex_col()
.items_center()
.size_full()
.top_0()
.left_0()
.z_index(400)
.child(
v_stack()
.h(px(0.0))
.top_20()
.track_focus(&active_modal.focus_handle)
.on_mouse_down_out(|this: &mut Self, event, cx| {
this.hide_modal(cx);
})
.child(active_modal.modal.clone()),
)
}
}

9
crates/workspace2/src/workspace2.rs
View file

@ -550,7 +550,7 @@ pub struct Workspace {
last_active_center_pane: Option<WeakView<Pane>>, last_active_center_pane: Option<WeakView<Pane>>,
last_active_view_id: Option<proto::ViewId>, last_active_view_id: Option<proto::ViewId>,
status_bar: View<StatusBar>, status_bar: View<StatusBar>,
modal_layer: ModalLayer, modal_layer: View<ModalLayer>,
// titlebar_item: Option<AnyViewHandle>, // titlebar_item: Option<AnyViewHandle>,
notifications: Vec<(TypeId, usize, Box<dyn NotificationHandle>)>, notifications: Vec<(TypeId, usize, Box<dyn NotificationHandle>)>,
project: Model<Project>, project: Model<Project>,
@ -702,7 +702,7 @@ impl Workspace {
}); });
let workspace_handle = cx.view().downgrade(); let workspace_handle = cx.view().downgrade();
let modal_layer = ModalLayer::new(); let modal_layer = cx.build_view(|cx| ModalLayer::new());
// todo!() // todo!()
// cx.update_default_global::<DragAndDrop<Workspace>, _, _>(|drag_and_drop, _| { // cx.update_default_global::<DragAndDrop<Workspace>, _, _>(|drag_and_drop, _| {
@ -3526,7 +3526,8 @@ impl Workspace {
where where
B: FnOnce(&mut ViewContext<V>) -> V, B: FnOnce(&mut ViewContext<V>) -> V,
{ {
self.modal_layer.toggle_modal(cx, build) self.modal_layer
.update(cx, |modal_layer, cx| modal_layer.toggle_modal(cx, build))
} }
} }
@ -3768,7 +3769,7 @@ impl Render for Workspace {
.border_t() .border_t()
.border_b() .border_b()
.border_color(cx.theme().colors().border) .border_color(cx.theme().colors().border)
.child(self.modal_layer.wrapper_element(cx)) .child(self.modal_layer.clone())
// .children( // .children(
// Some( // Some(
// Panel::new("project-panel-outer", cx) // Panel::new("project-panel-outer", cx)