404 lines
18 KiB
Rust
404 lines
18 KiB
Rust
mod assets;
|
|
pub mod languages;
|
|
mod only_instance;
|
|
mod open_listener;
|
|
|
|
pub use assets::*;
|
|
use collections::HashMap;
|
|
use gpui2::{
|
|
point, px, AppContext, AsyncAppContext, AsyncWindowContext, Point, Task, TitlebarOptions,
|
|
WeakView, WindowBounds, WindowKind, WindowOptions,
|
|
};
|
|
pub use only_instance::*;
|
|
pub use open_listener::*;
|
|
|
|
use anyhow::{Context, Result};
|
|
use cli::{
|
|
ipc::{self, IpcSender},
|
|
CliRequest, CliResponse, IpcHandshake,
|
|
};
|
|
use futures::{
|
|
channel::{mpsc, oneshot},
|
|
FutureExt, SinkExt, StreamExt,
|
|
};
|
|
use std::{path::Path, sync::Arc, thread, time::Duration};
|
|
use util::{paths::PathLikeWithPosition, ResultExt};
|
|
use uuid::Uuid;
|
|
use workspace2::{AppState, Workspace};
|
|
|
|
pub fn connect_to_cli(
|
|
server_name: &str,
|
|
) -> Result<(mpsc::Receiver<CliRequest>, IpcSender<CliResponse>)> {
|
|
let handshake_tx = cli::ipc::IpcSender::<IpcHandshake>::connect(server_name.to_string())
|
|
.context("error connecting to cli")?;
|
|
let (request_tx, request_rx) = ipc::channel::<CliRequest>()?;
|
|
let (response_tx, response_rx) = ipc::channel::<CliResponse>()?;
|
|
|
|
handshake_tx
|
|
.send(IpcHandshake {
|
|
requests: request_tx,
|
|
responses: response_rx,
|
|
})
|
|
.context("error sending ipc handshake")?;
|
|
|
|
let (mut async_request_tx, async_request_rx) =
|
|
futures::channel::mpsc::channel::<CliRequest>(16);
|
|
thread::spawn(move || {
|
|
while let Ok(cli_request) = request_rx.recv() {
|
|
if smol::block_on(async_request_tx.send(cli_request)).is_err() {
|
|
break;
|
|
}
|
|
}
|
|
Ok::<_, anyhow::Error>(())
|
|
});
|
|
|
|
Ok((async_request_rx, response_tx))
|
|
}
|
|
|
|
pub async fn handle_cli_connection(
|
|
(mut requests, responses): (mpsc::Receiver<CliRequest>, IpcSender<CliResponse>),
|
|
app_state: Arc<AppState>,
|
|
mut cx: AsyncAppContext,
|
|
) {
|
|
if let Some(request) = requests.next().await {
|
|
match request {
|
|
CliRequest::Open { paths, wait } => {
|
|
let mut caret_positions = HashMap::default();
|
|
|
|
let paths = if paths.is_empty() {
|
|
todo!()
|
|
// workspace::last_opened_workspace_paths()
|
|
// .await
|
|
// .map(|location| location.paths().to_vec())
|
|
// .unwrap_or_default()
|
|
} else {
|
|
paths
|
|
.into_iter()
|
|
.filter_map(|path_with_position_string| {
|
|
let path_with_position = PathLikeWithPosition::parse_str(
|
|
&path_with_position_string,
|
|
|path_str| {
|
|
Ok::<_, std::convert::Infallible>(
|
|
Path::new(path_str).to_path_buf(),
|
|
)
|
|
},
|
|
)
|
|
.expect("Infallible");
|
|
let path = path_with_position.path_like;
|
|
if let Some(row) = path_with_position.row {
|
|
if path.is_file() {
|
|
let row = row.saturating_sub(1);
|
|
let col =
|
|
path_with_position.column.unwrap_or(0).saturating_sub(1);
|
|
caret_positions.insert(path.clone(), Point::new(row, col));
|
|
}
|
|
}
|
|
Some(path)
|
|
})
|
|
.collect::<Vec<_>>()
|
|
};
|
|
|
|
let mut errored = false;
|
|
|
|
if let Some(open_paths_task) = cx
|
|
.update(|cx| workspace2::open_paths(&paths, &app_state, None, cx))
|
|
.log_err()
|
|
{
|
|
match open_paths_task.await {
|
|
Ok((workspace, items)) => {
|
|
let mut item_release_futures = Vec::new();
|
|
|
|
for (item, path) in items.into_iter().zip(&paths) {
|
|
match item {
|
|
Some(Ok(mut item)) => {
|
|
if let Some(point) = caret_positions.remove(path) {
|
|
todo!()
|
|
// if let Some(active_editor) = item.downcast::<Editor>() {
|
|
// active_editor
|
|
// .downgrade()
|
|
// .update(&mut cx, |editor, cx| {
|
|
// let snapshot =
|
|
// editor.snapshot(cx).display_snapshot;
|
|
// let point = snapshot
|
|
// .buffer_snapshot
|
|
// .clip_point(point, Bias::Left);
|
|
// editor.change_selections(
|
|
// Some(Autoscroll::center()),
|
|
// cx,
|
|
// |s| s.select_ranges([point..point]),
|
|
// );
|
|
// })
|
|
// .log_err();
|
|
// }
|
|
}
|
|
|
|
let released = oneshot::channel();
|
|
cx.update(move |cx| {
|
|
item.on_release(
|
|
cx,
|
|
Box::new(move |_| {
|
|
let _ = released.0.send(());
|
|
}),
|
|
)
|
|
.detach();
|
|
});
|
|
item_release_futures.push(released.1);
|
|
}
|
|
Some(Err(err)) => {
|
|
responses
|
|
.send(CliResponse::Stderr {
|
|
message: format!(
|
|
"error opening {:?}: {}",
|
|
path, err
|
|
),
|
|
})
|
|
.log_err();
|
|
errored = true;
|
|
}
|
|
None => {}
|
|
}
|
|
}
|
|
|
|
if wait {
|
|
let executor = cx.background_executor().clone();
|
|
let wait = async move {
|
|
if paths.is_empty() {
|
|
let (done_tx, done_rx) = oneshot::channel();
|
|
let _subscription =
|
|
workspace.update(&mut cx, move |_, cx| {
|
|
cx.on_release(|_, _| {
|
|
let _ = done_tx.send(());
|
|
})
|
|
});
|
|
drop(workspace);
|
|
let _ = done_rx.await;
|
|
} else {
|
|
let _ = futures::future::try_join_all(item_release_futures)
|
|
.await;
|
|
};
|
|
}
|
|
.fuse();
|
|
futures::pin_mut!(wait);
|
|
|
|
loop {
|
|
// Repeatedly check if CLI is still open to avoid wasting resources
|
|
// waiting for files or workspaces to close.
|
|
let mut timer = executor.timer(Duration::from_secs(1)).fuse();
|
|
futures::select_biased! {
|
|
_ = wait => break,
|
|
_ = timer => {
|
|
if responses.send(CliResponse::Ping).is_err() {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Err(error) => {
|
|
errored = true;
|
|
responses
|
|
.send(CliResponse::Stderr {
|
|
message: format!("error opening {:?}: {}", paths, error),
|
|
})
|
|
.log_err();
|
|
}
|
|
}
|
|
|
|
responses
|
|
.send(CliResponse::Exit {
|
|
status: i32::from(errored),
|
|
})
|
|
.log_err();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn build_window_options(
|
|
bounds: Option<WindowBounds>,
|
|
display_uuid: Option<Uuid>,
|
|
cx: &mut AppContext,
|
|
) -> WindowOptions {
|
|
let bounds = bounds.unwrap_or(WindowBounds::Maximized);
|
|
let display = display_uuid.and_then(|uuid| {
|
|
cx.displays()
|
|
.into_iter()
|
|
.find(|display| display.uuid().ok() == Some(uuid))
|
|
});
|
|
|
|
WindowOptions {
|
|
bounds,
|
|
titlebar: Some(TitlebarOptions {
|
|
title: None,
|
|
appears_transparent: true,
|
|
traffic_light_position: Some(point(px(8.), px(8.))),
|
|
}),
|
|
center: false,
|
|
focus: false,
|
|
show: false,
|
|
kind: WindowKind::Normal,
|
|
is_movable: false,
|
|
display_id: display.map(|display| display.id()),
|
|
}
|
|
}
|
|
|
|
pub fn initialize_workspace(
|
|
workspace_handle: WeakView<Workspace>,
|
|
was_deserialized: bool,
|
|
app_state: Arc<AppState>,
|
|
cx: AsyncWindowContext,
|
|
) -> Task<Result<()>> {
|
|
cx.spawn(|mut cx| async move {
|
|
workspace_handle.update(&mut cx, |workspace, cx| {
|
|
let workspace_handle = cx.view();
|
|
cx.subscribe(&workspace_handle, {
|
|
move |workspace, _, event, cx| {
|
|
if let workspace2::Event::PaneAdded(pane) = event {
|
|
pane.update(cx, |pane, cx| {
|
|
// todo!()
|
|
// pane.toolbar().update(cx, |toolbar, cx| {
|
|
// let breadcrumbs = cx.add_view(|_| Breadcrumbs::new(workspace));
|
|
// toolbar.add_item(breadcrumbs, cx);
|
|
// let buffer_search_bar = cx.add_view(BufferSearchBar::new);
|
|
// toolbar.add_item(buffer_search_bar.clone(), cx);
|
|
// let quick_action_bar = cx.add_view(|_| {
|
|
// QuickActionBar::new(buffer_search_bar, workspace)
|
|
// });
|
|
// toolbar.add_item(quick_action_bar, cx);
|
|
// let diagnostic_editor_controls =
|
|
// cx.add_view(|_| diagnostics2::ToolbarControls::new());
|
|
// toolbar.add_item(diagnostic_editor_controls, cx);
|
|
// let project_search_bar = cx.add_view(|_| ProjectSearchBar::new());
|
|
// toolbar.add_item(project_search_bar, cx);
|
|
// let submit_feedback_button =
|
|
// cx.add_view(|_| SubmitFeedbackButton::new());
|
|
// toolbar.add_item(submit_feedback_button, cx);
|
|
// let feedback_info_text = cx.add_view(|_| FeedbackInfoText::new());
|
|
// toolbar.add_item(feedback_info_text, cx);
|
|
// let lsp_log_item =
|
|
// cx.add_view(|_| language_tools::LspLogToolbarItemView::new());
|
|
// toolbar.add_item(lsp_log_item, cx);
|
|
// let syntax_tree_item = cx
|
|
// .add_view(|_| language_tools::SyntaxTreeToolbarItemView::new());
|
|
// toolbar.add_item(syntax_tree_item, cx);
|
|
// })
|
|
});
|
|
}
|
|
}
|
|
})
|
|
.detach();
|
|
|
|
// cx.emit(workspace2::Event::PaneAdded(
|
|
// workspace.active_pane().clone(),
|
|
// ));
|
|
|
|
// let collab_titlebar_item =
|
|
// cx.add_view(|cx| CollabTitlebarItem::new(workspace, &workspace_handle, cx));
|
|
// workspace.set_titlebar_item(collab_titlebar_item.into_any(), cx);
|
|
|
|
// let copilot =
|
|
// cx.add_view(|cx| copilot_button::CopilotButton::new(app_state.fs.clone(), cx));
|
|
// let diagnostic_summary =
|
|
// cx.add_view(|cx| diagnostics::items::DiagnosticIndicator::new(workspace, cx));
|
|
// let activity_indicator = activity_indicator::ActivityIndicator::new(
|
|
// workspace,
|
|
// app_state.languages.clone(),
|
|
// cx,
|
|
// );
|
|
// let active_buffer_language =
|
|
// cx.add_view(|_| language_selector::ActiveBufferLanguage::new(workspace));
|
|
// let vim_mode_indicator = cx.add_view(|cx| vim::ModeIndicator::new(cx));
|
|
// let feedback_button = cx.add_view(|_| {
|
|
// feedback::deploy_feedback_button::DeployFeedbackButton::new(workspace)
|
|
// });
|
|
// let cursor_position = cx.add_view(|_| editor::items::CursorPosition::new());
|
|
// workspace.status_bar().update(cx, |status_bar, cx| {
|
|
// status_bar.add_left_item(diagnostic_summary, cx);
|
|
// status_bar.add_left_item(activity_indicator, cx);
|
|
|
|
// status_bar.add_right_item(feedback_button, cx);
|
|
// status_bar.add_right_item(copilot, cx);
|
|
// status_bar.add_right_item(active_buffer_language, cx);
|
|
// status_bar.add_right_item(vim_mode_indicator, cx);
|
|
// status_bar.add_right_item(cursor_position, cx);
|
|
// });
|
|
|
|
// auto_update::notify_of_any_new_update(cx.weak_handle(), cx);
|
|
|
|
// vim::observe_keystrokes(cx);
|
|
|
|
// cx.on_window_should_close(|workspace, cx| {
|
|
// if let Some(task) = workspace.close(&Default::default(), cx) {
|
|
// task.detach_and_log_err(cx);
|
|
// }
|
|
// false
|
|
// });
|
|
// })?;
|
|
|
|
// let project_panel = ProjectPanel::load(workspace_handle.clone(), cx.clone());
|
|
// let terminal_panel = TerminalPanel::load(workspace_handle.clone(), cx.clone());
|
|
// let assistant_panel = AssistantPanel::load(workspace_handle.clone(), cx.clone());
|
|
// let channels_panel =
|
|
// collab_ui::collab_panel::CollabPanel::load(workspace_handle.clone(), cx.clone());
|
|
// let chat_panel =
|
|
// collab_ui::chat_panel::ChatPanel::load(workspace_handle.clone(), cx.clone());
|
|
// let notification_panel = collab_ui::notification_panel::NotificationPanel::load(
|
|
// workspace_handle.clone(),
|
|
// cx.clone(),
|
|
// );
|
|
// let (
|
|
// project_panel,
|
|
// terminal_panel,
|
|
// assistant_panel,
|
|
// channels_panel,
|
|
// chat_panel,
|
|
// notification_panel,
|
|
// ) = futures::try_join!(
|
|
// project_panel,
|
|
// terminal_panel,
|
|
// assistant_panel,
|
|
// channels_panel,
|
|
// chat_panel,
|
|
// notification_panel,
|
|
// )?;
|
|
// workspace_handle.update(&mut cx, |workspace, cx| {
|
|
// let project_panel_position = project_panel.position(cx);
|
|
// workspace.add_panel_with_extra_event_handler(
|
|
// project_panel,
|
|
// cx,
|
|
// |workspace, _, event, cx| match event {
|
|
// project_panel::Event::NewSearchInDirectory { dir_entry } => {
|
|
// search::ProjectSearchView::new_search_in_directory(workspace, dir_entry, cx)
|
|
// }
|
|
// project_panel::Event::ActivatePanel => {
|
|
// workspace.focus_panel::<ProjectPanel>(cx);
|
|
// }
|
|
// _ => {}
|
|
// },
|
|
// );
|
|
// workspace.add_panel(terminal_panel, cx);
|
|
// workspace.add_panel(assistant_panel, cx);
|
|
// workspace.add_panel(channels_panel, cx);
|
|
// workspace.add_panel(chat_panel, cx);
|
|
// workspace.add_panel(notification_panel, cx);
|
|
|
|
// if !was_deserialized
|
|
// && workspace
|
|
// .project()
|
|
// .read(cx)
|
|
// .visible_worktrees(cx)
|
|
// .any(|tree| {
|
|
// tree.read(cx)
|
|
// .root_entry()
|
|
// .map_or(false, |entry| entry.is_dir())
|
|
// })
|
|
// {
|
|
// workspace.toggle_dock(project_panel_position, cx);
|
|
// }
|
|
// cx.focus_self();
|
|
})?;
|
|
Ok(())
|
|
})
|
|
}
|