From 773423fcf49c27617be0b0cfce5478d7ceec9674 Mon Sep 17 00:00:00 2001 From: Joseph T Lyons Date: Wed, 28 Sep 2022 16:25:37 -0400 Subject: [PATCH 01/21] Initial work to add settings to journal feature --- Cargo.lock | 1 + assets/settings/default.json | 7 +++ crates/journal/Cargo.toml | 1 + crates/journal/src/journal.rs | 80 +++++++++++++++++++++++++++++---- crates/settings/src/settings.rs | 29 ++++++++++++ 5 files changed, 109 insertions(+), 9 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 363ee93c14adde698e2d2b578c275d6c517ce7ef..28fc8fcb612d6a65feae4f18d55692ed691991d0 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2764,6 +2764,7 @@ dependencies = [ "editor", "gpui", "log", + "settings", "util", "workspace", ] diff --git a/assets/settings/default.json b/assets/settings/default.json index a12cf44d94ae29c45851d3b39a3c4caa32008f96..25117521bf9846737dabcb3c8e111ea77eb89301 100644 --- a/assets/settings/default.json +++ b/assets/settings/default.json @@ -74,6 +74,13 @@ "hard_tabs": false, // How many columns a tab should occupy. "tab_size": 4, + // TODO + "journal": { + // TODO + "journal_directory": "always_home", + // TODO + "hour_format": "hour12" + }, // Settings specific to the terminal "terminal": { // What shell to use when opening a terminal. May take 3 values: diff --git a/crates/journal/Cargo.toml b/crates/journal/Cargo.toml index 94dcf8e407411a266ea9ab3752ffa8d66ad8097b..091aadd12e6ee7fe80d4e7003e7fc72457642203 100644 --- a/crates/journal/Cargo.toml +++ b/crates/journal/Cargo.toml @@ -15,3 +15,4 @@ workspace = { path = "../workspace" } chrono = "0.4" dirs = "4.0" log = { version = "0.4.16", features = ["kv_unstable_serde"] } +settings = { path = "../settings" } diff --git a/crates/journal/src/journal.rs b/crates/journal/src/journal.rs index 8135950e50cb9bd9ae1e7cff567b8dc411e2106e..3a44345b70f39e2abd5efc8fbe4eb2946be10e26 100644 --- a/crates/journal/src/journal.rs +++ b/crates/journal/src/journal.rs @@ -1,7 +1,8 @@ -use chrono::{Datelike, Local, Timelike}; +use chrono::{Datelike, Local, NaiveTime, Timelike}; use editor::{Autoscroll, Editor}; use gpui::{actions, MutableAppContext}; -use std::{fs::OpenOptions, sync::Arc}; +use settings::{HourFormat, JournalDirectory, Settings}; +use std::{fs::OpenOptions, path::PathBuf, str::FromStr, sync::Arc}; use util::TryFutureExt as _; use workspace::AppState; @@ -12,24 +13,23 @@ pub fn init(app_state: Arc, cx: &mut MutableAppContext) { } pub fn new_journal_entry(app_state: Arc, cx: &mut MutableAppContext) { - let now = Local::now(); - let home_dir = match dirs::home_dir() { - Some(home_dir) => home_dir, + let settings = cx.global::(); + let journal_dir = match get_journal_dir(&settings.journal_overrides.journal_directory) { + Some(journal_dir) => journal_dir, None => { log::error!("can't determine home directory"); return; } }; - let journal_dir = home_dir.join("journal"); + let now = Local::now(); let month_dir = journal_dir .join(format!("{:02}", now.year())) .join(format!("{:02}", now.month())); let entry_path = month_dir.join(format!("{:02}.md", now.day())); let now = now.time(); - let (pm, hour) = now.hour12(); - let am_or_pm = if pm { "PM" } else { "AM" }; - let entry_heading = format!("# {}:{:02} {}\n\n", hour, now.minute(), am_or_pm); + let hour_format = &settings.journal_overrides.hour_format; + let entry_heading = get_heading_entry(now, &hour_format); let create_entry = cx.background().spawn(async move { std::fs::create_dir_all(month_dir)?; @@ -64,6 +64,7 @@ pub fn new_journal_entry(app_state: Arc, cx: &mut MutableAppContext) { editor.insert("\n\n", cx); } editor.insert(&entry_heading, cx); + editor.insert("\n\n", cx); }); } } @@ -74,3 +75,64 @@ pub fn new_journal_entry(app_state: Arc, cx: &mut MutableAppContext) { }) .detach(); } + +fn get_journal_dir(a: &Option) -> Option { + let journal_default_dir = dirs::home_dir()?.join("journal"); + + let journal_dir = match a { + Some(JournalDirectory::Always { directory }) => { + PathBuf::from_str(&directory).unwrap_or(journal_default_dir) + } + _ => journal_default_dir, + }; + + Some(journal_dir) +} + +fn get_heading_entry(now: NaiveTime, hour_format: &Option) -> String { + match hour_format { + Some(HourFormat::Hour24) => { + let hour = now.hour(); + format!("# {}:{:02}", hour, now.minute()) + } + _ => { + let (pm, hour) = now.hour12(); + let am_or_pm = if pm { "PM" } else { "AM" }; + format!("# {}:{:02} {}", hour, now.minute(), am_or_pm) + } + } +} + +#[cfg(test)] +mod tests { + mod heading_entry_tests { + use super::super::*; + + #[test] + fn test_heading_entry_defaults_to_hour_12() { + let naive_time = NaiveTime::from_hms_milli(15, 0, 0, 0); + let actual_heading_entry = get_heading_entry(naive_time, &None); + let expected_heading_entry = "# 3:00 PM"; + + assert_eq!(actual_heading_entry, expected_heading_entry); + } + + #[test] + fn test_heading_entry_is_hour_12() { + let naive_time = NaiveTime::from_hms_milli(15, 0, 0, 0); + let actual_heading_entry = get_heading_entry(naive_time, &Some(HourFormat::Hour12)); + let expected_heading_entry = "# 3:00 PM"; + + assert_eq!(actual_heading_entry, expected_heading_entry); + } + + #[test] + fn test_heading_entry_is_hour_24() { + let naive_time = NaiveTime::from_hms_milli(15, 0, 0, 0); + let actual_heading_entry = get_heading_entry(naive_time, &Some(HourFormat::Hour24)); + let expected_heading_entry = "# 15:00"; + + assert_eq!(actual_heading_entry, expected_heading_entry); + } + } +} diff --git a/crates/settings/src/settings.rs b/crates/settings/src/settings.rs index e346ff60e6ba89a304e43b7e8696c90d09ac88cb..5d4195d3b2512a6e88e25a98f65cbba0cfe35b5a 100644 --- a/crates/settings/src/settings.rs +++ b/crates/settings/src/settings.rs @@ -32,6 +32,8 @@ pub struct Settings { pub default_dock_anchor: DockAnchor, pub editor_defaults: EditorSettings, pub editor_overrides: EditorSettings, + pub journal_defaults: JournalSettings, + pub journal_overrides: JournalSettings, pub terminal_defaults: TerminalSettings, pub terminal_overrides: TerminalSettings, pub language_defaults: HashMap, EditorSettings>, @@ -101,6 +103,26 @@ pub enum Autosave { OnWindowChange, } +#[derive(Clone, Debug, Default, Deserialize, JsonSchema)] +pub struct JournalSettings { + pub journal_directory: Option, + pub hour_format: Option, +} + +#[derive(Clone, Debug, Deserialize, JsonSchema)] +#[serde(rename_all = "snake_case")] +pub enum JournalDirectory { + AlwaysHome, + Always { directory: String }, +} + +#[derive(Clone, Debug, Deserialize, JsonSchema)] +#[serde(rename_all = "snake_case")] +pub enum HourFormat { + Hour12, + Hour24, +} + #[derive(Clone, Debug, Default, Deserialize, JsonSchema)] pub struct TerminalSettings { pub shell: Option, @@ -194,6 +216,8 @@ pub struct SettingsFileContent { #[serde(flatten)] pub editor: EditorSettings, #[serde(default)] + pub journal: JournalSettings, + #[serde(default)] pub terminal: TerminalSettings, #[serde(default)] #[serde(alias = "language_overrides")] @@ -252,6 +276,8 @@ impl Settings { enable_language_server: required(defaults.editor.enable_language_server), }, editor_overrides: Default::default(), + journal_defaults: Default::default(), + journal_overrides: Default::default(), terminal_defaults: Default::default(), terminal_overrides: Default::default(), language_defaults: defaults.languages, @@ -303,6 +329,7 @@ impl Settings { } self.editor_overrides = data.editor; + self.journal_overrides = data.journal; self.terminal_defaults.font_size = data.terminal.font_size; self.terminal_overrides = data.terminal; self.language_overrides = data.languages; @@ -380,6 +407,8 @@ impl Settings { enable_language_server: Some(true), }, editor_overrides: Default::default(), + journal_defaults: Default::default(), + journal_overrides: Default::default(), terminal_defaults: Default::default(), terminal_overrides: Default::default(), language_defaults: Default::default(), From fbe5f9225c97cd4de35750eb24143e66c07bd76d Mon Sep 17 00:00:00 2001 From: Joseph T Lyons Date: Wed, 28 Sep 2022 16:52:15 -0400 Subject: [PATCH 02/21] Add descriptions to journal settings --- assets/settings/default.json | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/assets/settings/default.json b/assets/settings/default.json index 25117521bf9846737dabcb3c8e111ea77eb89301..d46dc11df5ff8152f040e92ebbc108d774df8f40 100644 --- a/assets/settings/default.json +++ b/assets/settings/default.json @@ -74,11 +74,14 @@ "hard_tabs": false, // How many columns a tab should occupy. "tab_size": 4, - // TODO + // Settings specific to journaling "journal": { - // TODO + // The directory in which the journal entries are created "journal_directory": "always_home", - // TODO + // What format to present the hours in + // May take 2 values: + // 1. hour12 + // 2. hour24 "hour_format": "hour12" }, // Settings specific to the terminal From f8da5ab2e76503e1f94b79dc0f6b21f00005e3a3 Mon Sep 17 00:00:00 2001 From: Joseph T Lyons Date: Wed, 28 Sep 2022 17:07:11 -0400 Subject: [PATCH 03/21] Remove "get" prefix from function names --- crates/journal/src/journal.rs | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/crates/journal/src/journal.rs b/crates/journal/src/journal.rs index 3a44345b70f39e2abd5efc8fbe4eb2946be10e26..c6e33d1134713267f1c30f4e4d3030e63e5cb773 100644 --- a/crates/journal/src/journal.rs +++ b/crates/journal/src/journal.rs @@ -14,7 +14,7 @@ pub fn init(app_state: Arc, cx: &mut MutableAppContext) { pub fn new_journal_entry(app_state: Arc, cx: &mut MutableAppContext) { let settings = cx.global::(); - let journal_dir = match get_journal_dir(&settings.journal_overrides.journal_directory) { + let journal_dir = match journal_dir(&settings.journal_overrides.journal_directory) { Some(journal_dir) => journal_dir, None => { log::error!("can't determine home directory"); @@ -29,7 +29,7 @@ pub fn new_journal_entry(app_state: Arc, cx: &mut MutableAppContext) { let entry_path = month_dir.join(format!("{:02}.md", now.day())); let now = now.time(); let hour_format = &settings.journal_overrides.hour_format; - let entry_heading = get_heading_entry(now, &hour_format); + let entry_heading = heading_entry(now, &hour_format); let create_entry = cx.background().spawn(async move { std::fs::create_dir_all(month_dir)?; @@ -76,7 +76,7 @@ pub fn new_journal_entry(app_state: Arc, cx: &mut MutableAppContext) { .detach(); } -fn get_journal_dir(a: &Option) -> Option { +fn journal_dir(a: &Option) -> Option { let journal_default_dir = dirs::home_dir()?.join("journal"); let journal_dir = match a { @@ -89,7 +89,7 @@ fn get_journal_dir(a: &Option) -> Option { Some(journal_dir) } -fn get_heading_entry(now: NaiveTime, hour_format: &Option) -> String { +fn heading_entry(now: NaiveTime, hour_format: &Option) -> String { match hour_format { Some(HourFormat::Hour24) => { let hour = now.hour(); @@ -111,7 +111,7 @@ mod tests { #[test] fn test_heading_entry_defaults_to_hour_12() { let naive_time = NaiveTime::from_hms_milli(15, 0, 0, 0); - let actual_heading_entry = get_heading_entry(naive_time, &None); + let actual_heading_entry = heading_entry(naive_time, &None); let expected_heading_entry = "# 3:00 PM"; assert_eq!(actual_heading_entry, expected_heading_entry); @@ -120,7 +120,7 @@ mod tests { #[test] fn test_heading_entry_is_hour_12() { let naive_time = NaiveTime::from_hms_milli(15, 0, 0, 0); - let actual_heading_entry = get_heading_entry(naive_time, &Some(HourFormat::Hour12)); + let actual_heading_entry = heading_entry(naive_time, &Some(HourFormat::Hour12)); let expected_heading_entry = "# 3:00 PM"; assert_eq!(actual_heading_entry, expected_heading_entry); @@ -129,7 +129,7 @@ mod tests { #[test] fn test_heading_entry_is_hour_24() { let naive_time = NaiveTime::from_hms_milli(15, 0, 0, 0); - let actual_heading_entry = get_heading_entry(naive_time, &Some(HourFormat::Hour24)); + let actual_heading_entry = heading_entry(naive_time, &Some(HourFormat::Hour24)); let expected_heading_entry = "# 15:00"; assert_eq!(actual_heading_entry, expected_heading_entry); From 3c62de34f73f9b7d3e769b2fa61f9da173f42b4d Mon Sep 17 00:00:00 2001 From: Joseph T Lyons Date: Thu, 29 Sep 2022 16:18:16 -0400 Subject: [PATCH 04/21] Change journal location setting name to "path" and default to ~ --- Cargo.lock | 1 + assets/settings/default.json | 8 ++++---- crates/journal/Cargo.toml | 1 + crates/journal/src/journal.rs | 31 ++++++++++++++++++------------- crates/settings/src/settings.rs | 22 +++++++++++++++------- 5 files changed, 39 insertions(+), 24 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 28fc8fcb612d6a65feae4f18d55692ed691991d0..8859966acbc8ccdee73fbac5a347313201af4733 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2765,6 +2765,7 @@ dependencies = [ "gpui", "log", "settings", + "shellexpand", "util", "workspace", ] diff --git a/assets/settings/default.json b/assets/settings/default.json index d46dc11df5ff8152f040e92ebbc108d774df8f40..d88d229dfbf38725475848e9f811e3c50b0aba8c 100644 --- a/assets/settings/default.json +++ b/assets/settings/default.json @@ -76,10 +76,10 @@ "tab_size": 4, // Settings specific to journaling "journal": { - // The directory in which the journal entries are created - "journal_directory": "always_home", - // What format to present the hours in - // May take 2 values: + // The path of the directory where journal entries are stored + "path": "~", + // What format to display the hours in + // May take 2 values: // 1. hour12 // 2. hour24 "hour_format": "hour12" diff --git a/crates/journal/Cargo.toml b/crates/journal/Cargo.toml index 091aadd12e6ee7fe80d4e7003e7fc72457642203..8c900d9f4a24f517b48218b1d38c34e8dffd539d 100644 --- a/crates/journal/Cargo.toml +++ b/crates/journal/Cargo.toml @@ -16,3 +16,4 @@ chrono = "0.4" dirs = "4.0" log = { version = "0.4.16", features = ["kv_unstable_serde"] } settings = { path = "../settings" } +shellexpand = "2.1.0" \ No newline at end of file diff --git a/crates/journal/src/journal.rs b/crates/journal/src/journal.rs index c6e33d1134713267f1c30f4e4d3030e63e5cb773..4269556251bae736700eef8e6f0b761041f20d55 100644 --- a/crates/journal/src/journal.rs +++ b/crates/journal/src/journal.rs @@ -1,8 +1,12 @@ use chrono::{Datelike, Local, NaiveTime, Timelike}; use editor::{Autoscroll, Editor}; use gpui::{actions, MutableAppContext}; -use settings::{HourFormat, JournalDirectory, Settings}; -use std::{fs::OpenOptions, path::PathBuf, str::FromStr, sync::Arc}; +use settings::{HourFormat, Settings}; +use std::{ + fs::OpenOptions, + path::{Path, PathBuf}, + sync::Arc, +}; use util::TryFutureExt as _; use workspace::AppState; @@ -14,10 +18,10 @@ pub fn init(app_state: Arc, cx: &mut MutableAppContext) { pub fn new_journal_entry(app_state: Arc, cx: &mut MutableAppContext) { let settings = cx.global::(); - let journal_dir = match journal_dir(&settings.journal_overrides.journal_directory) { + let journal_dir = match journal_dir(&settings) { Some(journal_dir) => journal_dir, None => { - log::error!("can't determine home directory"); + log::error!("Can't determine journal directory"); return; } }; @@ -76,17 +80,18 @@ pub fn new_journal_entry(app_state: Arc, cx: &mut MutableAppContext) { .detach(); } -fn journal_dir(a: &Option) -> Option { - let journal_default_dir = dirs::home_dir()?.join("journal"); +fn journal_dir(settings: &Settings) -> Option { + let journal_dir = settings + .journal_overrides + .path + .as_ref() + .unwrap_or(settings.journal_defaults.path.as_ref()?); - let journal_dir = match a { - Some(JournalDirectory::Always { directory }) => { - PathBuf::from_str(&directory).unwrap_or(journal_default_dir) - } - _ => journal_default_dir, - }; + let expanded_journal_dir = shellexpand::full(&journal_dir) //TODO handle this better + .ok() + .map(|dir| Path::new(&dir.to_string()).to_path_buf().join("journal")); - Some(journal_dir) + return expanded_journal_dir; } fn heading_entry(now: NaiveTime, hour_format: &Option) -> String { diff --git a/crates/settings/src/settings.rs b/crates/settings/src/settings.rs index 5d4195d3b2512a6e88e25a98f65cbba0cfe35b5a..69a1ea9441b7a47c72afe65777f6c394734c5147 100644 --- a/crates/settings/src/settings.rs +++ b/crates/settings/src/settings.rs @@ -103,17 +103,19 @@ pub enum Autosave { OnWindowChange, } -#[derive(Clone, Debug, Default, Deserialize, JsonSchema)] +#[derive(Clone, Debug, Deserialize, JsonSchema)] pub struct JournalSettings { - pub journal_directory: Option, + pub path: Option, pub hour_format: Option, } -#[derive(Clone, Debug, Deserialize, JsonSchema)] -#[serde(rename_all = "snake_case")] -pub enum JournalDirectory { - AlwaysHome, - Always { directory: String }, +impl Default for JournalSettings { + fn default() -> Self { + Self { + path: Some("~".into()), + hour_format: Some(Default::default()), + } + } } #[derive(Clone, Debug, Deserialize, JsonSchema)] @@ -123,6 +125,12 @@ pub enum HourFormat { Hour24, } +impl Default for HourFormat { + fn default() -> Self { + Self::Hour12 + } +} + #[derive(Clone, Debug, Default, Deserialize, JsonSchema)] pub struct TerminalSettings { pub shell: Option, From a6910584b61f82873ee18908fdc642ab35455998 Mon Sep 17 00:00:00 2001 From: Julia Date: Wed, 12 Oct 2022 00:39:56 -0400 Subject: [PATCH 05/21] Something's happening, nothing correct, but something --- crates/editor/src/element.rs | 135 ++++++++++++++++++++++++----------- 1 file changed, 93 insertions(+), 42 deletions(-) diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs index 587133e9dd703b04beef2d8f51e602cfd609f446..97d29a404a5b36da5125db7fcfa805096f6f6918 100644 --- a/crates/editor/src/element.rs +++ b/crates/editor/src/element.rs @@ -48,6 +48,11 @@ use std::{ }; use theme::DiffStyle; +struct DiffHunkLayout { + visual_range: Range, + status: DiffHunkStatus, +} + struct SelectionLayout { head: DisplayPoint, range: Range, @@ -539,17 +544,17 @@ impl EditorElement { } fn diff_quad( - hunk: &DiffHunk, + hunk: &DiffHunkLayout, gutter_layout: &GutterLayout, diff_style: &DiffStyle, ) -> Quad { - let color = match hunk.status() { + let color = match hunk.status { DiffHunkStatus::Added => diff_style.inserted, DiffHunkStatus::Modified => diff_style.modified, //TODO: This rendering is entirely a horrible hack DiffHunkStatus::Removed => { - let row = hunk.buffer_range.start; + let row = hunk.visual_range.start; let offset = gutter_layout.line_height / 2.; let start_y = @@ -570,8 +575,8 @@ impl EditorElement { } }; - let start_row = hunk.buffer_range.start; - let end_row = hunk.buffer_range.end; + let start_row = hunk.visual_range.start; + let end_row = hunk.visual_range.end; let start_y = start_row as f32 * gutter_layout.line_height - gutter_layout.scroll_top; let end_y = end_row as f32 * gutter_layout.line_height - gutter_layout.scroll_top; @@ -613,7 +618,13 @@ impl EditorElement { GitGutter::TrackedFiles ); - // line is `None` when there's a line wrap + if show_gutter { + for hunk in &layout.hunk_layouts { + let quad = diff_quad(hunk, &gutter_layout, diff_style); + cx.scene.push_quad(quad); + } + } + for (ix, line) in layout.line_number_layouts.iter().enumerate() { if let Some(line) = line { let line_origin = bounds.origin() @@ -624,38 +635,9 @@ impl EditorElement { ); line.paint(line_origin, visible_bounds, gutter_layout.line_height, cx); - - if show_gutter { - //This line starts a buffer line, so let's do the diff calculation - let new_hunk = get_hunk(diff_layout.buffer_row, &layout.diff_hunks); - - let (is_ending, is_starting) = match (diff_layout.last_diff, new_hunk) { - (Some(old_hunk), Some(new_hunk)) if new_hunk == old_hunk => (false, false), - (a, b) => (a.is_some(), b.is_some()), - }; - - if is_ending { - let last_hunk = diff_layout.last_diff.take().unwrap(); - cx.scene - .push_quad(diff_quad(last_hunk, &gutter_layout, diff_style)); - } - - if is_starting { - let new_hunk = new_hunk.unwrap(); - diff_layout.last_diff = Some(new_hunk); - }; - - diff_layout.buffer_row += 1; - } } } - // If we ran out with a diff hunk still being prepped, paint it now - if let Some(last_hunk) = diff_layout.last_diff { - cx.scene - .push_quad(diff_quad(last_hunk, &gutter_layout, diff_style)) - } - if let Some((row, indicator)) = layout.code_actions_indicator.as_mut() { let mut x = bounds.width() - layout.gutter_padding; let mut y = *row as f32 * gutter_layout.line_height - gutter_layout.scroll_top; @@ -1013,6 +995,78 @@ impl EditorElement { .width() } + fn layout_diff_hunk( + hunk: &DiffHunk, + buffer_rows: &mut std::iter::Peekable>>, + ) -> DiffHunkLayout { + //This should start with a row which is contained in the hunk's buffer range + let visual_start = buffer_rows.peek().unwrap().unwrap(); + + let mut visual_count = 0; + while let Some(&buffer_row) = buffer_rows.peek() { + if let Some(buffer_row) = buffer_row { + if buffer_row == hunk.buffer_range.end { + visual_count += 1; + break; + } else if buffer_row > hunk.buffer_range.end { + break; + } + visual_count += 1; + buffer_rows.next(); + } + } + + DiffHunkLayout { + visual_range: visual_start..visual_start + visual_count, + status: hunk.status(), + } + } + + //Folds contained in a hunk are ignored apart from shrinking visual size + //If a fold contains any hunks then that fold line is marked as modified + fn layout_git_gutters( + &self, + rows: Range, + snapshot: &EditorSnapshot, + ) -> Vec { + let mut diff_hunks = snapshot + .buffer_snapshot + .git_diff_hunks_in_range(rows.clone()) + .peekable(); + + //Some number followed by Nones for wrapped lines + //Jump in number for folded lines + let mut buffer_rows = snapshot + .buffer_rows(rows.start) + .take((rows.end - rows.start) as usize) + .peekable(); + + let mut layouts = Vec::new(); + + while let Some(buffer_row) = buffer_rows.next() { + let buffer_row = buffer_row.unwrap(); + + if let Some(hunk) = diff_hunks.peek() { + if hunk.buffer_range.contains(&buffer_row) { + layouts.push(Self::layout_diff_hunk(hunk, &mut buffer_rows)); + diff_hunks.next(); + } else if hunk.buffer_range.end < buffer_row { + //A hunk that was missed due to being entirely contained in a fold + //We can safely assume that the previous visual row is the fold + //TODO: If there is another hunk that ends inside the fold then + //this will overlay over, but right now that seems fine + layouts.push(DiffHunkLayout { + visual_range: buffer_row - 1..buffer_row, + status: DiffHunkStatus::Modified, + }); + diff_hunks.next(); + } + } + } + + layouts + } + fn layout_line_numbers( &self, rows: Range, @@ -1367,7 +1421,7 @@ impl EditorElement { /// Get the hunk that contains buffer_line, starting from start_idx /// Returns none if there is none found, and -fn get_hunk(buffer_line: u32, hunks: &[DiffHunk]) -> Option<&DiffHunk> { +fn get_hunk(hunks: &[DiffHunk], buffer_line: u32) -> Option<&DiffHunk> { for i in 0..hunks.len() { // Safety: Index out of bounds is handled by the check above let hunk = hunks.get(i).unwrap(); @@ -1561,10 +1615,7 @@ impl Element for EditorElement { let line_number_layouts = self.layout_line_numbers(start_row..end_row, &active_rows, &snapshot, cx); - let diff_hunks = snapshot - .buffer_snapshot - .git_diff_hunks_in_range(start_row..end_row) - .collect(); + let hunk_layouts = self.layout_git_gutters(start_row..end_row, &snapshot); let mut max_visible_line_width = 0.0; let line_layouts = self.layout_lines(start_row..end_row, &snapshot, cx); @@ -1714,7 +1765,7 @@ impl Element for EditorElement { highlighted_rows, highlighted_ranges, line_number_layouts, - diff_hunks, + hunk_layouts, blocks, selections, context_menu, @@ -1848,11 +1899,11 @@ pub struct LayoutState { active_rows: BTreeMap, highlighted_rows: Option>, line_number_layouts: Vec>, + hunk_layouts: Vec, blocks: Vec, highlighted_ranges: Vec<(Range, Color)>, selections: Vec<(ReplicaId, Vec)>, context_menu: Option<(DisplayPoint, ElementBox)>, - diff_hunks: Vec>, code_actions_indicator: Option<(u32, ElementBox)>, hover_popovers: Option<(DisplayPoint, Vec)>, } From e744520d90883e0431b869772388808ac00a395f Mon Sep 17 00:00:00 2001 From: Julia Date: Wed, 12 Oct 2022 16:40:19 -0400 Subject: [PATCH 06/21] Correctly offset diff hunk layouts --- crates/editor/src/element.rs | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs index 97d29a404a5b36da5125db7fcfa805096f6f6918..b2cf6a19f3843a8271da4075d7dd057001a18d7e 100644 --- a/crates/editor/src/element.rs +++ b/crates/editor/src/element.rs @@ -997,14 +997,16 @@ impl EditorElement { fn layout_diff_hunk( hunk: &DiffHunk, - buffer_rows: &mut std::iter::Peekable>>, + start_row: u32, + buffer_rows: &mut std::iter::Peekable)>>, ) -> DiffHunkLayout { - //This should start with a row which is contained in the hunk's buffer range - let visual_start = buffer_rows.peek().unwrap().unwrap(); + //`buffer_rows` should start with a row which is contained in the hunk's buffer range + //The `usize` field is 1-index so we have to sub to move it into 0-offset to match actual rows + let visual_start = start_row + buffer_rows.peek().unwrap().0 as u32 - 1; let mut visual_count = 0; while let Some(&buffer_row) = buffer_rows.peek() { - if let Some(buffer_row) = buffer_row { + if let (_, Some(buffer_row)) = buffer_row { if buffer_row == hunk.buffer_range.end { visual_count += 1; break; @@ -1039,16 +1041,17 @@ impl EditorElement { let mut buffer_rows = snapshot .buffer_rows(rows.start) .take((rows.end - rows.start) as usize) + .enumerate() .peekable(); let mut layouts = Vec::new(); - while let Some(buffer_row) = buffer_rows.next() { + while let Some((_, buffer_row)) = buffer_rows.next() { let buffer_row = buffer_row.unwrap(); if let Some(hunk) = diff_hunks.peek() { if hunk.buffer_range.contains(&buffer_row) { - layouts.push(Self::layout_diff_hunk(hunk, &mut buffer_rows)); + layouts.push(Self::layout_diff_hunk(hunk, rows.start, &mut buffer_rows)); diff_hunks.next(); } else if hunk.buffer_range.end < buffer_row { //A hunk that was missed due to being entirely contained in a fold @@ -1060,7 +1063,7 @@ impl EditorElement { status: DiffHunkStatus::Modified, }); diff_hunks.next(); - } + } } } From e75dcc853b2327119c7cc0aeefd7c40d7e2295e5 Mon Sep 17 00:00:00 2001 From: Julia Date: Thu, 13 Oct 2022 00:42:53 -0400 Subject: [PATCH 07/21] Include deletion hunks in fold regardless of end --- crates/editor/src/element.rs | 51 +++++++++++++++++++++++++++--------- crates/git/src/diff.rs | 3 ++- 2 files changed, 40 insertions(+), 14 deletions(-) diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs index b2cf6a19f3843a8271da4075d7dd057001a18d7e..853aeec01adcad9ff8f4cb80c4df312b008303ce 100644 --- a/crates/editor/src/element.rs +++ b/crates/editor/src/element.rs @@ -558,7 +558,7 @@ impl EditorElement { let offset = gutter_layout.line_height / 2.; let start_y = - row as f32 * gutter_layout.line_height + offset - gutter_layout.scroll_top; + row as f32 * gutter_layout.line_height - offset - gutter_layout.scroll_top; let end_y = start_y + gutter_layout.line_height; let width = diff_style.removed_width_em * gutter_layout.line_height; @@ -1045,26 +1045,51 @@ impl EditorElement { .peekable(); let mut layouts = Vec::new(); + let mut previous_buffer_row = None; - while let Some((_, buffer_row)) = buffer_rows.next() { + while let Some((idx, buffer_row)) = buffer_rows.next() { let buffer_row = buffer_row.unwrap(); - - if let Some(hunk) = diff_hunks.peek() { - if hunk.buffer_range.contains(&buffer_row) { - layouts.push(Self::layout_diff_hunk(hunk, rows.start, &mut buffer_rows)); + let is_start_of_fold = previous_buffer_row + .map(|prev| buffer_row > prev + 1) + .unwrap_or(false); + + if is_start_of_fold { + //Consume all hunks within fold + let mut consumed_hunks = false; + while let Some(hunk) = diff_hunks.peek() { + let is_past = hunk.buffer_range.start > buffer_row; + let is_removal = hunk.status() == DiffHunkStatus::Removed; + let is_on_next_line = hunk.buffer_range.start == buffer_row + 1; + let is_removal_inside = is_removal && is_on_next_line; + + if is_past && !is_removal_inside { + break; + } diff_hunks.next(); - } else if hunk.buffer_range.end < buffer_row { - //A hunk that was missed due to being entirely contained in a fold - //We can safely assume that the previous visual row is the fold - //TODO: If there is another hunk that ends inside the fold then - //this will overlay over, but right now that seems fine + consumed_hunks = true; + } + + //And mark fold as modified if there were any + if consumed_hunks { + let current_visual_row = rows.start + idx as u32 - 1; layouts.push(DiffHunkLayout { - visual_range: buffer_row - 1..buffer_row, + visual_range: current_visual_row..current_visual_row + 1, status: DiffHunkStatus::Modified, }); - diff_hunks.next(); + } + } else { + //Not the start of a fold + if let Some(hunk) = diff_hunks.peek() { + if hunk.buffer_range.contains(&buffer_row) + || hunk.buffer_range.start == buffer_row + { + layouts.push(Self::layout_diff_hunk(hunk, rows.start, &mut buffer_rows)); + diff_hunks.next(); + } } } + + previous_buffer_row = Some(buffer_row); } layouts diff --git a/crates/git/src/diff.rs b/crates/git/src/diff.rs index 4191e5d260ad41e0e4f86a66d639f5702d37eecb..3fcaaa64968b2862d09fc4d7def9a53f04473c7b 100644 --- a/crates/git/src/diff.rs +++ b/crates/git/src/diff.rs @@ -191,7 +191,6 @@ impl BufferDiff { } if kind == GitDiffLineType::Deletion { - *buffer_row_divergence -= 1; let end = content_offset + content_len; match &mut head_byte_range { @@ -204,6 +203,8 @@ impl BufferDiff { let row = old_row as i64 + *buffer_row_divergence; first_deletion_buffer_row = Some(row as u32); } + + *buffer_row_divergence -= 1; } } From a6a7e85894e569f0a0919c5d30e078c140f22016 Mon Sep 17 00:00:00 2001 From: Julia Date: Thu, 13 Oct 2022 02:02:29 -0400 Subject: [PATCH 08/21] Misc fixes, still broken soft wrap --- crates/editor/src/element.rs | 50 ++++++++++++++++++++++++------------ 1 file changed, 34 insertions(+), 16 deletions(-) diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs index 853aeec01adcad9ff8f4cb80c4df312b008303ce..17dfabe57601c4e71591ad7857df3f6add628025 100644 --- a/crates/editor/src/element.rs +++ b/crates/editor/src/element.rs @@ -48,6 +48,7 @@ use std::{ }; use theme::DiffStyle; +#[derive(Debug)] struct DiffHunkLayout { visual_range: Range, status: DiffHunkStatus, @@ -995,18 +996,26 @@ impl EditorElement { .width() } + //-> (layout, buffer row advancement) fn layout_diff_hunk( hunk: &DiffHunk, start_row: u32, buffer_rows: &mut std::iter::Peekable)>>, - ) -> DiffHunkLayout { + ) -> (Option, u32) { //`buffer_rows` should start with a row which is contained in the hunk's buffer range + let first_buffer_rows = match buffer_rows.peek() { + Some(first_buffer_rows) => first_buffer_rows, + None => return (None, 0), + }; + //The `usize` field is 1-index so we have to sub to move it into 0-offset to match actual rows - let visual_start = start_row + buffer_rows.peek().unwrap().0 as u32 - 1; + let visual_start = start_row + first_buffer_rows.0 as u32 - 1; let mut visual_count = 0; + let mut buffer_row_advancement = 0; while let Some(&buffer_row) = buffer_rows.peek() { if let (_, Some(buffer_row)) = buffer_row { + buffer_row_advancement += 1; if buffer_row == hunk.buffer_range.end { visual_count += 1; break; @@ -1014,14 +1023,16 @@ impl EditorElement { break; } visual_count += 1; - buffer_rows.next(); } + + buffer_rows.next(); } - DiffHunkLayout { + let layout = DiffHunkLayout { visual_range: visual_start..visual_start + visual_count, status: hunk.status(), - } + }; + (Some(layout), buffer_row_advancement) } //Folds contained in a hunk are ignored apart from shrinking visual size @@ -1048,10 +1059,15 @@ impl EditorElement { let mut previous_buffer_row = None; while let Some((idx, buffer_row)) = buffer_rows.next() { - let buffer_row = buffer_row.unwrap(); + let buffer_row = match buffer_row { + Some(buffer_row) => buffer_row, + None => continue, + }; + let is_start_of_fold = previous_buffer_row .map(|prev| buffer_row > prev + 1) .unwrap_or(false); + previous_buffer_row = Some(buffer_row); if is_start_of_fold { //Consume all hunks within fold @@ -1077,19 +1093,21 @@ impl EditorElement { status: DiffHunkStatus::Modified, }); } - } else { - //Not the start of a fold - if let Some(hunk) = diff_hunks.peek() { - if hunk.buffer_range.contains(&buffer_row) - || hunk.buffer_range.start == buffer_row - { - layouts.push(Self::layout_diff_hunk(hunk, rows.start, &mut buffer_rows)); - diff_hunks.next(); + } else if let Some(hunk) = diff_hunks.peek() { + let row_inside_hunk = hunk.buffer_range.contains(&buffer_row); + let starts_on_row = hunk.buffer_range.start == buffer_row; + if row_inside_hunk || starts_on_row { + let (layout, buffer_row_advancement) = + Self::layout_diff_hunk(hunk, rows.start, &mut buffer_rows); + previous_buffer_row = Some(buffer_row + buffer_row_advancement); + + if let Some(layout) = layout { + layouts.push(layout); } + + diff_hunks.next(); } } - - previous_buffer_row = Some(buffer_row); } layouts From 9c47325c25f7b3aa30f33d9decf3d0c5d8d7313e Mon Sep 17 00:00:00 2001 From: Julia Date: Thu, 13 Oct 2022 13:52:44 -0400 Subject: [PATCH 09/21] Use correct range to get diff hunks in the presence of wrapped lines --- crates/editor/src/display_map/block_map.rs | 1 + crates/editor/src/display_map/fold_map.rs | 1 + crates/editor/src/display_map/wrap_map.rs | 1 + crates/editor/src/element.rs | 18 +++++++++++++++--- crates/editor/src/multi_buffer.rs | 1 + 5 files changed, 19 insertions(+), 3 deletions(-) diff --git a/crates/editor/src/display_map/block_map.rs b/crates/editor/src/display_map/block_map.rs index 210daccac26b54e057947457b52c4c749e2adb61..c60610997fb088320aec6908a3c24022a0d83d6b 100644 --- a/crates/editor/src/display_map/block_map.rs +++ b/crates/editor/src/display_map/block_map.rs @@ -157,6 +157,7 @@ pub struct BlockChunks<'a> { max_output_row: u32, } +#[derive(Clone)] pub struct BlockBufferRows<'a> { transforms: sum_tree::Cursor<'a, Transform, (BlockRow, WrapRow)>, input_buffer_rows: wrap_map::WrapBufferRows<'a>, diff --git a/crates/editor/src/display_map/fold_map.rs b/crates/editor/src/display_map/fold_map.rs index c17cfa39f2a7292198a1c953339e315824fe73b8..756fb35950384f9f61c39db38456475557b4b85d 100644 --- a/crates/editor/src/display_map/fold_map.rs +++ b/crates/editor/src/display_map/fold_map.rs @@ -987,6 +987,7 @@ impl<'a> sum_tree::Dimension<'a, FoldSummary> for usize { } } +#[derive(Clone)] pub struct FoldBufferRows<'a> { cursor: Cursor<'a, Transform, (FoldPoint, Point)>, input_buffer_rows: MultiBufferRows<'a>, diff --git a/crates/editor/src/display_map/wrap_map.rs b/crates/editor/src/display_map/wrap_map.rs index ee6ce2860ded8f830481258e5a8e4c59d7bbeba9..52f26ef2589c043877a56360934d072c14d15944 100644 --- a/crates/editor/src/display_map/wrap_map.rs +++ b/crates/editor/src/display_map/wrap_map.rs @@ -62,6 +62,7 @@ pub struct WrapChunks<'a> { transforms: Cursor<'a, Transform, (WrapPoint, TabPoint)>, } +#[derive(Clone)] pub struct WrapBufferRows<'a> { input_buffer_rows: fold_map::FoldBufferRows<'a>, input_buffer_row: Option, diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs index 17dfabe57601c4e71591ad7857df3f6add628025..5b752e05447b1d0ccba5209745bcd0e683371d24 100644 --- a/crates/editor/src/element.rs +++ b/crates/editor/src/element.rs @@ -1042,15 +1042,27 @@ impl EditorElement { rows: Range, snapshot: &EditorSnapshot, ) -> Vec { + let buffer_rows = snapshot.buffer_rows(rows.start); + let start_actual_row = match buffer_rows + .clone() + .take((rows.end - rows.start) as usize) + .find_map(|b| b) + { + Some(start_actual_row) => start_actual_row, + None => return Vec::new(), + }; + + //Get all hunks after our starting actual buffer row + //The loop is in terms of visual buffer rows so we simply + //return before touching any hunks past the end of the view let mut diff_hunks = snapshot .buffer_snapshot - .git_diff_hunks_in_range(rows.clone()) + .git_diff_hunks_in_range(start_actual_row..u32::MAX) .peekable(); //Some number followed by Nones for wrapped lines //Jump in number for folded lines - let mut buffer_rows = snapshot - .buffer_rows(rows.start) + let mut buffer_rows = buffer_rows .take((rows.end - rows.start) as usize) .enumerate() .peekable(); diff --git a/crates/editor/src/multi_buffer.rs b/crates/editor/src/multi_buffer.rs index a0eedb850c03b04ed9ccf879484f96553d13ac90..b2635712d96981653dfd49d6eb87f1cfc6fcce1d 100644 --- a/crates/editor/src/multi_buffer.rs +++ b/crates/editor/src/multi_buffer.rs @@ -143,6 +143,7 @@ struct ExcerptSummary { text: TextSummary, } +#[derive(Clone)] pub struct MultiBufferRows<'a> { buffer_row_range: Range, excerpts: Cursor<'a, Excerpt, Point>, From 16f854b63613c132f96f82a5c452542b66c46abf Mon Sep 17 00:00:00 2001 From: Julia Date: Thu, 13 Oct 2022 14:05:57 -0400 Subject: [PATCH 10/21] Expand diff gutter indicator to cover all of a wrapped line --- crates/editor/src/element.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs index 5b752e05447b1d0ccba5209745bcd0e683371d24..e5367e54f0a2055773a25beae09d44c71509d8a9 100644 --- a/crates/editor/src/element.rs +++ b/crates/editor/src/element.rs @@ -1023,6 +1023,8 @@ impl EditorElement { break; } visual_count += 1; + } else { + visual_count += 1; } buffer_rows.next(); From 8d609959f1254e217b9cdd636d749f326691f4c5 Mon Sep 17 00:00:00 2001 From: Julia Date: Thu, 13 Oct 2022 15:23:41 -0400 Subject: [PATCH 11/21] Clean --- crates/editor/src/element.rs | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs index e5367e54f0a2055773a25beae09d44c71509d8a9..054c34515d3686bac5eaf0cf14f58ebaef728f43 100644 --- a/crates/editor/src/element.rs +++ b/crates/editor/src/element.rs @@ -539,11 +539,6 @@ impl EditorElement { bounds: RectF, } - struct DiffLayout<'a> { - buffer_row: u32, - last_diff: Option<&'a DiffHunk>, - } - fn diff_quad( hunk: &DiffHunkLayout, gutter_layout: &GutterLayout, @@ -605,11 +600,6 @@ impl EditorElement { } }; - let mut diff_layout = DiffLayout { - buffer_row: scroll_position.y() as u32, - last_diff: None, - }; - let diff_style = &cx.global::().theme.editor.diff.clone(); let show_gutter = matches!( &cx.global::() From dde3dfdbf6a334331735d9ea2de9dd9f62f0b5c5 Mon Sep 17 00:00:00 2001 From: Julia Date: Thu, 13 Oct 2022 16:34:34 -0400 Subject: [PATCH 12/21] Quick cut of using display point conversion to layout hunks Co-Authored-By: Max Brunsfeld --- crates/editor/src/element.rs | 227 ++++++++++++++++------------------- 1 file changed, 106 insertions(+), 121 deletions(-) diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs index 054c34515d3686bac5eaf0cf14f58ebaef728f43..e6f876028aecaaedcba29a1c7a51a0d37137d899 100644 --- a/crates/editor/src/element.rs +++ b/crates/editor/src/element.rs @@ -35,7 +35,7 @@ use gpui::{ WeakViewHandle, }; use json::json; -use language::{Bias, DiagnosticSeverity, OffsetUtf16, Selection}; +use language::{Bias, DiagnosticSeverity, OffsetUtf16, Point, Selection}; use project::ProjectPath; use settings::{GitGutter, Settings}; use smallvec::SmallVec; @@ -52,6 +52,7 @@ use theme::DiffStyle; struct DiffHunkLayout { visual_range: Range, status: DiffHunkStatus, + is_folded: bool, } struct SelectionLayout { @@ -544,12 +545,12 @@ impl EditorElement { gutter_layout: &GutterLayout, diff_style: &DiffStyle, ) -> Quad { - let color = match hunk.status { - DiffHunkStatus::Added => diff_style.inserted, - DiffHunkStatus::Modified => diff_style.modified, + let color = match (hunk.status, hunk.is_folded) { + (DiffHunkStatus::Added, false) => diff_style.inserted, + (DiffHunkStatus::Modified, false) => diff_style.modified, //TODO: This rendering is entirely a horrible hack - DiffHunkStatus::Removed => { + (DiffHunkStatus::Removed, false) => { let row = hunk.visual_range.start; let offset = gutter_layout.line_height / 2.; @@ -569,6 +570,24 @@ impl EditorElement { corner_radius: 1. * gutter_layout.line_height, }; } + + (_, true) => { + let row = hunk.visual_range.start; + let start_y = row as f32 * gutter_layout.line_height - gutter_layout.scroll_top; + let end_y = start_y + gutter_layout.line_height; + + let width = diff_style.removed_width_em * gutter_layout.line_height; + let highlight_origin = gutter_layout.bounds.origin() + vec2f(-width, start_y); + let highlight_size = vec2f(width * 2., end_y - start_y); + let highlight_bounds = RectF::new(highlight_origin, highlight_size); + + return Quad { + bounds: highlight_bounds, + background: Some(diff_style.modified), + border: Border::new(0., Color::transparent_black()), + corner_radius: 1. * gutter_layout.line_height, + }; + } }; let start_row = hunk.visual_range.start; @@ -986,47 +1005,6 @@ impl EditorElement { .width() } - //-> (layout, buffer row advancement) - fn layout_diff_hunk( - hunk: &DiffHunk, - start_row: u32, - buffer_rows: &mut std::iter::Peekable)>>, - ) -> (Option, u32) { - //`buffer_rows` should start with a row which is contained in the hunk's buffer range - let first_buffer_rows = match buffer_rows.peek() { - Some(first_buffer_rows) => first_buffer_rows, - None => return (None, 0), - }; - - //The `usize` field is 1-index so we have to sub to move it into 0-offset to match actual rows - let visual_start = start_row + first_buffer_rows.0 as u32 - 1; - - let mut visual_count = 0; - let mut buffer_row_advancement = 0; - while let Some(&buffer_row) = buffer_rows.peek() { - if let (_, Some(buffer_row)) = buffer_row { - buffer_row_advancement += 1; - if buffer_row == hunk.buffer_range.end { - visual_count += 1; - break; - } else if buffer_row > hunk.buffer_range.end { - break; - } - visual_count += 1; - } else { - visual_count += 1; - } - - buffer_rows.next(); - } - - let layout = DiffHunkLayout { - visual_range: visual_start..visual_start + visual_count, - status: hunk.status(), - }; - (Some(layout), buffer_row_advancement) - } - //Folds contained in a hunk are ignored apart from shrinking visual size //If a fold contains any hunks then that fold line is marked as modified fn layout_git_gutters( @@ -1034,87 +1012,94 @@ impl EditorElement { rows: Range, snapshot: &EditorSnapshot, ) -> Vec { - let buffer_rows = snapshot.buffer_rows(rows.start); - let start_actual_row = match buffer_rows - .clone() - .take((rows.end - rows.start) as usize) - .find_map(|b| b) - { - Some(start_actual_row) => start_actual_row, - None => return Vec::new(), - }; - - //Get all hunks after our starting actual buffer row - //The loop is in terms of visual buffer rows so we simply - //return before touching any hunks past the end of the view - let mut diff_hunks = snapshot - .buffer_snapshot - .git_diff_hunks_in_range(start_actual_row..u32::MAX) - .peekable(); - - //Some number followed by Nones for wrapped lines - //Jump in number for folded lines - let mut buffer_rows = buffer_rows - .take((rows.end - rows.start) as usize) - .enumerate() - .peekable(); + let start_row = DisplayPoint::new(rows.start, 0).to_point(snapshot).row; + let end_row = DisplayPoint::new(rows.end, 0).to_point(snapshot).row; let mut layouts = Vec::new(); - let mut previous_buffer_row = None; - - while let Some((idx, buffer_row)) = buffer_rows.next() { - let buffer_row = match buffer_row { - Some(buffer_row) => buffer_row, - None => continue, - }; - - let is_start_of_fold = previous_buffer_row - .map(|prev| buffer_row > prev + 1) - .unwrap_or(false); - previous_buffer_row = Some(buffer_row); - - if is_start_of_fold { - //Consume all hunks within fold - let mut consumed_hunks = false; - while let Some(hunk) = diff_hunks.peek() { - let is_past = hunk.buffer_range.start > buffer_row; - let is_removal = hunk.status() == DiffHunkStatus::Removed; - let is_on_next_line = hunk.buffer_range.start == buffer_row + 1; - let is_removal_inside = is_removal && is_on_next_line; - - if is_past && !is_removal_inside { - break; - } - diff_hunks.next(); - consumed_hunks = true; - } - - //And mark fold as modified if there were any - if consumed_hunks { - let current_visual_row = rows.start + idx as u32 - 1; - layouts.push(DiffHunkLayout { - visual_range: current_visual_row..current_visual_row + 1, - status: DiffHunkStatus::Modified, - }); - } - } else if let Some(hunk) = diff_hunks.peek() { - let row_inside_hunk = hunk.buffer_range.contains(&buffer_row); - let starts_on_row = hunk.buffer_range.start == buffer_row; - if row_inside_hunk || starts_on_row { - let (layout, buffer_row_advancement) = - Self::layout_diff_hunk(hunk, rows.start, &mut buffer_rows); - previous_buffer_row = Some(buffer_row + buffer_row_advancement); - - if let Some(layout) = layout { - layouts.push(layout); - } + for hunk in snapshot + .buffer_snapshot + .git_diff_hunks_in_range(start_row..end_row) + { + let start = Point::new(hunk.buffer_range.start, 0).to_display_point(snapshot); + let end = Point::new(hunk.buffer_range.end, 0).to_display_point(snapshot); + let is_folded = start == end && snapshot.is_line_folded(start.row()); - diff_hunks.next(); - } + if let Some(hunk) = layouts.last_mut() { + // } + + layouts.push(DiffHunkLayout { + visual_range: start.row()..end.row(), + status: hunk.status(), + is_folded, + }); } - layouts + return layouts; + + //Some number followed by Nones for wrapped lines + //Jump in number for folded lines + // let mut buffer_rows = buffer_rows + // .take((rows.end - rows.start) as usize) + // .enumerate() + // .peekable(); + + // let mut layouts = Vec::new(); + // let mut previous_buffer_row = None; + + // while let Some((idx, buffer_row)) = buffer_rows.next() { + // let buffer_row = match buffer_row { + // Some(buffer_row) => buffer_row, + // None => continue, + // }; + + // let is_start_of_fold = previous_buffer_row + // .map(|prev| buffer_row > prev + 1) + // .unwrap_or(false); + // previous_buffer_row = Some(buffer_row); + + // if is_start_of_fold { + // //Consume all hunks within fold + // let mut consumed_hunks = false; + // while let Some(hunk) = diff_hunks.peek() { + // let is_past = hunk.buffer_range.start > buffer_row; + // let is_removal = hunk.status() == DiffHunkStatus::Removed; + // let is_on_next_line = hunk.buffer_range.start == buffer_row + 1; + // let is_removal_inside = is_removal && is_on_next_line; + + // if is_past && !is_removal_inside { + // break; + // } + // diff_hunks.next(); + // consumed_hunks = true; + // } + + // //And mark fold as modified if there were any + // if consumed_hunks { + // let current_visual_row = rows.start + idx as u32 - 1; + // layouts.push(DiffHunkLayout { + // visual_range: current_visual_row..current_visual_row + 1, + // status: DiffHunkStatus::Modified, + // }); + // } + // } else if let Some(hunk) = diff_hunks.peek() { + // let row_inside_hunk = hunk.buffer_range.contains(&buffer_row); + // let starts_on_row = hunk.buffer_range.start == buffer_row; + // if row_inside_hunk || starts_on_row { + // let (layout, buffer_row_advancement) = + // Self::layout_diff_hunk(hunk, rows.start, &mut buffer_rows); + // previous_buffer_row = Some(buffer_row + buffer_row_advancement); + + // if let Some(layout) = layout { + // layouts.push(layout); + // } + + // diff_hunks.next(); + // } + // } + // } + + // layouts } fn layout_line_numbers( From b3eb5f7cdf0b2b1875050524895f92048e1bb3e7 Mon Sep 17 00:00:00 2001 From: Julia Date: Fri, 14 Oct 2022 17:14:33 -0400 Subject: [PATCH 13/21] WIP Co-Authored-By: Kay Simmons --- crates/editor/src/element.rs | 103 +++++++++-------------------------- 1 file changed, 27 insertions(+), 76 deletions(-) diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs index e6f876028aecaaedcba29a1c7a51a0d37137d899..e4b8a762de77f743e1d8681bea0a4f210eba02b1 100644 --- a/crates/editor/src/element.rs +++ b/crates/editor/src/element.rs @@ -12,7 +12,7 @@ use crate::{ CmdShiftChanged, GoToFetchedDefinition, GoToFetchedTypeDefinition, UpdateGoToDefinitionLink, }, mouse_context_menu::DeployMouseContextMenu, - EditorStyle, + AnchorRangeExt, EditorStyle, ToOffset, }; use clock::ReplicaId; use collections::{BTreeMap, HashMap}; @@ -1020,86 +1020,37 @@ impl EditorElement { .buffer_snapshot .git_diff_hunks_in_range(start_row..end_row) { - let start = Point::new(hunk.buffer_range.start, 0).to_display_point(snapshot); - let end = Point::new(hunk.buffer_range.end, 0).to_display_point(snapshot); - let is_folded = start == end && snapshot.is_line_folded(start.row()); - - if let Some(hunk) = layouts.last_mut() { - // - } + let start = Point::new(hunk.buffer_range.start, 0); + let hunk_content_end_row = hunk + .buffer_range + .end + .saturating_sub(1) + .max(hunk.buffer_range.start); + let hunk_content_end = Point::new( + hunk_content_end_row, + snapshot.buffer_snapshot.line_len(hunk_content_end_row), + ); + let end = Point::new(hunk.buffer_range.end, 0); + + let is_folded = snapshot + .folds_in_range(start..end) + .any(|fold_range| { + let fold_point_range = fold_range.to_point(&snapshot.buffer_snapshot); + dbg!(&fold_point_range); + fold_point_range.contains(dbg!(&start)) + && fold_point_range.contains(dbg!(&hunk_content_end)) + || fold_point_range.end == hunk_content_end + }); - layouts.push(DiffHunkLayout { - visual_range: start.row()..end.row(), + layouts.push(dbg!(DiffHunkLayout { + visual_range: start.to_display_point(snapshot).row() + ..end.to_display_point(snapshot).row(), status: hunk.status(), is_folded, - }); + })); } - return layouts; - - //Some number followed by Nones for wrapped lines - //Jump in number for folded lines - // let mut buffer_rows = buffer_rows - // .take((rows.end - rows.start) as usize) - // .enumerate() - // .peekable(); - - // let mut layouts = Vec::new(); - // let mut previous_buffer_row = None; - - // while let Some((idx, buffer_row)) = buffer_rows.next() { - // let buffer_row = match buffer_row { - // Some(buffer_row) => buffer_row, - // None => continue, - // }; - - // let is_start_of_fold = previous_buffer_row - // .map(|prev| buffer_row > prev + 1) - // .unwrap_or(false); - // previous_buffer_row = Some(buffer_row); - - // if is_start_of_fold { - // //Consume all hunks within fold - // let mut consumed_hunks = false; - // while let Some(hunk) = diff_hunks.peek() { - // let is_past = hunk.buffer_range.start > buffer_row; - // let is_removal = hunk.status() == DiffHunkStatus::Removed; - // let is_on_next_line = hunk.buffer_range.start == buffer_row + 1; - // let is_removal_inside = is_removal && is_on_next_line; - - // if is_past && !is_removal_inside { - // break; - // } - // diff_hunks.next(); - // consumed_hunks = true; - // } - - // //And mark fold as modified if there were any - // if consumed_hunks { - // let current_visual_row = rows.start + idx as u32 - 1; - // layouts.push(DiffHunkLayout { - // visual_range: current_visual_row..current_visual_row + 1, - // status: DiffHunkStatus::Modified, - // }); - // } - // } else if let Some(hunk) = diff_hunks.peek() { - // let row_inside_hunk = hunk.buffer_range.contains(&buffer_row); - // let starts_on_row = hunk.buffer_range.start == buffer_row; - // if row_inside_hunk || starts_on_row { - // let (layout, buffer_row_advancement) = - // Self::layout_diff_hunk(hunk, rows.start, &mut buffer_rows); - // previous_buffer_row = Some(buffer_row + buffer_row_advancement); - - // if let Some(layout) = layout { - // layouts.push(layout); - // } - - // diff_hunks.next(); - // } - // } - // } - - // layouts + layouts } fn layout_line_numbers( From 6d020a3ee98a7a6dba693f802681d7c37f2526da Mon Sep 17 00:00:00 2001 From: Joseph T Lyons Date: Sun, 16 Oct 2022 12:51:34 -0400 Subject: [PATCH 14/21] Do not derive Default on JournalSettings --- crates/settings/src/settings.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/settings/src/settings.rs b/crates/settings/src/settings.rs index 48ba35f4d3f5fa160cb56f9b8fe5f9183c7975b8..9280a206001f6fe8dd20c52f73485fb22c7fc705 100644 --- a/crates/settings/src/settings.rs +++ b/crates/settings/src/settings.rs @@ -124,7 +124,7 @@ pub enum Autosave { OnWindowChange, } -#[derive(Clone, Debug, Default, Serialize, Deserialize, JsonSchema)] +#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)] pub struct JournalSettings { pub path: Option, pub hour_format: Option, From 0717c168d9a0f9bcc57aa3df05853c232c9ea393 Mon Sep 17 00:00:00 2001 From: Joseph T Lyons Date: Sun, 16 Oct 2022 12:51:48 -0400 Subject: [PATCH 15/21] Derive Serialize on HourFormat --- crates/settings/src/settings.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/settings/src/settings.rs b/crates/settings/src/settings.rs index 9280a206001f6fe8dd20c52f73485fb22c7fc705..63bc5962fa0bba24e6cc0875793f96643f17cfe4 100644 --- a/crates/settings/src/settings.rs +++ b/crates/settings/src/settings.rs @@ -139,7 +139,7 @@ impl Default for JournalSettings { } } -#[derive(Clone, Debug, Deserialize, JsonSchema)] +#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)] #[serde(rename_all = "snake_case")] pub enum HourFormat { Hour12, From f1ff557a25d244929f438771d86585b084625d35 Mon Sep 17 00:00:00 2001 From: Mikayla Maki Date: Sun, 16 Oct 2022 17:31:19 -0700 Subject: [PATCH 16/21] Rearranged mouse handling --- crates/terminal/src/terminal.rs | 76 +++++++++++++++------------------ 1 file changed, 34 insertions(+), 42 deletions(-) diff --git a/crates/terminal/src/terminal.rs b/crates/terminal/src/terminal.rs index 5485fb50ca2a94ad43d6e5dab5e7423be4946e3c..735b00ca62faf3be18d858cd0695b48fdc53decf 100644 --- a/crates/terminal/src/terminal.rs +++ b/crates/terminal/src/terminal.rs @@ -1018,55 +1018,34 @@ impl Terminal { self.last_content.size, self.last_content.display_offset, ); - // let side = mouse_side(position, self.last_content.size); if self.mouse_mode(e.shift) { if let Some(bytes) = mouse_button_report(point, e, true, self.last_content.mode) { self.pty_tx.notify(bytes); } } else if e.button == MouseButton::Left { - self.left_click(e, origin) - } - } - - pub fn left_click(&mut self, e: &DownRegionEvent, origin: Vector2F) { - let position = e.position.sub(origin); - if !self.mouse_mode(e.shift) { - //Hyperlinks - { - let mouse_cell_index = content_index_for_mouse(position, &self.last_content); - if let Some(link) = self.last_content.cells[mouse_cell_index].hyperlink() { - open_uri(link.uri()).log_err(); - } else { - self.events - .push_back(InternalEvent::FindHyperlink(position, true)); - } - } + let position = e.position.sub(origin); + let point = grid_point( + position, + self.last_content.size, + self.last_content.display_offset, + ); + let side = mouse_side(position, self.last_content.size); - // Selections - { - let point = grid_point( - position, - self.last_content.size, - self.last_content.display_offset, - ); - let side = mouse_side(position, self.last_content.size); - - let selection_type = match e.click_count { - 0 => return, //This is a release - 1 => Some(SelectionType::Simple), - 2 => Some(SelectionType::Semantic), - 3 => Some(SelectionType::Lines), - _ => None, - }; + let selection_type = match e.click_count { + 0 => return, //This is a release + 1 => Some(SelectionType::Simple), + 2 => Some(SelectionType::Semantic), + 3 => Some(SelectionType::Lines), + _ => None, + }; - let selection = selection_type - .map(|selection_type| Selection::new(selection_type, point, side)); + let selection = + selection_type.map(|selection_type| Selection::new(selection_type, point, side)); - if let Some(sel) = selection { - self.events - .push_back(InternalEvent::SetSelection(Some((sel, point)))); - } + if let Some(sel) = selection { + self.events + .push_back(InternalEvent::SetSelection(Some((sel, point)))); } } } @@ -1094,8 +1073,21 @@ impl Terminal { if let Some(bytes) = mouse_button_report(point, e, false, self.last_content.mode) { self.pty_tx.notify(bytes); } - } else if e.button == MouseButton::Left && copy_on_select { - self.copy(); + } else { + if e.button == MouseButton::Left && copy_on_select { + self.copy(); + } + + //Hyperlinks + if self.selection_phase == SelectionPhase::Ended { + let mouse_cell_index = content_index_for_mouse(position, &self.last_content); + if let Some(link) = self.last_content.cells[mouse_cell_index].hyperlink() { + open_uri(link.uri()).log_err(); + } else { + self.events + .push_back(InternalEvent::FindHyperlink(position, true)); + } + } } self.selection_phase = SelectionPhase::Ended; From 6bdbab2fafb2698febac66d73b4fceafcaefc18e Mon Sep 17 00:00:00 2001 From: Antonio Scandurra Date: Mon, 17 Oct 2022 10:05:38 +0200 Subject: [PATCH 17/21] Notify `ActivityIndicator` when `AutoUpdater` changes This fixes a bug that caused the status bar to not update when the auto-update system changed its status. --- crates/activity_indicator/src/activity_indicator.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/crates/activity_indicator/src/activity_indicator.rs b/crates/activity_indicator/src/activity_indicator.rs index 596e9ba9959a6cef00a145cfa153284ba86c32a3..cc788c1e482d58a9a49425e9e46adc288368f5a9 100644 --- a/crates/activity_indicator/src/activity_indicator.rs +++ b/crates/activity_indicator/src/activity_indicator.rs @@ -46,6 +46,7 @@ impl ActivityIndicator { cx: &mut ViewContext, ) -> ViewHandle { let project = workspace.project().clone(); + let auto_updater = AutoUpdater::get(cx); let this = cx.add_view(|cx: &mut ViewContext| { let mut status_events = languages.language_server_binary_statuses(); cx.spawn_weak(|this, mut cx| async move { @@ -66,11 +67,14 @@ impl ActivityIndicator { }) .detach(); cx.observe(&project, |_, _, cx| cx.notify()).detach(); + if let Some(auto_updater) = auto_updater.as_ref() { + cx.observe(auto_updater, |_, _, cx| cx.notify()).detach(); + } Self { statuses: Default::default(), project: project.clone(), - auto_updater: AutoUpdater::get(cx), + auto_updater, } }); cx.subscribe(&this, move |workspace, _, event, cx| match event { From 50ae3e03f75b25df64879634fe392f7165cc086b Mon Sep 17 00:00:00 2001 From: Julia Date: Mon, 17 Oct 2022 12:28:44 -0400 Subject: [PATCH 18/21] More concrete usage of display map to handle diff hunk gutter layout --- crates/editor/src/element.rs | 70 +++++++++++++++++++----------------- 1 file changed, 38 insertions(+), 32 deletions(-) diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs index e4b8a762de77f743e1d8681bea0a4f210eba02b1..f7d01bdb58731f61a4abc021e5026e13732e9131 100644 --- a/crates/editor/src/element.rs +++ b/crates/editor/src/element.rs @@ -1012,42 +1012,48 @@ impl EditorElement { rows: Range, snapshot: &EditorSnapshot, ) -> Vec { - let start_row = DisplayPoint::new(rows.start, 0).to_point(snapshot).row; - let end_row = DisplayPoint::new(rows.end, 0).to_point(snapshot).row; + let buffer_snapshot = &snapshot.buffer_snapshot; + let visual_start = DisplayPoint::new(rows.start, 0).to_point(snapshot).row; + let visual_end = DisplayPoint::new(rows.end, 0).to_point(snapshot).row; + let hunks = buffer_snapshot.git_diff_hunks_in_range(visual_start..visual_end); let mut layouts = Vec::new(); - for hunk in snapshot - .buffer_snapshot - .git_diff_hunks_in_range(start_row..end_row) - { - let start = Point::new(hunk.buffer_range.start, 0); - let hunk_content_end_row = hunk - .buffer_range - .end - .saturating_sub(1) - .max(hunk.buffer_range.start); - let hunk_content_end = Point::new( - hunk_content_end_row, - snapshot.buffer_snapshot.line_len(hunk_content_end_row), - ); - let end = Point::new(hunk.buffer_range.end, 0); - - let is_folded = snapshot - .folds_in_range(start..end) - .any(|fold_range| { - let fold_point_range = fold_range.to_point(&snapshot.buffer_snapshot); - dbg!(&fold_point_range); - fold_point_range.contains(dbg!(&start)) - && fold_point_range.contains(dbg!(&hunk_content_end)) - || fold_point_range.end == hunk_content_end - }); - layouts.push(dbg!(DiffHunkLayout { - visual_range: start.to_display_point(snapshot).row() - ..end.to_display_point(snapshot).row(), + for hunk in hunks { + let hunk_start_point = Point::new(hunk.buffer_range.start, 0); + let hunk_end_point = Point::new(hunk.buffer_range.end, 0); + let hunk_moved_start_point = Point::new(hunk.buffer_range.start.saturating_sub(1), 0); + + let is_removal = hunk.status() == DiffHunkStatus::Removed; + + let folds_start = Point::new(hunk.buffer_range.start.saturating_sub(1), 0); + let folds_end = Point::new(hunk.buffer_range.end + 1, 0); + let folds_range = folds_start..folds_end; + + let containing_fold = snapshot.folds_in_range(folds_range).find(|fold_range| { + let fold_point_range = fold_range.to_point(buffer_snapshot); + + let folded_start = fold_point_range.contains(&hunk_start_point); + let folded_end = fold_point_range.contains(&hunk_end_point); + let folded_moved_start = fold_point_range.contains(&hunk_moved_start_point); + + (folded_start && folded_end) || (is_removal && folded_moved_start) + }); + + let visual_range = if let Some(fold) = containing_fold { + let row = fold.start.to_display_point(snapshot).row(); + row..row + } else { + let start = hunk_start_point.to_display_point(snapshot).row(); + let end = hunk_end_point.to_display_point(snapshot).row(); + start..end + }; + + layouts.push(DiffHunkLayout { + visual_range, status: hunk.status(), - is_folded, - })); + is_folded: containing_fold.is_some(), + }); } layouts From be34c50c72d0da2bc67f041c84a49e80b38077bb Mon Sep 17 00:00:00 2001 From: Julia Date: Mon, 17 Oct 2022 12:41:20 -0400 Subject: [PATCH 19/21] Deduplicate identical hunk layouts --- crates/editor/src/element.rs | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs index f7d01bdb58731f61a4abc021e5026e13732e9131..e5a9f8f756e1cc6897a5f04c72e4ef671ffc0d1c 100644 --- a/crates/editor/src/element.rs +++ b/crates/editor/src/element.rs @@ -1017,7 +1017,7 @@ impl EditorElement { let visual_end = DisplayPoint::new(rows.end, 0).to_point(snapshot).row; let hunks = buffer_snapshot.git_diff_hunks_in_range(visual_start..visual_end); - let mut layouts = Vec::new(); + let mut layouts = Vec::::new(); for hunk in hunks { let hunk_start_point = Point::new(hunk.buffer_range.start, 0); @@ -1049,11 +1049,18 @@ impl EditorElement { start..end }; - layouts.push(DiffHunkLayout { - visual_range, - status: hunk.status(), - is_folded: containing_fold.is_some(), - }); + let has_existing_layout = match layouts.last() { + Some(e) => visual_range == e.visual_range && e.status == hunk.status(), + None => false, + }; + + if !has_existing_layout { + layouts.push(DiffHunkLayout { + visual_range, + status: hunk.status(), + is_folded: containing_fold.is_some(), + }); + } } layouts From 2a5d7ea2dea1eeb7ddfbe343c25d0784678ba6e7 Mon Sep 17 00:00:00 2001 From: Julia Date: Mon, 17 Oct 2022 13:11:11 -0400 Subject: [PATCH 20/21] Inclusively check for hunk in fold range --- crates/editor/src/element.rs | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs index e5a9f8f756e1cc6897a5f04c72e4ef671ffc0d1c..3da475351095469a749973bc8856c1438dda1e0f 100644 --- a/crates/editor/src/element.rs +++ b/crates/editor/src/element.rs @@ -1022,7 +1022,14 @@ impl EditorElement { for hunk in hunks { let hunk_start_point = Point::new(hunk.buffer_range.start, 0); let hunk_end_point = Point::new(hunk.buffer_range.end, 0); - let hunk_moved_start_point = Point::new(hunk.buffer_range.start.saturating_sub(1), 0); + let hunk_start_point_sub = Point::new(hunk.buffer_range.start.saturating_sub(1), 0); + let hunk_end_point_sub = Point::new( + hunk.buffer_range + .end + .saturating_sub(1) + .max(hunk.buffer_range.start), + 0, + ); let is_removal = hunk.status() == DiffHunkStatus::Removed; @@ -1032,12 +1039,13 @@ impl EditorElement { let containing_fold = snapshot.folds_in_range(folds_range).find(|fold_range| { let fold_point_range = fold_range.to_point(buffer_snapshot); + let fold_point_range = fold_point_range.start..=fold_point_range.end; let folded_start = fold_point_range.contains(&hunk_start_point); - let folded_end = fold_point_range.contains(&hunk_end_point); - let folded_moved_start = fold_point_range.contains(&hunk_moved_start_point); + let folded_end = fold_point_range.contains(&hunk_end_point_sub); + let folded_start_sub = fold_point_range.contains(&hunk_start_point_sub); - (folded_start && folded_end) || (is_removal && folded_moved_start) + (folded_start && folded_end) || (is_removal && folded_start_sub) }); let visual_range = if let Some(fold) = containing_fold { From 1716aff9697133b9b3a72ab27e71895791a3aa03 Mon Sep 17 00:00:00 2001 From: Julia Date: Mon, 17 Oct 2022 14:41:16 -0400 Subject: [PATCH 21/21] Cleanup --- crates/editor/src/element.rs | 176 ++++++++++++++--------------------- 1 file changed, 72 insertions(+), 104 deletions(-) diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs index 3da475351095469a749973bc8856c1438dda1e0f..3a686fd5bf9cc13c67078c597db0587e7dd04440 100644 --- a/crates/editor/src/element.rs +++ b/crates/editor/src/element.rs @@ -12,11 +12,11 @@ use crate::{ CmdShiftChanged, GoToFetchedDefinition, GoToFetchedTypeDefinition, UpdateGoToDefinitionLink, }, mouse_context_menu::DeployMouseContextMenu, - AnchorRangeExt, EditorStyle, ToOffset, + AnchorRangeExt, EditorStyle, }; use clock::ReplicaId; use collections::{BTreeMap, HashMap}; -use git::diff::{DiffHunk, DiffHunkStatus}; +use git::diff::DiffHunkStatus; use gpui::{ color::Color, elements::*, @@ -46,7 +46,6 @@ use std::{ ops::Range, sync::Arc, }; -use theme::DiffStyle; #[derive(Debug)] struct DiffHunkLayout { @@ -533,18 +532,52 @@ impl EditorElement { layout: &mut LayoutState, cx: &mut PaintContext, ) { - struct GutterLayout { - line_height: f32, - // scroll_position: Vector2F, - scroll_top: f32, - bounds: RectF, + let line_height = layout.position_map.line_height; + + let scroll_position = layout.position_map.snapshot.scroll_position(); + let scroll_top = scroll_position.y() * line_height; + + let show_gutter = matches!( + &cx.global::() + .git_overrides + .git_gutter + .unwrap_or_default(), + GitGutter::TrackedFiles + ); + + if show_gutter { + Self::paint_diff_hunks(bounds, layout, cx); + } + + for (ix, line) in layout.line_number_layouts.iter().enumerate() { + if let Some(line) = line { + let line_origin = bounds.origin() + + vec2f( + bounds.width() - line.width() - layout.gutter_padding, + ix as f32 * line_height - (scroll_top % line_height), + ); + + line.paint(line_origin, visible_bounds, line_height, cx); + } } - fn diff_quad( - hunk: &DiffHunkLayout, - gutter_layout: &GutterLayout, - diff_style: &DiffStyle, - ) -> Quad { + if let Some((row, indicator)) = layout.code_actions_indicator.as_mut() { + let mut x = bounds.width() - layout.gutter_padding; + let mut y = *row as f32 * line_height - scroll_top; + x += ((layout.gutter_padding + layout.gutter_margin) - indicator.size().x()) / 2.; + y += (line_height - indicator.size().y()) / 2.; + indicator.paint(bounds.origin() + vec2f(x, y), visible_bounds, cx); + } + } + + fn paint_diff_hunks(bounds: RectF, layout: &mut LayoutState, cx: &mut PaintContext) { + let diff_style = &cx.global::().theme.editor.diff.clone(); + let line_height = layout.position_map.line_height; + + let scroll_position = layout.position_map.snapshot.scroll_position(); + let scroll_top = scroll_position.y() * line_height; + + for hunk in &layout.hunk_layouts { let color = match (hunk.status, hunk.is_folded) { (DiffHunkStatus::Added, false) => diff_style.inserted, (DiffHunkStatus::Modified, false) => diff_style.modified, @@ -553,107 +586,63 @@ impl EditorElement { (DiffHunkStatus::Removed, false) => { let row = hunk.visual_range.start; - let offset = gutter_layout.line_height / 2.; - let start_y = - row as f32 * gutter_layout.line_height - offset - gutter_layout.scroll_top; - let end_y = start_y + gutter_layout.line_height; + let offset = line_height / 2.; + let start_y = row as f32 * line_height - offset - scroll_top; + let end_y = start_y + line_height; - let width = diff_style.removed_width_em * gutter_layout.line_height; - let highlight_origin = gutter_layout.bounds.origin() + vec2f(-width, start_y); + let width = diff_style.removed_width_em * line_height; + let highlight_origin = bounds.origin() + vec2f(-width, start_y); let highlight_size = vec2f(width * 2., end_y - start_y); let highlight_bounds = RectF::new(highlight_origin, highlight_size); - return Quad { + cx.scene.push_quad(Quad { bounds: highlight_bounds, background: Some(diff_style.deleted), border: Border::new(0., Color::transparent_black()), - corner_radius: 1. * gutter_layout.line_height, - }; + corner_radius: 1. * line_height, + }); + + continue; } (_, true) => { let row = hunk.visual_range.start; - let start_y = row as f32 * gutter_layout.line_height - gutter_layout.scroll_top; - let end_y = start_y + gutter_layout.line_height; + let start_y = row as f32 * line_height - scroll_top; + let end_y = start_y + line_height; - let width = diff_style.removed_width_em * gutter_layout.line_height; - let highlight_origin = gutter_layout.bounds.origin() + vec2f(-width, start_y); + let width = diff_style.removed_width_em * line_height; + let highlight_origin = bounds.origin() + vec2f(-width, start_y); let highlight_size = vec2f(width * 2., end_y - start_y); let highlight_bounds = RectF::new(highlight_origin, highlight_size); - return Quad { + cx.scene.push_quad(Quad { bounds: highlight_bounds, background: Some(diff_style.modified), border: Border::new(0., Color::transparent_black()), - corner_radius: 1. * gutter_layout.line_height, - }; + corner_radius: 1. * line_height, + }); + + continue; } }; let start_row = hunk.visual_range.start; let end_row = hunk.visual_range.end; - let start_y = start_row as f32 * gutter_layout.line_height - gutter_layout.scroll_top; - let end_y = end_row as f32 * gutter_layout.line_height - gutter_layout.scroll_top; + let start_y = start_row as f32 * line_height - scroll_top; + let end_y = end_row as f32 * line_height - scroll_top; - let width = diff_style.width_em * gutter_layout.line_height; - let highlight_origin = gutter_layout.bounds.origin() + vec2f(-width, start_y); + let width = diff_style.width_em * line_height; + let highlight_origin = bounds.origin() + vec2f(-width, start_y); let highlight_size = vec2f(width * 2., end_y - start_y); let highlight_bounds = RectF::new(highlight_origin, highlight_size); - Quad { + cx.scene.push_quad(Quad { bounds: highlight_bounds, background: Some(color), border: Border::new(0., Color::transparent_black()), - corner_radius: diff_style.corner_radius * gutter_layout.line_height, - } - } - - let scroll_position = layout.position_map.snapshot.scroll_position(); - let gutter_layout = { - let line_height = layout.position_map.line_height; - GutterLayout { - scroll_top: scroll_position.y() * line_height, - line_height, - bounds, - } - }; - - let diff_style = &cx.global::().theme.editor.diff.clone(); - let show_gutter = matches!( - &cx.global::() - .git_overrides - .git_gutter - .unwrap_or_default(), - GitGutter::TrackedFiles - ); - - if show_gutter { - for hunk in &layout.hunk_layouts { - let quad = diff_quad(hunk, &gutter_layout, diff_style); - cx.scene.push_quad(quad); - } - } - - for (ix, line) in layout.line_number_layouts.iter().enumerate() { - if let Some(line) = line { - let line_origin = bounds.origin() - + vec2f( - bounds.width() - line.width() - layout.gutter_padding, - ix as f32 * gutter_layout.line_height - - (gutter_layout.scroll_top % gutter_layout.line_height), - ); - - line.paint(line_origin, visible_bounds, gutter_layout.line_height, cx); - } - } - - if let Some((row, indicator)) = layout.code_actions_indicator.as_mut() { - let mut x = bounds.width() - layout.gutter_padding; - let mut y = *row as f32 * gutter_layout.line_height - gutter_layout.scroll_top; - x += ((layout.gutter_padding + layout.gutter_margin) - indicator.size().x()) / 2.; - y += (gutter_layout.line_height - indicator.size().y()) / 2.; - indicator.paint(bounds.origin() + vec2f(x, y), visible_bounds, cx); + corner_radius: diff_style.corner_radius * line_height, + }); } } @@ -1426,27 +1415,6 @@ impl EditorElement { } } -/// Get the hunk that contains buffer_line, starting from start_idx -/// Returns none if there is none found, and -fn get_hunk(hunks: &[DiffHunk], buffer_line: u32) -> Option<&DiffHunk> { - for i in 0..hunks.len() { - // Safety: Index out of bounds is handled by the check above - let hunk = hunks.get(i).unwrap(); - if hunk.buffer_range.contains(&(buffer_line as u32)) { - return Some(hunk); - } else if hunk.status() == DiffHunkStatus::Removed && buffer_line == hunk.buffer_range.start - { - return Some(hunk); - } else if hunk.buffer_range.start > buffer_line as u32 { - // If we've passed the buffer_line, just stop - return None; - } - } - - // We reached the end of the array without finding a hunk, just return none. - return None; -} - impl Element for EditorElement { type LayoutState = LayoutState; type PaintState = ();