Detailed changes
@@ -705,17 +705,6 @@ version = "1.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ec8a7b6a70fde80372154c65702f00a0f56f3e1c36abbc6c440484be248856db"
-[[package]]
-name = "bzip2-sys"
-version = "0.1.11+1.0.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "736a955f3fa7875102d57c82b8cac37ec45224a07fd32d58f9f7a186b6cd4cdc"
-dependencies = [
- "cc",
- "libc",
- "pkg-config",
-]
-
[[package]]
name = "cache-padded"
version = "1.2.0"
@@ -866,6 +855,22 @@ version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+[[package]]
+name = "chat_panel"
+version = "0.1.0"
+dependencies = [
+ "client",
+ "editor",
+ "gpui",
+ "menu",
+ "postage",
+ "settings",
+ "theme",
+ "time 0.3.15",
+ "util",
+ "workspace",
+]
+
[[package]]
name = "chrono"
version = "0.4.22"
@@ -1586,8 +1591,13 @@ dependencies = [
"async-trait",
"collections",
"gpui",
+ "lazy_static",
+ "log",
"parking_lot 0.11.2",
- "rocksdb",
+ "rusqlite",
+ "rusqlite_migration",
+ "serde",
+ "serde_rusqlite",
"tempdir",
]
@@ -1907,6 +1917,12 @@ version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4443176a9f2c162692bd3d352d745ef9413eec5782a80d8fd6f8a1ac692a07f7"
+[[package]]
+name = "fallible-streaming-iterator"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
+
[[package]]
name = "fastrand"
version = "1.8.0"
@@ -3102,17 +3118,14 @@ dependencies = [
]
[[package]]
-name = "librocksdb-sys"
-version = "0.7.1+7.3.1"
-source = "git+https://github.com/rust-rocksdb/rust-rocksdb?rev=39dc822dde743b2a26eb160b660e8fbdab079d49#39dc822dde743b2a26eb160b660e8fbdab079d49"
+name = "libsqlite3-sys"
+version = "0.25.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f0455f2c1bc9a7caa792907026e469c1d91761fb0ea37cbb16427c77280cf35"
dependencies = [
- "bindgen",
- "bzip2-sys",
"cc",
- "glob",
- "libc",
- "libz-sys",
- "zstd-sys",
+ "pkg-config",
+ "vcpkg",
]
[[package]]
@@ -4229,7 +4242,6 @@ dependencies = [
"pulldown-cmark",
"rand 0.8.5",
"regex",
- "rocksdb",
"rpc",
"serde",
"serde_json",
@@ -4728,15 +4740,6 @@ dependencies = [
"rmp",
]
-[[package]]
-name = "rocksdb"
-version = "0.18.0"
-source = "git+https://github.com/rust-rocksdb/rust-rocksdb?rev=39dc822dde743b2a26eb160b660e8fbdab079d49#39dc822dde743b2a26eb160b660e8fbdab079d49"
-dependencies = [
- "libc",
- "librocksdb-sys",
-]
-
[[package]]
name = "rope"
version = "0.1.0"
@@ -4808,6 +4811,31 @@ dependencies = [
"zeroize",
]
+[[package]]
+name = "rusqlite"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01e213bc3ecb39ac32e81e51ebe31fd888a940515173e3a18a35f8c6e896422a"
+dependencies = [
+ "bitflags",
+ "fallible-iterator",
+ "fallible-streaming-iterator",
+ "hashlink",
+ "libsqlite3-sys",
+ "serde_json",
+ "smallvec",
+]
+
+[[package]]
+name = "rusqlite_migration"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eda44233be97aea786691f9f6f7ef230bcf905061f4012e90f4f39e6dcf31163"
+dependencies = [
+ "log",
+ "rusqlite",
+]
+
[[package]]
name = "rust-embed"
version = "6.4.1"
@@ -5203,6 +5231,16 @@ dependencies = [
"syn",
]
+[[package]]
+name = "serde_rusqlite"
+version = "0.31.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "538b51f10ee271375cbd9caa04fa6e3e50af431a21db97caae48da92a074244a"
+dependencies = [
+ "rusqlite",
+ "serde",
+]
+
[[package]]
name = "serde_urlencoded"
version = "0.7.1"
@@ -5809,6 +5847,7 @@ dependencies = [
"futures 0.3.24",
"gpui",
"itertools",
+ "language",
"lazy_static",
"libc",
"mio-extras",
@@ -7580,7 +7619,7 @@ dependencies = [
[[package]]
name = "zed"
-version = "0.60.4"
+version = "0.61.0"
dependencies = [
"activity_indicator",
"anyhow",
@@ -18,8 +18,6 @@ cocoa-foundation = { git = "https://github.com/servo/core-foundation-rs", rev =
core-foundation = { git = "https://github.com/servo/core-foundation-rs", rev = "079665882507dd5e2ff77db3de5070c1f6c0fb85" }
core-foundation-sys = { git = "https://github.com/servo/core-foundation-rs", rev = "079665882507dd5e2ff77db3de5070c1f6c0fb85" }
core-graphics = { git = "https://github.com/servo/core-foundation-rs", rev = "079665882507dd5e2ff77db3de5070c1f6c0fb85" }
-# TODO - Remove when a new version of RustRocksDB is released
-rocksdb = { git = "https://github.com/rust-rocksdb/rust-rocksdb", rev = "39dc822dde743b2a26eb160b660e8fbdab079d49" }
[profile.dev]
split-debuginfo = "unpacked"
@@ -1,2 +1,2 @@
-web: cd ../zed.dev && PORT=3000 npx next dev
+web: cd ../zed.dev && PORT=3000 npx vercel dev
collab: cd crates/collab && cargo run
@@ -10,6 +10,8 @@
// Whether to show the informational hover box when moving the mouse
// over symbols in the editor.
"hover_popover_enabled": true,
+ // Whether the cursor blinks in the editor.
+ "cursor_blink": true,
// Whether to pop the completions menu while typing in an editor without
// explicitly requesting it.
"show_completions_on_input": true,
@@ -40,7 +40,7 @@ pub struct AutoUpdater {
current_version: AppVersion,
http_client: Arc<dyn HttpClient>,
pending_poll: Option<Task<()>>,
- db: Arc<project::Db>,
+ db: project::Db,
server_url: String,
}
@@ -55,7 +55,7 @@ impl Entity for AutoUpdater {
}
pub fn init(
- db: Arc<project::Db>,
+ db: project::Db,
http_client: Arc<dyn HttpClient>,
server_url: String,
cx: &mut MutableAppContext,
@@ -116,7 +116,7 @@ impl AutoUpdater {
fn new(
current_version: AppVersion,
- db: Arc<project::Db>,
+ db: project::Db,
http_client: Arc<dyn HttpClient>,
server_url: String,
) -> Self {
@@ -283,9 +283,9 @@ impl AutoUpdater {
let db = self.db.clone();
cx.background().spawn(async move {
if should_show {
- db.write([(SHOULD_SHOW_UPDATE_NOTIFICATION_KEY, "")])?;
+ db.write_kvp(SHOULD_SHOW_UPDATE_NOTIFICATION_KEY, "")?;
} else {
- db.delete([(SHOULD_SHOW_UPDATE_NOTIFICATION_KEY)])?;
+ db.delete_kvp(SHOULD_SHOW_UPDATE_NOTIFICATION_KEY)?;
}
Ok(())
})
@@ -293,8 +293,7 @@ impl AutoUpdater {
fn should_show_update_notification(&self, cx: &AppContext) -> Task<Result<bool>> {
let db = self.db.clone();
- cx.background().spawn(async move {
- Ok(db.read([(SHOULD_SHOW_UPDATE_NOTIFICATION_KEY)])?[0].is_some())
- })
+ cx.background()
+ .spawn(async move { Ok(db.read_kvp(SHOULD_SHOW_UPDATE_NOTIFICATION_KEY)?.is_some()) })
}
}
@@ -8,7 +8,7 @@ use collections::{BTreeMap, HashSet};
use futures::StreamExt;
use gpui::{AsyncAppContext, Entity, ModelContext, ModelHandle, MutableAppContext, Task};
use project::Project;
-use std::sync::Arc;
+use std::{os::unix::prelude::OsStrExt, sync::Arc};
use util::ResultExt;
#[derive(Clone, Debug, PartialEq, Eq)]
@@ -389,6 +389,7 @@ impl Room {
id: worktree.id().to_proto(),
root_name: worktree.root_name().into(),
visible: worktree.is_visible(),
+ abs_path: worktree.abs_path().as_os_str().as_bytes().to_vec(),
}
})
.collect(),
@@ -0,0 +1,20 @@
+[package]
+name = "chat_panel"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+path = "src/chat_panel.rs"
+doctest = false
+
+[dependencies]
+client = { path = "../client" }
+editor = { path = "../editor" }
+gpui = { path = "../gpui" }
+menu = { path = "../menu" }
+settings = { path = "../settings" }
+theme = { path = "../theme" }
+util = { path = "../util" }
+workspace = { path = "../workspace" }
+postage = { version = "0.4.1", features = ["futures-traits"] }
+time = { version = "0.3", features = ["serde", "serde-well-known"] }
@@ -0,0 +1,434 @@
+
+use client::{
+ channel::{Channel, ChannelEvent, ChannelList, ChannelMessage},
+ Client,
+};
+use editor::Editor;
+use gpui::{
+ actions,
+ elements::*,
+ platform::CursorStyle,
+ views::{ItemType, Select, SelectStyle},
+ AnyViewHandle, AppContext, Entity, ModelHandle, MouseButton, MutableAppContext, RenderContext,
+ Subscription, Task, View, ViewContext, ViewHandle,
+};
+use menu::Confirm;
+use postage::prelude::Stream;
+use settings::{Settings, SoftWrap};
+use std::sync::Arc;
+use time::{OffsetDateTime, UtcOffset};
+use util::{ResultExt, TryFutureExt};
+
+const MESSAGE_LOADING_THRESHOLD: usize = 50;
+
+pub struct ChatPanel {
+ rpc: Arc<Client>,
+ channel_list: ModelHandle<ChannelList>,
+ active_channel: Option<(ModelHandle<Channel>, Subscription)>,
+ message_list: ListState,
+ input_editor: ViewHandle<Editor>,
+ channel_select: ViewHandle<Select>,
+ local_timezone: UtcOffset,
+ _observe_status: Task<()>,
+}
+
+pub enum Event {}
+
+actions!(chat_panel, [LoadMoreMessages]);
+
+pub fn init(cx: &mut MutableAppContext) {
+ cx.add_action(ChatPanel::send);
+ cx.add_action(ChatPanel::load_more_messages);
+}
+
+impl ChatPanel {
+ pub fn new(
+ rpc: Arc<Client>,
+ channel_list: ModelHandle<ChannelList>,
+ cx: &mut ViewContext<Self>,
+ ) -> Self {
+ let input_editor = cx.add_view(|cx| {
+ let mut editor =
+ Editor::auto_height(4, Some(|theme| theme.chat_panel.input_editor.clone()), cx);
+ editor.set_soft_wrap_mode(SoftWrap::EditorWidth, cx);
+ editor
+ });
+ let channel_select = cx.add_view(|cx| {
+ let channel_list = channel_list.clone();
+ Select::new(0, cx, {
+ move |ix, item_type, is_hovered, cx| {
+ Self::render_channel_name(
+ &channel_list,
+ ix,
+ item_type,
+ is_hovered,
+ &cx.global::<Settings>().theme.chat_panel.channel_select,
+ cx,
+ )
+ }
+ })
+ .with_style(move |cx| {
+ let theme = &cx.global::<Settings>().theme.chat_panel.channel_select;
+ SelectStyle {
+ header: theme.header.container,
+ menu: theme.menu,
+ }
+ })
+ });
+
+ let mut message_list = ListState::new(0, Orientation::Bottom, 1000., cx, {
+ let this = cx.weak_handle();
+ move |_, ix, cx| {
+ let this = this.upgrade(cx).unwrap().read(cx);
+ let message = this.active_channel.as_ref().unwrap().0.read(cx).message(ix);
+ this.render_message(message, cx)
+ }
+ });
+ message_list.set_scroll_handler(|visible_range, cx| {
+ if visible_range.start < MESSAGE_LOADING_THRESHOLD {
+ cx.dispatch_action(LoadMoreMessages);
+ }
+ });
+ let _observe_status = cx.spawn_weak(|this, mut cx| {
+ let mut status = rpc.status();
+ async move {
+ while (status.recv().await).is_some() {
+ if let Some(this) = this.upgrade(&cx) {
+ this.update(&mut cx, |_, cx| cx.notify());
+ } else {
+ break;
+ }
+ }
+ }
+ });
+
+ let mut this = Self {
+ rpc,
+ channel_list,
+ active_channel: Default::default(),
+ message_list,
+ input_editor,
+ channel_select,
+ local_timezone: cx.platform().local_timezone(),
+ _observe_status,
+ };
+
+ this.init_active_channel(cx);
+ cx.observe(&this.channel_list, |this, _, cx| {
+ this.init_active_channel(cx);
+ })
+ .detach();
+ cx.observe(&this.channel_select, |this, channel_select, cx| {
+ let selected_ix = channel_select.read(cx).selected_index();
+ let selected_channel = this.channel_list.update(cx, |channel_list, cx| {
+ let available_channels = channel_list.available_channels()?;
+ let channel_id = available_channels.get(selected_ix)?.id;
+ channel_list.get_channel(channel_id, cx)
+ });
+ if let Some(selected_channel) = selected_channel {
+ this.set_active_channel(selected_channel, cx);
+ }
+ })
+ .detach();
+
+ this
+ }
+
+ fn init_active_channel(&mut self, cx: &mut ViewContext<Self>) {
+ let (active_channel, channel_count) = self.channel_list.update(cx, |list, cx| {
+ let channel_count;
+ let mut active_channel = None;
+
+ if let Some(available_channels) = list.available_channels() {
+ channel_count = available_channels.len();
+ if self.active_channel.is_none() {
+ if let Some(channel_id) = available_channels.first().map(|channel| channel.id) {
+ active_channel = list.get_channel(channel_id, cx);
+ }
+ }
+ } else {
+ channel_count = 0;
+ }
+
+ (active_channel, channel_count)
+ });
+
+ if let Some(active_channel) = active_channel {
+ self.set_active_channel(active_channel, cx);
+ } else {
+ self.message_list.reset(0);
+ self.active_channel = None;
+ }
+
+ self.channel_select.update(cx, |select, cx| {
+ select.set_item_count(channel_count, cx);
+ });
+ }
+
+ fn set_active_channel(&mut self, channel: ModelHandle<Channel>, cx: &mut ViewContext<Self>) {
+ if self.active_channel.as_ref().map(|e| &e.0) != Some(&channel) {
+ {
+ let channel = channel.read(cx);
+ self.message_list.reset(channel.message_count());
+ let placeholder = format!("Message #{}", channel.name());
+ self.input_editor.update(cx, move |editor, cx| {
+ editor.set_placeholder_text(placeholder, cx);
+ });
+ }
+ let subscription = cx.subscribe(&channel, Self::channel_did_change);
+ self.active_channel = Some((channel, subscription));
+ }
+ }
+
+ fn channel_did_change(
+ &mut self,
+ _: ModelHandle<Channel>,
+ event: &ChannelEvent,
+ cx: &mut ViewContext<Self>,
+ ) {
+ match event {
+ ChannelEvent::MessagesUpdated {
+ old_range,
+ new_count,
+ } => {
+ self.message_list.splice(old_range.clone(), *new_count);
+ }
+ }
+ cx.notify();
+ }
+
+ fn render_channel(&self, cx: &mut RenderContext<Self>) -> ElementBox {
+ let theme = &cx.global::<Settings>().theme;
+ Flex::column()
+ .with_child(
+ Container::new(ChildView::new(&self.channel_select, cx).boxed())
+ .with_style(theme.chat_panel.channel_select.container)
+ .boxed(),
+ )
+ .with_child(self.render_active_channel_messages())
+ .with_child(self.render_input_box(cx))
+ .boxed()
+ }
+
+ fn render_active_channel_messages(&self) -> ElementBox {
+ let messages = if self.active_channel.is_some() {
+ List::new(self.message_list.clone()).boxed()
+ } else {
+ Empty::new().boxed()
+ };
+
+ FlexItem::new(messages).flex(1., true).boxed()
+ }
+
+ fn render_message(&self, message: &ChannelMessage, cx: &AppContext) -> ElementBox {
+ let now = OffsetDateTime::now_utc();
+ let settings = cx.global::<Settings>();
+ let theme = if message.is_pending() {
+ &settings.theme.chat_panel.pending_message
+ } else {
+ &settings.theme.chat_panel.message
+ };
+
+ Container::new(
+ Flex::column()
+ .with_child(
+ Flex::row()
+ .with_child(
+ Container::new(
+ Label::new(
+ message.sender.github_login.clone(),
+ theme.sender.text.clone(),
+ )
+ .boxed(),
+ )
+ .with_style(theme.sender.container)
+ .boxed(),
+ )
+ .with_child(
+ Container::new(
+ Label::new(
+ format_timestamp(message.timestamp, now, self.local_timezone),
+ theme.timestamp.text.clone(),
+ )
+ .boxed(),
+ )
+ .with_style(theme.timestamp.container)
+ .boxed(),
+ )
+ .boxed(),
+ )
+ .with_child(Text::new(message.body.clone(), theme.body.clone()).boxed())
+ .boxed(),
+ )
+ .with_style(theme.container)
+ .boxed()
+ }
+
+ fn render_input_box(&self, cx: &AppContext) -> ElementBox {
+ let theme = &cx.global::<Settings>().theme;
+ Container::new(ChildView::new(&self.input_editor, cx).boxed())
+ .with_style(theme.chat_panel.input_editor.container)
+ .boxed()
+ }
+
+ fn render_channel_name(
+ channel_list: &ModelHandle<ChannelList>,
+ ix: usize,
+ item_type: ItemType,
+ is_hovered: bool,
+ theme: &theme::ChannelSelect,
+ cx: &AppContext,
+ ) -> ElementBox {
+ let channel = &channel_list.read(cx).available_channels().unwrap()[ix];
+ let theme = match (item_type, is_hovered) {
+ (ItemType::Header, _) => &theme.header,
+ (ItemType::Selected, false) => &theme.active_item,
+ (ItemType::Selected, true) => &theme.hovered_active_item,
+ (ItemType::Unselected, false) => &theme.item,
+ (ItemType::Unselected, true) => &theme.hovered_item,
+ };
+ Container::new(
+ Flex::row()
+ .with_child(
+ Container::new(Label::new("#".to_string(), theme.hash.text.clone()).boxed())
+ .with_style(theme.hash.container)
+ .boxed(),
+ )
+ .with_child(Label::new(channel.name.clone(), theme.name.clone()).boxed())
+ .boxed(),
+ )
+ .with_style(theme.container)
+ .boxed()
+ }
+
+ fn render_sign_in_prompt(&self, cx: &mut RenderContext<Self>) -> ElementBox {
+ let theme = cx.global::<Settings>().theme.clone();
+ let rpc = self.rpc.clone();
+ let this = cx.handle();
+
+ enum SignInPromptLabel {}
+
+ Align::new(
+ MouseEventHandler::<SignInPromptLabel>::new(0, cx, |mouse_state, _| {
+ Label::new(
+ "Sign in to use chat".to_string(),
+ if mouse_state.hovered() {
+ theme.chat_panel.hovered_sign_in_prompt.clone()
+ } else {
+ theme.chat_panel.sign_in_prompt.clone()
+ },
+ )
+ .boxed()
+ })
+ .with_cursor_style(CursorStyle::PointingHand)
+ .on_click(MouseButton::Left, move |_, cx| {
+ let rpc = rpc.clone();
+ let this = this.clone();
+ cx.spawn(|mut cx| async move {
+ if rpc
+ .authenticate_and_connect(true, &cx)
+ .log_err()
+ .await
+ .is_some()
+ {
+ cx.update(|cx| {
+ if let Some(this) = this.upgrade(cx) {
+ if this.is_focused(cx) {
+ this.update(cx, |this, cx| cx.focus(&this.input_editor));
+ }
+ }
+ })
+ }
+ })
+ .detach();
+ })
+ .boxed(),
+ )
+ .boxed()
+ }
+
+ fn send(&mut self, _: &Confirm, cx: &mut ViewContext<Self>) {
+ if let Some((channel, _)) = self.active_channel.as_ref() {
+ let body = self.input_editor.update(cx, |editor, cx| {
+ let body = editor.text(cx);
+ editor.clear(cx);
+ body
+ });
+
+ if let Some(task) = channel
+ .update(cx, |channel, cx| channel.send_message(body, cx))
+ .log_err()
+ {
+ task.detach();
+ }
+ }
+ }
+
+ fn load_more_messages(&mut self, _: &LoadMoreMessages, cx: &mut ViewContext<Self>) {
+ if let Some((channel, _)) = self.active_channel.as_ref() {
+ channel.update(cx, |channel, cx| {
+ channel.load_more_messages(cx);
+ })
+ }
+ }
+}
+
+impl Entity for ChatPanel {
+ type Event = Event;
+}
+
+impl View for ChatPanel {
+ fn ui_name() -> &'static str {
+ "ChatPanel"
+ }
+
+ fn render(&mut self, cx: &mut RenderContext<Self>) -> ElementBox {
+ let element = if self.rpc.user_id().is_some() {
+ self.render_channel(cx)
+ } else {
+ self.render_sign_in_prompt(cx)
+ };
+ let theme = &cx.global::<Settings>().theme;
+ ConstrainedBox::new(
+ Container::new(element)
+ .with_style(theme.chat_panel.container)
+ .boxed(),
+ )
+ .with_min_width(150.)
+ .boxed()
+ }
+
+ fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+ if matches!(
+ *self.rpc.status().borrow(),
+ client::Status::Connected { .. }
+ ) {
+ cx.focus(&self.input_editor);
+ }
+ }
+}
+
+fn format_timestamp(
+ mut timestamp: OffsetDateTime,
+ mut now: OffsetDateTime,
+ local_timezone: UtcOffset,
+) -> String {
+ timestamp = timestamp.to_offset(local_timezone);
+ now = now.to_offset(local_timezone);
+
+ let today = now.date();
+ let date = timestamp.date();
+ let mut hour = timestamp.hour();
+ let mut part = "am";
+ if hour > 12 {
+ hour -= 12;
+ part = "pm";
+ }
+ if date == today {
+ format!("{:02}:{:02}{}", hour, timestamp.minute(), part)
+ } else if date.next_day() == Some(today) {
+ format!("yesterday at {:02}:{:02}{}", hour, timestamp.minute(), part)
+ } else {
+ format!("{:02}/{}/{}", date.month() as u32, date.day(), date.year())
+ }
+}
@@ -143,11 +143,16 @@ pub enum Status {
Authenticating,
Connecting,
ConnectionError,
- Connected { connection_id: ConnectionId },
+ Connected {
+ peer_id: PeerId,
+ connection_id: ConnectionId,
+ },
ConnectionLost,
Reauthenticating,
Reconnecting,
- ReconnectionError { next_reconnection: Instant },
+ ReconnectionError {
+ next_reconnection: Instant,
+ },
}
impl Status {
@@ -314,6 +319,14 @@ impl Client {
.map(|credentials| credentials.user_id)
}
+ pub fn peer_id(&self) -> Option<PeerId> {
+ if let Status::Connected { peer_id, .. } = &*self.status().borrow() {
+ Some(*peer_id)
+ } else {
+ None
+ }
+ }
+
pub fn status(&self) -> watch::Receiver<Status> {
self.state.read().status.1.clone()
}
@@ -663,6 +676,7 @@ impl Client {
self.set_status(Status::Reconnecting, cx);
}
+ let mut timeout = cx.background().timer(CONNECTION_TIMEOUT).fuse();
futures::select_biased! {
connection = self.establish_connection(&credentials, cx).fuse() => {
match connection {
@@ -671,8 +685,14 @@ impl Client {
if !read_from_keychain && IMPERSONATE_LOGIN.is_none() {
write_credentials_to_keychain(&credentials, cx).log_err();
}
- self.set_connection(conn, cx);
- Ok(())
+
+ futures::select_biased! {
+ result = self.set_connection(conn, cx).fuse() => result,
+ _ = timeout => {
+ self.set_status(Status::ConnectionError, cx);
+ Err(anyhow!("timed out waiting on hello message from server"))
+ }
+ }
}
Err(EstablishConnectionError::Unauthorized) => {
self.state.write().credentials.take();
@@ -695,21 +715,65 @@ impl Client {
}
}
}
- _ = cx.background().timer(CONNECTION_TIMEOUT).fuse() => {
+ _ = &mut timeout => {
self.set_status(Status::ConnectionError, cx);
Err(anyhow!("timed out trying to establish connection"))
}
}
}
- fn set_connection(self: &Arc<Self>, conn: Connection, cx: &AsyncAppContext) {
+ async fn set_connection(
+ self: &Arc<Self>,
+ conn: Connection,
+ cx: &AsyncAppContext,
+ ) -> Result<()> {
let executor = cx.background();
log::info!("add connection to peer");
let (connection_id, handle_io, mut incoming) = self
.peer
.add_connection(conn, move |duration| executor.timer(duration));
- log::info!("set status to connected {}", connection_id);
- self.set_status(Status::Connected { connection_id }, cx);
+ let handle_io = cx.background().spawn(handle_io);
+
+ let peer_id = async {
+ log::info!("waiting for server hello");
+ let message = incoming
+ .next()
+ .await
+ .ok_or_else(|| anyhow!("no hello message received"))?;
+ log::info!("got server hello");
+ let hello_message_type_name = message.payload_type_name().to_string();
+ let hello = message
+ .into_any()
+ .downcast::<TypedEnvelope<proto::Hello>>()
+ .map_err(|_| {
+ anyhow!(
+ "invalid hello message received: {:?}",
+ hello_message_type_name
+ )
+ })?;
+ Ok(PeerId(hello.payload.peer_id))
+ };
+
+ let peer_id = match peer_id.await {
+ Ok(peer_id) => peer_id,
+ Err(error) => {
+ self.peer.disconnect(connection_id);
+ return Err(error);
+ }
+ };
+
+ log::info!(
+ "set status to connected (connection id: {}, peer id: {})",
+ connection_id,
+ peer_id
+ );
+ self.set_status(
+ Status::Connected {
+ peer_id,
+ connection_id,
+ },
+ cx,
+ );
cx.foreground()
.spawn({
let cx = cx.clone();
@@ -807,14 +871,18 @@ impl Client {
})
.detach();
- let handle_io = cx.background().spawn(handle_io);
let this = self.clone();
let cx = cx.clone();
cx.foreground()
.spawn(async move {
match handle_io.await {
Ok(()) => {
- if *this.status().borrow() == (Status::Connected { connection_id }) {
+ if *this.status().borrow()
+ == (Status::Connected {
+ connection_id,
+ peer_id,
+ })
+ {
this.set_status(Status::SignedOut, &cx);
}
}
@@ -825,6 +893,8 @@ impl Client {
}
})
.detach();
+
+ Ok(())
}
fn authenticate(self: &Arc<Self>, cx: &AsyncAppContext) -> Task<Result<Credentials>> {
@@ -1072,7 +1142,7 @@ impl Client {
self.peer.respond_with_error(receipt, error)
}
- pub fn start_telemetry(&self, db: Arc<Db>) {
+ pub fn start_telemetry(&self, db: Db) {
self.telemetry.start(db);
}
@@ -135,22 +135,16 @@ impl Telemetry {
Some(self.state.lock().log_file.as_ref()?.path().to_path_buf())
}
- pub fn start(self: &Arc<Self>, db: Arc<Db>) {
+ pub fn start(self: &Arc<Self>, db: Db) {
let this = self.clone();
self.executor
.spawn(
async move {
- let device_id = if let Some(device_id) = db
- .read(["device_id"])?
- .into_iter()
- .flatten()
- .next()
- .and_then(|bytes| String::from_utf8(bytes).ok())
- {
+ let device_id = if let Ok(Some(device_id)) = db.read_kvp("device_id") {
device_id
} else {
let device_id = Uuid::new_v4().to_string();
- db.write([("device_id", device_id.as_bytes())])?;
+ db.write_kvp("device_id", &device_id)?;
device_id
};
@@ -84,9 +84,19 @@ impl FakeServer {
let (connection_id, io, incoming) =
peer.add_test_connection(server_conn, cx.background());
cx.background().spawn(io).detach();
- let mut state = state.lock();
- state.connection_id = Some(connection_id);
- state.incoming = Some(incoming);
+ {
+ let mut state = state.lock();
+ state.connection_id = Some(connection_id);
+ state.incoming = Some(incoming);
+ }
+ peer.send(
+ connection_id,
+ proto::Hello {
+ peer_id: connection_id.0,
+ },
+ )
+ .unwrap();
+
Ok(client_conn)
})
}
@@ -8,15 +8,18 @@ use anyhow::anyhow;
use call::{room, ActiveCall, ParticipantLocation, Room};
use client::{
self, test::FakeHttpClient, Channel, ChannelDetails, ChannelList, Client, Connection,
- Credentials, EstablishConnectionError, User, UserStore, RECEIVE_TIMEOUT,
+ Credentials, EstablishConnectionError, PeerId, User, UserStore, RECEIVE_TIMEOUT,
};
use collections::{BTreeMap, HashMap, HashSet};
use editor::{
self, ConfirmCodeAction, ConfirmCompletion, ConfirmRename, Editor, Redo, Rename, ToOffset,
ToggleCodeActions, Undo,
};
-use fs::{FakeFs, Fs as _, LineEnding};
-use futures::{channel::mpsc, Future, StreamExt as _};
+use fs::{FakeFs, Fs as _, HomeDir, LineEnding};
+use futures::{
+ channel::{mpsc, oneshot},
+ Future, StreamExt as _,
+};
use gpui::{
executor::{self, Deterministic},
geometry::vector::vec2f,
@@ -34,7 +37,6 @@ use project::{
ProjectStore, WorktreeId,
};
use rand::prelude::*;
-use rpc::PeerId;
use serde_json::json;
use settings::{Formatter, Settings};
use sqlx::types::time::OffsetDateTime;
@@ -385,7 +387,7 @@ async fn test_leaving_room_on_disconnection(
);
// When user A disconnects, both client A and B clear their room on the active call.
- server.disconnect_client(client_a.current_user_id(cx_a));
+ server.disconnect_client(client_a.peer_id().unwrap());
cx_a.foreground().advance_clock(rpc::RECEIVE_TIMEOUT);
active_call_a.read_with(cx_a, |call, _| assert!(call.room().is_none()));
active_call_b.read_with(cx_b, |call, _| assert!(call.room().is_none()));
@@ -416,7 +418,7 @@ async fn test_calls_on_multiple_connections(
let mut server = TestServer::start(cx_a.foreground(), cx_a.background()).await;
let client_a = server.create_client(cx_a, "user_a").await;
let client_b1 = server.create_client(cx_b1, "user_b").await;
- let _client_b2 = server.create_client(cx_b2, "user_b").await;
+ let client_b2 = server.create_client(cx_b2, "user_b").await;
server
.make_contacts(&mut [(&client_a, cx_a), (&client_b1, cx_b1)])
.await;
@@ -468,6 +470,14 @@ async fn test_calls_on_multiple_connections(
assert!(incoming_call_b1.next().await.unwrap().is_none());
assert!(incoming_call_b2.next().await.unwrap().is_none());
+ // User B disconnects the client that is not on the call. Everything should be fine.
+ client_b1.disconnect(&cx_b1.to_async()).unwrap();
+ deterministic.advance_clock(rpc::RECEIVE_TIMEOUT);
+ client_b1
+ .authenticate_and_connect(false, &cx_b1.to_async())
+ .await
+ .unwrap();
+
// User B hangs up, and user A calls them again.
active_call_b2.update(cx_b2, |call, cx| call.hang_up(cx).unwrap());
deterministic.run_until_parked();
@@ -520,11 +530,29 @@ async fn test_calls_on_multiple_connections(
assert!(incoming_call_b1.next().await.unwrap().is_some());
assert!(incoming_call_b2.next().await.unwrap().is_some());
- // User A disconnects up, causing both connections to stop ringing.
- server.disconnect_client(client_a.current_user_id(cx_a));
- cx_a.foreground().advance_clock(rpc::RECEIVE_TIMEOUT);
+ // User A disconnects, causing both connections to stop ringing.
+ server.disconnect_client(client_a.peer_id().unwrap());
+ deterministic.advance_clock(rpc::RECEIVE_TIMEOUT);
assert!(incoming_call_b1.next().await.unwrap().is_none());
assert!(incoming_call_b2.next().await.unwrap().is_none());
+
+ // User A reconnects automatically, then calls user B again.
+ active_call_a
+ .update(cx_a, |call, cx| {
+ call.invite(client_b1.user_id().unwrap(), None, cx)
+ })
+ .await
+ .unwrap();
+ deterministic.run_until_parked();
+ assert!(incoming_call_b1.next().await.unwrap().is_some());
+ assert!(incoming_call_b2.next().await.unwrap().is_some());
+
+ // User B disconnects all clients, causing user A to no longer see a pending call for them.
+ server.forbid_connections();
+ server.disconnect_client(client_b1.peer_id().unwrap());
+ server.disconnect_client(client_b2.peer_id().unwrap());
+ deterministic.advance_clock(rpc::RECEIVE_TIMEOUT);
+ active_call_a.read_with(cx_a, |call, _| assert!(call.room().is_none()));
}
#[gpui::test(iterations = 10)]
@@ -582,7 +610,7 @@ async fn test_share_project(
.update(cx_b, |call, cx| call.accept_incoming(cx))
.await
.unwrap();
- let client_b_peer_id = client_b.peer_id;
+ let client_b_peer_id = client_b.peer_id().unwrap();
let project_b = client_b
.build_remote_project(initial_project.id, cx_b)
.await;
@@ -806,7 +834,7 @@ async fn test_host_disconnect(
assert!(cx_b.is_window_edited(workspace_b.window_id()));
// Drop client A's connection. Collaborators should disappear and the project should not be shown as shared.
- server.disconnect_client(client_a.current_user_id(cx_a));
+ server.disconnect_client(client_a.peer_id().unwrap());
deterministic.advance_clock(rpc::RECEIVE_TIMEOUT);
project_a
.condition(cx_a, |project, _| project.collaborators().is_empty())
@@ -849,7 +877,7 @@ async fn test_host_disconnect(
.unwrap();
// Drop client A's connection again. We should still unshare it successfully.
- server.disconnect_client(client_a.current_user_id(cx_a));
+ server.disconnect_client(client_a.peer_id().unwrap());
deterministic.advance_clock(rpc::RECEIVE_TIMEOUT);
project_a.read_with(cx_a, |project, _| assert!(!project.is_shared()));
}
@@ -2150,7 +2178,7 @@ async fn test_leaving_project(
// Simulate connection loss for client C and ensure client A observes client C leaving the project.
client_c.wait_for_current_user(cx_c).await;
- server.disconnect_client(client_c.current_user_id(cx_c));
+ server.disconnect_client(client_c.peer_id().unwrap());
cx_a.foreground().advance_clock(rpc::RECEIVE_TIMEOUT);
deterministic.run_until_parked();
project_a.read_with(cx_a, |project, _| {
@@ -3038,7 +3066,7 @@ async fn test_references(cx_a: &mut TestAppContext, cx_b: &mut TestAppContext) {
assert_eq!(references[1].buffer, references[0].buffer);
assert_eq!(
three_buffer.file().unwrap().full_path(cx),
- Path::new("three.rs")
+ Path::new("/root/dir-2/three.rs")
);
assert_eq!(references[0].range.to_offset(two_buffer), 24..27);
@@ -4313,7 +4341,7 @@ async fn test_chat_reconnection(cx_a: &mut TestAppContext, cx_b: &mut TestAppCon
// Disconnect client B, ensuring we can still access its cached channel data.
server.forbid_connections();
- server.disconnect_client(client_b.current_user_id(cx_b));
+ server.disconnect_client(client_b.peer_id().unwrap());
cx_b.foreground().advance_clock(rpc::RECEIVE_TIMEOUT);
while !matches!(
status_b.next().await,
@@ -4476,7 +4504,7 @@ async fn test_contacts(
]
);
- server.disconnect_client(client_c.current_user_id(cx_c));
+ server.disconnect_client(client_c.peer_id().unwrap());
server.forbid_connections();
deterministic.advance_clock(rpc::RECEIVE_TIMEOUT);
assert_eq!(
@@ -4716,7 +4744,7 @@ async fn test_contacts(
);
server.forbid_connections();
- server.disconnect_client(client_a.current_user_id(cx_a));
+ server.disconnect_client(client_a.peer_id().unwrap());
deterministic.advance_clock(rpc::RECEIVE_TIMEOUT);
assert_eq!(contacts(&client_a, cx_a), []);
assert_eq!(
@@ -5626,6 +5654,7 @@ async fn test_random_collaboration(
let mut clients = Vec::new();
let mut user_ids = Vec::new();
+ let mut peer_ids = Vec::new();
let mut op_start_signals = Vec::new();
let mut next_entity_id = 100000;
@@ -5814,6 +5843,7 @@ async fn test_random_collaboration(
let op_start_signal = futures::channel::mpsc::unbounded();
user_ids.push(host_user_id);
+ peer_ids.push(host.peer_id().unwrap());
op_start_signals.push(op_start_signal.0);
clients.push(host_cx.foreground().spawn(host.simulate_host(
host_project,
@@ -5831,7 +5861,7 @@ async fn test_random_collaboration(
let mut operations = 0;
while operations < max_operations {
if operations == disconnect_host_at {
- server.disconnect_client(user_ids[0]);
+ server.disconnect_client(peer_ids[0]);
deterministic.advance_clock(RECEIVE_TIMEOUT);
drop(op_start_signals);
@@ -5914,6 +5944,7 @@ async fn test_random_collaboration(
let op_start_signal = futures::channel::mpsc::unbounded();
user_ids.push(guest_user_id);
+ peer_ids.push(guest.peer_id().unwrap());
op_start_signals.push(op_start_signal.0);
clients.push(guest_cx.foreground().spawn(guest.simulate_guest(
guest_username.clone(),
@@ -5930,10 +5961,11 @@ async fn test_random_collaboration(
let guest_ix = rng.lock().gen_range(1..clients.len());
log::info!("Removing guest {}", user_ids[guest_ix]);
let removed_guest_id = user_ids.remove(guest_ix);
+ let removed_peer_id = peer_ids.remove(guest_ix);
let guest = clients.remove(guest_ix);
op_start_signals.remove(guest_ix);
server.forbid_connections();
- server.disconnect_client(removed_guest_id);
+ server.disconnect_client(removed_peer_id);
deterministic.advance_clock(RECEIVE_TIMEOUT);
deterministic.start_waiting();
log::info!("Waiting for guest {} to exit...", removed_guest_id);
@@ -6057,8 +6089,10 @@ async fn test_random_collaboration(
let host_buffer = host_project.read_with(&host_cx, |project, cx| {
project.buffer_for_id(buffer_id, cx).unwrap_or_else(|| {
panic!(
- "host does not have buffer for guest:{}, peer:{}, id:{}",
- guest_client.username, guest_client.peer_id, buffer_id
+ "host does not have buffer for guest:{}, peer:{:?}, id:{}",
+ guest_client.username,
+ guest_client.peer_id(),
+ buffer_id
)
})
});
@@ -6101,7 +6135,7 @@ struct TestServer {
server: Arc<Server>,
foreground: Rc<executor::Foreground>,
notifications: mpsc::UnboundedReceiver<()>,
- connection_killers: Arc<Mutex<HashMap<UserId, Arc<AtomicBool>>>>,
+ connection_killers: Arc<Mutex<HashMap<PeerId, Arc<AtomicBool>>>>,
forbid_connections: Arc<AtomicBool>,
_test_db: TestDb,
}
@@ -6130,6 +6164,8 @@ impl TestServer {
async fn create_client(&mut self, cx: &mut TestAppContext, name: &str) -> TestClient {
cx.update(|cx| {
+ cx.set_global(HomeDir(Path::new("/tmp/").to_path_buf()));
+
let mut settings = Settings::test(cx);
settings.projects_online_by_default = false;
cx.set_global(settings);
@@ -6165,7 +6201,6 @@ impl TestServer {
let db = self.app_state.db.clone();
let connection_killers = self.connection_killers.clone();
let forbid_connections = self.forbid_connections.clone();
- let (connection_id_tx, mut connection_id_rx) = mpsc::channel(16);
Arc::get_mut(&mut client)
.unwrap()
@@ -6188,7 +6223,6 @@ impl TestServer {
let connection_killers = connection_killers.clone();
let forbid_connections = forbid_connections.clone();
let client_name = client_name.clone();
- let connection_id_tx = connection_id_tx.clone();
cx.spawn(move |cx| async move {
if forbid_connections.load(SeqCst) {
Err(EstablishConnectionError::other(anyhow!(
@@ -6197,7 +6231,7 @@ impl TestServer {
} else {
let (client_conn, server_conn, killed) =
Connection::in_memory(cx.background());
- connection_killers.lock().insert(user_id, killed);
+ let (connection_id_tx, connection_id_rx) = oneshot::channel();
let user = db.get_user_by_id(user_id).await.unwrap().unwrap();
cx.background()
.spawn(server.handle_connection(
@@ -6208,6 +6242,10 @@ impl TestServer {
cx.background(),
))
.detach();
+ let connection_id = connection_id_rx.await.unwrap();
+ connection_killers
+ .lock()
+ .insert(PeerId(connection_id.0), killed);
Ok(client_conn)
}
})
@@ -6239,11 +6277,9 @@ impl TestServer {
.authenticate_and_connect(false, &cx.to_async())
.await
.unwrap();
- let peer_id = PeerId(connection_id_rx.next().await.unwrap().0);
let client = TestClient {
client,
- peer_id,
username: name.to_string(),
user_store,
project_store,
@@ -6255,10 +6291,10 @@ impl TestServer {
client
}
- fn disconnect_client(&self, user_id: UserId) {
+ fn disconnect_client(&self, peer_id: PeerId) {
self.connection_killers
.lock()
- .remove(&user_id)
+ .remove(&peer_id)
.unwrap()
.store(true, SeqCst);
}
@@ -6359,7 +6395,6 @@ impl Drop for TestServer {
struct TestClient {
client: Arc<Client>,
username: String,
- pub peer_id: PeerId,
pub user_store: ModelHandle<UserStore>,
pub project_store: ModelHandle<ProjectStore>,
language_registry: Arc<LanguageRegistry>,
@@ -24,7 +24,7 @@ use axum::{
};
use collections::{HashMap, HashSet};
use futures::{
- channel::mpsc,
+ channel::{mpsc, oneshot},
future::{self, BoxFuture},
stream::FuturesUnordered,
FutureExt, SinkExt, StreamExt, TryStreamExt,
@@ -42,6 +42,7 @@ use std::{
marker::PhantomData,
net::SocketAddr,
ops::{Deref, DerefMut},
+ os::unix::prelude::OsStrExt,
rc::Rc,
sync::{
atomic::{AtomicBool, Ordering::SeqCst},
@@ -347,7 +348,7 @@ impl Server {
connection: Connection,
address: String,
user: User,
- mut send_connection_id: Option<mpsc::Sender<ConnectionId>>,
+ mut send_connection_id: Option<oneshot::Sender<ConnectionId>>,
executor: E,
) -> impl Future<Output = Result<()>> {
let mut this = self.clone();
@@ -368,9 +369,11 @@ impl Server {
});
tracing::info!(%user_id, %login, %connection_id, %address, "connection opened");
+ this.peer.send(connection_id, proto::Hello { peer_id: connection_id.0 })?;
+ tracing::info!(%user_id, %login, %connection_id, %address, "sent hello message");
- if let Some(send_connection_id) = send_connection_id.as_mut() {
- let _ = send_connection_id.send(connection_id).await;
+ if let Some(send_connection_id) = send_connection_id.take() {
+ let _ = send_connection_id.send(connection_id);
}
if !user.connected_once {
@@ -476,6 +479,10 @@ impl Server {
let mut contacts_to_update = HashSet::default();
{
let mut store = self.store().await;
+
+ #[cfg(test)]
+ let removed_connection = store.remove_connection(connection_id).unwrap();
+ #[cfg(not(test))]
let removed_connection = store.remove_connection(connection_id)?;
for project in removed_connection.hosted_projects {
@@ -941,6 +948,7 @@ impl Server {
id: *id,
root_name: worktree.root_name.clone(),
visible: worktree.visible,
+ abs_path: worktree.abs_path.as_os_str().as_bytes().to_vec(),
})
.collect::<Vec<_>>();
@@ -989,6 +997,7 @@ impl Server {
let message = proto::UpdateWorktree {
project_id: project_id.to_proto(),
worktree_id: *worktree_id,
+ abs_path: worktree.abs_path.as_os_str().as_bytes().to_vec(),
root_name: worktree.root_name.clone(),
updated_entries: worktree.entries.values().cloned().collect(),
removed_entries: Default::default(),
@@ -66,6 +66,7 @@ pub struct Collaborator {
#[derive(Default, Serialize)]
pub struct Worktree {
+ pub abs_path: PathBuf,
pub root_name: String,
pub visible: bool,
#[serde(skip)]
@@ -214,11 +215,16 @@ impl Store {
let connected_user = self.connected_users.get(&user_id).unwrap();
if let Some(active_call) = connected_user.active_call.as_ref() {
let room_id = active_call.room_id;
- let left_room = self.leave_room(room_id, connection_id)?;
- result.hosted_projects = left_room.unshared_projects;
- result.guest_projects = left_room.left_projects;
- result.room_id = Some(room_id);
- result.canceled_call_connection_ids = left_room.canceled_call_connection_ids;
+ if active_call.connection_id == Some(connection_id) {
+ let left_room = self.leave_room(room_id, connection_id)?;
+ result.hosted_projects = left_room.unshared_projects;
+ result.guest_projects = left_room.left_projects;
+ result.room_id = Some(room_id);
+ result.canceled_call_connection_ids = left_room.canceled_call_connection_ids;
+ } else if connected_user.connection_ids.len() == 1 {
+ self.decline_call(room_id, connection_id)?;
+ result.room_id = Some(room_id);
+ }
}
let connected_user = self.connected_users.get_mut(&user_id).unwrap();
@@ -526,18 +526,6 @@ impl Element for AvatarRibbon {
cx.scene.push_path(path.build(self.color, None));
}
- fn dispatch_event(
- &mut self,
- _: &gpui::Event,
- _: RectF,
- _: RectF,
- _: &mut Self::LayoutState,
- _: &mut Self::PaintState,
- _: &mut gpui::EventContext,
- ) -> bool {
- false
- }
-
fn rect_for_text_range(
&self,
_: Range<usize>,
@@ -36,7 +36,7 @@ impl View for ContactFinder {
ChildView::new(self.picker.clone(), cx).boxed()
}
- fn on_focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+ fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
if cx.is_self_focused() {
cx.focus(&self.picker);
}
@@ -1121,13 +1121,13 @@ impl View for ContactList {
.boxed()
}
- fn on_focus_in(&mut self, _: gpui::AnyViewHandle, cx: &mut ViewContext<Self>) {
+ fn focus_in(&mut self, _: gpui::AnyViewHandle, cx: &mut ViewContext<Self>) {
if !self.filter_editor.is_focused(cx) {
cx.focus(&self.filter_editor);
}
}
- fn on_focus_out(&mut self, _: gpui::AnyViewHandle, cx: &mut ViewContext<Self>) {
+ fn focus_out(&mut self, _: gpui::AnyViewHandle, cx: &mut ViewContext<Self>) {
if !self.filter_editor.is_focused(cx) {
cx.emit(Event::Dismissed);
}
@@ -160,7 +160,7 @@ impl View for ContactsPopover {
.boxed()
}
- fn on_focus_in(&mut self, _: gpui::AnyViewHandle, cx: &mut ViewContext<Self>) {
+ fn focus_in(&mut self, _: gpui::AnyViewHandle, cx: &mut ViewContext<Self>) {
if cx.is_self_focused() {
match &self.child {
Child::ContactList(child) => cx.focus(child),
@@ -135,7 +135,7 @@ impl View for CommandPalette {
ChildView::new(self.picker.clone(), cx).boxed()
}
- fn on_focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+ fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
if cx.is_self_focused() {
cx.focus(&self.picker);
}
@@ -107,7 +107,7 @@ impl View for ContextMenu {
.boxed()
}
- fn on_focus_out(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+ fn focus_out(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
self.reset(cx);
}
}
@@ -315,13 +315,16 @@ impl ContextMenu {
fn render_menu(&self, cx: &mut RenderContext<Self>) -> impl Element {
enum Menu {}
enum MenuItem {}
+
let style = cx.global::<Settings>().theme.context_menu.clone();
+
MouseEventHandler::<Menu>::new(0, cx, |_, cx| {
Flex::column()
.with_children(self.items.iter().enumerate().map(|(ix, item)| {
match item {
ContextMenuItem::Item { label, action } => {
let action = action.boxed_clone();
+
MouseEventHandler::<MenuItem>::new(ix, cx, |state, _| {
let style =
style.item.style_for(state, Some(ix) == self.selected_index);
@@ -350,6 +353,7 @@ impl ContextMenu {
cx.dispatch_action(Clicked);
cx.dispatch_any_action(action.boxed_clone());
})
+ .on_drag(MouseButton::Left, |_, _| {})
.boxed()
}
ContextMenuItem::Separator => Empty::new()
@@ -14,8 +14,13 @@ test-support = []
collections = { path = "../collections" }
anyhow = "1.0.57"
async-trait = "0.1"
+lazy_static = "1.4.0"
+log = { version = "0.4.16", features = ["kv_unstable_serde"] }
parking_lot = "0.11.1"
-rocksdb = "0.18"
+rusqlite = { version = "0.28.0", features = ["bundled", "serde_json"] }
+rusqlite_migration = "1.0.0"
+serde = { workspace = true }
+serde_rusqlite = "0.31.0"
[dev-dependencies]
gpui = { path = "../gpui", features = ["test-support"] }
@@ -1,161 +1,119 @@
-use anyhow::Result;
-use std::path::Path;
+mod kvp;
+mod migrations;
+
+use std::fs;
+use std::path::{Path, PathBuf};
use std::sync::Arc;
-pub struct Db(DbStore);
+use anyhow::Result;
+use log::error;
+use parking_lot::Mutex;
+use rusqlite::Connection;
+
+use migrations::MIGRATIONS;
-enum DbStore {
+#[derive(Clone)]
+pub enum Db {
+ Real(Arc<RealDb>),
Null,
- Real(rocksdb::DB),
+}
- #[cfg(any(test, feature = "test-support"))]
- Fake {
- data: parking_lot::Mutex<collections::HashMap<Vec<u8>, Vec<u8>>>,
- },
+pub struct RealDb {
+ connection: Mutex<Connection>,
+ path: Option<PathBuf>,
}
impl Db {
- /// Open or create a database at the given file path.
- pub fn open(path: &Path) -> Result<Arc<Self>> {
- let db = rocksdb::DB::open_default(path)?;
- Ok(Arc::new(Self(DbStore::Real(db))))
+ /// Open or create a database at the given directory path.
+ pub fn open(db_dir: &Path) -> Self {
+ // Use 0 for now. Will implement incrementing and clearing of old db files soon TM
+ let current_db_dir = db_dir.join(Path::new("0"));
+ fs::create_dir_all(¤t_db_dir)
+ .expect("Should be able to create the database directory");
+ let db_path = current_db_dir.join(Path::new("db.sqlite"));
+
+ Connection::open(db_path)
+ .map_err(Into::into)
+ .and_then(|connection| Self::initialize(connection))
+ .map(|connection| {
+ Db::Real(Arc::new(RealDb {
+ connection,
+ path: Some(db_dir.to_path_buf()),
+ }))
+ })
+ .unwrap_or_else(|e| {
+ error!(
+ "Connecting to file backed db failed. Reverting to null db. {}",
+ e
+ );
+ Self::Null
+ })
}
- /// Open a null database that stores no data, for use as a fallback
- /// when there is an error opening the real database.
- pub fn null() -> Arc<Self> {
- Arc::new(Self(DbStore::Null))
- }
-
- /// Open a fake database for testing.
+ /// Open a in memory database for testing and as a fallback.
#[cfg(any(test, feature = "test-support"))]
- pub fn open_fake() -> Arc<Self> {
- Arc::new(Self(DbStore::Fake {
- data: Default::default(),
- }))
+ pub fn open_in_memory() -> Self {
+ Connection::open_in_memory()
+ .map_err(Into::into)
+ .and_then(|connection| Self::initialize(connection))
+ .map(|connection| {
+ Db::Real(Arc::new(RealDb {
+ connection,
+ path: None,
+ }))
+ })
+ .unwrap_or_else(|e| {
+ error!(
+ "Connecting to in memory db failed. Reverting to null db. {}",
+ e
+ );
+ Self::Null
+ })
}
- pub fn read<K, I>(&self, keys: I) -> Result<Vec<Option<Vec<u8>>>>
- where
- K: AsRef<[u8]>,
- I: IntoIterator<Item = K>,
- {
- match &self.0 {
- DbStore::Real(db) => db
- .multi_get(keys)
- .into_iter()
- .map(|e| e.map_err(Into::into))
- .collect(),
-
- DbStore::Null => Ok(keys.into_iter().map(|_| None).collect()),
-
- #[cfg(any(test, feature = "test-support"))]
- DbStore::Fake { data: db } => {
- let db = db.lock();
- Ok(keys
- .into_iter()
- .map(|key| db.get(key.as_ref()).cloned())
- .collect())
- }
- }
- }
+ fn initialize(mut conn: Connection) -> Result<Mutex<Connection>> {
+ MIGRATIONS.to_latest(&mut conn)?;
- pub fn delete<K, I>(&self, keys: I) -> Result<()>
- where
- K: AsRef<[u8]>,
- I: IntoIterator<Item = K>,
- {
- match &self.0 {
- DbStore::Real(db) => {
- let mut batch = rocksdb::WriteBatch::default();
- for key in keys {
- batch.delete(key);
- }
- db.write(batch)?;
- }
+ conn.pragma_update(None, "journal_mode", "WAL")?;
+ conn.pragma_update(None, "synchronous", "NORMAL")?;
+ conn.pragma_update(None, "foreign_keys", true)?;
+ conn.pragma_update(None, "case_sensitive_like", true)?;
- DbStore::Null => {}
+ Ok(Mutex::new(conn))
+ }
- #[cfg(any(test, feature = "test-support"))]
- DbStore::Fake { data: db } => {
- let mut db = db.lock();
- for key in keys {
- db.remove(key.as_ref());
- }
- }
- }
- Ok(())
+ pub fn persisting(&self) -> bool {
+ self.real().and_then(|db| db.path.as_ref()).is_some()
}
- pub fn write<K, V, I>(&self, entries: I) -> Result<()>
- where
- K: AsRef<[u8]>,
- V: AsRef<[u8]>,
- I: IntoIterator<Item = (K, V)>,
- {
- match &self.0 {
- DbStore::Real(db) => {
- let mut batch = rocksdb::WriteBatch::default();
- for (key, value) in entries {
- batch.put(key, value);
- }
- db.write(batch)?;
- }
+ pub fn real(&self) -> Option<&RealDb> {
+ match self {
+ Db::Real(db) => Some(&db),
+ _ => None,
+ }
+ }
+}
- DbStore::Null => {}
+impl Drop for Db {
+ fn drop(&mut self) {
+ match self {
+ Db::Real(real_db) => {
+ let lock = real_db.connection.lock();
- #[cfg(any(test, feature = "test-support"))]
- DbStore::Fake { data: db } => {
- let mut db = db.lock();
- for (key, value) in entries {
- db.insert(key.as_ref().into(), value.as_ref().into());
- }
+ let _ = lock.pragma_update(None, "analysis_limit", "500");
+ let _ = lock.pragma_update(None, "optimize", "");
}
+ Db::Null => {}
}
- Ok(())
}
}
#[cfg(test)]
mod tests {
- use super::*;
- use tempdir::TempDir;
-
- #[gpui::test]
- fn test_db() {
- let dir = TempDir::new("db-test").unwrap();
- let fake_db = Db::open_fake();
- let real_db = Db::open(&dir.path().join("test.db")).unwrap();
-
- for db in [&real_db, &fake_db] {
- assert_eq!(
- db.read(["key-1", "key-2", "key-3"]).unwrap(),
- &[None, None, None]
- );
-
- db.write([("key-1", "one"), ("key-3", "three")]).unwrap();
- assert_eq!(
- db.read(["key-1", "key-2", "key-3"]).unwrap(),
- &[
- Some("one".as_bytes().to_vec()),
- None,
- Some("three".as_bytes().to_vec())
- ]
- );
-
- db.delete(["key-3", "key-4"]).unwrap();
- assert_eq!(
- db.read(["key-1", "key-2", "key-3"]).unwrap(),
- &[Some("one".as_bytes().to_vec()), None, None,]
- );
- }
-
- drop(real_db);
+ use crate::migrations::MIGRATIONS;
- let real_db = Db::open(&dir.path().join("test.db")).unwrap();
- assert_eq!(
- real_db.read(["key-1", "key-2", "key-3"]).unwrap(),
- &[Some("one".as_bytes().to_vec()), None, None,]
- );
+ #[test]
+ fn test_migrations() {
+ assert!(MIGRATIONS.validate().is_ok());
}
}
@@ -0,0 +1,311 @@
+use std::{ffi::OsStr, fmt::Display, hash::Hash, os::unix::prelude::OsStrExt, path::PathBuf};
+
+use anyhow::Result;
+use collections::HashSet;
+use rusqlite::{named_params, params};
+
+use super::Db;
+
+pub(crate) const ITEMS_M_1: &str = "
+CREATE TABLE items(
+ id INTEGER PRIMARY KEY,
+ kind TEXT
+) STRICT;
+CREATE TABLE item_path(
+ item_id INTEGER PRIMARY KEY,
+ path BLOB
+) STRICT;
+CREATE TABLE item_query(
+ item_id INTEGER PRIMARY KEY,
+ query TEXT
+) STRICT;
+";
+
+#[derive(PartialEq, Eq, Hash, Debug)]
+pub enum SerializedItemKind {
+ Editor,
+ Terminal,
+ ProjectSearch,
+ Diagnostics,
+}
+
+impl Display for SerializedItemKind {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ f.write_str(&format!("{:?}", self))
+ }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum SerializedItem {
+ Editor(usize, PathBuf),
+ Terminal(usize),
+ ProjectSearch(usize, String),
+ Diagnostics(usize),
+}
+
+impl SerializedItem {
+ fn kind(&self) -> SerializedItemKind {
+ match self {
+ SerializedItem::Editor(_, _) => SerializedItemKind::Editor,
+ SerializedItem::Terminal(_) => SerializedItemKind::Terminal,
+ SerializedItem::ProjectSearch(_, _) => SerializedItemKind::ProjectSearch,
+ SerializedItem::Diagnostics(_) => SerializedItemKind::Diagnostics,
+ }
+ }
+
+ fn id(&self) -> usize {
+ match self {
+ SerializedItem::Editor(id, _)
+ | SerializedItem::Terminal(id)
+ | SerializedItem::ProjectSearch(id, _)
+ | SerializedItem::Diagnostics(id) => *id,
+ }
+ }
+}
+
+impl Db {
+ fn write_item(&self, serialized_item: SerializedItem) -> Result<()> {
+ self.real()
+ .map(|db| {
+ let mut lock = db.connection.lock();
+ let tx = lock.transaction()?;
+
+ // Serialize the item
+ let id = serialized_item.id();
+ {
+ let mut stmt = tx.prepare_cached(
+ "INSERT OR REPLACE INTO items(id, kind) VALUES ((?), (?))",
+ )?;
+
+ dbg!("inserting item");
+ stmt.execute(params![id, serialized_item.kind().to_string()])?;
+ }
+
+ // Serialize item data
+ match &serialized_item {
+ SerializedItem::Editor(_, path) => {
+ dbg!("inserting path");
+ let mut stmt = tx.prepare_cached(
+ "INSERT OR REPLACE INTO item_path(item_id, path) VALUES ((?), (?))",
+ )?;
+
+ let path_bytes = path.as_os_str().as_bytes();
+ stmt.execute(params![id, path_bytes])?;
+ }
+ SerializedItem::ProjectSearch(_, query) => {
+ dbg!("inserting query");
+ let mut stmt = tx.prepare_cached(
+ "INSERT OR REPLACE INTO item_query(item_id, query) VALUES ((?), (?))",
+ )?;
+
+ stmt.execute(params![id, query])?;
+ }
+ _ => {}
+ }
+
+ tx.commit()?;
+
+ let mut stmt = lock.prepare_cached("SELECT id, kind FROM items")?;
+ let _ = stmt
+ .query_map([], |row| {
+ let zero: usize = row.get(0)?;
+ let one: String = row.get(1)?;
+
+ dbg!(zero, one);
+ Ok(())
+ })?
+ .collect::<Vec<Result<(), _>>>();
+
+ Ok(())
+ })
+ .unwrap_or(Ok(()))
+ }
+
+ fn delete_item(&self, item_id: usize) -> Result<()> {
+ self.real()
+ .map(|db| {
+ let lock = db.connection.lock();
+
+ let mut stmt = lock.prepare_cached(
+ r#"
+ DELETE FROM items WHERE id = (:id);
+ DELETE FROM item_path WHERE id = (:id);
+ DELETE FROM item_query WHERE id = (:id);
+ "#,
+ )?;
+
+ stmt.execute(named_params! {":id": item_id})?;
+
+ Ok(())
+ })
+ .unwrap_or(Ok(()))
+ }
+
+ fn take_items(&self) -> Result<HashSet<SerializedItem>> {
+ self.real()
+ .map(|db| {
+ let mut lock = db.connection.lock();
+
+ let tx = lock.transaction()?;
+
+ // When working with transactions in rusqlite, need to make this kind of scope
+ // To make the borrow stuff work correctly. Don't know why, rust is wild.
+ let result = {
+ let mut editors_stmt = tx.prepare_cached(
+ r#"
+ SELECT items.id, item_path.path
+ FROM items
+ LEFT JOIN item_path
+ ON items.id = item_path.item_id
+ WHERE items.kind = ?;
+ "#,
+ )?;
+
+ let editors_iter = editors_stmt.query_map(
+ [SerializedItemKind::Editor.to_string()],
+ |row| {
+ let id: usize = row.get(0)?;
+
+ let buf: Vec<u8> = row.get(1)?;
+ let path: PathBuf = OsStr::from_bytes(&buf).into();
+
+ Ok(SerializedItem::Editor(id, path))
+ },
+ )?;
+
+ let mut terminals_stmt = tx.prepare_cached(
+ r#"
+ SELECT items.id
+ FROM items
+ WHERE items.kind = ?;
+ "#,
+ )?;
+ let terminals_iter = terminals_stmt.query_map(
+ [SerializedItemKind::Terminal.to_string()],
+ |row| {
+ let id: usize = row.get(0)?;
+
+ Ok(SerializedItem::Terminal(id))
+ },
+ )?;
+
+ let mut search_stmt = tx.prepare_cached(
+ r#"
+ SELECT items.id, item_query.query
+ FROM items
+ LEFT JOIN item_query
+ ON items.id = item_query.item_id
+ WHERE items.kind = ?;
+ "#,
+ )?;
+ let searches_iter = search_stmt.query_map(
+ [SerializedItemKind::ProjectSearch.to_string()],
+ |row| {
+ let id: usize = row.get(0)?;
+ let query = row.get(1)?;
+
+ Ok(SerializedItem::ProjectSearch(id, query))
+ },
+ )?;
+
+ #[cfg(debug_assertions)]
+ let tmp =
+ searches_iter.collect::<Vec<Result<SerializedItem, rusqlite::Error>>>();
+ #[cfg(debug_assertions)]
+ debug_assert!(tmp.len() == 0 || tmp.len() == 1);
+ #[cfg(debug_assertions)]
+ let searches_iter = tmp.into_iter();
+
+ let mut diagnostic_stmt = tx.prepare_cached(
+ r#"
+ SELECT items.id
+ FROM items
+ WHERE items.kind = ?;
+ "#,
+ )?;
+
+ let diagnostics_iter = diagnostic_stmt.query_map(
+ [SerializedItemKind::Diagnostics.to_string()],
+ |row| {
+ let id: usize = row.get(0)?;
+
+ Ok(SerializedItem::Diagnostics(id))
+ },
+ )?;
+
+ #[cfg(debug_assertions)]
+ let tmp =
+ diagnostics_iter.collect::<Vec<Result<SerializedItem, rusqlite::Error>>>();
+ #[cfg(debug_assertions)]
+ debug_assert!(tmp.len() == 0 || tmp.len() == 1);
+ #[cfg(debug_assertions)]
+ let diagnostics_iter = tmp.into_iter();
+
+ let res = editors_iter
+ .chain(terminals_iter)
+ .chain(diagnostics_iter)
+ .chain(searches_iter)
+ .collect::<Result<HashSet<SerializedItem>, rusqlite::Error>>()?;
+
+ let mut delete_stmt = tx.prepare_cached(
+ r#"
+ DELETE FROM items;
+ DELETE FROM item_path;
+ DELETE FROM item_query;
+ "#,
+ )?;
+
+ delete_stmt.execute([])?;
+
+ res
+ };
+
+ tx.commit()?;
+
+ Ok(result)
+ })
+ .unwrap_or(Ok(HashSet::default()))
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use anyhow::Result;
+
+ use super::*;
+
+ #[test]
+ fn test_items_round_trip() -> Result<()> {
+ let db = Db::open_in_memory();
+
+ let mut items = vec![
+ SerializedItem::Editor(0, PathBuf::from("/tmp/test.txt")),
+ SerializedItem::Terminal(1),
+ SerializedItem::ProjectSearch(2, "Test query!".to_string()),
+ SerializedItem::Diagnostics(3),
+ ]
+ .into_iter()
+ .collect::<HashSet<_>>();
+
+ for item in items.iter() {
+ dbg!("Inserting... ");
+ db.write_item(item.clone())?;
+ }
+
+ assert_eq!(items, db.take_items()?);
+
+ // Check that it's empty, as expected
+ assert_eq!(HashSet::default(), db.take_items()?);
+
+ for item in items.iter() {
+ db.write_item(item.clone())?;
+ }
+
+ items.remove(&SerializedItem::ProjectSearch(2, "Test query!".to_string()));
+ db.delete_item(2)?;
+
+ assert_eq!(items, db.take_items()?);
+
+ Ok(())
+ }
+}
@@ -0,0 +1,82 @@
+use anyhow::Result;
+use rusqlite::OptionalExtension;
+
+use super::Db;
+
+pub(crate) const KVP_M_1_UP: &str = "
+CREATE TABLE kv_store(
+ key TEXT PRIMARY KEY,
+ value TEXT NOT NULL
+) STRICT;
+";
+
+impl Db {
+ pub fn read_kvp(&self, key: &str) -> Result<Option<String>> {
+ self.real()
+ .map(|db| {
+ let lock = db.connection.lock();
+ let mut stmt = lock.prepare_cached("SELECT value FROM kv_store WHERE key = (?)")?;
+
+ Ok(stmt.query_row([key], |row| row.get(0)).optional()?)
+ })
+ .unwrap_or(Ok(None))
+ }
+
+ pub fn write_kvp(&self, key: &str, value: &str) -> Result<()> {
+ self.real()
+ .map(|db| {
+ let lock = db.connection.lock();
+
+ let mut stmt = lock.prepare_cached(
+ "INSERT OR REPLACE INTO kv_store(key, value) VALUES ((?), (?))",
+ )?;
+
+ stmt.execute([key, value])?;
+
+ Ok(())
+ })
+ .unwrap_or(Ok(()))
+ }
+
+ pub fn delete_kvp(&self, key: &str) -> Result<()> {
+ self.real()
+ .map(|db| {
+ let lock = db.connection.lock();
+
+ let mut stmt = lock.prepare_cached("DELETE FROM kv_store WHERE key = (?)")?;
+
+ stmt.execute([key])?;
+
+ Ok(())
+ })
+ .unwrap_or(Ok(()))
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use anyhow::Result;
+
+ use super::*;
+
+ #[test]
+ fn test_kvp() -> Result<()> {
+ let db = Db::open_in_memory();
+
+ assert_eq!(db.read_kvp("key-1")?, None);
+
+ db.write_kvp("key-1", "one")?;
+ assert_eq!(db.read_kvp("key-1")?, Some("one".to_string()));
+
+ db.write_kvp("key-1", "one-2")?;
+ assert_eq!(db.read_kvp("key-1")?, Some("one-2".to_string()));
+
+ db.write_kvp("key-2", "two")?;
+ assert_eq!(db.read_kvp("key-2")?, Some("two".to_string()));
+
+ db.delete_kvp("key-1")?;
+ assert_eq!(db.read_kvp("key-1")?, None);
+
+ Ok(())
+ }
+}
@@ -0,0 +1,15 @@
+use rusqlite_migration::{Migrations, M};
+
+// use crate::items::ITEMS_M_1;
+use crate::kvp::KVP_M_1_UP;
+
+// This must be ordered by development time! Only ever add new migrations to the end!!
+// Bad things will probably happen if you don't monotonically edit this vec!!!!
+// And no re-ordering ever!!!!!!!!!! The results of these migrations are on the user's
+// file system and so everything we do here is locked in _f_o_r_e_v_e_r_.
+lazy_static::lazy_static! {
+ pub static ref MIGRATIONS: Migrations<'static> = Migrations::new(vec![
+ M::up(KVP_M_1_UP),
+ // M::up(ITEMS_M_1),
+ ]);
+}
@@ -99,7 +99,7 @@ impl View for ProjectDiagnosticsEditor {
}
}
- fn on_focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+ fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
if !self.path_states.is_empty() {
cx.focus(&self.editor);
}
@@ -4,7 +4,7 @@ use collections::HashSet;
use gpui::{
elements::{MouseEventHandler, Overlay},
geometry::vector::Vector2F,
- scene::DragRegionEvent,
+ scene::MouseDrag,
CursorStyle, Element, ElementBox, EventContext, MouseButton, MutableAppContext, RenderContext,
View, WeakViewHandle,
};
@@ -70,7 +70,7 @@ impl<V: View> DragAndDrop<V> {
}
pub fn dragging<T: Any>(
- event: DragRegionEvent,
+ event: MouseDrag,
payload: Rc<T>,
cx: &mut EventContext,
render: Rc<impl 'static + Fn(&T, &mut RenderContext<V>) -> ElementBox>,
@@ -0,0 +1,110 @@
+use std::time::Duration;
+
+use gpui::{Entity, ModelContext};
+use settings::Settings;
+use smol::Timer;
+
+pub struct BlinkManager {
+ blink_interval: Duration,
+
+ blink_epoch: usize,
+ blinking_paused: bool,
+ visible: bool,
+ enabled: bool,
+}
+
+impl BlinkManager {
+ pub fn new(blink_interval: Duration, cx: &mut ModelContext<Self>) -> Self {
+ let weak_handle = cx.weak_handle();
+ cx.observe_global::<Settings, _>(move |_, cx| {
+ if let Some(this) = weak_handle.upgrade(cx) {
+ // Make sure we blink the cursors if the setting is re-enabled
+ this.update(cx, |this, cx| this.blink_cursors(this.blink_epoch, cx));
+ }
+ })
+ .detach();
+
+ Self {
+ blink_interval,
+
+ blink_epoch: 0,
+ blinking_paused: false,
+ visible: true,
+ enabled: true,
+ }
+ }
+
+ fn next_blink_epoch(&mut self) -> usize {
+ self.blink_epoch += 1;
+ self.blink_epoch
+ }
+
+ pub fn pause_blinking(&mut self, cx: &mut ModelContext<Self>) {
+ if !self.visible {
+ self.visible = true;
+ cx.notify();
+ }
+
+ let epoch = self.next_blink_epoch();
+ let interval = self.blink_interval;
+ cx.spawn(|this, mut cx| {
+ let this = this.downgrade();
+ async move {
+ Timer::after(interval).await;
+ if let Some(this) = this.upgrade(&cx) {
+ this.update(&mut cx, |this, cx| this.resume_cursor_blinking(epoch, cx))
+ }
+ }
+ })
+ .detach();
+ }
+
+ fn resume_cursor_blinking(&mut self, epoch: usize, cx: &mut ModelContext<Self>) {
+ if epoch == self.blink_epoch {
+ self.blinking_paused = false;
+ self.blink_cursors(epoch, cx);
+ }
+ }
+
+ fn blink_cursors(&mut self, epoch: usize, cx: &mut ModelContext<Self>) {
+ if cx.global::<Settings>().cursor_blink {
+ if epoch == self.blink_epoch && self.enabled && !self.blinking_paused {
+ self.visible = !self.visible;
+ cx.notify();
+
+ let epoch = self.next_blink_epoch();
+ let interval = self.blink_interval;
+ cx.spawn(|this, mut cx| {
+ let this = this.downgrade();
+ async move {
+ Timer::after(interval).await;
+ if let Some(this) = this.upgrade(&cx) {
+ this.update(&mut cx, |this, cx| this.blink_cursors(epoch, cx));
+ }
+ }
+ })
+ .detach();
+ }
+ } else if !self.visible {
+ self.visible = true;
+ cx.notify();
+ }
+ }
+
+ pub fn enable(&mut self, cx: &mut ModelContext<Self>) {
+ self.enabled = true;
+ self.blink_cursors(self.blink_epoch, cx);
+ }
+
+ pub fn disable(&mut self, _: &mut ModelContext<Self>) {
+ self.enabled = true;
+ }
+
+ pub fn visible(&self) -> bool {
+ self.visible
+ }
+}
+
+impl Entity for BlinkManager {
+ type Event = ();
+}
@@ -1,3 +1,4 @@
+mod blink_manager;
pub mod display_map;
mod element;
mod highlight_matching_bracket;
@@ -16,6 +17,7 @@ pub mod test;
use aho_corasick::AhoCorasick;
use anyhow::Result;
+use blink_manager::BlinkManager;
use clock::ReplicaId;
use collections::{BTreeMap, Bound, HashMap, HashSet, VecDeque};
pub use display_map::DisplayPoint;
@@ -33,20 +35,22 @@ use gpui::{
impl_actions, impl_internal_actions,
platform::CursorStyle,
serde_json::json,
- text_layout, AnyViewHandle, AppContext, AsyncAppContext, ClipboardItem, Element, ElementBox,
- Entity, ModelHandle, MouseButton, MutableAppContext, RenderContext, Subscription, Task, View,
- ViewContext, ViewHandle, WeakViewHandle,
+ text_layout, AnyViewHandle, AppContext, AsyncAppContext, Axis, ClipboardItem, Element,
+ ElementBox, Entity, ModelHandle, MouseButton, MutableAppContext, RenderContext, Subscription,
+ Task, View, ViewContext, ViewHandle, WeakViewHandle,
};
use highlight_matching_bracket::refresh_matching_bracket_highlights;
use hover_popover::{hide_hover, HoverState};
pub use items::MAX_TAB_TITLE_LEN;
pub use language::{char_kind, CharKind};
use language::{
- AutoindentMode, BracketPair, Buffer, CodeAction, CodeLabel, Completion, Diagnostic,
- DiagnosticSeverity, IndentKind, IndentSize, Language, OffsetRangeExt, OffsetUtf16, Point,
- Selection, SelectionGoal, TransactionId,
+ AutoindentMode, BracketPair, Buffer, CodeAction, CodeLabel, Completion, CursorShape,
+ Diagnostic, DiagnosticSeverity, IndentKind, IndentSize, Language, OffsetRangeExt, OffsetUtf16,
+ Point, Selection, SelectionGoal, TransactionId,
+};
+use link_go_to_definition::{
+ hide_link_definition, show_link_definition, LinkDefinitionKind, LinkGoToDefinitionState,
};
-use link_go_to_definition::{hide_link_definition, LinkGoToDefinitionState};
pub use multi_buffer::{
Anchor, AnchorRangeExt, ExcerptId, ExcerptRange, MultiBuffer, MultiBufferSnapshot, ToOffset,
ToPoint,
@@ -80,6 +84,7 @@ const SCROLLBAR_SHOW_INTERVAL: Duration = Duration::from_secs(1);
const MAX_LINE_LEN: usize = 1024;
const MIN_NAVIGATION_HISTORY_ROW_DELTA: i64 = 10;
const MAX_SELECTION_HISTORY_LEN: usize = 1024;
+pub const SCROLL_EVENT_SEPARATION: Duration = Duration::from_millis(28);
pub const FORMAT_TIMEOUT: Duration = Duration::from_secs(2);
@@ -90,7 +95,10 @@ pub struct SelectNext {
}
#[derive(Clone, PartialEq)]
-pub struct Scroll(pub Vector2F);
+pub struct Scroll {
+ pub scroll_position: Vector2F,
+ pub axis: Option<Axis>,
+}
#[derive(Clone, PartialEq)]
pub struct Select(pub SelectPhase);
@@ -259,7 +267,7 @@ struct ScrollbarAutoHide(bool);
pub fn init(cx: &mut MutableAppContext) {
cx.add_action(Editor::new_file);
- cx.add_action(|this: &mut Editor, action: &Scroll, cx| this.set_scroll_position(action.0, cx));
+ cx.add_action(Editor::scroll);
cx.add_action(Editor::select);
cx.add_action(Editor::cancel);
cx.add_action(Editor::newline);
@@ -425,6 +433,69 @@ pub type GetFieldEditorTheme = fn(&theme::Theme) -> theme::FieldEditor;
type OverrideTextStyle = dyn Fn(&EditorStyle) -> Option<HighlightStyle>;
+#[derive(Clone, Copy)]
+pub struct OngoingScroll {
+ last_timestamp: Instant,
+ axis: Option<Axis>,
+}
+
+impl OngoingScroll {
+ fn initial() -> OngoingScroll {
+ OngoingScroll {
+ last_timestamp: Instant::now() - SCROLL_EVENT_SEPARATION,
+ axis: None,
+ }
+ }
+
+ fn update(&mut self, axis: Option<Axis>) {
+ self.last_timestamp = Instant::now();
+ self.axis = axis;
+ }
+
+ pub fn filter(&self, delta: &mut Vector2F) -> Option<Axis> {
+ const UNLOCK_PERCENT: f32 = 1.9;
+ const UNLOCK_LOWER_BOUND: f32 = 6.;
+ let mut axis = self.axis;
+
+ let x = delta.x().abs();
+ let y = delta.y().abs();
+ let duration = Instant::now().duration_since(self.last_timestamp);
+ if duration > SCROLL_EVENT_SEPARATION {
+ //New ongoing scroll will start, determine axis
+ axis = if x <= y {
+ Some(Axis::Vertical)
+ } else {
+ Some(Axis::Horizontal)
+ };
+ } else if x.max(y) >= UNLOCK_LOWER_BOUND {
+ //Check if the current ongoing will need to unlock
+ match axis {
+ Some(Axis::Vertical) => {
+ if x > y && x >= y * UNLOCK_PERCENT {
+ axis = None;
+ }
+ }
+
+ Some(Axis::Horizontal) => {
+ if y > x && y >= x * UNLOCK_PERCENT {
+ axis = None;
+ }
+ }
+
+ None => {}
+ }
+ }
+
+ match axis {
+ Some(Axis::Vertical) => *delta = vec2f(0., delta.y()),
+ Some(Axis::Horizontal) => *delta = vec2f(delta.x(), 0.),
+ None => {}
+ }
+
+ axis
+ }
+}
+
pub struct Editor {
handle: WeakViewHandle<Self>,
buffer: ModelHandle<MultiBuffer>,
@@ -439,6 +510,7 @@ pub struct Editor {
select_larger_syntax_node_stack: Vec<Box<[Selection<usize>]>>,
ime_transaction: Option<TransactionId>,
active_diagnostics: Option<ActiveDiagnosticGroup>,
+ ongoing_scroll: OngoingScroll,
scroll_position: Vector2F,
scroll_top_anchor: Anchor,
autoscroll_request: Option<(Autoscroll, bool)>,
@@ -447,12 +519,10 @@ pub struct Editor {
override_text_style: Option<Box<OverrideTextStyle>>,
project: Option<ModelHandle<Project>>,
focused: bool,
- show_local_cursors: bool,
+ blink_manager: ModelHandle<BlinkManager>,
show_local_selections: bool,
show_scrollbars: bool,
hide_scrollbar_task: Option<Task<()>>,
- blink_epoch: usize,
- blinking_paused: bool,
mode: EditorMode,
vertical_scroll_margin: f32,
placeholder_text: Option<Arc<str>>,
@@ -484,6 +554,7 @@ pub struct EditorSnapshot {
pub display_snapshot: DisplaySnapshot,
pub placeholder_text: Option<Arc<str>>,
is_focused: bool,
+ ongoing_scroll: OngoingScroll,
scroll_position: Vector2F,
scroll_top_anchor: Anchor,
}
@@ -1076,6 +1147,8 @@ impl Editor {
let selections = SelectionsCollection::new(display_map.clone(), buffer.clone());
+ let blink_manager = cx.add_model(|cx| BlinkManager::new(CURSOR_BLINK_INTERVAL, cx));
+
let mut this = Self {
handle: cx.weak_handle(),
buffer: buffer.clone(),
@@ -1093,16 +1166,15 @@ impl Editor {
soft_wrap_mode_override: None,
get_field_editor_theme,
project,
+ ongoing_scroll: OngoingScroll::initial(),
scroll_position: Vector2F::zero(),
scroll_top_anchor: Anchor::min(),
autoscroll_request: None,
focused: false,
- show_local_cursors: false,
+ blink_manager: blink_manager.clone(),
show_local_selections: true,
show_scrollbars: true,
hide_scrollbar_task: None,
- blink_epoch: 0,
- blinking_paused: false,
mode,
vertical_scroll_margin: 3.0,
placeholder_text: None,
@@ -1130,6 +1202,7 @@ impl Editor {
cx.observe(&buffer, Self::on_buffer_changed),
cx.subscribe(&buffer, Self::on_buffer_event),
cx.observe(&display_map, Self::on_display_map_changed),
+ cx.observe(&blink_manager, |_, _, cx| cx.notify()),
],
};
this.end_selection(cx);
@@ -1186,6 +1259,7 @@ impl Editor {
EditorSnapshot {
mode: self.mode,
display_snapshot: self.display_map.update(cx, |map, cx| map.snapshot(cx)),
+ ongoing_scroll: self.ongoing_scroll,
scroll_position: self.scroll_position,
scroll_top_anchor: self.scroll_top_anchor.clone(),
placeholder_text: self.placeholder_text.clone(),
@@ -1478,6 +1552,7 @@ impl Editor {
buffer.set_active_selections(
&self.selections.disjoint_anchors(),
self.selections.line_mode,
+ self.cursor_shape,
cx,
)
});
@@ -1541,7 +1616,7 @@ impl Editor {
refresh_matching_bracket_highlights(self, cx);
}
- self.pause_cursor_blinking(cx);
+ self.blink_manager.update(cx, BlinkManager::pause_blinking);
cx.emit(Event::SelectionsChanged { local });
cx.notify();
}
@@ -1588,6 +1663,11 @@ impl Editor {
});
}
+ fn scroll(&mut self, action: &Scroll, cx: &mut ViewContext<Self>) {
+ self.ongoing_scroll.update(action.axis);
+ self.set_scroll_position(action.scroll_position, cx);
+ }
+
fn select(&mut self, Select(phase): &Select, cx: &mut ViewContext<Self>) {
self.hide_context_menu(cx);
@@ -6110,60 +6190,8 @@ impl Editor {
highlights
}
- fn next_blink_epoch(&mut self) -> usize {
- self.blink_epoch += 1;
- self.blink_epoch
- }
-
- fn pause_cursor_blinking(&mut self, cx: &mut ViewContext<Self>) {
- if !self.focused {
- return;
- }
-
- self.show_local_cursors = true;
- cx.notify();
-
- let epoch = self.next_blink_epoch();
- cx.spawn(|this, mut cx| {
- let this = this.downgrade();
- async move {
- Timer::after(CURSOR_BLINK_INTERVAL).await;
- if let Some(this) = this.upgrade(&cx) {
- this.update(&mut cx, |this, cx| this.resume_cursor_blinking(epoch, cx))
- }
- }
- })
- .detach();
- }
-
- fn resume_cursor_blinking(&mut self, epoch: usize, cx: &mut ViewContext<Self>) {
- if epoch == self.blink_epoch {
- self.blinking_paused = false;
- self.blink_cursors(epoch, cx);
- }
- }
-
- fn blink_cursors(&mut self, epoch: usize, cx: &mut ViewContext<Self>) {
- if epoch == self.blink_epoch && self.focused && !self.blinking_paused {
- self.show_local_cursors = !self.show_local_cursors;
- cx.notify();
-
- let epoch = self.next_blink_epoch();
- cx.spawn(|this, mut cx| {
- let this = this.downgrade();
- async move {
- Timer::after(CURSOR_BLINK_INTERVAL).await;
- if let Some(this) = this.upgrade(&cx) {
- this.update(&mut cx, |this, cx| this.blink_cursors(epoch, cx));
- }
- }
- })
- .detach();
- }
- }
-
- pub fn show_local_cursors(&self) -> bool {
- self.show_local_cursors && self.focused
+ pub fn show_local_cursors(&self, cx: &AppContext) -> bool {
+ self.blink_manager.read(cx).visible() && self.focused
}
pub fn show_scrollbars(&self) -> bool {
@@ -6466,9 +6494,7 @@ impl View for Editor {
}
Stack::new()
- .with_child(
- EditorElement::new(self.handle.clone(), style.clone(), self.cursor_shape).boxed(),
- )
+ .with_child(EditorElement::new(self.handle.clone(), style.clone()).boxed())
.with_child(ChildView::new(&self.mouse_context_menu, cx).boxed())
.boxed()
}
@@ -6477,20 +6503,21 @@ impl View for Editor {
"Editor"
}
- fn on_focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+ fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
let focused_event = EditorFocused(cx.handle());
cx.emit_global(focused_event);
if let Some(rename) = self.pending_rename.as_ref() {
cx.focus(&rename.editor);
} else {
self.focused = true;
- self.blink_cursors(self.blink_epoch, cx);
+ self.blink_manager.update(cx, BlinkManager::enable);
self.buffer.update(cx, |buffer, cx| {
buffer.finalize_last_transaction(cx);
if self.leader_replica_id.is_none() {
buffer.set_active_selections(
&self.selections.disjoint_anchors(),
self.selections.line_mode,
+ self.cursor_shape,
cx,
);
}
@@ -6498,10 +6525,11 @@ impl View for Editor {
}
}
- fn on_focus_out(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+ fn focus_out(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
let blurred_event = EditorBlurred(cx.handle());
cx.emit_global(blurred_event);
self.focused = false;
+ self.blink_manager.update(cx, BlinkManager::disable);
self.buffer
.update(cx, |buffer, cx| buffer.remove_active_selections(cx));
self.hide_context_menu(cx);
@@ -6510,6 +6538,44 @@ impl View for Editor {
cx.notify();
}
+ fn modifiers_changed(
+ &mut self,
+ event: &gpui::ModifiersChangedEvent,
+ cx: &mut ViewContext<Self>,
+ ) -> bool {
+ let pending_selection = self.has_pending_selection();
+
+ if let Some(point) = self.link_go_to_definition_state.last_mouse_location.clone() {
+ if event.cmd && !pending_selection {
+ let snapshot = self.snapshot(cx);
+ let kind = if event.shift {
+ LinkDefinitionKind::Type
+ } else {
+ LinkDefinitionKind::Symbol
+ };
+
+ show_link_definition(kind, self, point, snapshot, cx);
+ return false;
+ }
+ }
+
+ {
+ if self.link_go_to_definition_state.symbol_range.is_some()
+ || !self.link_go_to_definition_state.definitions.is_empty()
+ {
+ self.link_go_to_definition_state.symbol_range.take();
+ self.link_go_to_definition_state.definitions.clear();
+ cx.notify();
+ }
+
+ self.link_go_to_definition_state.task = None;
+
+ self.clear_text_highlights::<LinkGoToDefinitionState>(cx);
+ }
+
+ false
+ }
+
fn keymap_context(&self, _: &AppContext) -> gpui::keymap::Context {
let mut context = Self::default_keymap_context();
let mode = match self.mode {
@@ -9,7 +9,7 @@ use crate::{
HoverAt, HOVER_POPOVER_GAP, MIN_POPOVER_CHARACTER_WIDTH, MIN_POPOVER_LINE_HEIGHT,
},
link_go_to_definition::{
- CmdShiftChanged, GoToFetchedDefinition, GoToFetchedTypeDefinition, UpdateGoToDefinitionLink,
+ GoToFetchedDefinition, GoToFetchedTypeDefinition, UpdateGoToDefinitionLink,
},
mouse_context_menu::DeployMouseContextMenu,
AnchorRangeExt, EditorStyle,
@@ -29,13 +29,12 @@ use gpui::{
json::{self, ToJson},
platform::CursorStyle,
text_layout::{self, Line, RunStyle, TextLayoutCache},
- AppContext, Axis, Border, CursorRegion, Element, ElementBox, Event, EventContext,
- LayoutContext, ModifiersChangedEvent, MouseButton, MouseButtonEvent, MouseMovedEvent,
- MouseRegion, MutableAppContext, PaintContext, Quad, Scene, SizeConstraint, ViewContext,
- WeakViewHandle,
+ AppContext, Axis, Border, CursorRegion, Element, ElementBox, EventContext, LayoutContext,
+ MouseButton, MouseButtonEvent, MouseMovedEvent, MouseRegion, MutableAppContext, PaintContext,
+ Quad, Scene, SizeConstraint, ViewContext, WeakViewHandle,
};
use json::json;
-use language::{Bias, DiagnosticSeverity, OffsetUtf16, Point, Selection};
+use language::{Bias, CursorShape, DiagnosticSeverity, OffsetUtf16, Point, Selection};
use project::ProjectPath;
use settings::{GitGutter, Settings};
use smallvec::SmallVec;
@@ -56,6 +55,7 @@ struct DiffHunkLayout {
struct SelectionLayout {
head: DisplayPoint,
+ cursor_shape: CursorShape,
range: Range<DisplayPoint>,
}
@@ -63,6 +63,7 @@ impl SelectionLayout {
fn new<T: ToPoint + ToDisplayPoint + Clone>(
selection: Selection<T>,
line_mode: bool,
+ cursor_shape: CursorShape,
map: &DisplaySnapshot,
) -> Self {
if line_mode {
@@ -70,6 +71,7 @@ impl SelectionLayout {
let point_range = map.expand_to_line(selection.range());
Self {
head: selection.head().to_display_point(map),
+ cursor_shape,
range: point_range.start.to_display_point(map)
..point_range.end.to_display_point(map),
}
@@ -77,6 +79,7 @@ impl SelectionLayout {
let selection = selection.map(|p| p.to_display_point(map));
Self {
head: selection.head(),
+ cursor_shape,
range: selection.range(),
}
}
@@ -87,19 +90,13 @@ impl SelectionLayout {
pub struct EditorElement {
view: WeakViewHandle<Editor>,
style: Arc<EditorStyle>,
- cursor_shape: CursorShape,
}
impl EditorElement {
- pub fn new(
- view: WeakViewHandle<Editor>,
- style: EditorStyle,
- cursor_shape: CursorShape,
- ) -> Self {
+ pub fn new(view: WeakViewHandle<Editor>, style: EditorStyle) -> Self {
Self {
view,
style: Arc::new(style),
- cursor_shape,
}
}
@@ -414,14 +411,6 @@ impl EditorElement {
true
}
- fn modifiers_changed(&self, event: ModifiersChangedEvent, cx: &mut EventContext) -> bool {
- cx.dispatch_action(CmdShiftChanged {
- cmd_down: event.cmd,
- shift_down: event.shift,
- });
- false
- }
-
fn scroll(
position: Vector2F,
mut delta: Vector2F,
@@ -434,18 +423,27 @@ impl EditorElement {
return false;
}
+ let line_height = position_map.line_height;
let max_glyph_width = position_map.em_width;
- if !precise {
- delta *= vec2f(max_glyph_width, position_map.line_height);
- }
+
+ let axis = if precise {
+ //Trackpad
+ position_map.snapshot.ongoing_scroll.filter(&mut delta)
+ } else {
+ //Not trackpad
+ delta *= vec2f(max_glyph_width, line_height);
+ None //Resets ongoing scroll
+ };
let scroll_position = position_map.snapshot.scroll_position();
let x = (scroll_position.x() * max_glyph_width - delta.x()) / max_glyph_width;
- let y =
- (scroll_position.y() * position_map.line_height - delta.y()) / position_map.line_height;
+ let y = (scroll_position.y() * line_height - delta.y()) / line_height;
let scroll_position = vec2f(x, y).clamp(Vector2F::zero(), position_map.scroll_max);
- cx.dispatch_action(Scroll(scroll_position));
+ cx.dispatch_action(Scroll {
+ scroll_position,
+ axis,
+ });
true
}
@@ -707,7 +705,7 @@ impl EditorElement {
cx,
);
- if view.show_local_cursors() || *replica_id != local_replica_id {
+ if view.show_local_cursors(cx) || *replica_id != local_replica_id {
let cursor_position = selection.head;
if layout
.visible_display_row_range
@@ -723,7 +721,7 @@ impl EditorElement {
if block_width == 0.0 {
block_width = layout.position_map.em_width;
}
- let block_text = if let CursorShape::Block = self.cursor_shape {
+ let block_text = if let CursorShape::Block = selection.cursor_shape {
layout
.position_map
.snapshot
@@ -759,7 +757,7 @@ impl EditorElement {
block_width,
origin: vec2f(x, y),
line_height: layout.position_map.line_height,
- shape: self.cursor_shape,
+ shape: selection.cursor_shape,
block_text,
});
}
@@ -1326,6 +1324,7 @@ impl EditorElement {
line_height: f32,
style: &EditorStyle,
line_layouts: &[text_layout::Line],
+ include_root: bool,
cx: &mut LayoutContext,
) -> (f32, Vec<BlockLayout>) {
let editor = if let Some(editor) = self.view.upgrade(cx) {
@@ -1429,10 +1428,11 @@ impl EditorElement {
let font_size =
(style.text_scale_factor * self.style.text.font_size).round();
+ let path = buffer.resolve_file_path(cx, include_root);
let mut filename = None;
let mut parent_path = None;
- if let Some(file) = buffer.file() {
- let path = file.path();
+ // Can't use .and_then() because `.file_name()` and `.parent()` return references :(
+ if let Some(path) = path {
filename = path.file_name().map(|f| f.to_string_lossy().to_string());
parent_path =
path.parent().map(|p| p.to_string_lossy().to_string() + "/");
@@ -1636,6 +1636,7 @@ impl Element for EditorElement {
let mut highlighted_rows = None;
let mut highlighted_ranges = Vec::new();
let mut show_scrollbars = false;
+ let mut include_root = false;
self.update_view(cx.app, |view, cx| {
let display_map = view.display_map.update(cx, |map, cx| map.snapshot(cx));
@@ -1648,7 +1649,7 @@ impl Element for EditorElement {
);
let mut remote_selections = HashMap::default();
- for (replica_id, line_mode, selection) in display_map
+ for (replica_id, line_mode, cursor_shape, selection) in display_map
.buffer_snapshot
.remote_selections_in_range(&(start_anchor.clone()..end_anchor.clone()))
{
@@ -1659,7 +1660,12 @@ impl Element for EditorElement {
remote_selections
.entry(replica_id)
.or_insert(Vec::new())
- .push(SelectionLayout::new(selection, line_mode, &display_map));
+ .push(SelectionLayout::new(
+ selection,
+ line_mode,
+ cursor_shape,
+ &display_map,
+ ));
}
selections.extend(remote_selections);
@@ -1691,13 +1697,23 @@ impl Element for EditorElement {
local_selections
.into_iter()
.map(|selection| {
- SelectionLayout::new(selection, view.selections.line_mode, &display_map)
+ SelectionLayout::new(
+ selection,
+ view.selections.line_mode,
+ view.cursor_shape,
+ &display_map,
+ )
})
.collect(),
));
}
show_scrollbars = view.show_scrollbars();
+ include_root = view
+ .project
+ .as_ref()
+ .map(|project| project.read(cx).visible_worktrees(cx).count() > 1)
+ .unwrap_or_default()
});
let line_number_layouts =
@@ -1737,6 +1753,7 @@ impl Element for EditorElement {
line_height,
&style,
&line_layouts,
+ include_root,
cx,
);
@@ -1913,22 +1930,6 @@ impl Element for EditorElement {
cx.scene.pop_layer();
}
- fn dispatch_event(
- &mut self,
- event: &Event,
- _: RectF,
- _: RectF,
- _: &mut LayoutState,
- _: &mut (),
- cx: &mut EventContext,
- ) -> bool {
- if let Event::ModifiersChanged(event) = event {
- self.modifiers_changed(*event, cx);
- }
-
- false
- }
-
fn rect_for_text_range(
&self,
range_utf16: Range<usize>,
@@ -2094,20 +2095,6 @@ fn layout_line(
)
}
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
-pub enum CursorShape {
- Bar,
- Block,
- Underscore,
- Hollow,
-}
-
-impl Default for CursorShape {
- fn default() -> Self {
- CursorShape::Bar
- }
-}
-
#[derive(Debug)]
pub struct Cursor {
origin: Vector2F,
@@ -2348,11 +2335,7 @@ mod tests {
let (window_id, editor) = cx.add_window(Default::default(), |cx| {
Editor::new(EditorMode::Full, buffer, None, None, cx)
});
- let element = EditorElement::new(
- editor.downgrade(),
- editor.read(cx).style(cx),
- CursorShape::Bar,
- );
+ let element = EditorElement::new(editor.downgrade(), editor.read(cx).style(cx));
let layouts = editor.update(cx, |editor, cx| {
let snapshot = editor.snapshot(cx);
@@ -2388,11 +2371,7 @@ mod tests {
cx.blur();
});
- let mut element = EditorElement::new(
- editor.downgrade(),
- editor.read(cx).style(cx),
- CursorShape::Bar,
- );
+ let mut element = EditorElement::new(editor.downgrade(), editor.read(cx).style(cx));
let mut scene = Scene::new(1.0);
let mut presenter = cx.build_presenter(window_id, 30., Default::default());
@@ -120,6 +120,7 @@ impl FollowableItem for Editor {
buffer.set_active_selections(
&self.selections.disjoint_anchors(),
self.selections.line_mode,
+ self.cursor_shape,
cx,
);
}
@@ -531,21 +532,17 @@ impl Item for Editor {
let buffer = multibuffer.buffer(buffer_id)?;
let buffer = buffer.read(cx);
- let filename = if let Some(file) = buffer.file() {
- if file.path().file_name().is_none()
- || self
- .project
+ let filename = buffer
+ .snapshot()
+ .resolve_file_path(
+ cx,
+ self.project
.as_ref()
.map(|project| project.read(cx).visible_worktrees(cx).count() > 1)
- .unwrap_or_default()
- {
- file.full_path(cx).to_string_lossy().to_string()
- } else {
- file.path().to_string_lossy().to_string()
- }
- } else {
- "untitled".to_string()
- };
+ .unwrap_or_default(),
+ )
+ .map(|path| path.to_string_lossy().to_string())
+ .unwrap_or_else(|| "untitled".to_string());
let mut breadcrumbs = vec![Label::new(filename, theme.breadcrumbs.text.clone()).boxed()];
breadcrumbs.extend(symbols.into_iter().map(|symbol| {
@@ -19,12 +19,6 @@ pub struct UpdateGoToDefinitionLink {
pub shift_held: bool,
}
-#[derive(Clone, PartialEq)]
-pub struct CmdShiftChanged {
- pub cmd_down: bool,
- pub shift_down: bool,
-}
-
#[derive(Clone, PartialEq)]
pub struct GoToFetchedDefinition {
pub point: DisplayPoint,
@@ -39,7 +33,6 @@ impl_internal_actions!(
editor,
[
UpdateGoToDefinitionLink,
- CmdShiftChanged,
GoToFetchedDefinition,
GoToFetchedTypeDefinition
]
@@ -47,7 +40,6 @@ impl_internal_actions!(
pub fn init(cx: &mut MutableAppContext) {
cx.add_action(update_go_to_definition_link);
- cx.add_action(cmd_shift_changed);
cx.add_action(go_to_fetched_definition);
cx.add_action(go_to_fetched_type_definition);
}
@@ -113,37 +105,6 @@ pub fn update_go_to_definition_link(
hide_link_definition(editor, cx);
}
-pub fn cmd_shift_changed(
- editor: &mut Editor,
- &CmdShiftChanged {
- cmd_down,
- shift_down,
- }: &CmdShiftChanged,
- cx: &mut ViewContext<Editor>,
-) {
- let pending_selection = editor.has_pending_selection();
-
- if let Some(point) = editor
- .link_go_to_definition_state
- .last_mouse_location
- .clone()
- {
- if cmd_down && !pending_selection {
- let snapshot = editor.snapshot(cx);
- let kind = if shift_down {
- LinkDefinitionKind::Type
- } else {
- LinkDefinitionKind::Symbol
- };
-
- show_link_definition(kind, editor, point, snapshot, cx);
- return;
- }
- }
-
- hide_link_definition(editor, cx)
-}
-
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum LinkDefinitionKind {
Symbol,
@@ -397,6 +358,7 @@ fn go_to_fetched_definition_of_kind(
#[cfg(test)]
mod tests {
use futures::StreamExt;
+ use gpui::{ModifiersChangedEvent, View};
use indoc::indoc;
use lsp::request::{GotoDefinition, GotoTypeDefinition};
@@ -467,11 +429,10 @@ mod tests {
// Unpress shift causes highlight to go away (normal goto-definition is not valid here)
cx.update_editor(|editor, cx| {
- cmd_shift_changed(
- editor,
- &CmdShiftChanged {
- cmd_down: true,
- shift_down: false,
+ editor.modifiers_changed(
+ &gpui::ModifiersChangedEvent {
+ cmd: true,
+ ..Default::default()
},
cx,
);
@@ -581,14 +542,7 @@ mod tests {
// Unpress cmd causes highlight to go away
cx.update_editor(|editor, cx| {
- cmd_shift_changed(
- editor,
- &CmdShiftChanged {
- cmd_down: false,
- shift_down: false,
- },
- cx,
- );
+ editor.modifiers_changed(&Default::default(), cx);
});
// Assert no link highlights
@@ -704,11 +658,10 @@ mod tests {
])))
});
cx.update_editor(|editor, cx| {
- cmd_shift_changed(
- editor,
- &CmdShiftChanged {
- cmd_down: true,
- shift_down: false,
+ editor.modifiers_changed(
+ &ModifiersChangedEvent {
+ cmd: true,
+ ..Default::default()
},
cx,
);
@@ -8,7 +8,7 @@ use git::diff::DiffHunk;
use gpui::{AppContext, Entity, ModelContext, ModelHandle, Task};
pub use language::Completion;
use language::{
- char_kind, AutoindentMode, Buffer, BufferChunks, BufferSnapshot, CharKind, Chunk,
+ char_kind, AutoindentMode, Buffer, BufferChunks, BufferSnapshot, CharKind, Chunk, CursorShape,
DiagnosticEntry, Event, File, IndentSize, Language, OffsetRangeExt, OffsetUtf16, Outline,
OutlineItem, Point, PointUtf16, Selection, TextDimension, ToOffset as _, ToOffsetUtf16 as _,
ToPoint as _, ToPointUtf16 as _, TransactionId,
@@ -604,6 +604,7 @@ impl MultiBuffer {
&mut self,
selections: &[Selection<Anchor>],
line_mode: bool,
+ cursor_shape: CursorShape,
cx: &mut ModelContext<Self>,
) {
let mut selections_by_buffer: HashMap<usize, Vec<Selection<text::Anchor>>> =
@@ -668,7 +669,7 @@ impl MultiBuffer {
}
Some(selection)
}));
- buffer.set_active_selections(merged_selections, line_mode, cx);
+ buffer.set_active_selections(merged_selections, line_mode, cursor_shape, cx);
});
}
}
@@ -2698,7 +2699,7 @@ impl MultiBufferSnapshot {
pub fn remote_selections_in_range<'a>(
&'a self,
range: &'a Range<Anchor>,
- ) -> impl 'a + Iterator<Item = (ReplicaId, bool, Selection<Anchor>)> {
+ ) -> impl 'a + Iterator<Item = (ReplicaId, bool, CursorShape, Selection<Anchor>)> {
let mut cursor = self.excerpts.cursor::<Option<&ExcerptId>>();
cursor.seek(&Some(&range.start.excerpt_id), Bias::Left, &());
cursor
@@ -2715,7 +2716,7 @@ impl MultiBufferSnapshot {
excerpt
.buffer
.remote_selections_in_range(query_range)
- .flat_map(move |(replica_id, line_mode, selections)| {
+ .flat_map(move |(replica_id, line_mode, cursor_shape, selections)| {
selections.map(move |selection| {
let mut start = Anchor {
buffer_id: Some(excerpt.buffer_id),
@@ -2737,6 +2738,7 @@ impl MultiBufferSnapshot {
(
replica_id,
line_mode,
+ cursor_shape,
Selection {
id: selection.id,
start,
@@ -53,7 +53,7 @@ impl View for FileFinder {
ChildView::new(self.picker.clone(), cx).boxed()
}
- fn on_focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+ fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
if cx.is_self_focused() {
cx.focus(&self.picker);
}
@@ -13,6 +13,7 @@ use smol::io::{AsyncReadExt, AsyncWriteExt};
use std::borrow::Cow;
use std::cmp;
use std::io::Write;
+use std::ops::Deref;
use std::sync::Arc;
use std::{
io,
@@ -92,6 +93,17 @@ impl LineEnding {
}
}
}
+
+pub struct HomeDir(pub PathBuf);
+
+impl Deref for HomeDir {
+ type Target = PathBuf;
+
+ fn deref(&self) -> &Self::Target {
+ &self.0
+ }
+}
+
#[async_trait::async_trait]
pub trait Fs: Send + Sync {
async fn create_dir(&self, path: &Path) -> Result<()>;
@@ -183,7 +183,7 @@ impl View for GoToLine {
.named("go to line")
}
- fn on_focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+ fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
cx.focus(&self.line_editor);
}
}
@@ -101,18 +101,6 @@ impl gpui::Element for TextElement {
line.paint(bounds.origin(), visible_bounds, bounds.height(), cx);
}
- fn dispatch_event(
- &mut self,
- _: &gpui::Event,
- _: RectF,
- _: RectF,
- _: &mut Self::LayoutState,
- _: &mut Self::PaintState,
- _: &mut gpui::EventContext,
- ) -> bool {
- false
- }
-
fn rect_for_text_range(
&self,
_: Range<usize>,
@@ -41,8 +41,8 @@ use crate::{
platform::{self, KeyDownEvent, Platform, PromptLevel, WindowOptions},
presenter::Presenter,
util::post_inc,
- Appearance, AssetCache, AssetSource, ClipboardItem, FontCache, InputHandler, MouseButton,
- MouseRegionId, PathPromptOptions, TextLayoutCache,
+ Appearance, AssetCache, AssetSource, ClipboardItem, FontCache, InputHandler, KeyUpEvent,
+ ModifiersChangedEvent, MouseButton, MouseRegionId, PathPromptOptions, TextLayoutCache,
};
pub trait Entity: 'static {
@@ -60,8 +60,18 @@ pub trait Entity: 'static {
pub trait View: Entity + Sized {
fn ui_name() -> &'static str;
fn render(&mut self, cx: &mut RenderContext<'_, Self>) -> ElementBox;
- fn on_focus_in(&mut self, _: AnyViewHandle, _: &mut ViewContext<Self>) {}
- fn on_focus_out(&mut self, _: AnyViewHandle, _: &mut ViewContext<Self>) {}
+ fn focus_in(&mut self, _: AnyViewHandle, _: &mut ViewContext<Self>) {}
+ fn focus_out(&mut self, _: AnyViewHandle, _: &mut ViewContext<Self>) {}
+ fn key_down(&mut self, _: &KeyDownEvent, _: &mut ViewContext<Self>) -> bool {
+ false
+ }
+ fn key_up(&mut self, _: &KeyUpEvent, _: &mut ViewContext<Self>) -> bool {
+ false
+ }
+ fn modifiers_changed(&mut self, _: &ModifiersChangedEvent, _: &mut ViewContext<Self>) -> bool {
+ false
+ }
+
fn keymap_context(&self, _: &AppContext) -> keymap::Context {
Self::default_keymap_context()
}
@@ -1297,7 +1307,7 @@ impl MutableAppContext {
) -> impl Iterator<Item = (&'static str, Box<dyn Action>, SmallVec<[&Binding; 1]>)> {
let mut action_types: HashSet<_> = self.global_actions.keys().copied().collect();
- for view_id in self.parents(window_id, view_id) {
+ for view_id in self.ancestors(window_id, view_id) {
if let Some(view) = self.views.get(&(window_id, view_id)) {
let view_type = view.as_any().type_id();
if let Some(actions) = self.actions.get(&view_type) {
@@ -1327,7 +1337,7 @@ impl MutableAppContext {
let action_type = action.as_any().type_id();
if let Some(window_id) = self.cx.platform.key_window_id() {
if let Some(focused_view_id) = self.focused_view_id(window_id) {
- for view_id in self.parents(window_id, focused_view_id) {
+ for view_id in self.ancestors(window_id, focused_view_id) {
if let Some(view) = self.views.get(&(window_id, view_id)) {
let view_type = view.as_any().type_id();
if let Some(actions) = self.actions.get(&view_type) {
@@ -1376,7 +1386,7 @@ impl MutableAppContext {
mut visit: impl FnMut(usize, bool, &mut MutableAppContext) -> bool,
) -> bool {
// List of view ids from the leaf to the root of the window
- let path = self.parents(window_id, view_id).collect::<Vec<_>>();
+ let path = self.ancestors(window_id, view_id).collect::<Vec<_>>();
// Walk down from the root to the leaf calling visit with capture_phase = true
for view_id in path.iter().rev() {
@@ -1397,7 +1407,7 @@ impl MutableAppContext {
// Returns an iterator over all of the view ids from the passed view up to the root of the window
// Includes the passed view itself
- fn parents(&self, window_id: usize, mut view_id: usize) -> impl Iterator<Item = usize> + '_ {
+ fn ancestors(&self, window_id: usize, mut view_id: usize) -> impl Iterator<Item = usize> + '_ {
std::iter::once(view_id)
.into_iter()
.chain(std::iter::from_fn(move || {
@@ -1445,11 +1455,81 @@ impl MutableAppContext {
self.keystroke_matcher.clear_bindings();
}
+ pub fn dispatch_key_down(&mut self, window_id: usize, event: &KeyDownEvent) -> bool {
+ if let Some(focused_view_id) = self.focused_view_id(window_id) {
+ for view_id in self
+ .ancestors(window_id, focused_view_id)
+ .collect::<Vec<_>>()
+ {
+ if let Some(mut view) = self.cx.views.remove(&(window_id, view_id)) {
+ let handled = view.key_down(event, self, window_id, view_id);
+ self.cx.views.insert((window_id, view_id), view);
+ if handled {
+ return true;
+ }
+ } else {
+ log::error!("view {} does not exist", view_id)
+ }
+ }
+ }
+
+ false
+ }
+
+ pub fn dispatch_key_up(&mut self, window_id: usize, event: &KeyUpEvent) -> bool {
+ if let Some(focused_view_id) = self.focused_view_id(window_id) {
+ for view_id in self
+ .ancestors(window_id, focused_view_id)
+ .collect::<Vec<_>>()
+ {
+ if let Some(mut view) = self.cx.views.remove(&(window_id, view_id)) {
+ let handled = view.key_up(event, self, window_id, view_id);
+ self.cx.views.insert((window_id, view_id), view);
+ if handled {
+ return true;
+ }
+ } else {
+ log::error!("view {} does not exist", view_id)
+ }
+ }
+ }
+
+ false
+ }
+
+ pub fn dispatch_modifiers_changed(
+ &mut self,
+ window_id: usize,
+ event: &ModifiersChangedEvent,
+ ) -> bool {
+ if let Some(focused_view_id) = self.focused_view_id(window_id) {
+ for view_id in self
+ .ancestors(window_id, focused_view_id)
+ .collect::<Vec<_>>()
+ {
+ if let Some(mut view) = self.cx.views.remove(&(window_id, view_id)) {
+ let handled = view.modifiers_changed(event, self, window_id, view_id);
+ self.cx.views.insert((window_id, view_id), view);
+ if handled {
+ return true;
+ }
+ } else {
+ log::error!("view {} does not exist", view_id)
+ }
+ }
+ }
+
+ false
+ }
+
pub fn dispatch_keystroke(&mut self, window_id: usize, keystroke: &Keystroke) -> bool {
let mut pending = false;
if let Some(focused_view_id) = self.focused_view_id(window_id) {
- for view_id in self.parents(window_id, focused_view_id).collect::<Vec<_>>() {
+ for view_id in self
+ .ancestors(window_id, focused_view_id)
+ .collect::<Vec<_>>()
+ {
let keymap_context = self
.cx
.views
@@ -1580,7 +1660,7 @@ impl MutableAppContext {
is_fullscreen: false,
},
);
- root_view.update(this, |view, cx| view.on_focus_in(cx.handle().into(), cx));
+ root_view.update(this, |view, cx| view.focus_in(cx.handle().into(), cx));
let window =
this.cx
@@ -1612,7 +1692,7 @@ impl MutableAppContext {
is_fullscreen: false,
},
);
- root_view.update(this, |view, cx| view.on_focus_in(cx.handle().into(), cx));
+ root_view.update(this, |view, cx| view.focus_in(cx.handle().into(), cx));
let status_item = this.cx.platform.add_status_item();
this.register_platform_window(window_id, status_item);
@@ -2235,12 +2315,12 @@ impl MutableAppContext {
//Handle focus
let focused_id = window.focused_view_id?;
- for view_id in this.parents(window_id, focused_id).collect::<Vec<_>>() {
+ for view_id in this.ancestors(window_id, focused_id).collect::<Vec<_>>() {
if let Some(mut view) = this.cx.views.remove(&(window_id, view_id)) {
if active {
- view.on_focus_in(this, window_id, view_id, focused_id);
+ view.focus_in(this, window_id, view_id, focused_id);
} else {
- view.on_focus_out(this, window_id, view_id, focused_id);
+ view.focus_out(this, window_id, view_id, focused_id);
}
this.cx.views.insert((window_id, view_id), view);
}
@@ -2272,16 +2352,16 @@ impl MutableAppContext {
});
let blurred_parents = blurred_id
- .map(|blurred_id| this.parents(window_id, blurred_id).collect::<Vec<_>>())
+ .map(|blurred_id| this.ancestors(window_id, blurred_id).collect::<Vec<_>>())
.unwrap_or_default();
let focused_parents = focused_id
- .map(|focused_id| this.parents(window_id, focused_id).collect::<Vec<_>>())
+ .map(|focused_id| this.ancestors(window_id, focused_id).collect::<Vec<_>>())
.unwrap_or_default();
if let Some(blurred_id) = blurred_id {
for view_id in blurred_parents.iter().copied() {
if let Some(mut view) = this.cx.views.remove(&(window_id, view_id)) {
- view.on_focus_out(this, window_id, view_id, blurred_id);
+ view.focus_out(this, window_id, view_id, blurred_id);
this.cx.views.insert((window_id, view_id), view);
}
}
@@ -2294,7 +2374,7 @@ impl MutableAppContext {
if let Some(focused_id) = focused_id {
for view_id in focused_parents {
if let Some(mut view) = this.cx.views.remove(&(window_id, view_id)) {
- view.on_focus_in(this, window_id, view_id, focused_id);
+ view.focus_in(this, window_id, view_id, focused_id);
this.cx.views.insert((window_id, view_id), view);
}
}
@@ -2961,20 +3041,41 @@ pub trait AnyView {
) -> Option<Pin<Box<dyn 'static + Future<Output = ()>>>>;
fn ui_name(&self) -> &'static str;
fn render(&mut self, params: RenderParams, cx: &mut MutableAppContext) -> ElementBox;
- fn on_focus_in(
+ fn focus_in(
&mut self,
cx: &mut MutableAppContext,
window_id: usize,
view_id: usize,
focused_id: usize,
);
- fn on_focus_out(
+ fn focus_out(
&mut self,
cx: &mut MutableAppContext,
window_id: usize,
view_id: usize,
focused_id: usize,
);
+ fn key_down(
+ &mut self,
+ event: &KeyDownEvent,
+ cx: &mut MutableAppContext,
+ window_id: usize,
+ view_id: usize,
+ ) -> bool;
+ fn key_up(
+ &mut self,
+ event: &KeyUpEvent,
+ cx: &mut MutableAppContext,
+ window_id: usize,
+ view_id: usize,
+ ) -> bool;
+ fn modifiers_changed(
+ &mut self,
+ event: &ModifiersChangedEvent,
+ cx: &mut MutableAppContext,
+ window_id: usize,
+ view_id: usize,
+ ) -> bool;
fn keymap_context(&self, cx: &AppContext) -> keymap::Context;
fn debug_json(&self, cx: &AppContext) -> serde_json::Value;
@@ -3040,7 +3141,7 @@ where
View::render(self, &mut RenderContext::new(params, cx))
}
- fn on_focus_in(
+ fn focus_in(
&mut self,
cx: &mut MutableAppContext,
window_id: usize,
@@ -3059,10 +3160,10 @@ where
.type_id();
AnyViewHandle::new(window_id, focused_id, focused_type, cx.ref_counts.clone())
};
- View::on_focus_in(self, focused_view_handle, &mut cx);
+ View::focus_in(self, focused_view_handle, &mut cx);
}
- fn on_focus_out(
+ fn focus_out(
&mut self,
cx: &mut MutableAppContext,
window_id: usize,
@@ -3081,7 +3182,40 @@ where
.type_id();
AnyViewHandle::new(window_id, blurred_id, blurred_type, cx.ref_counts.clone())
};
- View::on_focus_out(self, blurred_view_handle, &mut cx);
+ View::focus_out(self, blurred_view_handle, &mut cx);
+ }
+
+ fn key_down(
+ &mut self,
+ event: &KeyDownEvent,
+ cx: &mut MutableAppContext,
+ window_id: usize,
+ view_id: usize,
+ ) -> bool {
+ let mut cx = ViewContext::new(cx, window_id, view_id);
+ View::key_down(self, event, &mut cx)
+ }
+
+ fn key_up(
+ &mut self,
+ event: &KeyUpEvent,
+ cx: &mut MutableAppContext,
+ window_id: usize,
+ view_id: usize,
+ ) -> bool {
+ let mut cx = ViewContext::new(cx, window_id, view_id);
+ View::key_up(self, event, &mut cx)
+ }
+
+ fn modifiers_changed(
+ &mut self,
+ event: &ModifiersChangedEvent,
+ cx: &mut MutableAppContext,
+ window_id: usize,
+ view_id: usize,
+ ) -> bool {
+ let mut cx = ViewContext::new(cx, window_id, view_id);
+ View::modifiers_changed(self, event, &mut cx)
}
fn keymap_context(&self, cx: &AppContext) -> keymap::Context {
@@ -3463,7 +3597,7 @@ impl<'a, T: View> ViewContext<'a, T> {
if self.window_id != view.window_id {
return false;
}
- self.parents(view.window_id, view.view_id)
+ self.ancestors(view.window_id, view.view_id)
.any(|parent| parent == self.view_id)
}
@@ -6354,13 +6488,13 @@ mod tests {
"View"
}
- fn on_focus_in(&mut self, focused: AnyViewHandle, cx: &mut ViewContext<Self>) {
+ fn focus_in(&mut self, focused: AnyViewHandle, cx: &mut ViewContext<Self>) {
if cx.handle().id() == focused.id() {
self.events.lock().push(format!("{} focused", &self.name));
}
}
- fn on_focus_out(&mut self, blurred: AnyViewHandle, cx: &mut ViewContext<Self>) {
+ fn focus_out(&mut self, blurred: AnyViewHandle, cx: &mut ViewContext<Self>) {
if cx.handle().id() == blurred.id() {
self.events.lock().push(format!("{} blurred", &self.name));
}
@@ -33,8 +33,8 @@ use crate::{
},
json,
presenter::MeasurementContext,
- Action, DebugContext, Event, EventContext, LayoutContext, PaintContext, RenderContext,
- SizeConstraint, View,
+ Action, DebugContext, EventContext, LayoutContext, PaintContext, RenderContext, SizeConstraint,
+ View,
};
use core::panic;
use json::ToJson;
@@ -50,7 +50,6 @@ use std::{
trait AnyElement {
fn layout(&mut self, constraint: SizeConstraint, cx: &mut LayoutContext) -> Vector2F;
fn paint(&mut self, origin: Vector2F, visible_bounds: RectF, cx: &mut PaintContext);
- fn dispatch_event(&mut self, event: &Event, cx: &mut EventContext) -> bool;
fn rect_for_text_range(
&self,
range_utf16: Range<usize>,
@@ -80,16 +79,6 @@ pub trait Element {
cx: &mut PaintContext,
) -> Self::PaintState;
- fn dispatch_event(
- &mut self,
- event: &Event,
- bounds: RectF,
- visible_bounds: RectF,
- layout: &mut Self::LayoutState,
- paint: &mut Self::PaintState,
- cx: &mut EventContext,
- ) -> bool;
-
fn rect_for_text_range(
&self,
range_utf16: Range<usize>,
@@ -303,22 +292,6 @@ impl<T: Element> AnyElement for Lifecycle<T> {
}
}
- fn dispatch_event(&mut self, event: &Event, cx: &mut EventContext) -> bool {
- if let Lifecycle::PostPaint {
- element,
- bounds,
- visible_bounds,
- layout,
- paint,
- ..
- } = self
- {
- element.dispatch_event(event, *bounds, *visible_bounds, layout, paint, cx)
- } else {
- panic!("invalid element lifecycle state");
- }
- }
-
fn rect_for_text_range(
&self,
range_utf16: Range<usize>,
@@ -433,10 +406,6 @@ impl ElementRc {
self.element.borrow_mut().paint(origin, visible_bounds, cx);
}
- pub fn dispatch_event(&mut self, event: &Event, cx: &mut EventContext) -> bool {
- self.element.borrow_mut().dispatch_event(event, cx)
- }
-
pub fn rect_for_text_range(
&self,
range_utf16: Range<usize>,
@@ -2,8 +2,7 @@ use crate::{
geometry::{rect::RectF, vector::Vector2F},
json,
presenter::MeasurementContext,
- DebugContext, Element, ElementBox, Event, EventContext, LayoutContext, PaintContext,
- SizeConstraint,
+ DebugContext, Element, ElementBox, LayoutContext, PaintContext, SizeConstraint,
};
use json::ToJson;
@@ -84,18 +83,6 @@ impl Element for Align {
);
}
- fn dispatch_event(
- &mut self,
- event: &Event,
- _: RectF,
- _: RectF,
- _: &mut Self::LayoutState,
- _: &mut Self::PaintState,
- cx: &mut EventContext,
- ) -> bool {
- self.child.dispatch_event(event, cx)
- }
-
fn rect_for_text_range(
&self,
range_utf16: std::ops::Range<usize>,
@@ -56,18 +56,6 @@ where
self.0(bounds, visible_bounds, cx)
}
- fn dispatch_event(
- &mut self,
- _: &crate::Event,
- _: RectF,
- _: RectF,
- _: &mut Self::LayoutState,
- _: &mut Self::PaintState,
- _: &mut crate::EventContext,
- ) -> bool {
- false
- }
-
fn rect_for_text_range(
&self,
_: std::ops::Range<usize>,
@@ -7,8 +7,7 @@ use crate::{
geometry::{rect::RectF, vector::Vector2F},
json,
presenter::MeasurementContext,
- DebugContext, Element, ElementBox, Event, EventContext, LayoutContext, PaintContext,
- SizeConstraint,
+ DebugContext, Element, ElementBox, LayoutContext, PaintContext, SizeConstraint,
};
pub struct ConstrainedBox {
@@ -157,18 +156,6 @@ impl Element for ConstrainedBox {
self.child.paint(bounds.origin(), visible_bounds, cx);
}
- fn dispatch_event(
- &mut self,
- event: &Event,
- _: RectF,
- _: RectF,
- _: &mut Self::LayoutState,
- _: &mut Self::PaintState,
- cx: &mut EventContext,
- ) -> bool {
- self.child.dispatch_event(event, cx)
- }
-
fn rect_for_text_range(
&self,
range_utf16: Range<usize>,
@@ -11,7 +11,7 @@ use crate::{
platform::CursorStyle,
presenter::MeasurementContext,
scene::{self, Border, CursorRegion, Quad},
- Element, ElementBox, Event, EventContext, LayoutContext, PaintContext, SizeConstraint,
+ Element, ElementBox, LayoutContext, PaintContext, SizeConstraint,
};
use serde::Deserialize;
use serde_json::json;
@@ -285,18 +285,6 @@ impl Element for Container {
}
}
- fn dispatch_event(
- &mut self,
- event: &Event,
- _: RectF,
- _: RectF,
- _: &mut Self::LayoutState,
- _: &mut Self::PaintState,
- cx: &mut EventContext,
- ) -> bool {
- self.child.dispatch_event(event, cx)
- }
-
fn rect_for_text_range(
&self,
range_utf16: Range<usize>,
@@ -9,7 +9,7 @@ use crate::{
presenter::MeasurementContext,
DebugContext,
};
-use crate::{Element, Event, EventContext, LayoutContext, PaintContext, SizeConstraint};
+use crate::{Element, LayoutContext, PaintContext, SizeConstraint};
#[derive(Default)]
pub struct Empty {
@@ -59,18 +59,6 @@ impl Element for Empty {
) -> Self::PaintState {
}
- fn dispatch_event(
- &mut self,
- _: &Event,
- _: RectF,
- _: RectF,
- _: &mut Self::LayoutState,
- _: &mut Self::PaintState,
- _: &mut EventContext,
- ) -> bool {
- false
- }
-
fn rect_for_text_range(
&self,
_: Range<usize>,
@@ -4,8 +4,7 @@ use crate::{
geometry::{rect::RectF, vector::Vector2F},
json,
presenter::MeasurementContext,
- DebugContext, Element, ElementBox, Event, EventContext, LayoutContext, PaintContext,
- SizeConstraint,
+ DebugContext, Element, ElementBox, LayoutContext, PaintContext, SizeConstraint,
};
use serde_json::json;
@@ -66,18 +65,6 @@ impl Element for Expanded {
self.child.paint(bounds.origin(), visible_bounds, cx);
}
- fn dispatch_event(
- &mut self,
- event: &Event,
- _: RectF,
- _: RectF,
- _: &mut Self::LayoutState,
- _: &mut Self::PaintState,
- cx: &mut EventContext,
- ) -> bool {
- self.child.dispatch_event(event, cx)
- }
-
fn rect_for_text_range(
&self,
range_utf16: Range<usize>,
@@ -3,8 +3,8 @@ use std::{any::Any, cell::Cell, f32::INFINITY, ops::Range, rc::Rc};
use crate::{
json::{self, ToJson, Value},
presenter::MeasurementContext,
- Axis, DebugContext, Element, ElementBox, ElementStateHandle, Event, EventContext,
- LayoutContext, PaintContext, RenderContext, SizeConstraint, Vector2FExt, View,
+ Axis, DebugContext, Element, ElementBox, ElementStateHandle, LayoutContext, PaintContext,
+ RenderContext, SizeConstraint, Vector2FExt, View,
};
use pathfinder_geometry::{
rect::RectF,
@@ -259,7 +259,7 @@ impl Element for Flex {
if remaining_space < 0. {
let mut delta = match axis {
Axis::Horizontal => {
- if e.delta.x() != 0. {
+ if e.delta.x().abs() >= e.delta.y().abs() {
e.delta.x()
} else {
e.delta.y()
@@ -318,23 +318,6 @@ impl Element for Flex {
}
}
- fn dispatch_event(
- &mut self,
- event: &Event,
- _: RectF,
- _: RectF,
- _: &mut Self::LayoutState,
- _: &mut Self::PaintState,
- cx: &mut EventContext,
- ) -> bool {
- let mut handled = false;
- for child in &mut self.children {
- handled = child.dispatch_event(event, cx) || handled;
- }
-
- handled
- }
-
fn rect_for_text_range(
&self,
range_utf16: Range<usize>,
@@ -420,18 +403,6 @@ impl Element for FlexItem {
self.child.paint(bounds.origin(), visible_bounds, cx)
}
- fn dispatch_event(
- &mut self,
- event: &Event,
- _: RectF,
- _: RectF,
- _: &mut Self::LayoutState,
- _: &mut Self::PaintState,
- cx: &mut EventContext,
- ) -> bool {
- self.child.dispatch_event(event, cx)
- }
-
fn rect_for_text_range(
&self,
range_utf16: Range<usize>,
@@ -4,8 +4,7 @@ use crate::{
geometry::{rect::RectF, vector::Vector2F},
json::json,
presenter::MeasurementContext,
- DebugContext, Element, ElementBox, Event, EventContext, LayoutContext, PaintContext,
- SizeConstraint,
+ DebugContext, Element, ElementBox, LayoutContext, PaintContext, SizeConstraint,
};
pub struct Hook {
@@ -56,18 +55,6 @@ impl Element for Hook {
self.child.paint(bounds.origin(), visible_bounds, cx);
}
- fn dispatch_event(
- &mut self,
- event: &Event,
- _: RectF,
- _: RectF,
- _: &mut Self::LayoutState,
- _: &mut Self::PaintState,
- cx: &mut EventContext,
- ) -> bool {
- self.child.dispatch_event(event, cx)
- }
-
fn rect_for_text_range(
&self,
range_utf16: Range<usize>,
@@ -6,8 +6,7 @@ use crate::{
},
json::{json, ToJson},
presenter::MeasurementContext,
- scene, Border, DebugContext, Element, Event, EventContext, ImageData, LayoutContext,
- PaintContext, SizeConstraint,
+ scene, Border, DebugContext, Element, ImageData, LayoutContext, PaintContext, SizeConstraint,
};
use serde::Deserialize;
use std::{ops::Range, sync::Arc};
@@ -81,18 +80,6 @@ impl Element for Image {
});
}
- fn dispatch_event(
- &mut self,
- _: &Event,
- _: RectF,
- _: RectF,
- _: &mut Self::LayoutState,
- _: &mut Self::PaintState,
- _: &mut EventContext,
- ) -> bool {
- false
- }
-
fn rect_for_text_range(
&self,
_: Range<usize>,
@@ -2,7 +2,7 @@ use crate::{
elements::*,
fonts::TextStyle,
geometry::{rect::RectF, vector::Vector2F},
- Action, ElementBox, Event, EventContext, LayoutContext, PaintContext, SizeConstraint,
+ Action, ElementBox, LayoutContext, PaintContext, SizeConstraint,
};
use serde_json::json;
@@ -64,18 +64,6 @@ impl Element for KeystrokeLabel {
element.paint(bounds.origin(), visible_bounds, cx);
}
- fn dispatch_event(
- &mut self,
- event: &Event,
- _: RectF,
- _: RectF,
- element: &mut ElementBox,
- _: &mut (),
- cx: &mut EventContext,
- ) -> bool {
- element.dispatch_event(event, cx)
- }
-
fn rect_for_text_range(
&self,
_: Range<usize>,
@@ -9,7 +9,7 @@ use crate::{
json::{ToJson, Value},
presenter::MeasurementContext,
text_layout::{Line, RunStyle},
- DebugContext, Element, Event, EventContext, LayoutContext, PaintContext, SizeConstraint,
+ DebugContext, Element, LayoutContext, PaintContext, SizeConstraint,
};
use serde::Deserialize;
use serde_json::json;
@@ -165,18 +165,6 @@ impl Element for Label {
line.paint(bounds.origin(), visible_bounds, bounds.size().y(), cx)
}
- fn dispatch_event(
- &mut self,
- _: &Event,
- _: RectF,
- _: RectF,
- _: &mut Self::LayoutState,
- _: &mut Self::PaintState,
- _: &mut EventContext,
- ) -> bool {
- false
- }
-
fn rect_for_text_range(
&self,
_: Range<usize>,
@@ -5,7 +5,7 @@ use crate::{
},
json::json,
presenter::MeasurementContext,
- DebugContext, Element, ElementBox, ElementRc, Event, EventContext, LayoutContext, MouseRegion,
+ DebugContext, Element, ElementBox, ElementRc, EventContext, LayoutContext, MouseRegion,
PaintContext, RenderContext, SizeConstraint, View, ViewContext,
};
use std::{cell::RefCell, collections::VecDeque, ops::Range, rc::Rc};
@@ -13,7 +13,6 @@ use sum_tree::{Bias, SumTree};
pub struct List {
state: ListState,
- invalidated_elements: Vec<ElementRc>,
}
#[derive(Clone)]
@@ -82,10 +81,7 @@ struct Height(f32);
impl List {
pub fn new(state: ListState) -> Self {
- Self {
- state,
- invalidated_elements: Default::default(),
- }
+ Self { state }
}
}
@@ -289,50 +285,6 @@ impl Element for List {
cx.scene.pop_layer();
}
- fn dispatch_event(
- &mut self,
- event: &Event,
- bounds: RectF,
- _: RectF,
- scroll_top: &mut ListOffset,
- _: &mut (),
- cx: &mut EventContext,
- ) -> bool {
- let mut handled = false;
-
- let mut state = self.state.0.borrow_mut();
- let mut item_origin = bounds.origin() - vec2f(0., scroll_top.offset_in_item);
- let mut cursor = state.items.cursor::<Count>();
- let mut new_items = cursor.slice(&Count(scroll_top.item_ix), Bias::Right, &());
- while let Some(item) = cursor.item() {
- if item_origin.y() > bounds.max_y() {
- break;
- }
-
- if let ListItem::Rendered(element) = item {
- let prev_notify_count = cx.notify_count();
- let mut element = element.clone();
- handled = element.dispatch_event(event, cx) || handled;
- item_origin.set_y(item_origin.y() + element.size().y());
- if cx.notify_count() > prev_notify_count {
- new_items.push(ListItem::Unrendered, &());
- self.invalidated_elements.push(element);
- } else {
- new_items.push(item.clone(), &());
- }
- cursor.next(&());
- } else {
- unreachable!();
- }
- }
-
- new_items.push_tree(cursor.suffix(&()), &());
- drop(cursor);
- state.items = new_items;
-
- handled
- }
-
fn rect_for_text_range(
&self,
range_utf16: Range<usize>,
@@ -964,18 +916,6 @@ mod tests {
todo!()
}
- fn dispatch_event(
- &mut self,
- _: &Event,
- _: RectF,
- _: RectF,
- _: &mut (),
- _: &mut (),
- _: &mut EventContext,
- ) -> bool {
- todo!()
- }
-
fn rect_for_text_range(
&self,
_: Range<usize>,
@@ -6,11 +6,10 @@ use crate::{
},
platform::CursorStyle,
scene::{
- ClickRegionEvent, CursorRegion, DownOutRegionEvent, DownRegionEvent, DragRegionEvent,
- HandlerSet, HoverRegionEvent, MoveRegionEvent, ScrollWheelRegionEvent, UpOutRegionEvent,
- UpRegionEvent,
+ CursorRegion, HandlerSet, MouseClick, MouseDown, MouseDownOut, MouseDrag, MouseHover,
+ MouseMove, MouseScrollWheel, MouseUp, MouseUpOut,
},
- DebugContext, Element, ElementBox, Event, EventContext, LayoutContext, MeasurementContext,
+ DebugContext, Element, ElementBox, EventContext, LayoutContext, MeasurementContext,
MouseButton, MouseRegion, MouseState, PaintContext, RenderContext, SizeConstraint, View,
};
use serde_json::json;
@@ -61,10 +60,7 @@ impl<Tag> MouseEventHandler<Tag> {
self
}
- pub fn on_move(
- mut self,
- handler: impl Fn(MoveRegionEvent, &mut EventContext) + 'static,
- ) -> Self {
+ pub fn on_move(mut self, handler: impl Fn(MouseMove, &mut EventContext) + 'static) -> Self {
self.handlers = self.handlers.on_move(handler);
self
}
@@ -72,7 +68,7 @@ impl<Tag> MouseEventHandler<Tag> {
pub fn on_down(
mut self,
button: MouseButton,
- handler: impl Fn(DownRegionEvent, &mut EventContext) + 'static,
+ handler: impl Fn(MouseDown, &mut EventContext) + 'static,
) -> Self {
self.handlers = self.handlers.on_down(button, handler);
self
@@ -81,7 +77,7 @@ impl<Tag> MouseEventHandler<Tag> {
pub fn on_up(
mut self,
button: MouseButton,
- handler: impl Fn(UpRegionEvent, &mut EventContext) + 'static,
+ handler: impl Fn(MouseUp, &mut EventContext) + 'static,
) -> Self {
self.handlers = self.handlers.on_up(button, handler);
self
@@ -90,7 +86,7 @@ impl<Tag> MouseEventHandler<Tag> {
pub fn on_click(
mut self,
button: MouseButton,
- handler: impl Fn(ClickRegionEvent, &mut EventContext) + 'static,
+ handler: impl Fn(MouseClick, &mut EventContext) + 'static,
) -> Self {
self.handlers = self.handlers.on_click(button, handler);
self
@@ -99,7 +95,7 @@ impl<Tag> MouseEventHandler<Tag> {
pub fn on_down_out(
mut self,
button: MouseButton,
- handler: impl Fn(DownOutRegionEvent, &mut EventContext) + 'static,
+ handler: impl Fn(MouseDownOut, &mut EventContext) + 'static,
) -> Self {
self.handlers = self.handlers.on_down_out(button, handler);
self
@@ -108,7 +104,7 @@ impl<Tag> MouseEventHandler<Tag> {
pub fn on_up_out(
mut self,
button: MouseButton,
- handler: impl Fn(UpOutRegionEvent, &mut EventContext) + 'static,
+ handler: impl Fn(MouseUpOut, &mut EventContext) + 'static,
) -> Self {
self.handlers = self.handlers.on_up_out(button, handler);
self
@@ -117,23 +113,20 @@ impl<Tag> MouseEventHandler<Tag> {
pub fn on_drag(
mut self,
button: MouseButton,
- handler: impl Fn(DragRegionEvent, &mut EventContext) + 'static,
+ handler: impl Fn(MouseDrag, &mut EventContext) + 'static,
) -> Self {
self.handlers = self.handlers.on_drag(button, handler);
self
}
- pub fn on_hover(
- mut self,
- handler: impl Fn(HoverRegionEvent, &mut EventContext) + 'static,
- ) -> Self {
+ pub fn on_hover(mut self, handler: impl Fn(MouseHover, &mut EventContext) + 'static) -> Self {
self.handlers = self.handlers.on_hover(handler);
self
}
pub fn on_scroll(
mut self,
- handler: impl Fn(ScrollWheelRegionEvent, &mut EventContext) + 'static,
+ handler: impl Fn(MouseScrollWheel, &mut EventContext) + 'static,
) -> Self {
self.handlers = self.handlers.on_scroll(handler);
self
@@ -201,18 +194,6 @@ impl<Tag> Element for MouseEventHandler<Tag> {
self.child.paint(bounds.origin(), visible_bounds, cx);
}
- fn dispatch_event(
- &mut self,
- event: &Event,
- _: RectF,
- _: RectF,
- _: &mut Self::LayoutState,
- _: &mut Self::PaintState,
- cx: &mut EventContext,
- ) -> bool {
- self.child.dispatch_event(event, cx)
- }
-
fn rect_for_text_range(
&self,
range_utf16: Range<usize>,
@@ -4,8 +4,8 @@ use crate::{
geometry::{rect::RectF, vector::Vector2F},
json::ToJson,
presenter::MeasurementContext,
- Axis, DebugContext, Element, ElementBox, Event, EventContext, LayoutContext, MouseRegion,
- PaintContext, SizeConstraint,
+ Axis, DebugContext, Element, ElementBox, LayoutContext, MouseRegion, PaintContext,
+ SizeConstraint,
};
use serde_json::json;
@@ -225,18 +225,6 @@ impl Element for Overlay {
cx.scene.pop_stacking_context();
}
- fn dispatch_event(
- &mut self,
- event: &Event,
- _: RectF,
- _: RectF,
- _: &mut Self::LayoutState,
- _: &mut Self::PaintState,
- cx: &mut EventContext,
- ) -> bool {
- self.child.dispatch_event(event, cx)
- }
-
fn rect_for_text_range(
&self,
range_utf16: Range<usize>,
@@ -4,7 +4,7 @@ use pathfinder_geometry::vector::{vec2f, Vector2F};
use serde_json::json;
use crate::{
- geometry::rect::RectF, scene::DragRegionEvent, Axis, CursorStyle, Element, ElementBox,
+ geometry::rect::RectF, scene::MouseDrag, Axis, CursorStyle, Element, ElementBox,
ElementStateHandle, MouseButton, MouseRegion, RenderContext, View,
};
@@ -42,7 +42,7 @@ impl Side {
}
}
- fn compute_delta(&self, e: DragRegionEvent) -> f32 {
+ fn compute_delta(&self, e: MouseDrag) -> f32 {
if self.before_content() {
self.relevant_component(e.prev_mouse_position) - self.relevant_component(e.position)
} else {
@@ -187,18 +187,6 @@ impl Element for Resizable {
self.child.paint(bounds.origin(), visible_bounds, cx);
}
- fn dispatch_event(
- &mut self,
- event: &crate::Event,
- _bounds: pathfinder_geometry::rect::RectF,
- _visible_bounds: pathfinder_geometry::rect::RectF,
- _layout: &mut Self::LayoutState,
- _paint: &mut Self::PaintState,
- cx: &mut crate::EventContext,
- ) -> bool {
- self.child.dispatch_event(event, cx)
- }
-
fn rect_for_text_range(
&self,
range_utf16: std::ops::Range<usize>,
@@ -4,8 +4,7 @@ use crate::{
geometry::{rect::RectF, vector::Vector2F},
json::{self, json, ToJson},
presenter::MeasurementContext,
- DebugContext, Element, ElementBox, Event, EventContext, LayoutContext, PaintContext,
- SizeConstraint,
+ DebugContext, Element, ElementBox, LayoutContext, PaintContext, SizeConstraint,
};
#[derive(Default)]
@@ -49,23 +48,6 @@ impl Element for Stack {
}
}
- fn dispatch_event(
- &mut self,
- event: &Event,
- _: RectF,
- _: RectF,
- _: &mut Self::LayoutState,
- _: &mut Self::PaintState,
- cx: &mut EventContext,
- ) -> bool {
- for child in self.children.iter_mut().rev() {
- if child.dispatch_event(event, cx) {
- return true;
- }
- }
- false
- }
-
fn rect_for_text_range(
&self,
range_utf16: Range<usize>,
@@ -9,7 +9,7 @@ use crate::{
vector::{vec2f, Vector2F},
},
presenter::MeasurementContext,
- scene, DebugContext, Element, Event, EventContext, LayoutContext, PaintContext, SizeConstraint,
+ scene, DebugContext, Element, LayoutContext, PaintContext, SizeConstraint,
};
pub struct Svg {
@@ -73,18 +73,6 @@ impl Element for Svg {
}
}
- fn dispatch_event(
- &mut self,
- _: &Event,
- _: RectF,
- _: RectF,
- _: &mut Self::LayoutState,
- _: &mut Self::PaintState,
- _: &mut EventContext,
- ) -> bool {
- false
- }
-
fn rect_for_text_range(
&self,
_: Range<usize>,
@@ -8,8 +8,7 @@ use crate::{
json::{ToJson, Value},
presenter::MeasurementContext,
text_layout::{Line, RunStyle, ShapedBoundary},
- DebugContext, Element, Event, EventContext, FontCache, LayoutContext, PaintContext,
- SizeConstraint, TextLayoutCache,
+ DebugContext, Element, FontCache, LayoutContext, PaintContext, SizeConstraint, TextLayoutCache,
};
use log::warn;
use serde_json::json;
@@ -178,18 +177,6 @@ impl Element for Text {
}
}
- fn dispatch_event(
- &mut self,
- _: &Event,
- _: RectF,
- _: RectF,
- _: &mut Self::LayoutState,
- _: &mut Self::PaintState,
- _: &mut EventContext,
- ) -> bool {
- false
- }
-
fn rect_for_text_range(
&self,
_: Range<usize>,
@@ -186,18 +186,6 @@ impl Element for Tooltip {
}
}
- fn dispatch_event(
- &mut self,
- event: &crate::Event,
- _: RectF,
- _: RectF,
- _: &mut Self::LayoutState,
- _: &mut Self::PaintState,
- cx: &mut crate::EventContext,
- ) -> bool {
- self.child.dispatch_event(event, cx)
- }
-
fn rect_for_text_range(
&self,
range: Range<usize>,
@@ -1,4 +1,4 @@
-use super::{Element, Event, EventContext, LayoutContext, PaintContext, SizeConstraint};
+use super::{Element, EventContext, LayoutContext, PaintContext, SizeConstraint};
use crate::{
geometry::{
rect::RectF,
@@ -6,7 +6,7 @@ use crate::{
},
json::{self, json},
presenter::MeasurementContext,
- scene::ScrollWheelRegionEvent,
+ scene::MouseScrollWheel,
ElementBox, MouseRegion, RenderContext, ScrollWheelEvent, View,
};
use json::ToJson;
@@ -292,7 +292,7 @@ impl Element for UniformList {
MouseRegion::new::<Self>(self.view_id, 0, visible_bounds).on_scroll({
let scroll_max = layout.scroll_max;
let state = self.state.clone();
- move |ScrollWheelRegionEvent {
+ move |MouseScrollWheel {
platform_event:
ScrollWheelEvent {
position,
@@ -324,23 +324,6 @@ impl Element for UniformList {
cx.scene.pop_layer();
}
- fn dispatch_event(
- &mut self,
- event: &Event,
- _: RectF,
- _: RectF,
- layout: &mut Self::LayoutState,
- _: &mut Self::PaintState,
- cx: &mut EventContext,
- ) -> bool {
- let mut handled = false;
- for item in &mut layout.items {
- handled = item.dispatch_event(event, cx) || handled;
- }
-
- handled
- }
-
fn rect_for_text_range(
&self,
range: Range<usize>,
@@ -11,7 +11,7 @@ pub struct KeyUpEvent {
pub keystroke: Keystroke,
}
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, Default)]
pub struct ModifiersChangedEvent {
pub ctrl: bool,
pub alt: bool,
@@ -7,9 +7,8 @@ use crate::{
keymap::Keystroke,
platform::{CursorStyle, Event},
scene::{
- ClickRegionEvent, CursorRegion, DownOutRegionEvent, DownRegionEvent, DragRegionEvent,
- HoverRegionEvent, MouseRegionEvent, MoveRegionEvent, ScrollWheelRegionEvent,
- UpOutRegionEvent, UpRegionEvent,
+ CursorRegion, MouseClick, MouseDown, MouseDownOut, MouseDrag, MouseEvent, MouseHover,
+ MouseMove, MouseScrollWheel, MouseUp, MouseUpOut,
},
text_layout::TextLayoutCache,
Action, AnyModelHandle, AnyViewHandle, AnyWeakModelHandle, AnyWeakViewHandle, Appearance,
@@ -229,293 +228,283 @@ impl Presenter {
event_reused: bool,
cx: &mut MutableAppContext,
) -> bool {
- if let Some(root_view_id) = cx.root_view_id(self.window_id) {
- let mut events_to_send = Vec::new();
- let mut notified_views: HashSet<usize> = Default::default();
-
- // 1. Allocate the correct set of GPUI events generated from the platform events
- // -> These are usually small: [Mouse Down] or [Mouse up, Click] or [Mouse Moved, Mouse Dragged?]
- // -> Also moves around mouse related state
- match &event {
- Event::MouseDown(e) => {
- // Click events are weird because they can be fired after a drag event.
- // MDN says that browsers handle this by starting from 'the most
- // specific ancestor element that contained both [positions]'
- // So we need to store the overlapping regions on mouse down.
-
- // If there is already clicked_button stored, don't replace it.
- if self.clicked_button.is_none() {
- self.clicked_region_ids = self
- .mouse_regions
- .iter()
- .filter_map(|(region, _)| {
- if region.bounds.contains_point(e.position) {
- Some(region.id())
- } else {
- None
- }
- })
- .collect();
-
- self.clicked_button = Some(e.button);
- }
+ let mut mouse_events = SmallVec::<[_; 2]>::new();
+ let mut notified_views: HashSet<usize> = Default::default();
+
+ // 1. Handle platform event. Keyboard events get dispatched immediately, while mouse events
+ // get mapped into the mouse-specific MouseEvent type.
+ // -> These are usually small: [Mouse Down] or [Mouse up, Click] or [Mouse Moved, Mouse Dragged?]
+ // -> Also updates mouse-related state
+ match &event {
+ Event::KeyDown(e) => return cx.dispatch_key_down(self.window_id, e),
+ Event::KeyUp(e) => return cx.dispatch_key_up(self.window_id, e),
+ Event::ModifiersChanged(e) => return cx.dispatch_modifiers_changed(self.window_id, e),
+ Event::MouseDown(e) => {
+ // Click events are weird because they can be fired after a drag event.
+ // MDN says that browsers handle this by starting from 'the most
+ // specific ancestor element that contained both [positions]'
+ // So we need to store the overlapping regions on mouse down.
+
+ // If there is already clicked_button stored, don't replace it.
+ if self.clicked_button.is_none() {
+ self.clicked_region_ids = self
+ .mouse_regions
+ .iter()
+ .filter_map(|(region, _)| {
+ if region.bounds.contains_point(e.position) {
+ Some(region.id())
+ } else {
+ None
+ }
+ })
+ .collect();
- events_to_send.push(MouseRegionEvent::Down(DownRegionEvent {
- region: Default::default(),
- platform_event: e.clone(),
- }));
- events_to_send.push(MouseRegionEvent::DownOut(DownOutRegionEvent {
- region: Default::default(),
- platform_event: e.clone(),
- }));
+ self.clicked_button = Some(e.button);
}
- Event::MouseUp(e) => {
- // NOTE: The order of event pushes is important! MouseUp events MUST be fired
- // before click events, and so the UpRegionEvent events need to be pushed before
- // ClickRegionEvents
- events_to_send.push(MouseRegionEvent::Up(UpRegionEvent {
- region: Default::default(),
- platform_event: e.clone(),
- }));
- events_to_send.push(MouseRegionEvent::UpOut(UpOutRegionEvent {
- region: Default::default(),
- platform_event: e.clone(),
- }));
- events_to_send.push(MouseRegionEvent::Click(ClickRegionEvent {
- region: Default::default(),
- platform_event: e.clone(),
- }));
- }
- Event::MouseMoved(
- e @ MouseMovedEvent {
- position,
- pressed_button,
- ..
- },
- ) => {
- let mut style_to_assign = CursorStyle::Arrow;
- for region in self.cursor_regions.iter().rev() {
- if region.bounds.contains_point(*position) {
- style_to_assign = region.style;
- break;
- }
+
+ mouse_events.push(MouseEvent::Down(MouseDown {
+ region: Default::default(),
+ platform_event: e.clone(),
+ }));
+ mouse_events.push(MouseEvent::DownOut(MouseDownOut {
+ region: Default::default(),
+ platform_event: e.clone(),
+ }));
+ }
+ Event::MouseUp(e) => {
+ // NOTE: The order of event pushes is important! MouseUp events MUST be fired
+ // before click events, and so the MouseUp events need to be pushed before
+ // MouseClick events.
+ mouse_events.push(MouseEvent::Up(MouseUp {
+ region: Default::default(),
+ platform_event: e.clone(),
+ }));
+ mouse_events.push(MouseEvent::UpOut(MouseUpOut {
+ region: Default::default(),
+ platform_event: e.clone(),
+ }));
+ mouse_events.push(MouseEvent::Click(MouseClick {
+ region: Default::default(),
+ platform_event: e.clone(),
+ }));
+ }
+ Event::MouseMoved(
+ e @ MouseMovedEvent {
+ position,
+ pressed_button,
+ ..
+ },
+ ) => {
+ let mut style_to_assign = CursorStyle::Arrow;
+ for region in self.cursor_regions.iter().rev() {
+ if region.bounds.contains_point(*position) {
+ style_to_assign = region.style;
+ break;
}
- cx.platform().set_cursor_style(style_to_assign);
-
- if !event_reused {
- if pressed_button.is_some() {
- events_to_send.push(MouseRegionEvent::Drag(DragRegionEvent {
- region: Default::default(),
- prev_mouse_position: self.mouse_position,
- platform_event: e.clone(),
- }));
- } else if let Some(clicked_button) = self.clicked_button {
- // Mouse up event happened outside the current window. Simulate mouse up button event
- let button_event = e.to_button_event(clicked_button);
- events_to_send.push(MouseRegionEvent::Up(UpRegionEvent {
- region: Default::default(),
- platform_event: button_event.clone(),
- }));
- events_to_send.push(MouseRegionEvent::UpOut(UpOutRegionEvent {
- region: Default::default(),
- platform_event: button_event.clone(),
- }));
- events_to_send.push(MouseRegionEvent::Click(ClickRegionEvent {
- region: Default::default(),
- platform_event: button_event.clone(),
- }));
- }
+ }
+ cx.platform().set_cursor_style(style_to_assign);
- events_to_send.push(MouseRegionEvent::Move(MoveRegionEvent {
+ if !event_reused {
+ if pressed_button.is_some() {
+ mouse_events.push(MouseEvent::Drag(MouseDrag {
region: Default::default(),
+ prev_mouse_position: self.mouse_position,
platform_event: e.clone(),
}));
+ } else if let Some(clicked_button) = self.clicked_button {
+ // Mouse up event happened outside the current window. Simulate mouse up button event
+ let button_event = e.to_button_event(clicked_button);
+ mouse_events.push(MouseEvent::Up(MouseUp {
+ region: Default::default(),
+ platform_event: button_event.clone(),
+ }));
+ mouse_events.push(MouseEvent::UpOut(MouseUpOut {
+ region: Default::default(),
+ platform_event: button_event.clone(),
+ }));
+ mouse_events.push(MouseEvent::Click(MouseClick {
+ region: Default::default(),
+ platform_event: button_event.clone(),
+ }));
}
- events_to_send.push(MouseRegionEvent::Hover(HoverRegionEvent {
+ mouse_events.push(MouseEvent::Move(MouseMove {
region: Default::default(),
platform_event: e.clone(),
- started: false,
}));
-
- self.last_mouse_moved_event = Some(event.clone());
- }
- Event::ScrollWheel(e) => {
- events_to_send.push(MouseRegionEvent::ScrollWheel(ScrollWheelRegionEvent {
- region: Default::default(),
- platform_event: e.clone(),
- }))
}
- _ => {}
- }
+ mouse_events.push(MouseEvent::Hover(MouseHover {
+ region: Default::default(),
+ platform_event: e.clone(),
+ started: false,
+ }));
- if let Some(position) = event.position() {
- self.mouse_position = position;
+ self.last_mouse_moved_event = Some(event.clone());
}
+ Event::ScrollWheel(e) => mouse_events.push(MouseEvent::ScrollWheel(MouseScrollWheel {
+ region: Default::default(),
+ platform_event: e.clone(),
+ })),
+ }
- let mut any_event_handled = false;
- // 2. Process the raw mouse events into region events
- for mut region_event in events_to_send {
- let mut valid_regions = Vec::new();
-
- // GPUI elements are arranged by depth but sibling elements can register overlapping
- // mouse regions. As such, hover events are only fired on overlapping elements which
- // are at the same depth as the topmost element which overlaps with the mouse.
-
- match ®ion_event {
- MouseRegionEvent::Hover(_) => {
- let mut top_most_depth = None;
- let mouse_position = self.mouse_position.clone();
- for (region, depth) in self.mouse_regions.iter().rev() {
- // Allow mouse regions to appear transparent to hovers
- if !region.hoverable {
- continue;
- }
+ if let Some(position) = event.position() {
+ self.mouse_position = position;
+ }
- let contains_mouse = region.bounds.contains_point(mouse_position);
+ // 2. Dispatch mouse events on regions
+ let mut any_event_handled = false;
+ for mut mouse_event in mouse_events {
+ let mut valid_regions = Vec::new();
+
+ // GPUI elements are arranged by depth but sibling elements can register overlapping
+ // mouse regions. As such, hover events are only fired on overlapping elements which
+ // are at the same depth as the topmost element which overlaps with the mouse.
+ match &mouse_event {
+ MouseEvent::Hover(_) => {
+ let mut top_most_depth = None;
+ let mouse_position = self.mouse_position.clone();
+ for (region, depth) in self.mouse_regions.iter().rev() {
+ // Allow mouse regions to appear transparent to hovers
+ if !region.hoverable {
+ continue;
+ }
- if contains_mouse && top_most_depth.is_none() {
- top_most_depth = Some(depth);
- }
+ let contains_mouse = region.bounds.contains_point(mouse_position);
- // This unwrap relies on short circuiting boolean expressions
- // The right side of the && is only executed when contains_mouse
- // is true, and we know above that when contains_mouse is true
- // top_most_depth is set
- if contains_mouse && depth == top_most_depth.unwrap() {
- //Ensure that hover entrance events aren't sent twice
- if self.hovered_region_ids.insert(region.id()) {
- valid_regions.push(region.clone());
- if region.notify_on_hover {
- notified_views.insert(region.id().view_id());
- }
- }
- } else {
- // Ensure that hover exit events aren't sent twice
- if self.hovered_region_ids.remove(®ion.id()) {
- valid_regions.push(region.clone());
- if region.notify_on_hover {
- notified_views.insert(region.id().view_id());
- }
- }
- }
+ if contains_mouse && top_most_depth.is_none() {
+ top_most_depth = Some(depth);
}
- }
- MouseRegionEvent::Down(_) | MouseRegionEvent::Up(_) => {
- for (region, _) in self.mouse_regions.iter().rev() {
- if region.bounds.contains_point(self.mouse_position) {
- if region.notify_on_click {
+
+ // This unwrap relies on short circuiting boolean expressions
+ // The right side of the && is only executed when contains_mouse
+ // is true, and we know above that when contains_mouse is true
+ // top_most_depth is set
+ if contains_mouse && depth == top_most_depth.unwrap() {
+ //Ensure that hover entrance events aren't sent twice
+ if self.hovered_region_ids.insert(region.id()) {
+ valid_regions.push(region.clone());
+ if region.notify_on_hover {
notified_views.insert(region.id().view_id());
}
- valid_regions.push(region.clone());
}
- }
- }
- MouseRegionEvent::Click(e) => {
- // Only raise click events if the released button is the same as the one stored
- if self
- .clicked_button
- .map(|clicked_button| clicked_button == e.button)
- .unwrap_or(false)
- {
- // Clear clicked regions and clicked button
- let clicked_region_ids =
- std::mem::replace(&mut self.clicked_region_ids, Default::default());
- self.clicked_button = None;
-
- // Find regions which still overlap with the mouse since the last MouseDown happened
- for (mouse_region, _) in self.mouse_regions.iter().rev() {
- if clicked_region_ids.contains(&mouse_region.id()) {
- if mouse_region.bounds.contains_point(self.mouse_position) {
- valid_regions.push(mouse_region.clone());
- }
+ } else {
+ // Ensure that hover exit events aren't sent twice
+ if self.hovered_region_ids.remove(®ion.id()) {
+ valid_regions.push(region.clone());
+ if region.notify_on_hover {
+ notified_views.insert(region.id().view_id());
}
}
}
}
- MouseRegionEvent::Drag(_) => {
- for (mouse_region, _) in self.mouse_regions.iter().rev() {
- if self.clicked_region_ids.contains(&mouse_region.id()) {
- valid_regions.push(mouse_region.clone());
+ }
+ MouseEvent::Down(_) | MouseEvent::Up(_) => {
+ for (region, _) in self.mouse_regions.iter().rev() {
+ if region.bounds.contains_point(self.mouse_position) {
+ if region.notify_on_click {
+ notified_views.insert(region.id().view_id());
}
+ valid_regions.push(region.clone());
}
}
-
- MouseRegionEvent::UpOut(_) | MouseRegionEvent::DownOut(_) => {
+ }
+ MouseEvent::Click(e) => {
+ // Only raise click events if the released button is the same as the one stored
+ if self
+ .clicked_button
+ .map(|clicked_button| clicked_button == e.button)
+ .unwrap_or(false)
+ {
+ // Clear clicked regions and clicked button
+ let clicked_region_ids =
+ std::mem::replace(&mut self.clicked_region_ids, Default::default());
+ self.clicked_button = None;
+
+ // Find regions which still overlap with the mouse since the last MouseDown happened
for (mouse_region, _) in self.mouse_regions.iter().rev() {
- // NOT contains
- if !mouse_region.bounds.contains_point(self.mouse_position) {
- valid_regions.push(mouse_region.clone());
+ if clicked_region_ids.contains(&mouse_region.id()) {
+ if mouse_region.bounds.contains_point(self.mouse_position) {
+ valid_regions.push(mouse_region.clone());
+ }
}
}
}
- _ => {
- for (mouse_region, _) in self.mouse_regions.iter().rev() {
- // Contains
- if mouse_region.bounds.contains_point(self.mouse_position) {
- valid_regions.push(mouse_region.clone());
- }
+ }
+ MouseEvent::Drag(_) => {
+ for (mouse_region, _) in self.mouse_regions.iter().rev() {
+ if self.clicked_region_ids.contains(&mouse_region.id()) {
+ valid_regions.push(mouse_region.clone());
}
}
}
- //3. Fire region events
- let hovered_region_ids = self.hovered_region_ids.clone();
- for valid_region in valid_regions.into_iter() {
- let mut event_cx = self.build_event_context(&mut notified_views, cx);
-
- region_event.set_region(valid_region.bounds);
- if let MouseRegionEvent::Hover(e) = &mut region_event {
- e.started = hovered_region_ids.contains(&valid_region.id())
+ MouseEvent::UpOut(_) | MouseEvent::DownOut(_) => {
+ for (mouse_region, _) in self.mouse_regions.iter().rev() {
+ // NOT contains
+ if !mouse_region.bounds.contains_point(self.mouse_position) {
+ valid_regions.push(mouse_region.clone());
+ }
}
- // Handle Down events if the MouseRegion has a Click or Drag handler. This makes the api more intuitive as you would
- // not expect a MouseRegion to be transparent to Down events if it also has a Click handler.
- // This behavior can be overridden by adding a Down handler that calls cx.propogate_event
- if let MouseRegionEvent::Down(e) = ®ion_event {
- if valid_region
- .handlers
- .contains_handler(MouseRegionEvent::click_disc(), Some(e.button))
- || valid_region
- .handlers
- .contains_handler(MouseRegionEvent::drag_disc(), Some(e.button))
- {
- event_cx.handled = true;
+ }
+ _ => {
+ for (mouse_region, _) in self.mouse_regions.iter().rev() {
+ // Contains
+ if mouse_region.bounds.contains_point(self.mouse_position) {
+ valid_regions.push(mouse_region.clone());
}
}
+ }
+ }
- if let Some(callback) = valid_region.handlers.get(®ion_event.handler_key()) {
- event_cx.handled = true;
- event_cx.with_current_view(valid_region.id().view_id(), {
- let region_event = region_event.clone();
- |cx| {
- callback(region_event, cx);
- }
- });
- }
+ //3. Fire region events
+ let hovered_region_ids = self.hovered_region_ids.clone();
+ for valid_region in valid_regions.into_iter() {
+ let mut event_cx = self.build_event_context(&mut notified_views, cx);
- any_event_handled = any_event_handled || event_cx.handled;
- // For bubbling events, if the event was handled, don't continue dispatching
- // This only makes sense for local events.
- if event_cx.handled && region_event.is_capturable() {
- break;
+ mouse_event.set_region(valid_region.bounds);
+ if let MouseEvent::Hover(e) = &mut mouse_event {
+ e.started = hovered_region_ids.contains(&valid_region.id())
+ }
+ // Handle Down events if the MouseRegion has a Click or Drag handler. This makes the api more intuitive as you would
+ // not expect a MouseRegion to be transparent to Down events if it also has a Click handler.
+ // This behavior can be overridden by adding a Down handler that calls cx.propogate_event
+ if let MouseEvent::Down(e) = &mouse_event {
+ if valid_region
+ .handlers
+ .contains_handler(MouseEvent::click_disc(), Some(e.button))
+ || valid_region
+ .handlers
+ .contains_handler(MouseEvent::drag_disc(), Some(e.button))
+ {
+ event_cx.handled = true;
}
}
- }
- if !any_event_handled && !event_reused {
- let mut event_cx = self.build_event_context(&mut notified_views, cx);
- any_event_handled = event_cx.dispatch_event(root_view_id, &event);
- }
+ if let Some(callback) = valid_region.handlers.get(&mouse_event.handler_key()) {
+ event_cx.handled = true;
+ event_cx.with_current_view(valid_region.id().view_id(), {
+ let region_event = mouse_event.clone();
+ |cx| {
+ callback(region_event, cx);
+ }
+ });
+ }
- for view_id in notified_views {
- cx.notify_view(self.window_id, view_id);
+ any_event_handled = any_event_handled || event_cx.handled;
+ // For bubbling events, if the event was handled, don't continue dispatching
+ // This only makes sense for local events.
+ if event_cx.handled && mouse_event.is_capturable() {
+ break;
+ }
}
+ }
- any_event_handled
- } else {
- false
+ for view_id in notified_views {
+ cx.notify_view(self.window_id, view_id);
}
+
+ any_event_handled
}
pub fn build_event_context<'a>(
@@ -524,7 +513,6 @@ impl Presenter {
cx: &'a mut MutableAppContext,
) -> EventContext<'a> {
EventContext {
- rendered_views: &mut self.rendered_views,
font_cache: &self.font_cache,
text_layout_cache: &self.text_layout_cache,
view_stack: Default::default(),
@@ -743,7 +731,6 @@ impl<'a> Deref for PaintContext<'a> {
}
pub struct EventContext<'a> {
- rendered_views: &'a mut HashMap<usize, ElementBox>,
pub font_cache: &'a FontCache,
pub text_layout_cache: &'a TextLayoutCache,
pub app: &'a mut MutableAppContext,
@@ -755,17 +742,6 @@ pub struct EventContext<'a> {
}
impl<'a> EventContext<'a> {
- fn dispatch_event(&mut self, view_id: usize, event: &Event) -> bool {
- if let Some(mut element) = self.rendered_views.remove(&view_id) {
- let result =
- self.with_current_view(view_id, |this| element.dispatch_event(event, this));
- self.rendered_views.insert(view_id, element);
- result
- } else {
- false
- }
- }
-
fn with_current_view<F, T>(&mut self, view_id: usize, f: F) -> T
where
F: FnOnce(&mut Self) -> T,
@@ -1028,27 +1004,6 @@ impl Element for ChildView {
}
}
- fn dispatch_event(
- &mut self,
- event: &Event,
- _: RectF,
- _: RectF,
- view_is_valid: &mut Self::LayoutState,
- _: &mut Self::PaintState,
- cx: &mut EventContext,
- ) -> bool {
- if *view_is_valid {
- cx.dispatch_event(self.view.id(), event)
- } else {
- log::error!(
- "dispatch_event called on a ChildView element whose underlying view was dropped (view_id: {}, name: {:?})",
- self.view.id(),
- self.view_name
- );
- false
- }
- }
-
fn rect_for_text_range(
&self,
range_utf16: Range<usize>,
@@ -1,5 +1,5 @@
+mod mouse_event;
mod mouse_region;
-mod mouse_region_event;
#[cfg(debug_assertions)]
use collections::HashSet;
@@ -15,8 +15,8 @@ use crate::{
platform::{current::Surface, CursorStyle},
ImageData,
};
+pub use mouse_event::*;
pub use mouse_region::*;
-pub use mouse_region_event::*;
pub struct Scene {
scale_factor: f32,
@@ -0,0 +1,233 @@
+use std::{
+ mem::{discriminant, Discriminant},
+ ops::Deref,
+};
+
+use pathfinder_geometry::{rect::RectF, vector::Vector2F};
+
+use crate::{MouseButton, MouseButtonEvent, MouseMovedEvent, ScrollWheelEvent};
+
+#[derive(Debug, Default, Clone)]
+pub struct MouseMove {
+ pub region: RectF,
+ pub platform_event: MouseMovedEvent,
+}
+
+impl Deref for MouseMove {
+ type Target = MouseMovedEvent;
+
+ fn deref(&self) -> &Self::Target {
+ &self.platform_event
+ }
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct MouseDrag {
+ pub region: RectF,
+ pub prev_mouse_position: Vector2F,
+ pub platform_event: MouseMovedEvent,
+}
+
+impl Deref for MouseDrag {
+ type Target = MouseMovedEvent;
+
+ fn deref(&self) -> &Self::Target {
+ &self.platform_event
+ }
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct MouseHover {
+ pub region: RectF,
+ pub started: bool,
+ pub platform_event: MouseMovedEvent,
+}
+
+impl Deref for MouseHover {
+ type Target = MouseMovedEvent;
+
+ fn deref(&self) -> &Self::Target {
+ &self.platform_event
+ }
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct MouseDown {
+ pub region: RectF,
+ pub platform_event: MouseButtonEvent,
+}
+
+impl Deref for MouseDown {
+ type Target = MouseButtonEvent;
+
+ fn deref(&self) -> &Self::Target {
+ &self.platform_event
+ }
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct MouseUp {
+ pub region: RectF,
+ pub platform_event: MouseButtonEvent,
+}
+
+impl Deref for MouseUp {
+ type Target = MouseButtonEvent;
+
+ fn deref(&self) -> &Self::Target {
+ &self.platform_event
+ }
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct MouseClick {
+ pub region: RectF,
+ pub platform_event: MouseButtonEvent,
+}
+
+impl Deref for MouseClick {
+ type Target = MouseButtonEvent;
+
+ fn deref(&self) -> &Self::Target {
+ &self.platform_event
+ }
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct MouseDownOut {
+ pub region: RectF,
+ pub platform_event: MouseButtonEvent,
+}
+
+impl Deref for MouseDownOut {
+ type Target = MouseButtonEvent;
+
+ fn deref(&self) -> &Self::Target {
+ &self.platform_event
+ }
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct MouseUpOut {
+ pub region: RectF,
+ pub platform_event: MouseButtonEvent,
+}
+
+impl Deref for MouseUpOut {
+ type Target = MouseButtonEvent;
+
+ fn deref(&self) -> &Self::Target {
+ &self.platform_event
+ }
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct MouseScrollWheel {
+ pub region: RectF,
+ pub platform_event: ScrollWheelEvent,
+}
+
+impl Deref for MouseScrollWheel {
+ type Target = ScrollWheelEvent;
+
+ fn deref(&self) -> &Self::Target {
+ &self.platform_event
+ }
+}
+
+#[derive(Debug, Clone)]
+pub enum MouseEvent {
+ Move(MouseMove),
+ Drag(MouseDrag),
+ Hover(MouseHover),
+ Down(MouseDown),
+ Up(MouseUp),
+ Click(MouseClick),
+ DownOut(MouseDownOut),
+ UpOut(MouseUpOut),
+ ScrollWheel(MouseScrollWheel),
+}
+
+impl MouseEvent {
+ pub fn set_region(&mut self, region: RectF) {
+ match self {
+ MouseEvent::Move(r) => r.region = region,
+ MouseEvent::Drag(r) => r.region = region,
+ MouseEvent::Hover(r) => r.region = region,
+ MouseEvent::Down(r) => r.region = region,
+ MouseEvent::Up(r) => r.region = region,
+ MouseEvent::Click(r) => r.region = region,
+ MouseEvent::DownOut(r) => r.region = region,
+ MouseEvent::UpOut(r) => r.region = region,
+ MouseEvent::ScrollWheel(r) => r.region = region,
+ }
+ }
+
+ /// When true, mouse event handlers must call cx.propagate_event() to bubble
+ /// the event to handlers they are painted on top of.
+ pub fn is_capturable(&self) -> bool {
+ match self {
+ MouseEvent::Move(_) => true,
+ MouseEvent::Drag(_) => true,
+ MouseEvent::Hover(_) => false,
+ MouseEvent::Down(_) => true,
+ MouseEvent::Up(_) => true,
+ MouseEvent::Click(_) => true,
+ MouseEvent::DownOut(_) => false,
+ MouseEvent::UpOut(_) => false,
+ MouseEvent::ScrollWheel(_) => true,
+ }
+ }
+}
+
+impl MouseEvent {
+ pub fn move_disc() -> Discriminant<MouseEvent> {
+ discriminant(&MouseEvent::Move(Default::default()))
+ }
+
+ pub fn drag_disc() -> Discriminant<MouseEvent> {
+ discriminant(&MouseEvent::Drag(Default::default()))
+ }
+
+ pub fn hover_disc() -> Discriminant<MouseEvent> {
+ discriminant(&MouseEvent::Hover(Default::default()))
+ }
+
+ pub fn down_disc() -> Discriminant<MouseEvent> {
+ discriminant(&MouseEvent::Down(Default::default()))
+ }
+
+ pub fn up_disc() -> Discriminant<MouseEvent> {
+ discriminant(&MouseEvent::Up(Default::default()))
+ }
+
+ pub fn up_out_disc() -> Discriminant<MouseEvent> {
+ discriminant(&MouseEvent::UpOut(Default::default()))
+ }
+
+ pub fn click_disc() -> Discriminant<MouseEvent> {
+ discriminant(&MouseEvent::Click(Default::default()))
+ }
+
+ pub fn down_out_disc() -> Discriminant<MouseEvent> {
+ discriminant(&MouseEvent::DownOut(Default::default()))
+ }
+
+ pub fn scroll_wheel_disc() -> Discriminant<MouseEvent> {
+ discriminant(&MouseEvent::ScrollWheel(Default::default()))
+ }
+
+ pub fn handler_key(&self) -> (Discriminant<MouseEvent>, Option<MouseButton>) {
+ match self {
+ MouseEvent::Move(_) => (Self::move_disc(), None),
+ MouseEvent::Drag(e) => (Self::drag_disc(), e.pressed_button),
+ MouseEvent::Hover(_) => (Self::hover_disc(), None),
+ MouseEvent::Down(e) => (Self::down_disc(), Some(e.button)),
+ MouseEvent::Up(e) => (Self::up_disc(), Some(e.button)),
+ MouseEvent::Click(e) => (Self::click_disc(), Some(e.button)),
+ MouseEvent::UpOut(e) => (Self::up_out_disc(), Some(e.button)),
+ MouseEvent::DownOut(e) => (Self::down_out_disc(), Some(e.button)),
+ MouseEvent::ScrollWheel(_) => (Self::scroll_wheel_disc(), None),
+ }
+ }
+}
@@ -7,11 +7,11 @@ use pathfinder_geometry::rect::RectF;
use crate::{EventContext, MouseButton};
use super::{
- mouse_region_event::{
- ClickRegionEvent, DownOutRegionEvent, DownRegionEvent, DragRegionEvent, HoverRegionEvent,
- MouseRegionEvent, MoveRegionEvent, UpOutRegionEvent, UpRegionEvent,
+ mouse_event::{
+ MouseClick, MouseDown, MouseDownOut, MouseDrag, MouseEvent, MouseHover, MouseMove, MouseUp,
+ MouseUpOut,
},
- ScrollWheelRegionEvent,
+ MouseScrollWheel,
};
#[derive(Clone)]
@@ -62,7 +62,7 @@ impl MouseRegion {
pub fn on_down(
mut self,
button: MouseButton,
- handler: impl Fn(DownRegionEvent, &mut EventContext) + 'static,
+ handler: impl Fn(MouseDown, &mut EventContext) + 'static,
) -> Self {
self.handlers = self.handlers.on_down(button, handler);
self
@@ -71,7 +71,7 @@ impl MouseRegion {
pub fn on_up(
mut self,
button: MouseButton,
- handler: impl Fn(UpRegionEvent, &mut EventContext) + 'static,
+ handler: impl Fn(MouseUp, &mut EventContext) + 'static,
) -> Self {
self.handlers = self.handlers.on_up(button, handler);
self
@@ -80,7 +80,7 @@ impl MouseRegion {
pub fn on_click(
mut self,
button: MouseButton,
- handler: impl Fn(ClickRegionEvent, &mut EventContext) + 'static,
+ handler: impl Fn(MouseClick, &mut EventContext) + 'static,
) -> Self {
self.handlers = self.handlers.on_click(button, handler);
self
@@ -89,7 +89,7 @@ impl MouseRegion {
pub fn on_down_out(
mut self,
button: MouseButton,
- handler: impl Fn(DownOutRegionEvent, &mut EventContext) + 'static,
+ handler: impl Fn(MouseDownOut, &mut EventContext) + 'static,
) -> Self {
self.handlers = self.handlers.on_down_out(button, handler);
self
@@ -98,7 +98,7 @@ impl MouseRegion {
pub fn on_up_out(
mut self,
button: MouseButton,
- handler: impl Fn(UpOutRegionEvent, &mut EventContext) + 'static,
+ handler: impl Fn(MouseUpOut, &mut EventContext) + 'static,
) -> Self {
self.handlers = self.handlers.on_up_out(button, handler);
self
@@ -107,31 +107,25 @@ impl MouseRegion {
pub fn on_drag(
mut self,
button: MouseButton,
- handler: impl Fn(DragRegionEvent, &mut EventContext) + 'static,
+ handler: impl Fn(MouseDrag, &mut EventContext) + 'static,
) -> Self {
self.handlers = self.handlers.on_drag(button, handler);
self
}
- pub fn on_hover(
- mut self,
- handler: impl Fn(HoverRegionEvent, &mut EventContext) + 'static,
- ) -> Self {
+ pub fn on_hover(mut self, handler: impl Fn(MouseHover, &mut EventContext) + 'static) -> Self {
self.handlers = self.handlers.on_hover(handler);
self
}
- pub fn on_move(
- mut self,
- handler: impl Fn(MoveRegionEvent, &mut EventContext) + 'static,
- ) -> Self {
+ pub fn on_move(mut self, handler: impl Fn(MouseMove, &mut EventContext) + 'static) -> Self {
self.handlers = self.handlers.on_move(handler);
self
}
pub fn on_scroll(
mut self,
- handler: impl Fn(ScrollWheelRegionEvent, &mut EventContext) + 'static,
+ handler: impl Fn(MouseScrollWheel, &mut EventContext) + 'static,
) -> Self {
self.handlers = self.handlers.on_scroll(handler);
self
@@ -187,8 +181,8 @@ impl MouseRegionId {
pub struct HandlerSet {
#[allow(clippy::type_complexity)]
pub set: HashMap<
- (Discriminant<MouseRegionEvent>, Option<MouseButton>),
- Rc<dyn Fn(MouseRegionEvent, &mut EventContext)>,
+ (Discriminant<MouseEvent>, Option<MouseButton>),
+ Rc<dyn Fn(MouseEvent, &mut EventContext)>,
>,
}
@@ -196,68 +190,50 @@ impl HandlerSet {
pub fn capture_all() -> Self {
#[allow(clippy::type_complexity)]
let mut set: HashMap<
- (Discriminant<MouseRegionEvent>, Option<MouseButton>),
- Rc<dyn Fn(MouseRegionEvent, &mut EventContext)>,
+ (Discriminant<MouseEvent>, Option<MouseButton>),
+ Rc<dyn Fn(MouseEvent, &mut EventContext)>,
> = Default::default();
- set.insert((MouseRegionEvent::move_disc(), None), Rc::new(|_, _| {}));
- set.insert((MouseRegionEvent::hover_disc(), None), Rc::new(|_, _| {}));
+ set.insert((MouseEvent::move_disc(), None), Rc::new(|_, _| {}));
+ set.insert((MouseEvent::hover_disc(), None), Rc::new(|_, _| {}));
for button in MouseButton::all() {
+ set.insert((MouseEvent::drag_disc(), Some(button)), Rc::new(|_, _| {}));
+ set.insert((MouseEvent::down_disc(), Some(button)), Rc::new(|_, _| {}));
+ set.insert((MouseEvent::up_disc(), Some(button)), Rc::new(|_, _| {}));
+ set.insert((MouseEvent::click_disc(), Some(button)), Rc::new(|_, _| {}));
set.insert(
- (MouseRegionEvent::drag_disc(), Some(button)),
- Rc::new(|_, _| {}),
- );
- set.insert(
- (MouseRegionEvent::down_disc(), Some(button)),
- Rc::new(|_, _| {}),
- );
- set.insert(
- (MouseRegionEvent::up_disc(), Some(button)),
+ (MouseEvent::down_out_disc(), Some(button)),
Rc::new(|_, _| {}),
);
set.insert(
- (MouseRegionEvent::click_disc(), Some(button)),
- Rc::new(|_, _| {}),
- );
- set.insert(
- (MouseRegionEvent::down_out_disc(), Some(button)),
- Rc::new(|_, _| {}),
- );
- set.insert(
- (MouseRegionEvent::up_out_disc(), Some(button)),
+ (MouseEvent::up_out_disc(), Some(button)),
Rc::new(|_, _| {}),
);
}
- set.insert(
- (MouseRegionEvent::scroll_wheel_disc(), None),
- Rc::new(|_, _| {}),
- );
+ set.insert((MouseEvent::scroll_wheel_disc(), None), Rc::new(|_, _| {}));
HandlerSet { set }
}
pub fn get(
&self,
- key: &(Discriminant<MouseRegionEvent>, Option<MouseButton>),
- ) -> Option<Rc<dyn Fn(MouseRegionEvent, &mut EventContext)>> {
+ key: &(Discriminant<MouseEvent>, Option<MouseButton>),
+ ) -> Option<Rc<dyn Fn(MouseEvent, &mut EventContext)>> {
self.set.get(key).cloned()
}
pub fn contains_handler(
&self,
- event: Discriminant<MouseRegionEvent>,
+ event: Discriminant<MouseEvent>,
button: Option<MouseButton>,
) -> bool {
self.set.contains_key(&(event, button))
}
- pub fn on_move(
- mut self,
- handler: impl Fn(MoveRegionEvent, &mut EventContext) + 'static,
- ) -> Self {
- self.set.insert((MouseRegionEvent::move_disc(), None),
+ pub fn on_move(mut self, handler: impl Fn(MouseMove, &mut EventContext) + 'static) -> Self {
+ self.set.insert((MouseEvent::move_disc(), None),
Rc::new(move |region_event, cx| {
- if let MouseRegionEvent::Move(e) = region_event {
+ if let MouseEvent::Move(e) = region_event {
handler(e, cx);
} else {
panic!(
@@ -271,11 +247,11 @@ impl HandlerSet {
pub fn on_down(
mut self,
button: MouseButton,
- handler: impl Fn(DownRegionEvent, &mut EventContext) + 'static,
+ handler: impl Fn(MouseDown, &mut EventContext) + 'static,
) -> Self {
- self.set.insert((MouseRegionEvent::down_disc(), Some(button)),
+ self.set.insert((MouseEvent::down_disc(), Some(button)),
Rc::new(move |region_event, cx| {
- if let MouseRegionEvent::Down(e) = region_event {
+ if let MouseEvent::Down(e) = region_event {
handler(e, cx);
} else {
panic!(
@@ -289,11 +265,11 @@ impl HandlerSet {
pub fn on_up(
mut self,
button: MouseButton,
- handler: impl Fn(UpRegionEvent, &mut EventContext) + 'static,
+ handler: impl Fn(MouseUp, &mut EventContext) + 'static,
) -> Self {
- self.set.insert((MouseRegionEvent::up_disc(), Some(button)),
+ self.set.insert((MouseEvent::up_disc(), Some(button)),
Rc::new(move |region_event, cx| {
- if let MouseRegionEvent::Up(e) = region_event {
+ if let MouseEvent::Up(e) = region_event {
handler(e, cx);
} else {
panic!(
@@ -307,11 +283,11 @@ impl HandlerSet {
pub fn on_click(
mut self,
button: MouseButton,
- handler: impl Fn(ClickRegionEvent, &mut EventContext) + 'static,
+ handler: impl Fn(MouseClick, &mut EventContext) + 'static,
) -> Self {
- self.set.insert((MouseRegionEvent::click_disc(), Some(button)),
+ self.set.insert((MouseEvent::click_disc(), Some(button)),
Rc::new(move |region_event, cx| {
- if let MouseRegionEvent::Click(e) = region_event {
+ if let MouseEvent::Click(e) = region_event {
handler(e, cx);
} else {
panic!(
@@ -325,11 +301,11 @@ impl HandlerSet {
pub fn on_down_out(
mut self,
button: MouseButton,
- handler: impl Fn(DownOutRegionEvent, &mut EventContext) + 'static,
+ handler: impl Fn(MouseDownOut, &mut EventContext) + 'static,
) -> Self {
- self.set.insert((MouseRegionEvent::down_out_disc(), Some(button)),
+ self.set.insert((MouseEvent::down_out_disc(), Some(button)),
Rc::new(move |region_event, cx| {
- if let MouseRegionEvent::DownOut(e) = region_event {
+ if let MouseEvent::DownOut(e) = region_event {
handler(e, cx);
} else {
panic!(
@@ -343,11 +319,11 @@ impl HandlerSet {
pub fn on_up_out(
mut self,
button: MouseButton,
- handler: impl Fn(UpOutRegionEvent, &mut EventContext) + 'static,
+ handler: impl Fn(MouseUpOut, &mut EventContext) + 'static,
) -> Self {
- self.set.insert((MouseRegionEvent::up_out_disc(), Some(button)),
+ self.set.insert((MouseEvent::up_out_disc(), Some(button)),
Rc::new(move |region_event, cx| {
- if let MouseRegionEvent::UpOut(e) = region_event {
+ if let MouseEvent::UpOut(e) = region_event {
handler(e, cx);
} else {
panic!(
@@ -361,11 +337,11 @@ impl HandlerSet {
pub fn on_drag(
mut self,
button: MouseButton,
- handler: impl Fn(DragRegionEvent, &mut EventContext) + 'static,
+ handler: impl Fn(MouseDrag, &mut EventContext) + 'static,
) -> Self {
- self.set.insert((MouseRegionEvent::drag_disc(), Some(button)),
+ self.set.insert((MouseEvent::drag_disc(), Some(button)),
Rc::new(move |region_event, cx| {
- if let MouseRegionEvent::Drag(e) = region_event {
+ if let MouseEvent::Drag(e) = region_event {
handler(e, cx);
} else {
panic!(
@@ -376,13 +352,10 @@ impl HandlerSet {
self
}
- pub fn on_hover(
- mut self,
- handler: impl Fn(HoverRegionEvent, &mut EventContext) + 'static,
- ) -> Self {
- self.set.insert((MouseRegionEvent::hover_disc(), None),
+ pub fn on_hover(mut self, handler: impl Fn(MouseHover, &mut EventContext) + 'static) -> Self {
+ self.set.insert((MouseEvent::hover_disc(), None),
Rc::new(move |region_event, cx| {
- if let MouseRegionEvent::Hover(e) = region_event {
+ if let MouseEvent::Hover(e) = region_event {
handler(e, cx);
} else {
panic!(
@@ -395,11 +368,11 @@ impl HandlerSet {
pub fn on_scroll(
mut self,
- handler: impl Fn(ScrollWheelRegionEvent, &mut EventContext) + 'static,
+ handler: impl Fn(MouseScrollWheel, &mut EventContext) + 'static,
) -> Self {
- self.set.insert((MouseRegionEvent::scroll_wheel_disc(), None),
+ self.set.insert((MouseEvent::scroll_wheel_disc(), None),
Rc::new(move |region_event, cx| {
- if let MouseRegionEvent::ScrollWheel(e) = region_event {
+ if let MouseEvent::ScrollWheel(e) = region_event {
handler(e, cx);
} else {
panic!(
@@ -1,233 +0,0 @@
-use std::{
- mem::{discriminant, Discriminant},
- ops::Deref,
-};
-
-use pathfinder_geometry::{rect::RectF, vector::Vector2F};
-
-use crate::{MouseButton, MouseButtonEvent, MouseMovedEvent, ScrollWheelEvent};
-
-#[derive(Debug, Default, Clone)]
-pub struct MoveRegionEvent {
- pub region: RectF,
- pub platform_event: MouseMovedEvent,
-}
-
-impl Deref for MoveRegionEvent {
- type Target = MouseMovedEvent;
-
- fn deref(&self) -> &Self::Target {
- &self.platform_event
- }
-}
-
-#[derive(Debug, Default, Clone)]
-pub struct DragRegionEvent {
- pub region: RectF,
- pub prev_mouse_position: Vector2F,
- pub platform_event: MouseMovedEvent,
-}
-
-impl Deref for DragRegionEvent {
- type Target = MouseMovedEvent;
-
- fn deref(&self) -> &Self::Target {
- &self.platform_event
- }
-}
-
-#[derive(Debug, Default, Clone)]
-pub struct HoverRegionEvent {
- pub region: RectF,
- pub started: bool,
- pub platform_event: MouseMovedEvent,
-}
-
-impl Deref for HoverRegionEvent {
- type Target = MouseMovedEvent;
-
- fn deref(&self) -> &Self::Target {
- &self.platform_event
- }
-}
-
-#[derive(Debug, Default, Clone)]
-pub struct DownRegionEvent {
- pub region: RectF,
- pub platform_event: MouseButtonEvent,
-}
-
-impl Deref for DownRegionEvent {
- type Target = MouseButtonEvent;
-
- fn deref(&self) -> &Self::Target {
- &self.platform_event
- }
-}
-
-#[derive(Debug, Default, Clone)]
-pub struct UpRegionEvent {
- pub region: RectF,
- pub platform_event: MouseButtonEvent,
-}
-
-impl Deref for UpRegionEvent {
- type Target = MouseButtonEvent;
-
- fn deref(&self) -> &Self::Target {
- &self.platform_event
- }
-}
-
-#[derive(Debug, Default, Clone)]
-pub struct ClickRegionEvent {
- pub region: RectF,
- pub platform_event: MouseButtonEvent,
-}
-
-impl Deref for ClickRegionEvent {
- type Target = MouseButtonEvent;
-
- fn deref(&self) -> &Self::Target {
- &self.platform_event
- }
-}
-
-#[derive(Debug, Default, Clone)]
-pub struct DownOutRegionEvent {
- pub region: RectF,
- pub platform_event: MouseButtonEvent,
-}
-
-impl Deref for DownOutRegionEvent {
- type Target = MouseButtonEvent;
-
- fn deref(&self) -> &Self::Target {
- &self.platform_event
- }
-}
-
-#[derive(Debug, Default, Clone)]
-pub struct UpOutRegionEvent {
- pub region: RectF,
- pub platform_event: MouseButtonEvent,
-}
-
-impl Deref for UpOutRegionEvent {
- type Target = MouseButtonEvent;
-
- fn deref(&self) -> &Self::Target {
- &self.platform_event
- }
-}
-
-#[derive(Debug, Default, Clone)]
-pub struct ScrollWheelRegionEvent {
- pub region: RectF,
- pub platform_event: ScrollWheelEvent,
-}
-
-impl Deref for ScrollWheelRegionEvent {
- type Target = ScrollWheelEvent;
-
- fn deref(&self) -> &Self::Target {
- &self.platform_event
- }
-}
-
-#[derive(Debug, Clone)]
-pub enum MouseRegionEvent {
- Move(MoveRegionEvent),
- Drag(DragRegionEvent),
- Hover(HoverRegionEvent),
- Down(DownRegionEvent),
- Up(UpRegionEvent),
- Click(ClickRegionEvent),
- DownOut(DownOutRegionEvent),
- UpOut(UpOutRegionEvent),
- ScrollWheel(ScrollWheelRegionEvent),
-}
-
-impl MouseRegionEvent {
- pub fn set_region(&mut self, region: RectF) {
- match self {
- MouseRegionEvent::Move(r) => r.region = region,
- MouseRegionEvent::Drag(r) => r.region = region,
- MouseRegionEvent::Hover(r) => r.region = region,
- MouseRegionEvent::Down(r) => r.region = region,
- MouseRegionEvent::Up(r) => r.region = region,
- MouseRegionEvent::Click(r) => r.region = region,
- MouseRegionEvent::DownOut(r) => r.region = region,
- MouseRegionEvent::UpOut(r) => r.region = region,
- MouseRegionEvent::ScrollWheel(r) => r.region = region,
- }
- }
-
- /// When true, mouse event handlers must call cx.propagate_event() to bubble
- /// the event to handlers they are painted on top of.
- pub fn is_capturable(&self) -> bool {
- match self {
- MouseRegionEvent::Move(_) => true,
- MouseRegionEvent::Drag(_) => true,
- MouseRegionEvent::Hover(_) => false,
- MouseRegionEvent::Down(_) => true,
- MouseRegionEvent::Up(_) => true,
- MouseRegionEvent::Click(_) => true,
- MouseRegionEvent::DownOut(_) => false,
- MouseRegionEvent::UpOut(_) => false,
- MouseRegionEvent::ScrollWheel(_) => true,
- }
- }
-}
-
-impl MouseRegionEvent {
- pub fn move_disc() -> Discriminant<MouseRegionEvent> {
- discriminant(&MouseRegionEvent::Move(Default::default()))
- }
-
- pub fn drag_disc() -> Discriminant<MouseRegionEvent> {
- discriminant(&MouseRegionEvent::Drag(Default::default()))
- }
-
- pub fn hover_disc() -> Discriminant<MouseRegionEvent> {
- discriminant(&MouseRegionEvent::Hover(Default::default()))
- }
-
- pub fn down_disc() -> Discriminant<MouseRegionEvent> {
- discriminant(&MouseRegionEvent::Down(Default::default()))
- }
-
- pub fn up_disc() -> Discriminant<MouseRegionEvent> {
- discriminant(&MouseRegionEvent::Up(Default::default()))
- }
-
- pub fn up_out_disc() -> Discriminant<MouseRegionEvent> {
- discriminant(&MouseRegionEvent::UpOut(Default::default()))
- }
-
- pub fn click_disc() -> Discriminant<MouseRegionEvent> {
- discriminant(&MouseRegionEvent::Click(Default::default()))
- }
-
- pub fn down_out_disc() -> Discriminant<MouseRegionEvent> {
- discriminant(&MouseRegionEvent::DownOut(Default::default()))
- }
-
- pub fn scroll_wheel_disc() -> Discriminant<MouseRegionEvent> {
- discriminant(&MouseRegionEvent::ScrollWheel(Default::default()))
- }
-
- pub fn handler_key(&self) -> (Discriminant<MouseRegionEvent>, Option<MouseButton>) {
- match self {
- MouseRegionEvent::Move(_) => (Self::move_disc(), None),
- MouseRegionEvent::Drag(e) => (Self::drag_disc(), e.pressed_button),
- MouseRegionEvent::Hover(_) => (Self::hover_disc(), None),
- MouseRegionEvent::Down(e) => (Self::down_disc(), Some(e.button)),
- MouseRegionEvent::Up(e) => (Self::up_disc(), Some(e.button)),
- MouseRegionEvent::Click(e) => (Self::click_disc(), Some(e.button)),
- MouseRegionEvent::UpOut(e) => (Self::up_out_disc(), Some(e.button)),
- MouseRegionEvent::DownOut(e) => (Self::down_out_disc(), Some(e.button)),
- MouseRegionEvent::ScrollWheel(_) => (Self::scroll_wheel_disc(), None),
- }
- }
-}
@@ -111,9 +111,19 @@ pub enum IndentKind {
Tab,
}
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Default)]
+pub enum CursorShape {
+ #[default]
+ Bar,
+ Block,
+ Underscore,
+ Hollow,
+}
+
#[derive(Clone, Debug)]
struct SelectionSet {
line_mode: bool,
+ cursor_shape: CursorShape,
selections: Arc<[Selection<Anchor>]>,
lamport_timestamp: clock::Lamport,
}
@@ -161,6 +171,7 @@ pub enum Operation {
selections: Arc<[Selection<Anchor>]>,
lamport_timestamp: clock::Lamport,
line_mode: bool,
+ cursor_shape: CursorShape,
},
UpdateCompletionTriggers {
triggers: Vec<String>,
@@ -395,6 +406,7 @@ impl Buffer {
selections: set.selections.clone(),
lamport_timestamp: set.lamport_timestamp,
line_mode: set.line_mode,
+ cursor_shape: set.cursor_shape,
})
}));
operations.push(proto::serialize_operation(&Operation::UpdateDiagnostics {
@@ -1227,6 +1239,7 @@ impl Buffer {
&mut self,
selections: Arc<[Selection<Anchor>]>,
line_mode: bool,
+ cursor_shape: CursorShape,
cx: &mut ModelContext<Self>,
) {
let lamport_timestamp = self.text.lamport_clock.tick();
@@ -1236,6 +1249,7 @@ impl Buffer {
selections: selections.clone(),
lamport_timestamp,
line_mode,
+ cursor_shape,
},
);
self.send_operation(
@@ -1243,13 +1257,14 @@ impl Buffer {
selections,
line_mode,
lamport_timestamp,
+ cursor_shape,
},
cx,
);
}
pub fn remove_active_selections(&mut self, cx: &mut ModelContext<Self>) {
- self.set_active_selections(Arc::from([]), false, cx);
+ self.set_active_selections(Arc::from([]), false, Default::default(), cx);
}
pub fn set_text<T>(&mut self, text: T, cx: &mut ModelContext<Self>) -> Option<clock::Local>
@@ -1474,6 +1489,7 @@ impl Buffer {
selections,
lamport_timestamp,
line_mode,
+ cursor_shape,
} => {
if let Some(set) = self.remote_selections.get(&lamport_timestamp.replica_id) {
if set.lamport_timestamp > lamport_timestamp {
@@ -1487,6 +1503,7 @@ impl Buffer {
selections,
lamport_timestamp,
line_mode,
+ cursor_shape,
},
);
self.text.lamport_clock.observe(lamport_timestamp);
@@ -2236,6 +2253,7 @@ impl BufferSnapshot {
Item = (
ReplicaId,
bool,
+ CursorShape,
impl Iterator<Item = &Selection<Anchor>> + '_,
),
> + '_ {
@@ -2259,6 +2277,7 @@ impl BufferSnapshot {
(
*replica_id,
set.line_mode,
+ set.cursor_shape,
set.selections[start_ix..end_ix].iter(),
)
})
@@ -2315,6 +2334,18 @@ impl BufferSnapshot {
self.file.as_deref()
}
+ pub fn resolve_file_path(&self, cx: &AppContext, include_root: bool) -> Option<PathBuf> {
+ if let Some(file) = self.file() {
+ if file.path().file_name().is_none() || include_root {
+ Some(file.full_path(cx))
+ } else {
+ Some(file.path().to_path_buf())
+ }
+ } else {
+ None
+ }
+ }
+
pub fn file_update_count(&self) -> usize {
self.file_update_count
}
@@ -1283,7 +1283,7 @@ fn test_random_collaboration(cx: &mut MutableAppContext, mut rng: StdRng) {
selections
);
active_selections.insert(replica_id, selections.clone());
- buffer.set_active_selections(selections, false, cx);
+ buffer.set_active_selections(selections, false, Default::default(), cx);
});
mutation_count -= 1;
}
@@ -1448,7 +1448,7 @@ fn test_random_collaboration(cx: &mut MutableAppContext, mut rng: StdRng) {
let buffer = buffer.read(cx).snapshot();
let actual_remote_selections = buffer
.remote_selections_in_range(Anchor::MIN..Anchor::MAX)
- .map(|(replica_id, _, selections)| (replica_id, selections.collect::<Vec<_>>()))
+ .map(|(replica_id, _, _, selections)| (replica_id, selections.collect::<Vec<_>>()))
.collect::<Vec<_>>();
let expected_remote_selections = active_selections
.iter()
@@ -1,5 +1,6 @@
use crate::{
- diagnostic_set::DiagnosticEntry, CodeAction, CodeLabel, Completion, Diagnostic, Language,
+ diagnostic_set::DiagnosticEntry, CodeAction, CodeLabel, Completion, CursorShape, Diagnostic,
+ Language,
};
use anyhow::{anyhow, Result};
use clock::ReplicaId;
@@ -52,11 +53,13 @@ pub fn serialize_operation(operation: &crate::Operation) -> proto::Operation {
selections,
line_mode,
lamport_timestamp,
+ cursor_shape,
} => proto::operation::Variant::UpdateSelections(proto::operation::UpdateSelections {
replica_id: lamport_timestamp.replica_id as u32,
lamport_timestamp: lamport_timestamp.value,
selections: serialize_selections(selections),
line_mode: *line_mode,
+ cursor_shape: serialize_cursor_shape(cursor_shape) as i32,
}),
crate::Operation::UpdateDiagnostics {
diagnostics,
@@ -125,6 +128,24 @@ pub fn serialize_selection(selection: &Selection<Anchor>) -> proto::Selection {
}
}
+pub fn serialize_cursor_shape(cursor_shape: &CursorShape) -> proto::CursorShape {
+ match cursor_shape {
+ CursorShape::Bar => proto::CursorShape::CursorBar,
+ CursorShape::Block => proto::CursorShape::CursorBlock,
+ CursorShape::Underscore => proto::CursorShape::CursorUnderscore,
+ CursorShape::Hollow => proto::CursorShape::CursorHollow,
+ }
+}
+
+pub fn deserialize_cursor_shape(cursor_shape: proto::CursorShape) -> CursorShape {
+ match cursor_shape {
+ proto::CursorShape::CursorBar => CursorShape::Bar,
+ proto::CursorShape::CursorBlock => CursorShape::Block,
+ proto::CursorShape::CursorUnderscore => CursorShape::Underscore,
+ proto::CursorShape::CursorHollow => CursorShape::Hollow,
+ }
+}
+
pub fn serialize_diagnostics<'a>(
diagnostics: impl IntoIterator<Item = &'a DiagnosticEntry<Anchor>>,
) -> Vec<proto::Diagnostic> {
@@ -223,6 +244,10 @@ pub fn deserialize_operation(message: proto::Operation) -> Result<crate::Operati
},
selections: Arc::from(selections),
line_mode: message.line_mode,
+ cursor_shape: deserialize_cursor_shape(
+ proto::CursorShape::from_i32(message.cursor_shape)
+ .ok_or_else(|| anyhow!("Missing cursor shape"))?,
+ ),
}
}
proto::operation::Variant::UpdateDiagnostics(message) => {
@@ -52,7 +52,7 @@ impl View for OutlineView {
ChildView::new(self.picker.clone(), cx).boxed()
}
- fn on_focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+ fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
if cx.is_self_focused() {
cx.focus(&self.picker);
}
@@ -116,7 +116,7 @@ impl<D: PickerDelegate> View for Picker<D> {
cx
}
- fn on_focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+ fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
if cx.is_self_focused() {
cx.focus(&self.query_editor);
}
@@ -52,7 +52,6 @@ similar = "1.3"
smol = "1.2.5"
thiserror = "1.0.29"
toml = "0.5"
-rocksdb = "0.18"
[dev-dependencies]
client = { path = "../client", features = ["test-support"] }
@@ -583,7 +583,10 @@ impl Project {
cx: &mut gpui::TestAppContext,
) -> ModelHandle<Project> {
if !cx.read(|cx| cx.has_global::<Settings>()) {
- cx.update(|cx| cx.set_global(Settings::test(cx)));
+ cx.update(|cx| {
+ cx.set_global(Settings::test(cx));
+ cx.set_global(HomeDir(Path::new("/tmp/").to_path_buf()))
+ });
}
let languages = Arc::new(LanguageRegistry::test());
@@ -2164,6 +2164,7 @@ async fn test_rescan_and_remote_updates(
proto::WorktreeMetadata {
id: initial_snapshot.id().to_proto(),
root_name: initial_snapshot.root_name().into(),
+ abs_path: initial_snapshot.abs_path().as_os_str().as_bytes().to_vec(),
visible: true,
},
rpc.clone(),
@@ -5,8 +5,8 @@ use anyhow::{anyhow, Context, Result};
use client::{proto, Client};
use clock::ReplicaId;
use collections::{HashMap, VecDeque};
-use fs::LineEnding;
use fs::{repository::GitRepository, Fs};
+use fs::{HomeDir, LineEnding};
use futures::{
channel::{
mpsc::{self, UnboundedSender},
@@ -87,6 +87,7 @@ pub struct RemoteWorktree {
#[derive(Clone)]
pub struct Snapshot {
id: WorktreeId,
+ abs_path: Arc<Path>,
root_name: String,
root_char_bag: CharBag,
entries_by_path: SumTree<Entry>,
@@ -118,7 +119,6 @@ impl std::fmt::Debug for GitRepositoryEntry {
}
pub struct LocalSnapshot {
- abs_path: Arc<Path>,
ignores_by_parent_abs_path: HashMap<Arc<Path>, (Arc<Gitignore>, usize)>,
git_repositories: Vec<GitRepositoryEntry>,
removed_entry_ids: HashMap<u64, ProjectEntryId>,
@@ -130,7 +130,6 @@ pub struct LocalSnapshot {
impl Clone for LocalSnapshot {
fn clone(&self) -> Self {
Self {
- abs_path: self.abs_path.clone(),
ignores_by_parent_abs_path: self.ignores_by_parent_abs_path.clone(),
git_repositories: self.git_repositories.iter().cloned().collect(),
removed_entry_ids: self.removed_entry_ids.clone(),
@@ -221,8 +220,11 @@ impl Worktree {
.collect();
let root_name = worktree.root_name.clone();
let visible = worktree.visible;
+
+ let abs_path = PathBuf::from(OsString::from_vec(worktree.abs_path));
let snapshot = Snapshot {
id: WorktreeId(remote_id as usize),
+ abs_path: Arc::from(abs_path.deref()),
root_name,
root_char_bag,
entries_by_path: Default::default(),
@@ -372,6 +374,13 @@ impl Worktree {
Self::Remote(worktree) => worktree.poll_snapshot(cx),
};
}
+
+ pub fn abs_path(&self) -> Arc<Path> {
+ match self {
+ Worktree::Local(worktree) => worktree.abs_path.clone(),
+ Worktree::Remote(worktree) => worktree.abs_path.clone(),
+ }
+ }
}
impl LocalWorktree {
@@ -402,13 +411,13 @@ impl LocalWorktree {
watch::channel_with(ScanState::Initializing);
let tree = cx.add_model(move |cx: &mut ModelContext<Worktree>| {
let mut snapshot = LocalSnapshot {
- abs_path,
ignores_by_parent_abs_path: Default::default(),
git_repositories: Default::default(),
removed_entry_ids: Default::default(),
next_entry_id,
snapshot: Snapshot {
id: WorktreeId::from_usize(cx.model_id()),
+ abs_path,
root_name: root_name.clone(),
root_char_bag,
entries_by_path: Default::default(),
@@ -647,6 +656,7 @@ impl LocalWorktree {
id: self.id().to_proto(),
root_name: self.root_name().to_string(),
visible: self.visible,
+ abs_path: self.abs_path().as_os_str().as_bytes().to_vec(),
}
}
@@ -980,6 +990,7 @@ impl LocalWorktree {
let update = proto::UpdateWorktree {
project_id,
worktree_id,
+ abs_path: snapshot.abs_path().as_os_str().as_bytes().to_vec(),
root_name: snapshot.root_name().to_string(),
updated_entries: snapshot
.entries_by_path
@@ -1389,6 +1400,7 @@ impl LocalSnapshot {
proto::UpdateWorktree {
project_id,
worktree_id: self.id().to_proto(),
+ abs_path: self.abs_path().as_os_str().as_bytes().to_vec(),
root_name,
updated_entries: self.entries_by_path.iter().map(Into::into).collect(),
removed_entries: Default::default(),
@@ -1456,6 +1468,7 @@ impl LocalSnapshot {
proto::UpdateWorktree {
project_id,
worktree_id,
+ abs_path: self.abs_path().as_os_str().as_bytes().to_vec(),
root_name: self.root_name().to_string(),
updated_entries,
removed_entries,
@@ -1839,10 +1852,25 @@ impl language::File for File {
fn full_path(&self, cx: &AppContext) -> PathBuf {
let mut full_path = PathBuf::new();
- full_path.push(self.worktree.read(cx).root_name());
+ let worktree = self.worktree.read(cx);
+
+ if worktree.is_visible() {
+ full_path.push(worktree.root_name());
+ } else {
+ let path = worktree.abs_path();
+
+ if worktree.is_local() && path.starts_with(cx.global::<HomeDir>().as_path()) {
+ full_path.push("~");
+ full_path.push(path.strip_prefix(cx.global::<HomeDir>().as_path()).unwrap());
+ } else {
+ full_path.push(path)
+ }
+ }
+
if self.path.components().next().is_some() {
full_path.push(&self.path);
}
+
full_path
}
@@ -3455,7 +3483,6 @@ mod tests {
let fs = Arc::new(RealFs);
let next_entry_id = Arc::new(AtomicUsize::new(0));
let mut initial_snapshot = LocalSnapshot {
- abs_path: root_dir.path().into(),
removed_entry_ids: Default::default(),
ignores_by_parent_abs_path: Default::default(),
git_repositories: Default::default(),
@@ -3464,6 +3491,7 @@ mod tests {
id: WorktreeId::from_usize(0),
entries_by_path: Default::default(),
entries_by_id: Default::default(),
+ abs_path: root_dir.path().into(),
root_name: Default::default(),
root_char_bag: Default::default(),
scan_id: 0,
@@ -51,7 +51,7 @@ impl View for ProjectSymbolsView {
ChildView::new(self.picker.clone(), cx).boxed()
}
- fn on_focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+ fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
if cx.is_self_focused() {
cx.focus(&self.picker);
}
@@ -6,125 +6,130 @@ message Envelope {
optional uint32 responding_to = 2;
optional uint32 original_sender_id = 3;
oneof payload {
- Ack ack = 4;
- Error error = 5;
- Ping ping = 6;
- Test test = 7;
+ Hello hello = 4;
+ Ack ack = 5;
+ Error error = 6;
+ Ping ping = 7;
+ Test test = 8;
- CreateRoom create_room = 8;
- CreateRoomResponse create_room_response = 9;
- JoinRoom join_room = 10;
- JoinRoomResponse join_room_response = 11;
- LeaveRoom leave_room = 12;
- Call call = 13;
- IncomingCall incoming_call = 14;
- CallCanceled call_canceled = 15;
- CancelCall cancel_call = 16;
- DeclineCall decline_call = 17;
- UpdateParticipantLocation update_participant_location = 18;
- RoomUpdated room_updated = 19;
-
- ShareProject share_project = 20;
- ShareProjectResponse share_project_response = 21;
- UnshareProject unshare_project = 22;
- JoinProject join_project = 23;
- JoinProjectResponse join_project_response = 24;
- LeaveProject leave_project = 25;
- AddProjectCollaborator add_project_collaborator = 26;
- RemoveProjectCollaborator remove_project_collaborator = 27;
-
- GetDefinition get_definition = 28;
- GetDefinitionResponse get_definition_response = 29;
- GetTypeDefinition get_type_definition = 30;
- GetTypeDefinitionResponse get_type_definition_response = 31;
- GetReferences get_references = 32;
- GetReferencesResponse get_references_response = 33;
- GetDocumentHighlights get_document_highlights = 34;
- GetDocumentHighlightsResponse get_document_highlights_response = 35;
- GetProjectSymbols get_project_symbols = 36;
- GetProjectSymbolsResponse get_project_symbols_response = 37;
- OpenBufferForSymbol open_buffer_for_symbol = 38;
- OpenBufferForSymbolResponse open_buffer_for_symbol_response = 39;
-
- UpdateProject update_project = 40;
- RegisterProjectActivity register_project_activity = 41;
- UpdateWorktree update_worktree = 42;
- UpdateWorktreeExtensions update_worktree_extensions = 43;
-
- CreateProjectEntry create_project_entry = 44;
- RenameProjectEntry rename_project_entry = 45;
- CopyProjectEntry copy_project_entry = 46;
- DeleteProjectEntry delete_project_entry = 47;
- ProjectEntryResponse project_entry_response = 48;
-
- UpdateDiagnosticSummary update_diagnostic_summary = 49;
- StartLanguageServer start_language_server = 50;
- UpdateLanguageServer update_language_server = 51;
-
- OpenBufferById open_buffer_by_id = 52;
- OpenBufferByPath open_buffer_by_path = 53;
- OpenBufferResponse open_buffer_response = 54;
- CreateBufferForPeer create_buffer_for_peer = 55;
- UpdateBuffer update_buffer = 56;
- UpdateBufferFile update_buffer_file = 57;
- SaveBuffer save_buffer = 58;
- BufferSaved buffer_saved = 59;
- BufferReloaded buffer_reloaded = 60;
- ReloadBuffers reload_buffers = 61;
- ReloadBuffersResponse reload_buffers_response = 62;
- FormatBuffers format_buffers = 63;
- FormatBuffersResponse format_buffers_response = 64;
- GetCompletions get_completions = 65;
- GetCompletionsResponse get_completions_response = 66;
- ApplyCompletionAdditionalEdits apply_completion_additional_edits = 67;
- ApplyCompletionAdditionalEditsResponse apply_completion_additional_edits_response = 68;
- GetCodeActions get_code_actions = 69;
- GetCodeActionsResponse get_code_actions_response = 70;
- GetHover get_hover = 71;
- GetHoverResponse get_hover_response = 72;
- ApplyCodeAction apply_code_action = 73;
- ApplyCodeActionResponse apply_code_action_response = 74;
- PrepareRename prepare_rename = 75;
- PrepareRenameResponse prepare_rename_response = 76;
- PerformRename perform_rename = 77;
- PerformRenameResponse perform_rename_response = 78;
- SearchProject search_project = 79;
- SearchProjectResponse search_project_response = 80;
-
- GetChannels get_channels = 81;
- GetChannelsResponse get_channels_response = 82;
- JoinChannel join_channel = 83;
- JoinChannelResponse join_channel_response = 84;
- LeaveChannel leave_channel = 85;
- SendChannelMessage send_channel_message = 86;
- SendChannelMessageResponse send_channel_message_response = 87;
- ChannelMessageSent channel_message_sent = 88;
- GetChannelMessages get_channel_messages = 89;
- GetChannelMessagesResponse get_channel_messages_response = 90;
-
- UpdateContacts update_contacts = 91;
- UpdateInviteInfo update_invite_info = 92;
- ShowContacts show_contacts = 93;
-
- GetUsers get_users = 94;
- FuzzySearchUsers fuzzy_search_users = 95;
- UsersResponse users_response = 96;
- RequestContact request_contact = 97;
- RespondToContactRequest respond_to_contact_request = 98;
- RemoveContact remove_contact = 99;
-
- Follow follow = 100;
- FollowResponse follow_response = 101;
- UpdateFollowers update_followers = 102;
- Unfollow unfollow = 103;
- GetPrivateUserInfo get_private_user_info = 104;
- GetPrivateUserInfoResponse get_private_user_info_response = 105;
- UpdateDiffBase update_diff_base = 106;
+ CreateRoom create_room = 9;
+ CreateRoomResponse create_room_response = 10;
+ JoinRoom join_room = 11;
+ JoinRoomResponse join_room_response = 12;
+ LeaveRoom leave_room = 13;
+ Call call = 14;
+ IncomingCall incoming_call = 15;
+ CallCanceled call_canceled = 16;
+ CancelCall cancel_call = 17;
+ DeclineCall decline_call = 18;
+ UpdateParticipantLocation update_participant_location = 19;
+ RoomUpdated room_updated = 20;
+
+ ShareProject share_project = 21;
+ ShareProjectResponse share_project_response = 22;
+ UnshareProject unshare_project = 23;
+ JoinProject join_project = 24;
+ JoinProjectResponse join_project_response = 25;
+ LeaveProject leave_project = 26;
+ AddProjectCollaborator add_project_collaborator = 27;
+ RemoveProjectCollaborator remove_project_collaborator = 28;
+
+ GetDefinition get_definition = 29;
+ GetDefinitionResponse get_definition_response = 30;
+ GetTypeDefinition get_type_definition = 31;
+ GetTypeDefinitionResponse get_type_definition_response = 32;
+ GetReferences get_references = 33;
+ GetReferencesResponse get_references_response = 34;
+ GetDocumentHighlights get_document_highlights = 35;
+ GetDocumentHighlightsResponse get_document_highlights_response = 36;
+ GetProjectSymbols get_project_symbols = 37;
+ GetProjectSymbolsResponse get_project_symbols_response = 38;
+ OpenBufferForSymbol open_buffer_for_symbol = 39;
+ OpenBufferForSymbolResponse open_buffer_for_symbol_response = 40;
+
+ UpdateProject update_project = 41;
+ RegisterProjectActivity register_project_activity = 42;
+ UpdateWorktree update_worktree = 43;
+ UpdateWorktreeExtensions update_worktree_extensions = 44;
+
+ CreateProjectEntry create_project_entry = 45;
+ RenameProjectEntry rename_project_entry = 46;
+ CopyProjectEntry copy_project_entry = 47;
+ DeleteProjectEntry delete_project_entry = 48;
+ ProjectEntryResponse project_entry_response = 49;
+
+ UpdateDiagnosticSummary update_diagnostic_summary = 50;
+ StartLanguageServer start_language_server = 51;
+ UpdateLanguageServer update_language_server = 52;
+
+ OpenBufferById open_buffer_by_id = 53;
+ OpenBufferByPath open_buffer_by_path = 54;
+ OpenBufferResponse open_buffer_response = 55;
+ CreateBufferForPeer create_buffer_for_peer = 56;
+ UpdateBuffer update_buffer = 57;
+ UpdateBufferFile update_buffer_file = 58;
+ SaveBuffer save_buffer = 59;
+ BufferSaved buffer_saved = 60;
+ BufferReloaded buffer_reloaded = 61;
+ ReloadBuffers reload_buffers = 62;
+ ReloadBuffersResponse reload_buffers_response = 63;
+ FormatBuffers format_buffers = 64;
+ FormatBuffersResponse format_buffers_response = 65;
+ GetCompletions get_completions = 66;
+ GetCompletionsResponse get_completions_response = 67;
+ ApplyCompletionAdditionalEdits apply_completion_additional_edits = 68;
+ ApplyCompletionAdditionalEditsResponse apply_completion_additional_edits_response = 69;
+ GetCodeActions get_code_actions = 70;
+ GetCodeActionsResponse get_code_actions_response = 71;
+ GetHover get_hover = 72;
+ GetHoverResponse get_hover_response = 73;
+ ApplyCodeAction apply_code_action = 74;
+ ApplyCodeActionResponse apply_code_action_response = 75;
+ PrepareRename prepare_rename = 76;
+ PrepareRenameResponse prepare_rename_response = 77;
+ PerformRename perform_rename = 78;
+ PerformRenameResponse perform_rename_response = 79;
+ SearchProject search_project = 80;
+ SearchProjectResponse search_project_response = 81;
+
+ GetChannels get_channels = 82;
+ GetChannelsResponse get_channels_response = 83;
+ JoinChannel join_channel = 84;
+ JoinChannelResponse join_channel_response = 85;
+ LeaveChannel leave_channel = 86;
+ SendChannelMessage send_channel_message = 87;
+ SendChannelMessageResponse send_channel_message_response = 88;
+ ChannelMessageSent channel_message_sent = 89;
+ GetChannelMessages get_channel_messages = 90;
+ GetChannelMessagesResponse get_channel_messages_response = 91;
+
+ UpdateContacts update_contacts = 92;
+ UpdateInviteInfo update_invite_info = 93;
+ ShowContacts show_contacts = 94;
+
+ GetUsers get_users = 95;
+ FuzzySearchUsers fuzzy_search_users = 96;
+ UsersResponse users_response = 97;
+ RequestContact request_contact = 98;
+ RespondToContactRequest respond_to_contact_request = 99;
+ RemoveContact remove_contact = 100;
+
+ Follow follow = 101;
+ FollowResponse follow_response = 102;
+ UpdateFollowers update_followers = 103;
+ Unfollow unfollow = 104;
+ GetPrivateUserInfo get_private_user_info = 105;
+ GetPrivateUserInfoResponse get_private_user_info_response = 106;
+ UpdateDiffBase update_diff_base = 107;
}
}
// Messages
+message Hello {
+ uint32 peer_id = 1;
+}
+
message Ping {}
message Ack {}
@@ -266,6 +271,7 @@ message UpdateWorktree {
repeated uint64 removed_entries = 5;
uint64 scan_id = 6;
bool is_last_update = 7;
+ bytes abs_path = 8;
}
message UpdateWorktreeExtensions {
@@ -908,6 +914,7 @@ message SelectionSet {
repeated Selection selections = 2;
uint32 lamport_timestamp = 3;
bool line_mode = 4;
+ CursorShape cursor_shape = 5;
}
message Selection {
@@ -917,6 +924,13 @@ message Selection {
bool reversed = 4;
}
+enum CursorShape {
+ CursorBar = 0;
+ CursorBlock = 1;
+ CursorUnderscore = 2;
+ CursorHollow = 3;
+}
+
message Anchor {
uint32 replica_id = 1;
uint32 local_timestamp = 2;
@@ -982,6 +996,7 @@ message Operation {
uint32 lamport_timestamp = 2;
repeated Selection selections = 3;
bool line_mode = 4;
+ CursorShape cursor_shape = 5;
}
message UpdateCompletionTriggers {
@@ -1052,6 +1067,7 @@ message WorktreeMetadata {
uint64 id = 1;
string root_name = 2;
bool visible = 3;
+ bytes abs_path = 4;
}
message UpdateDiffBase {
@@ -121,6 +121,7 @@ messages!(
(GetProjectSymbols, Background),
(GetProjectSymbolsResponse, Background),
(GetUsers, Foreground),
+ (Hello, Foreground),
(IncomingCall, Foreground),
(UsersResponse, Foreground),
(JoinChannel, Foreground),
@@ -435,6 +436,7 @@ pub fn split_worktree_update(
project_id: message.project_id,
worktree_id: message.worktree_id,
root_name: message.root_name.clone(),
+ abs_path: message.abs_path.clone(),
updated_entries,
removed_entries: mem::take(&mut message.removed_entries),
scan_id: message.scan_id,
@@ -6,4 +6,4 @@ pub use conn::Connection;
pub use peer::*;
mod macros;
-pub const PROTOCOL_VERSION: u32 = 35;
+pub const PROTOCOL_VERSION: u32 = 38;
@@ -82,7 +82,7 @@ impl View for BufferSearchBar {
"BufferSearchBar"
}
- fn on_focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+ fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
if cx.is_self_focused() {
cx.focus(&self.query_editor);
}
@@ -195,7 +195,7 @@ impl View for ProjectSearchView {
}
}
- fn on_focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+ fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
let handle = cx.weak_handle();
cx.update_global(|state: &mut ActiveSearches, cx| {
state
@@ -28,6 +28,7 @@ pub struct Settings {
pub buffer_font_family: FamilyId,
pub default_buffer_font_size: f32,
pub buffer_font_size: f32,
+ pub cursor_blink: bool,
pub hover_popover_enabled: bool,
pub show_completions_on_input: bool,
pub vim_mode: bool,
@@ -234,6 +235,8 @@ pub struct SettingsFileContent {
#[serde(default)]
pub buffer_font_size: Option<f32>,
#[serde(default)]
+ pub cursor_blink: Option<bool>,
+ #[serde(default)]
pub hover_popover_enabled: Option<bool>,
#[serde(default)]
pub show_completions_on_input: Option<bool>,
@@ -292,6 +295,7 @@ impl Settings {
.unwrap(),
buffer_font_size: defaults.buffer_font_size.unwrap(),
default_buffer_font_size: defaults.buffer_font_size.unwrap(),
+ cursor_blink: defaults.cursor_blink.unwrap(),
hover_popover_enabled: defaults.hover_popover_enabled.unwrap(),
show_completions_on_input: defaults.show_completions_on_input.unwrap(),
projects_online_by_default: defaults.projects_online_by_default.unwrap(),
@@ -346,6 +350,7 @@ impl Settings {
);
merge(&mut self.buffer_font_size, data.buffer_font_size);
merge(&mut self.default_buffer_font_size, data.buffer_font_size);
+ merge(&mut self.cursor_blink, data.cursor_blink);
merge(&mut self.hover_popover_enabled, data.hover_popover_enabled);
merge(
&mut self.show_completions_on_input,
@@ -436,6 +441,7 @@ impl Settings {
buffer_font_family: cx.font_cache().load_family(&["Monaco"]).unwrap(),
buffer_font_size: 14.,
default_buffer_font_size: 14.,
+ cursor_blink: true,
hover_popover_enabled: true,
show_completions_on_input: true,
vim_mode: false,
@@ -8,16 +8,17 @@ path = "src/terminal.rs"
doctest = false
[dependencies]
-alacritty_terminal = { git = "https://github.com/zed-industries/alacritty", rev = "a51dbe25d67e84d6ed4261e640d3954fbdd9be45" }
-procinfo = { git = "https://github.com/zed-industries/wezterm", rev = "5cd757e5f2eb039ed0c6bb6512223e69d5efc64d", default-features = false }
+context_menu = { path = "../context_menu" }
editor = { path = "../editor" }
-util = { path = "../util" }
+language = { path = "../language" }
gpui = { path = "../gpui" }
-theme = { path = "../theme" }
+project = { path = "../project" }
settings = { path = "../settings" }
+theme = { path = "../theme" }
+util = { path = "../util" }
workspace = { path = "../workspace" }
-project = { path = "../project" }
-context_menu = { path = "../context_menu" }
+alacritty_terminal = { git = "https://github.com/zed-industries/alacritty", rev = "a51dbe25d67e84d6ed4261e640d3954fbdd9be45" }
+procinfo = { git = "https://github.com/zed-industries/wezterm", rev = "5cd757e5f2eb039ed0c6bb6512223e69d5efc64d", default-features = false }
smallvec = { version = "1.6", features = ["union"] }
smol = "1.2.5"
mio-extras = "2.0.6"
@@ -6,7 +6,7 @@ use alacritty_terminal::grid::Dimensions;
/// with modifications for our circumstances
use alacritty_terminal::index::{Column as GridCol, Line as GridLine, Point, Side};
use alacritty_terminal::term::TermMode;
-use gpui::scene::ScrollWheelRegionEvent;
+use gpui::scene::MouseScrollWheel;
use gpui::{geometry::vector::Vector2F, MouseButtonEvent, MouseMovedEvent, ScrollWheelEvent};
use crate::TerminalSize;
@@ -115,7 +115,7 @@ impl MouseButton {
pub fn scroll_report(
point: Point,
scroll_lines: i32,
- e: &ScrollWheelRegionEvent,
+ e: &MouseScrollWheel,
mode: TermMode,
) -> Option<impl Iterator<Item = Vec<u8>>> {
if mode.intersects(TermMode::MOUSE_MODE) {
@@ -53,7 +53,7 @@ use thiserror::Error;
use gpui::{
geometry::vector::{vec2f, Vector2F},
keymap::Keystroke,
- scene::{DownRegionEvent, DragRegionEvent, ScrollWheelRegionEvent, UpRegionEvent},
+ scene::{MouseDown, MouseDrag, MouseScrollWheel, MouseUp},
ClipboardItem, Entity, ModelContext, MouseButton, MouseMovedEvent, MutableAppContext, Task,
};
@@ -971,7 +971,7 @@ impl Terminal {
}
}
- pub fn mouse_drag(&mut self, e: DragRegionEvent, origin: Vector2F) {
+ pub fn mouse_drag(&mut self, e: MouseDrag, origin: Vector2F) {
let position = e.position.sub(origin);
self.last_mouse_position = Some(position);
@@ -997,7 +997,7 @@ impl Terminal {
}
}
- fn drag_line_delta(&mut self, e: DragRegionEvent) -> Option<f32> {
+ fn drag_line_delta(&mut self, e: MouseDrag) -> Option<f32> {
//TODO: Why do these need to be doubled? Probably the same problem that the IME has
let top = e.region.origin_y() + (self.last_content.size.line_height * 2.);
let bottom = e.region.lower_left().y() - (self.last_content.size.line_height * 2.);
@@ -1011,7 +1011,7 @@ impl Terminal {
Some(scroll_delta)
}
- pub fn mouse_down(&mut self, e: &DownRegionEvent, origin: Vector2F) {
+ pub fn mouse_down(&mut self, e: &MouseDown, origin: Vector2F) {
let position = e.position.sub(origin);
let point = grid_point(
position,
@@ -1050,7 +1050,7 @@ impl Terminal {
}
}
- pub fn mouse_up(&mut self, e: &UpRegionEvent, origin: Vector2F, cx: &mut ModelContext<Self>) {
+ pub fn mouse_up(&mut self, e: &MouseUp, origin: Vector2F, cx: &mut ModelContext<Self>) {
let settings = cx.global::<Settings>();
let copy_on_select = settings
.terminal_overrides
@@ -1095,7 +1095,7 @@ impl Terminal {
}
///Scroll the terminal
- pub fn scroll_wheel(&mut self, e: ScrollWheelRegionEvent, origin: Vector2F) {
+ pub fn scroll_wheel(&mut self, e: MouseScrollWheel, origin: Vector2F) {
let mouse_mode = self.mouse_mode(e.shift);
if let Some(scroll_lines) = self.determine_scroll_lines(&e, mouse_mode) {
@@ -1134,11 +1134,7 @@ impl Terminal {
self.hyperlink_from_position(self.last_mouse_position);
}
- fn determine_scroll_lines(
- &mut self,
- e: &ScrollWheelRegionEvent,
- mouse_mode: bool,
- ) -> Option<i32> {
+ fn determine_scroll_lines(&mut self, e: &MouseScrollWheel, mouse_mode: bool) -> Option<i32> {
let scroll_multiplier = if mouse_mode { 1. } else { SCROLL_MULTIPLIER };
match e.phase {
@@ -165,7 +165,7 @@ impl View for TerminalContainer {
.boxed()
}
- fn on_focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+ fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
if cx.is_self_focused() {
cx.focus(self.content.handle());
}
@@ -4,7 +4,7 @@ use alacritty_terminal::{
index::Point,
term::{cell::Flags, TermMode},
};
-use editor::{Cursor, CursorShape, HighlightedRange, HighlightedRangeLine};
+use editor::{Cursor, HighlightedRange, HighlightedRangeLine};
use gpui::{
color::Color,
elements::{Empty, Overlay},
@@ -15,11 +15,11 @@ use gpui::{
},
serde_json::json,
text_layout::{Line, RunStyle},
- Element, ElementBox, Event, EventContext, FontCache, KeyDownEvent, ModelContext, MouseButton,
- MouseRegion, PaintContext, Quad, SizeConstraint, TextLayoutCache, WeakModelHandle,
- WeakViewHandle,
+ Element, ElementBox, EventContext, FontCache, ModelContext, MouseButton, MouseRegion,
+ PaintContext, Quad, SizeConstraint, TextLayoutCache, WeakModelHandle, WeakViewHandle,
};
use itertools::Itertools;
+use language::CursorShape;
use ordered_float::OrderedFloat;
use settings::Settings;
use theme::TerminalStyle;
@@ -788,46 +788,6 @@ impl Element for TerminalElement {
});
}
- fn dispatch_event(
- &mut self,
- event: &gpui::Event,
- _bounds: gpui::geometry::rect::RectF,
- _visible_bounds: gpui::geometry::rect::RectF,
- _layout: &mut Self::LayoutState,
- _paint: &mut Self::PaintState,
- cx: &mut gpui::EventContext,
- ) -> bool {
- if let Event::KeyDown(KeyDownEvent { keystroke, .. }) = event {
- if !cx.is_parent_view_focused() {
- return false;
- }
-
- if let Some(view) = self.view.upgrade(cx.app) {
- view.update(cx.app, |view, cx| {
- view.clear_bel(cx);
- view.pause_cursor_blinking(cx);
- })
- }
-
- self.terminal
- .upgrade(cx.app)
- .map(|model_handle| {
- model_handle.update(cx.app, |term, cx| {
- term.try_keystroke(
- keystroke,
- cx.global::<Settings>()
- .terminal_overrides
- .option_as_meta
- .unwrap_or(false),
- )
- })
- })
- .unwrap_or(false)
- } else {
- false
- }
- }
-
fn metadata(&self) -> Option<&dyn std::any::Any> {
None
}
@@ -38,18 +38,7 @@ pub struct SendKeystroke(String);
actions!(
terminal,
- [
- Up,
- Down,
- CtrlC,
- Escape,
- Enter,
- Clear,
- Copy,
- Paste,
- ShowCharacterPalette,
- SearchTest
- ]
+ [Clear, Copy, Paste, ShowCharacterPalette, SearchTest]
);
impl_actions!(terminal, [SendText, SendKeystroke]);
@@ -342,20 +331,35 @@ impl View for TerminalView {
.boxed()
}
- fn on_focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+ fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
self.has_new_content = false;
self.terminal.read(cx).focus_in();
self.blink_cursors(self.blink_epoch, cx);
cx.notify();
}
- fn on_focus_out(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+ fn focus_out(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
self.terminal.update(cx, |terminal, _| {
terminal.focus_out();
});
cx.notify();
}
+ fn key_down(&mut self, event: &gpui::KeyDownEvent, cx: &mut ViewContext<Self>) -> bool {
+ self.clear_bel(cx);
+ self.pause_cursor_blinking(cx);
+
+ self.terminal.update(cx, |term, cx| {
+ term.try_keystroke(
+ &event.keystroke,
+ cx.global::<Settings>()
+ .terminal_overrides
+ .option_as_meta
+ .unwrap_or(false),
+ )
+ })
+ }
+
//IME stuff
fn selected_text_range(&self, cx: &AppContext) -> Option<std::ops::Range<usize>> {
if self
@@ -266,7 +266,7 @@ impl View for ThemeSelector {
ChildView::new(self.picker.clone(), cx).boxed()
}
- fn on_focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+ fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
if cx.is_self_focused() {
cx.focus(&self.picker);
}
@@ -1,5 +1,5 @@
-use editor::CursorShape;
use gpui::keymap::Context;
+use language::CursorShape;
use serde::{Deserialize, Serialize};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize, Serialize)]
@@ -12,8 +12,9 @@ mod visual;
use collections::HashMap;
use command_palette::CommandPaletteFilter;
-use editor::{Bias, Cancel, CursorShape, Editor};
+use editor::{Bias, Cancel, Editor};
use gpui::{impl_actions, MutableAppContext, Subscription, ViewContext, WeakViewHandle};
+use language::CursorShape;
use serde::Deserialize;
use settings::Settings;
@@ -1485,7 +1485,7 @@ impl View for Pane {
.named("pane")
}
- fn on_focus_in(&mut self, focused: AnyViewHandle, cx: &mut ViewContext<Self>) {
+ fn focus_in(&mut self, focused: AnyViewHandle, cx: &mut ViewContext<Self>) {
if let Some(active_item) = self.active_item() {
if cx.is_self_focused() {
// Pane was focused directly. We need to either focus a view inside the active item,
@@ -927,6 +927,9 @@ impl From<&dyn NotificationHandle> for AnyViewHandle {
impl AppState {
#[cfg(any(test, feature = "test-support"))]
pub fn test(cx: &mut MutableAppContext) -> Arc<Self> {
+ use fs::HomeDir;
+
+ cx.set_global(HomeDir(Path::new("/tmp/").to_path_buf()));
let settings = Settings::test(cx);
cx.set_global(settings);
@@ -2656,7 +2659,7 @@ impl View for Workspace {
.named("workspace")
}
- fn on_focus_in(&mut self, view: AnyViewHandle, cx: &mut ViewContext<Self>) {
+ fn focus_in(&mut self, view: AnyViewHandle, cx: &mut ViewContext<Self>) {
if cx.is_self_focused() {
cx.focus(&self.active_pane);
} else {
@@ -3,7 +3,7 @@ authors = ["Nathan Sobo <nathansobo@gmail.com>"]
description = "The fast, collaborative code editor."
edition = "2021"
name = "zed"
-version = "0.60.4"
+version = "0.61.0"
[lib]
name = "zed"
@@ -23,7 +23,7 @@ use isahc::{config::Configurable, Request};
use language::LanguageRegistry;
use log::LevelFilter;
use parking_lot::Mutex;
-use project::{Fs, ProjectStore};
+use project::{Fs, HomeDir, ProjectStore};
use serde_json::json;
use settings::{
self, settings_file::SettingsFile, KeymapFileContent, Settings, SettingsFileContent,
@@ -52,11 +52,9 @@ fn main() {
.or_else(|| app.platform().app_version().ok())
.map_or("dev".to_string(), |v| v.to_string());
init_panic_hook(app_version, http.clone(), app.background());
- let db = app.background().spawn(async move {
- project::Db::open(&*zed::paths::DB)
- .log_err()
- .unwrap_or_else(project::Db::null)
- });
+ let db = app
+ .background()
+ .spawn(async move { project::Db::open(&*zed::paths::DB_DIR) });
load_embedded_fonts(&app);
@@ -99,6 +97,8 @@ fn main() {
let (settings_file_content, keymap_file) = cx.background().block(config_files).unwrap();
+ cx.set_global(HomeDir(zed::paths::HOME.to_path_buf()));
+
//Setup settings global before binding actions
cx.set_global(SettingsFile::new(
&*zed::paths::SETTINGS,
@@ -1,12 +1,11 @@
use std::path::PathBuf;
lazy_static::lazy_static! {
- static ref HOME: PathBuf = dirs::home_dir().expect("failed to determine home directory");
+ pub static ref HOME: PathBuf = dirs::home_dir().expect("failed to determine home directory");
pub static ref CONFIG_DIR: PathBuf = HOME.join(".config").join("zed");
pub static ref LOGS_DIR: PathBuf = HOME.join("Library/Logs/Zed");
pub static ref LANGUAGES_DIR: PathBuf = HOME.join("Library/Application Support/Zed/languages");
pub static ref DB_DIR: PathBuf = HOME.join("Library/Application Support/Zed/db");
- pub static ref DB: PathBuf = DB_DIR.join("zed.db");
pub static ref SETTINGS: PathBuf = CONFIG_DIR.join("settings.json");
pub static ref KEYMAP: PathBuf = CONFIG_DIR.join("keymap.json");
pub static ref LAST_USERNAME: PathBuf = CONFIG_DIR.join("last-username.txt");
@@ -63,6 +63,7 @@ actions!(
DecreaseBufferFontSize,
ResetBufferFontSize,
InstallCommandLineInterface,
+ ResetDatabase,
]
);
@@ -67,7 +67,7 @@ async function main() {
console.log(" URL: ", webURL);
// If the pull request contains a 'closes' line, print the closed issue.
- const fixesMatch = pullRequest.body.match(FIXES_REGEX);
+ const fixesMatch = (pullRequest.body || '').match(FIXES_REGEX);
if (fixesMatch) {
const fixedIssueURL = fixesMatch[2];
console.log(" Issue: ", fixedIssueURL);