chore: use WindowContext in Workspace where it is a sufficient context type

Piotr Osiewicz committed 2 years ago

Commit c3102fe1 parent 29e74a61 file · +24 −30Browse files

Unified · Split

         self.window_edited
     }
-    pub fn add_panel<T: Panel>(&mut self, panel: View<T>, cx: &mut ViewContext<Self>) {
+    pub fn add_panel<T: Panel>(&mut self, panel: View<T>, cx: &mut WindowContext) {
         let dock = match panel.position(cx) {
             DockPosition::Left => &self.left_dock,
             DockPosition::Bottom => &self.bottom_dock,
         item.to_any().downcast::<I>().ok()
     }
-    fn active_project_path(&self, cx: &ViewContext<Self>) -> Option<ProjectPath> {
+    fn active_project_path(&self, cx: &AppContext) -> Option<ProjectPath> {
         self.active_item(cx).and_then(|item| item.project_path(cx))
     }
     pub fn save_active_item(
         &mut self,
         save_intent: SaveIntent,
-        cx: &mut ViewContext<Self>,
+        cx: &mut WindowContext,
     ) -> Task<Result<()>> {
         let project = self.project.clone();
         let pane = self.active_pane();
         let item = pane.read(cx).active_item();
         let pane = pane.downgrade();
-        cx.spawn(|_, mut cx| async move {
+        cx.spawn(|mut cx| async move {
             if let Some(item) = item {
                 Pane::save_item(project, &pane, item_ix, item.as_ref(), save_intent, &mut cx)
                     .await
         }
     }
-    pub fn add_item(&mut self, item: Box<dyn ItemHandle>, cx: &mut ViewContext<Self>) {
+    pub fn add_item(&mut self, item: Box<dyn ItemHandle>, cx: &mut WindowContext) {
         if let Some(text) = item.telemetry_event_text(cx) {
             self.client()
                 .telemetry()
         path: impl Into<ProjectPath>,
         pane: Option<WeakView<Pane>>,
         focus_item: bool,
-        cx: &mut ViewContext<Self>,
+        cx: &mut WindowContext,
     ) -> Task<Result<Box<dyn ItemHandle>, anyhow::Error>> {
         let pane = pane.unwrap_or_else(|| {
             self.last_active_center_pane.clone().unwrap_or_else(|| {
         });
         let task = self.load_path(path.into(), cx);
-        cx.spawn(move |_, mut cx| async move {
+        cx.spawn(move |mut cx| async move {
             let (project_entry_id, build_item) = task.await?;
             pane.update(&mut cx, |pane, cx| {
                 pane.open_item(project_entry_id, focus_item, cx, build_item)
     fn load_path(
         &mut self,
         path: ProjectPath,
-        cx: &mut ViewContext<Self>,
+        cx: &mut WindowContext,
     ) -> Task<
         Result<(
             Option<ProjectEntryId>,
     > {
         let project = self.project().clone();
         let project_item = project.update(cx, |project, cx| project.open_path(path, cx));
-        cx.spawn(|_, mut cx| async move {
+        cx.spawn(|mut cx| async move {
             let (project_entry_id, project_item) = project_item.await?;
             let build_item = cx.update(|cx| {
                 cx.default_global::<ProjectItemBuilders>()
         }
     }
-    pub fn activate_item(&mut self, item: &dyn ItemHandle, cx: &mut ViewContext<Self>) -> bool {
+    pub fn activate_item(&mut self, item: &dyn ItemHandle, cx: &mut WindowContext) -> bool {
         let result = self.panes.iter().find_map(|pane| {
             pane.read(cx)
                 .index_for_item(item)
         }
     }
-    pub fn activate_next_pane(&mut self, cx: &mut ViewContext<Self>) {
+    pub fn activate_next_pane(&mut self, cx: &mut WindowContext) {
         let panes = self.center.panes();
         if let Some(ix) = panes.iter().position(|pane| **pane == self.active_pane) {
             let next_ix = (ix + 1) % panes.len();
         }
     }
-    pub fn activate_previous_pane(&mut self, cx: &mut ViewContext<Self>) {
+    pub fn activate_previous_pane(&mut self, cx: &mut WindowContext) {
         let panes = self.center.panes();
         if let Some(ix) = panes.iter().position(|pane| **pane == self.active_pane) {
             let prev_ix = cmp::min(ix.wrapping_sub(1), panes.len() - 1);
     pub fn activate_pane_in_direction(
         &mut self,
         direction: SplitDirection,
-        cx: &mut ViewContext<Self>,
+        cx: &mut WindowContext,
     ) {
         if let Some(pane) = self.find_pane_in_direction(direction, cx) {
             cx.focus_view(pane);
     fn find_pane_in_direction(
         &mut self,
         direction: SplitDirection,
-        cx: &mut ViewContext<Self>,
+        cx: &AppContext,
     ) -> Option<&View<Pane>> {
         let Some(bounding_box) = self.center.bounding_box_for_pane(&self.active_pane) else {
             return None;
             .any(|state| state.leader_id == peer_id)
     }
-    fn active_item_path_changed(&mut self, cx: &mut ViewContext<Self>) {
+    fn active_item_path_changed(&mut self, cx: &mut WindowContext) {
         let active_entry = self.active_project_path(cx);
         self.project
             .update(cx, |project, cx| project.set_active_path(active_entry, cx));
         self.update_window_title(cx);
     }
-    fn update_window_title(&mut self, cx: &mut ViewContext<Self>) {
+    fn update_window_title(&mut self, cx: &mut WindowContext) {
         let project = self.project().read(cx);
         let mut title = String::new();
         cx.set_window_title(&title);
     }
-    fn update_window_edited(&mut self, cx: &mut ViewContext<Self>) {
+    fn update_window_edited(&mut self, cx: &mut WindowContext) {
         let is_edited = !self.project.read(cx).is_disconnected()
             && self
                 .items(cx)
         Ok(())
     }
-    fn update_active_view_for_followers(&mut self, cx: &mut ViewContext<Self>) {
+    fn update_active_view_for_followers(&mut self, cx: &mut WindowContext) {
         let mut is_project_item = true;
         let mut update = proto::UpdateActiveView::default();
         &self,
         peer_id: PeerId,
         pane: &View<Pane>,
-        cx: &mut ViewContext<Self>,
+        cx: &mut WindowContext,
     ) -> Option<View<SharedScreen>> {
         let call = self.active_call()?;
         let room = call.read(cx).room()?.read(cx);
         }));
     }
-    fn serialize_workspace(&self, cx: &mut ViewContext<Self>) {
+    fn serialize_workspace(&self, cx: &mut WindowContext) {
         fn serialize_pane_handle(pane_handle: &View<Pane>, cx: &WindowContext) -> SerializedPane {
             let (items, active) = {
                 let pane = pane_handle.read(cx);
             }
         }
-        fn build_serialized_docks(
+        fn build_serialized_docks(this: &Workspace, cx: &mut WindowContext) -> DockStructure {
-            this: &Workspace,
-            cx: &mut ViewContext<Workspace>,
-        ) -> DockStructure {
             let left_dock = this.left_dock.read(cx);
             let left_visible = left_dock.is_open();
             let left_active_panel = left_dock
                     docks,
                 };
-                cx.spawn(|_, _| persistence::DB.save_workspace(serialized_workspace))
+                cx.spawn(|_| persistence::DB.save_workspace(serialized_workspace))
                     .detach();
             }
         }
         self.modal_layer.read(cx).has_active_modal()
     }
-    pub fn active_modal<V: ManagedView + 'static>(
+    pub fn active_modal<V: ManagedView + 'static>(&mut self, cx: &AppContext) -> Option<View<V>> {
-        &mut self,
-        cx: &ViewContext<Self>,
-    ) -> Option<View<V>> {
         self.modal_layer.read(cx).active_modal()
     }
-    pub fn toggle_modal<V: ModalView, B>(&mut self, cx: &mut ViewContext<Self>, build: B)
+    pub fn toggle_modal<V: ModalView, B>(&mut self, cx: &mut WindowContext, build: B)
     where
         B: FnOnce(&mut ViewContext<V>) -> V,
     {