1use anyhow::Result;
2use async_recursion::async_recursion;
3use collections::HashSet;
4use futures::{StreamExt as _, stream::FuturesUnordered};
5use gpui::{AppContext as _, AsyncWindowContext, Axis, Entity, Task, WeakEntity};
6use project::{Project, terminals::TerminalKind};
7use serde::{Deserialize, Serialize};
8use std::path::{Path, PathBuf};
9use ui::{App, Context, Pixels, Window};
10use util::ResultExt as _;
11
12use db::{define_connection, query, sqlez::statement::Statement, sqlez_macros::sql};
13use workspace::{
14 ItemHandle, ItemId, Member, Pane, PaneAxis, PaneGroup, SerializableItem as _, Workspace,
15 WorkspaceDb, WorkspaceId,
16};
17
18use crate::{
19 TerminalView, default_working_directory,
20 terminal_panel::{TerminalPanel, new_terminal_pane},
21};
22
23pub(crate) fn serialize_pane_group(
24 pane_group: &PaneGroup,
25 active_pane: &Entity<Pane>,
26 cx: &mut App,
27) -> SerializedPaneGroup {
28 build_serialized_pane_group(&pane_group.root, active_pane, cx)
29}
30
31fn build_serialized_pane_group(
32 pane_group: &Member,
33 active_pane: &Entity<Pane>,
34 cx: &mut App,
35) -> SerializedPaneGroup {
36 match pane_group {
37 Member::Axis(PaneAxis {
38 axis,
39 members,
40 flexes,
41 bounding_boxes: _,
42 }) => SerializedPaneGroup::Group {
43 axis: SerializedAxis(*axis),
44 children: members
45 .iter()
46 .map(|member| build_serialized_pane_group(member, active_pane, cx))
47 .collect::<Vec<_>>(),
48 flexes: Some(flexes.lock().clone()),
49 },
50 Member::Pane(pane_handle) => {
51 SerializedPaneGroup::Pane(serialize_pane(pane_handle, pane_handle == active_pane, cx))
52 }
53 }
54}
55
56fn serialize_pane(pane: &Entity<Pane>, active: bool, cx: &mut App) -> SerializedPane {
57 let mut items_to_serialize = HashSet::default();
58 let pane = pane.read(cx);
59 let children = pane
60 .items()
61 .filter_map(|item| {
62 let terminal_view = item.act_as::<TerminalView>(cx)?;
63 if terminal_view.read(cx).terminal().read(cx).task().is_some() {
64 None
65 } else {
66 let id = item.item_id().as_u64();
67 items_to_serialize.insert(id);
68 Some(id)
69 }
70 })
71 .collect::<Vec<_>>();
72 let active_item = pane
73 .active_item()
74 .map(|item| item.item_id().as_u64())
75 .filter(|active_id| items_to_serialize.contains(active_id));
76
77 let pinned_count = pane.pinned_count();
78 SerializedPane {
79 active,
80 children,
81 active_item,
82 pinned_count,
83 }
84}
85
86pub(crate) fn deserialize_terminal_panel(
87 workspace: WeakEntity<Workspace>,
88 project: Entity<Project>,
89 database_id: WorkspaceId,
90 serialized_panel: SerializedTerminalPanel,
91 window: &mut Window,
92 cx: &mut App,
93) -> Task<anyhow::Result<Entity<TerminalPanel>>> {
94 window.spawn(cx, async move |cx| {
95 let terminal_panel = workspace.update_in(cx, |workspace, window, cx| {
96 cx.new(|cx| {
97 let mut panel = TerminalPanel::new(workspace, window, cx);
98 panel.height = serialized_panel.height.map(|h| h.round());
99 panel.width = serialized_panel.width.map(|w| w.round());
100 panel
101 })
102 })?;
103 match &serialized_panel.items {
104 SerializedItems::NoSplits(item_ids) => {
105 let items = deserialize_terminal_views(
106 database_id,
107 project,
108 workspace,
109 item_ids.as_slice(),
110 cx,
111 )
112 .await;
113 let active_item = serialized_panel.active_item_id;
114 terminal_panel.update_in(cx, |terminal_panel, window, cx| {
115 terminal_panel.active_pane.update(cx, |pane, cx| {
116 populate_pane_items(pane, items, active_item, window, cx);
117 });
118 })?;
119 }
120 SerializedItems::WithSplits(serialized_pane_group) => {
121 let center_pane = deserialize_pane_group(
122 workspace,
123 project,
124 terminal_panel.clone(),
125 database_id,
126 serialized_pane_group,
127 cx,
128 )
129 .await;
130 if let Some((center_group, active_pane)) = center_pane {
131 terminal_panel.update(cx, |terminal_panel, _| {
132 terminal_panel.center = PaneGroup::with_root(center_group);
133 terminal_panel.active_pane =
134 active_pane.unwrap_or_else(|| terminal_panel.center.first_pane());
135 })?;
136 }
137 }
138 }
139
140 Ok(terminal_panel)
141 })
142}
143
144fn populate_pane_items(
145 pane: &mut Pane,
146 items: Vec<Entity<TerminalView>>,
147 active_item: Option<u64>,
148 window: &mut Window,
149 cx: &mut Context<Pane>,
150) {
151 let mut item_index = pane.items_len();
152 let mut active_item_index = None;
153 for item in items {
154 if Some(item.item_id().as_u64()) == active_item {
155 active_item_index = Some(item_index);
156 }
157 pane.add_item(Box::new(item), false, false, None, window, cx);
158 item_index += 1;
159 }
160 if let Some(index) = active_item_index {
161 pane.activate_item(index, false, false, window, cx);
162 }
163}
164
165#[async_recursion(?Send)]
166async fn deserialize_pane_group(
167 workspace: WeakEntity<Workspace>,
168 project: Entity<Project>,
169 panel: Entity<TerminalPanel>,
170 workspace_id: WorkspaceId,
171 serialized: &SerializedPaneGroup,
172 cx: &mut AsyncWindowContext,
173) -> Option<(Member, Option<Entity<Pane>>)> {
174 match serialized {
175 SerializedPaneGroup::Group {
176 axis,
177 flexes,
178 children,
179 } => {
180 let mut current_active_pane = None;
181 let mut members = Vec::new();
182 for child in children {
183 if let Some((new_member, active_pane)) = deserialize_pane_group(
184 workspace.clone(),
185 project.clone(),
186 panel.clone(),
187 workspace_id,
188 child,
189 cx,
190 )
191 .await
192 {
193 members.push(new_member);
194 current_active_pane = current_active_pane.or(active_pane);
195 }
196 }
197
198 if members.is_empty() {
199 return None;
200 }
201
202 if members.len() == 1 {
203 return Some((members.remove(0), current_active_pane));
204 }
205
206 Some((
207 Member::Axis(PaneAxis::load(axis.0, members, flexes.clone())),
208 current_active_pane,
209 ))
210 }
211 SerializedPaneGroup::Pane(serialized_pane) => {
212 let active = serialized_pane.active;
213 let new_items = deserialize_terminal_views(
214 workspace_id,
215 project.clone(),
216 workspace.clone(),
217 serialized_pane.children.as_slice(),
218 cx,
219 )
220 .await;
221
222 let pane = panel
223 .update_in(cx, |terminal_panel, window, cx| {
224 new_terminal_pane(
225 workspace.clone(),
226 project.clone(),
227 terminal_panel.active_pane.read(cx).is_zoomed(),
228 window,
229 cx,
230 )
231 })
232 .log_err()?;
233 let active_item = serialized_pane.active_item;
234 let pinned_count = serialized_pane.pinned_count;
235 let terminal = pane
236 .update_in(cx, |pane, window, cx| {
237 populate_pane_items(pane, new_items, active_item, window, cx);
238 pane.set_pinned_count(pinned_count);
239 // Avoid blank panes in splits
240 if pane.items_len() == 0 {
241 let working_directory = workspace
242 .update(cx, |workspace, cx| default_working_directory(workspace, cx))
243 .ok()
244 .flatten();
245 let kind = TerminalKind::Shell(
246 working_directory.as_deref().map(Path::to_path_buf),
247 );
248 let window = window.window_handle();
249 let terminal = project
250 .update(cx, |project, cx| project.create_terminal(kind, window, cx));
251 Some(Some(terminal))
252 } else {
253 Some(None)
254 }
255 })
256 .ok()
257 .flatten()?;
258 if let Some(terminal) = terminal {
259 let terminal = terminal.await.ok()?;
260 pane.update_in(cx, |pane, window, cx| {
261 let terminal_view = Box::new(cx.new(|cx| {
262 TerminalView::new(
263 terminal,
264 workspace.clone(),
265 Some(workspace_id),
266 project.downgrade(),
267 false,
268 window,
269 cx,
270 )
271 }));
272 pane.add_item(terminal_view, true, false, None, window, cx);
273 })
274 .ok()?;
275 }
276 Some((Member::Pane(pane.clone()), active.then_some(pane)))
277 }
278 }
279}
280
281async fn deserialize_terminal_views(
282 workspace_id: WorkspaceId,
283 project: Entity<Project>,
284 workspace: WeakEntity<Workspace>,
285 item_ids: &[u64],
286 cx: &mut AsyncWindowContext,
287) -> Vec<Entity<TerminalView>> {
288 let mut items = Vec::with_capacity(item_ids.len());
289 let mut deserialized_items = item_ids
290 .iter()
291 .map(|item_id| {
292 cx.update(|window, cx| {
293 TerminalView::deserialize(
294 project.clone(),
295 workspace.clone(),
296 workspace_id,
297 *item_id,
298 window,
299 cx,
300 )
301 })
302 .unwrap_or_else(|e| Task::ready(Err(e.context("no window present"))))
303 })
304 .collect::<FuturesUnordered<_>>();
305 while let Some(item) = deserialized_items.next().await {
306 if let Some(item) = item.log_err() {
307 items.push(item);
308 }
309 }
310 items
311}
312
313#[derive(Debug, Serialize, Deserialize)]
314pub(crate) struct SerializedTerminalPanel {
315 pub items: SerializedItems,
316 // A deprecated field, kept for backwards compatibility for the code before terminal splits were introduced.
317 pub active_item_id: Option<u64>,
318 pub width: Option<Pixels>,
319 pub height: Option<Pixels>,
320}
321
322#[derive(Debug, Serialize, Deserialize)]
323#[serde(untagged)]
324pub(crate) enum SerializedItems {
325 // The data stored before terminal splits were introduced.
326 NoSplits(Vec<u64>),
327 WithSplits(SerializedPaneGroup),
328}
329
330#[derive(Debug, Serialize, Deserialize)]
331pub(crate) enum SerializedPaneGroup {
332 Pane(SerializedPane),
333 Group {
334 axis: SerializedAxis,
335 flexes: Option<Vec<f32>>,
336 children: Vec<SerializedPaneGroup>,
337 },
338}
339
340#[derive(Debug, Serialize, Deserialize)]
341pub(crate) struct SerializedPane {
342 pub active: bool,
343 pub children: Vec<u64>,
344 pub active_item: Option<u64>,
345 #[serde(default)]
346 pub pinned_count: usize,
347}
348
349#[derive(Debug)]
350pub(crate) struct SerializedAxis(pub Axis);
351
352impl Serialize for SerializedAxis {
353 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
354 where
355 S: serde::Serializer,
356 {
357 match self.0 {
358 Axis::Horizontal => serializer.serialize_str("horizontal"),
359 Axis::Vertical => serializer.serialize_str("vertical"),
360 }
361 }
362}
363
364impl<'de> Deserialize<'de> for SerializedAxis {
365 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
366 where
367 D: serde::Deserializer<'de>,
368 {
369 let s = String::deserialize(deserializer)?;
370 match s.as_str() {
371 "horizontal" => Ok(SerializedAxis(Axis::Horizontal)),
372 "vertical" => Ok(SerializedAxis(Axis::Vertical)),
373 invalid => Err(serde::de::Error::custom(format!(
374 "Invalid axis value: '{invalid}'"
375 ))),
376 }
377 }
378}
379
380define_connection! {
381 pub static ref TERMINAL_DB: TerminalDb<WorkspaceDb> =
382 &[sql!(
383 CREATE TABLE terminals (
384 workspace_id INTEGER,
385 item_id INTEGER UNIQUE,
386 working_directory BLOB,
387 PRIMARY KEY(workspace_id, item_id),
388 FOREIGN KEY(workspace_id) REFERENCES workspaces(workspace_id)
389 ON DELETE CASCADE
390 ) STRICT;
391 ),
392 // Remove the unique constraint on the item_id table
393 // SQLite doesn't have a way of doing this automatically, so
394 // we have to do this silly copying.
395 sql!(
396 CREATE TABLE terminals2 (
397 workspace_id INTEGER,
398 item_id INTEGER,
399 working_directory BLOB,
400 PRIMARY KEY(workspace_id, item_id),
401 FOREIGN KEY(workspace_id) REFERENCES workspaces(workspace_id)
402 ON DELETE CASCADE
403 ) STRICT;
404
405 INSERT INTO terminals2 (workspace_id, item_id, working_directory)
406 SELECT workspace_id, item_id, working_directory FROM terminals;
407
408 DROP TABLE terminals;
409
410 ALTER TABLE terminals2 RENAME TO terminals;
411 ),
412 sql! (
413 ALTER TABLE terminals ADD COLUMN working_directory_path TEXT;
414 UPDATE terminals SET working_directory_path = CAST(working_directory AS TEXT);
415 ),
416 ];
417}
418
419impl TerminalDb {
420 query! {
421 pub async fn update_workspace_id(
422 new_id: WorkspaceId,
423 old_id: WorkspaceId,
424 item_id: ItemId
425 ) -> Result<()> {
426 UPDATE terminals
427 SET workspace_id = ?
428 WHERE workspace_id = ? AND item_id = ?
429 }
430 }
431
432 pub async fn save_working_directory(
433 &self,
434 item_id: ItemId,
435 workspace_id: WorkspaceId,
436 working_directory: PathBuf,
437 ) -> Result<()> {
438 log::debug!(
439 "Saving working directory {working_directory:?} for item {item_id} in workspace {workspace_id:?}"
440 );
441 let query =
442 "INSERT INTO terminals(item_id, workspace_id, working_directory, working_directory_path)
443 VALUES (?1, ?2, ?3, ?4)
444 ON CONFLICT DO UPDATE SET
445 item_id = ?1,
446 workspace_id = ?2,
447 working_directory = ?3,
448 working_directory_path = ?4"
449 ;
450 self.write(move |conn| {
451 let mut statement = Statement::prepare(conn, query)?;
452 let mut next_index = statement.bind(&item_id, 1)?;
453 next_index = statement.bind(&workspace_id, next_index)?;
454 next_index = statement.bind(&working_directory, next_index)?;
455 statement.bind(&working_directory.to_string_lossy().to_string(), next_index)?;
456 statement.exec()
457 })
458 .await
459 }
460
461 query! {
462 pub fn get_working_directory(item_id: ItemId, workspace_id: WorkspaceId) -> Result<Option<PathBuf>> {
463 SELECT working_directory
464 FROM terminals
465 WHERE item_id = ? AND workspace_id = ?
466 }
467 }
468}