krisyotam/zed

crates/editor2/src/editor.rs+2−1

     Diagnostic, IndentKind, IndentSize, Language, LanguageRegistry, LanguageServerName,
     OffsetRangeExt, Point, Selection, SelectionGoal, TransactionId,
 };
+use lazy_static::lazy_static;
 use link_go_to_definition::{GoToDefinitionLink, InlayHighlight, LinkGoToDefinitionState};
 use lsp::{DiagnosticSeverity, Documentation, LanguageServerId};
 use movement::TextLayoutDetails;
     ToPoint,
 };
 use ordered_float::OrderedFloat;
-use parking_lot::RwLock;
+use parking_lot::{Mutex, RwLock};
 use project::{FormatTrigger, Location, Project};
 use rand::prelude::*;
 use rpc::proto::*;

crates/go_to_line2/src/go_to_line.rs+43−12

@@ -1,25 +1,55 @@
1	use editor::Editor;	1	use editor::Editor;
2	use gpui::{	2	use gpui::{
3	actions, div, AppContext, Div, EventEmitter, ParentElement, Render, SharedString,	3	actions, div, AppContext, Div, EventEmitter, ParentElement, Render, SharedString,
4	StatelessInteractive, Styled, View, ViewContext, VisualContext,	4	StatefulInteractivity, StatelessInteractive, Styled, View, ViewContext, VisualContext,
5	};	5	};
6	use text::Point;	6	use text::Point;
7	use theme::ActiveTheme;	7	use theme::ActiveTheme;
8	use ui::{h_stack, modal, v_stack, Label, LabelColor};	8	use ui::{h_stack, modal, v_stack, Label, LabelColor};
9	use util::paths::FILE_ROW_COLUMN_DELIMITER;	9	use util::paths::FILE_ROW_COLUMN_DELIMITER;
10	use workspace::{ModalRegistry, Modal, ModalEvent};	10	use workspace::{Modal, ModalEvent, Workspace};
11		11
12	actions!(Toggle);	12	actions!(Toggle);
13		13
14	pub fn init(cx: &mut AppContext) {	14	pub fn init(cx: &mut AppContext) {
15	cx.global_mut::<ModalRegistry>()	15	cx.observe_new_views(
16	.register_modal(Toggle, \|workspace, cx\| {	16	\|workspace: &mut Workspace, _: &mut ViewContext<Workspace>\| {
17	let editor = workspace	17	workspace
18	.active_item(cx)	18	.modal_layer()
19	.and_then(\|active_item\| active_item.downcast::<Editor>())?;	19	.register_modal(Toggle, \|workspace, cx\| {
20		20	let editor = workspace
21	Some(cx.build_view(\|cx\| GoToLine::new(editor, cx)))	21	.active_item(cx)
22	});	22	.and_then(\|active_item\| active_item.downcast::<Editor>())?;
		23
		24	Some(cx.build_view(\|cx\| GoToLine::new(editor, cx)))
		25	});
		26	dbg!("hey!");
		27	},
		28	)
		29	.detach();
		30
		31	// // cx.window_global()
		32	// // cx.window_global::<Workspace>
		33	// // cx.window_global::<ActiveEditor>()
		34	// Workspace::on_init(\|workspace, cx\| {
		35	// workspace.on_open_item()
		36	// });
		37
		38	// Editor::on_init(\|editor, cx\|{
		39
		40	// })
		41
		42	// Editor::register_action(\|_editor, _: &Toggle, cx\| {
		43	// dbg!("HEY!");
		44	// // let editor = cx.view();
		45	// // cx.update_window(cx.window().handle(), \|cx, view\| {
		46	// // let workspace = view.downcast::<Workspace>();
		47	// // })
		48	// // workspace.show_modal(cx.build_view(\|cx\| GoToLine::new(editor, cx)))
		49	// })
		50	// cx.global_mut::<ModalRegistry>()
		51	// .register_modal(Toggle, \|workspace, cx\| {
		52	// });
23	}	53	}
24		54
25	pub struct GoToLine {	55	pub struct GoToLine {
@@ -128,13 +158,14 @@ impl Modal for GoToLine { · 102 unmodified lines
128	}	158	}
129		159
130	impl Render for GoToLine {	160	impl Render for GoToLine {
131	type Element = Div<Self>;	161	type Element = Div<Self, StatefulInteractivity<Self>>;
132		162
133	fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {	163	fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
134	modal(cx)	164	modal(cx)
135	.w_96()	165	.id("go to line")
136	.on_action(Self::cancel)	166	.on_action(Self::cancel)
137	.on_action(Self::confirm)	167	.on_action(Self::confirm)
		168	.w_96()
138	.child(	169	.child(
139	v_stack()	170	v_stack()
140	.px_1()	171	.px_1()

crates/gpui2/src/app.rs+23−2

     AppMetadata, AssetSource, BackgroundExecutor, ClipboardItem, Context, DispatchPhase, DisplayId,
     Entity, EventEmitter, FocusEvent, FocusHandle, FocusId, ForegroundExecutor, KeyBinding, Keymap,
     LayoutId, PathPromptOptions, Pixels, Platform, PlatformDisplay, Point, Render, SubscriberSet,
-    Subscription, SvgRenderer, Task, TextStyle, TextStyleRefinement, TextSystem, View, Window,
+    Subscription, SvgRenderer, Task, TextStyle, TextStyleRefinement, TextSystem, View, ViewContext,
-    WindowContext, WindowHandle, WindowId,
+    Window, WindowContext, WindowHandle, WindowId,
 };
 use anyhow::{anyhow, Result};
 use collections::{HashMap, HashSet, VecDeque};
 type Listener = Box<dyn FnMut(&dyn Any, &mut AppContext) -> bool + 'static>;
 type QuitHandler = Box<dyn FnOnce(&mut AppContext) -> LocalBoxFuture<'static, ()> + 'static>;
 type ReleaseListener = Box<dyn FnOnce(&mut dyn Any, &mut AppContext) + 'static>;
+type NewViewListener = Box<dyn FnMut(AnyView, &mut WindowContext) + 'static>;
 // struct FrameConsumer {
 //     next_frame_callbacks: Vec<FrameCallback>,
     pub(crate) text_style_stack: Vec<TextStyleRefinement>,
     pub(crate) globals_by_type: HashMap<TypeId, AnyBox>,
     pub(crate) entities: EntityMap,
+    pub(crate) new_view_observers: SubscriberSet<TypeId, NewViewListener>,
     pub(crate) windows: SlotMap<WindowId, Option<Window>>,
     pub(crate) keymap: Arc<Mutex<Keymap>>,
     pub(crate) global_action_listeners:
                 text_style_stack: Vec::new(),
                 globals_by_type: HashMap::default(),
                 entities,
+                new_view_observers: SubscriberSet::new(),
                 windows: SlotMap::with_key(),
                 keymap: Arc::new(Mutex::new(Keymap::default())),
                 global_action_listeners: HashMap::default(),
     fn apply_notify_effect(&mut self, emitter: EntityId) {
         self.pending_notifications.remove(&emitter);
         self.observers
             .clone()
             .retain(&emitter, |handler| handler(self));
         self.globals_by_type.insert(global_type, lease.global);
     }
+    pub fn observe_new_views<V: 'static>(
+        &mut self,
+        on_new: impl 'static + Fn(&mut V, &mut ViewContext<V>),
+    ) -> Subscription {
+        self.new_view_observers.insert(
+            TypeId::of::<V>(),
+            Box::new(move |any_view: AnyView, cx: &mut WindowContext| {
+                any_view
+                    .downcast::<V>()
+                    .unwrap()
+                    .update(cx, |view_state, cx| {
+                        on_new(view_state, cx);
+                    })
+            }),
+        )
+    }
     pub fn observe_release<E, T>(
         &mut self,
         handle: &E,

crates/gpui2/src/app/async_context.rs+1−1

@@ -258,7 +258,7 @@ impl VisualContext for AsyncWindowContext { · 257 unmodified lines
258	build_view_state: impl FnOnce(&mut ViewContext<'_, V>) -> V,	258	build_view_state: impl FnOnce(&mut ViewContext<'_, V>) -> V,
259	) -> Self::Result<View<V>>	259	) -> Self::Result<View<V>>
260	where	260	where
261	V: 'static,	261	V: 'static + Render,
262	{	262	{
263	self.window	263	self.window
264	.update(self, \|_, cx\| cx.build_view(build_view_state))	264	.update(self, \|_, cx\| cx.build_view(build_view_state))

crates/gpui2/src/gpui2.rs+1−1

@@ -112,7 +112,7 @@ pub trait VisualContext: Context { · 111 unmodified lines
112	build_view: impl FnOnce(&mut ViewContext<'_, V>) -> V,	112	build_view: impl FnOnce(&mut ViewContext<'_, V>) -> V,
113	) -> Self::Result<View<V>>	113	) -> Self::Result<View<V>>
114	where	114	where
115	V: 'static;	115	V: 'static + Render;
116		116
117	fn update_view<V: 'static, R>(	117	fn update_view<V: 'static, R>(
118	&mut self,	118	&mut self,

crates/gpui2/src/interactive.rs+4−0

                     Box::new(move |_, key_down, context, phase, cx| {
                         if phase == DispatchPhase::Bubble {
                             let key_down = key_down.downcast_ref::<KeyDownEvent>().unwrap();
+                            dbg!(key_down);
                             if let KeyMatch::Some(action) =
                                 cx.match_keystroke(&global_id, &key_down.keystroke, context)
                             {
+                                dbg!(&action);
                                 return Some(action);
+                            } else {
+                                dbg!("none");
                             }
                         }

crates/gpui2/src/window.rs+12−3

         build_view_state: impl FnOnce(&mut ViewContext<'_, V>) -> V,
     ) -> Self::Result<View<V>>
     where
-        V: 'static,
+        V: 'static + Render,
     {
         let slot = self.app.entities.reserve();
         let view = View {
         };
         let mut cx = ViewContext::new(&mut *self.app, &mut *self.window, &view);
         let entity = build_view_state(&mut cx);
-        self.entities.insert(slot, entity);
+        cx.entities.insert(slot, entity);
+        cx.new_view_observers
+            .clone()
+            .retain(&TypeId::of::<V>(), |observer| {
+                let any_view = AnyView::from(view.clone());
+                (observer)(any_view, self);
+                true
+            });
         view
     }
 }
 impl<V: 'static> VisualContext for ViewContext<'_, V> {
-    fn build_view<W: 'static>(
+    fn build_view<W: Render + 'static>(
         &mut self,
         build_view_state: impl FnOnce(&mut ViewContext<'_, W>) -> W,
     ) -> Self::Result<View<W>> {

crates/workspace2/src/dock.rs+8−0

@@ -407,6 +407,14 @@ impl Dock { · 406 unmodified lines
407	// }	407	// }
408	}	408	}
409		409
		410	impl Render for Dock {
		411	type Element = Div<Self>;
		412
		413	fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
		414	todo!()
		415	}
		416	}
		417
410	// todo!()	418	// todo!()
411	// impl View for Dock {	419	// impl View for Dock {
412	// fn ui_name() -> &'static str {	420	// fn ui_name() -> &'static str {

crates/workspace2/src/modal_layer.rs+21−36

 use crate::Workspace;
 use gpui::{
-    div, px, AnyView, AppContext, Component, Div, EventEmitter, ParentElement, Render,
+    div, px, AnyView, Component, Div, EventEmitter, ParentElement, Render, StatelessInteractive,
-    StatelessInteractive, Styled, Subscription, View, ViewContext, WeakView,
+    Styled, Subscription, View, ViewContext,
 };
 use std::{any::TypeId, sync::Arc};
 use ui::v_stack;
-pub struct ModalRegistry {
-    registered_modals: Vec<(TypeId, Box<dyn Fn(Div<Workspace>) -> Div<Workspace>>)>,
-}
 pub struct ModalLayer {
-    workspace: WeakView<Workspace>,
     open_modal: Option<AnyView>,
     subscription: Option<Subscription>,
-}
+    registered_modals: Vec<(TypeId, Box<dyn Fn(Div<Workspace>) -> Div<Workspace>>)>,
-pub fn init_modal_registry(cx: &mut AppContext) {
-    cx.set_global(ModalRegistry {
-        registered_modals: Vec::new(),
-    });
 }
 pub enum ModalEvent {
     fn to_modal_event(&self, _: &Self::Event) -> Option<ModalEvent>;
 }
-impl ModalRegistry {
+impl ModalLayer {
+    pub fn new() -> Self {
+        Self {
+            open_modal: None,
+            subscription: None,
+            registered_modals: Vec::new(),
+        }
+    }
     pub fn register_modal<A: 'static, V, B>(&mut self, action: A, build_view: B)
     where
         V: Modal,
                 let build_view = build_view.clone();
                 div.on_action(move |workspace, event: &A, cx| {
-                    let Some(new_modal) =
+                    let Some(new_modal) = (build_view)(workspace, cx) else {
-                        (build_view)(workspace, cx) else {
+                        return;
-                            return
+                    };
-                        };
+                    workspace.modal_layer().show_modal(new_modal, cx);
-                    workspace.modal_layer.update(cx, |modal_layer, cx| {
-                        modal_layer.show_modal(new_modal, cx);
-                    })
                 })
             }),
         ));
     }
-}
-impl ModalLayer {
-    pub fn new(workspace: WeakView<Workspace>) -> Self {
-        Self {
-            workspace,
-            open_modal: None,
-            subscription: None,
-        }
-    }
-    pub fn show_modal<V: Modal>(&mut self, new_modal: View<V>, cx: &mut ViewContext<Self>) {
+    pub fn show_modal<V: Modal>(&mut self, new_modal: View<V>, cx: &mut ViewContext<Workspace>) {
         self.subscription = Some(cx.subscribe(&new_modal, |this, modal, e, cx| {
             match modal.read(cx).to_modal_event(e) {
-                Some(ModalEvent::Dismissed) => this.hide_modal(cx),
+                Some(ModalEvent::Dismissed) => this.modal_layer().hide_modal(cx),
                 None => {}
             }
         }));
         cx.notify();
     }
-    pub fn hide_modal(&mut self, cx: &mut ViewContext<Self>) {
+    pub fn hide_modal(&mut self, cx: &mut ViewContext<Workspace>) {
         self.open_modal.take();
         self.subscription.take();
         cx.notify();
     }
-    pub fn render(&self, cx: &ViewContext<Workspace>) -> Div<Workspace> {
+    pub fn wrapper_element(&self, cx: &ViewContext<Workspace>) -> Div<Workspace> {
         let mut parent = div().relative().size_full();
-        for (_, action) in cx.global::<ModalRegistry>().registered_modals.iter() {
+        for (_, action) in self.registered_modals.iter() {
             parent = (action)(parent);
         }

crates/workspace2/src/toolbar.rs+10−1

 use crate::ItemHandle;
 use gpui::{
-    AnyView, AppContext, Entity, EntityId, EventEmitter, Render, View, ViewContext, WindowContext,
+    AnyView, AppContext, Div, Entity, EntityId, EventEmitter, Render, View, ViewContext,
+    WindowContext,
 };
 pub trait ToolbarItemView: Render + EventEmitter {
     items: Vec<(Box<dyn ToolbarItemViewHandle>, ToolbarItemLocation)>,
 }
+impl Render for Toolbar {
+    type Element = Div<Self>;
+    fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
+        todo!()
+    }
+}
 // todo!()
 // impl View for Toolbar {
 //     fn ui_name() -> &'static str {

crates/workspace2/src/workspace2.rs+12−9

 };
 use gpui::{
     div, point, size, AnyModel, AnyView, AnyWeakView, AppContext, AsyncAppContext,
-    AsyncWindowContext, Bounds, Component, Div, Entity, EntityId, EventEmitter, FocusHandle,
+    AsyncWindowContext, Bounds, Component, Context, Div, Entity, EntityId, EventEmitter,
-    GlobalPixels, Model, ModelContext, ParentElement, Point, Render, Size, StatefulInteractive,
+    FocusHandle, GlobalPixels, Model, ModelContext, ParentElement, Point, Render, Size,
-    Styled, Subscription, Task, View, ViewContext, VisualContext, WeakView, WindowBounds,
+    StatefulInteractive, Styled, Subscription, Task, View, ViewContext, VisualContext, WeakView,
-    WindowContext, WindowHandle, WindowOptions,
+    WindowBounds, WindowContext, WindowHandle, WindowOptions,
 };
 use item::{FollowableItem, FollowableItemHandle, Item, ItemHandle, ItemSettings, ProjectItem};
 use itertools::Itertools;
 pub fn init(app_state: Arc<AppState>, cx: &mut AppContext) {
     init_settings(cx);
-    init_modal_registry(cx);
     pane::init(cx);
     notifications::init(cx);
     last_active_center_pane: Option<WeakView<Pane>>,
     last_active_view_id: Option<proto::ViewId>,
     status_bar: View<StatusBar>,
-    modal_layer: View<ModalLayer>,
+    modal_layer: ModalLayer,
     //     titlebar_item: Option<AnyViewHandle>,
     notifications: Vec<(TypeId, usize, Box<dyn NotificationHandle>)>,
     project: Model<Project>,
         });
         let workspace_handle = cx.view().downgrade();
-        let modal_layer = cx.build_view(|cx| ModalLayer::new(workspace_handle));
+        let modal_layer = ModalLayer::new();
         // todo!()
         // cx.update_default_global::<DragAndDrop<Workspace>, _, _>(|drag_and_drop, _| {
         }
     }
+    pub fn modal_layer(&mut self) -> &mut ModalLayer {
+        &mut self.modal_layer
+    }
     fn new_local(
         abs_paths: Vec<PathBuf>,
         app_state: Arc<AppState>,
             .bg(cx.theme().colors().background)
             .child(self.render_titlebar(cx))
             .child(
+                // todo! should this be a component a view?
                 self.modal_layer
-                    .read(cx)
+                    .wrapper_element(cx)
-                    .render(cx)
                     .relative()
                     .flex_1()
                     .w_full()

Refactor GoToLine to use cx.observe_new_views()

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code