diff --git a/Cargo.lock b/Cargo.lock
index 40cc8052..c7efd7a7 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1880,6 +1880,7 @@ dependencies = [
"gpui-pre",
"log",
"settings",
+ "window-wrapper",
]
[[package]]
@@ -10835,6 +10836,7 @@ dependencies = [
"serde_json",
"settings",
"table",
+ "window-wrapper",
]
[[package]]
diff --git a/assets/icons/map-pin.svg b/assets/icons/map-pin.svg
new file mode 100644
index 00000000..9029b306
--- /dev/null
+++ b/assets/icons/map-pin.svg
@@ -0,0 +1 @@
+
diff --git a/assets/icons/message-square.svg b/assets/icons/message-square.svg
new file mode 100644
index 00000000..89008980
--- /dev/null
+++ b/assets/icons/message-square.svg
@@ -0,0 +1 @@
+
diff --git a/assets/icons/mouse-pointer-2.svg b/assets/icons/mouse-pointer-2.svg
new file mode 100644
index 00000000..21a7c20a
--- /dev/null
+++ b/assets/icons/mouse-pointer-2.svg
@@ -0,0 +1 @@
+
diff --git a/assets/icons/pencil.svg b/assets/icons/pencil.svg
new file mode 100644
index 00000000..f458a3f5
--- /dev/null
+++ b/assets/icons/pencil.svg
@@ -0,0 +1 @@
+
diff --git a/assets/icons/rectangle.svg b/assets/icons/rectangle.svg
new file mode 100644
index 00000000..1df393fd
--- /dev/null
+++ b/assets/icons/rectangle.svg
@@ -0,0 +1 @@
+
diff --git a/assets/icons/square-pen.svg b/assets/icons/square-pen.svg
new file mode 100644
index 00000000..56ca1e39
--- /dev/null
+++ b/assets/icons/square-pen.svg
@@ -0,0 +1 @@
+
diff --git a/crates/app/src/assets.rs b/crates/app/src/assets.rs
index ef91e7b6..513d128c 100644
--- a/crates/app/src/assets.rs
+++ b/crates/app/src/assets.rs
@@ -1,7 +1,8 @@
//! Our own icons in front of `gpui_component_assets`, which is otherwise the only asset source.
//! The bundled icon set has no filled panel glyphs (the title bar's "this dock is open" state) and
//! no picture glyph (visual search), and none of the pop-out viewer's window, pin or missing-file
-//! glyphs, nor the viewer's fit-to-width glyph, so those SVGs are ours, copied from Lucide.
+//! glyphs, nor the viewer's fit-to-width or annotation glyphs, so those SVGs are ours, copied from
+//! Lucide.
use std::borrow::Cow;
@@ -9,7 +10,7 @@ use gpui::{AssetSource, Result, SharedString};
pub struct Assets;
-const OWN: [(&str, &str); 10] = [
+const OWN: [(&str, &str); 16] = [
(
"icons/history.svg",
include_str!("../../../assets/icons/history.svg"),
@@ -50,6 +51,30 @@ const OWN: [(&str, &str); 10] = [
"icons/move-horizontal.svg",
include_str!("../../../assets/icons/move-horizontal.svg"),
),
+ (
+ "icons/square-pen.svg",
+ include_str!("../../../assets/icons/square-pen.svg"),
+ ),
+ (
+ "icons/mouse-pointer-2.svg",
+ include_str!("../../../assets/icons/mouse-pointer-2.svg"),
+ ),
+ (
+ "icons/rectangle.svg",
+ include_str!("../../../assets/icons/rectangle.svg"),
+ ),
+ (
+ "icons/map-pin.svg",
+ include_str!("../../../assets/icons/map-pin.svg"),
+ ),
+ (
+ "icons/message-square.svg",
+ include_str!("../../../assets/icons/message-square.svg"),
+ ),
+ (
+ "icons/pencil.svg",
+ include_str!("../../../assets/icons/pencil.svg"),
+ ),
];
impl AssetSource for Assets {
diff --git a/crates/app/src/export.rs b/crates/app/src/export.rs
index b28ce414..60762ac2 100644
--- a/crates/app/src/export.rs
+++ b/crates/app/src/export.rs
@@ -398,6 +398,9 @@ fn sheet_notes(file: &Path, grid: &ExportGrid) -> anyhow::Result>
message: note.message,
created_at: note.created_at,
author: note.author,
+ id: Some(note.id),
+ region: note.region.and_then(|r| serde_json::to_string(&r).ok()),
+ kind: note.kind.map(|kind| kind.key().to_string()),
})
.collect::>();
Ok(qrate_export::sheet_notes(
diff --git a/crates/app/src/macos_services.rs b/crates/app/src/macos_services.rs
index 42047e4b..3d0c6c07 100644
--- a/crates/app/src/macos_services.rs
+++ b/crates/app/src/macos_services.rs
@@ -1,4 +1,8 @@
-use std::{cell::RefCell, ffi::CStr, sync::OnceLock};
+use std::{
+ cell::RefCell,
+ ffi::{CStr, c_void},
+ sync::OnceLock,
+};
use cocoa::{
base::{id, nil},
@@ -28,7 +32,7 @@ pub(crate) fn register(sender: async_channel::Sender) {
.expect("qrate's folder service class is registered once");
provider.add_method(
sel!(openWithQrate:userData:error:),
- open_folder as extern "C" fn(&Object, Sel, id, id, *mut id),
+ open_folder as extern "C" fn(&Object, Sel, id, id, *mut c_void),
);
let object: id = msg_send![provider.register(), new];
let app: id = msg_send![class!(NSApplication), sharedApplication];
@@ -37,7 +41,7 @@ pub(crate) fn register(sender: async_channel::Sender) {
}
}
-extern "C" fn open_folder(_: &Object, _: Sel, pasteboard: id, _: id, error: *mut id) {
+extern "C" fn open_folder(_: &Object, _: Sel, pasteboard: id, _: id, error: *mut c_void) {
unsafe {
let classes: id = msg_send![class!(NSArray), arrayWithObject: class!(NSURL)];
let urls: id = msg_send![pasteboard, readObjectsForClasses: classes options: nil];
@@ -64,7 +68,7 @@ extern "C" fn open_folder(_: &Object, _: Sel, pasteboard: id, _: id, error: *mut
if !error.is_null() {
let message =
NSString::alloc(nil).init_str("Choose a folder to start a qrate project.");
- *error = msg_send![message, autorelease];
+ *error.cast::() = msg_send![message, autorelease];
}
}
}
diff --git a/crates/app/src/status_items/plugin_bar.rs b/crates/app/src/status_items/plugin_bar.rs
index 10644e59..09c16c71 100644
--- a/crates/app/src/status_items/plugin_bar.rs
+++ b/crates/app/src/status_items/plugin_bar.rs
@@ -33,6 +33,43 @@ impl PluginBar {
_sub: cx.observe_global::(|_, cx| cx.notify()),
}
}
+
+ /// Menu equivalents of the bar contributions, using the same command dispatcher.
+ pub fn overflow_menu(
+ bar: Bar,
+ menu: PopupMenu,
+ window: &mut Window,
+ cx: &mut Context,
+ ) -> PopupMenu {
+ let items = [Side::Left, Side::Right]
+ .into_iter()
+ .flat_map(|side| BarContributions::at(bar, side, cx))
+ .collect::>();
+ if items.is_empty() {
+ return menu;
+ }
+ menu.submenu("Plugin controls", window, cx, move |menu, window, cx| {
+ items.iter().cloned().fold(menu, |menu, (plugin, item)| {
+ let mut actions = Vec::new();
+ for action in [item.left, item.right].into_iter().flatten() {
+ match action {
+ BarAction::Command(command) => actions.push((item.text.clone(), command)),
+ BarAction::Menu(commands) => actions.extend(commands),
+ }
+ }
+ // One command may be exposed by both mouse buttons.
+ let mut seen = std::collections::HashSet::new();
+ actions.retain(|(_, command)| seen.insert(command.clone()));
+ if actions.is_empty() {
+ menu.label(item.text)
+ } else {
+ menu.submenu(item.text, window, cx, move |menu, _, _| {
+ entries(plugin.clone(), actions.clone(), menu)
+ })
+ }
+ })
+ })
+ }
}
/// Run one of a plugin's commands against whatever the table has selected. The command answers on
diff --git a/crates/app/src/title_items/mod.rs b/crates/app/src/title_items/mod.rs
index 8625b738..37527848 100644
--- a/crates/app/src/title_items/mod.rs
+++ b/crates/app/src/title_items/mod.rs
@@ -1,12 +1,14 @@
pub mod launcher_bar;
mod update_notice;
+use std::rc::Rc;
+
use gpui::*;
use gpui_component::{
ActiveTheme,
dock::{DockArea, DockPlacement},
h_flex,
- menu::AppMenuBar,
+ menu::{AppMenuBar, PopupMenu, PopupMenuItem},
};
use plugin_api::{Bar, Side};
@@ -39,6 +41,56 @@ impl Render for FeedbackButton {
/// are registered on the left by default. Right: generic open/close buttons for each dock.
pub fn build_title_bar_registry(cx: &mut App, dock: WeakEntity) -> TitleBarRegistry {
let mut registry = TitleBarRegistry::default();
+ let menu_dock = dock.clone();
+ registry.overflow_menu = Some(Rc::new(move |menu, window, cx, focus| {
+ let menus = gpui_component::GlobalState::global(cx).app_menus().to_vec();
+ let menu = menus.into_iter().fold(menu, |menu, app_menu| {
+ let focus = focus.clone();
+ let submenu = PopupMenu::build(window, cx, move |menu, window, cx| {
+ append_menu_items(menu, app_menu.items, window, cx, focus)
+ });
+ menu.item(PopupMenuItem::submenu(app_menu.name, submenu).disabled(app_menu.disabled))
+ });
+ let menu = PluginBar::overflow_menu(Bar::Title, menu, window, cx);
+ let dock = menu_dock.clone();
+ let dock_focus = focus.clone();
+ let menu = menu
+ .separator()
+ .item(PopupMenuItem::new("Feedback").on_click(|_, _, cx| {
+ cx.open_url(&crate::logging::feedback_url(cx, None));
+ }))
+ .submenu("Panels", window, cx, move |menu, _, cx| {
+ let menu = match &dock_focus {
+ Some(focus) => menu.action_context(focus.clone()),
+ None => menu,
+ };
+ [
+ (
+ "Left dock",
+ DockPlacement::Left,
+ Box::new(ToggleLeftDock) as Box,
+ ),
+ (
+ "Bottom dock",
+ DockPlacement::Bottom,
+ Box::new(ToggleBottomDock),
+ ),
+ (
+ "Right dock",
+ DockPlacement::Right,
+ Box::new(ToggleRightDock),
+ ),
+ ]
+ .into_iter()
+ .fold(menu, |menu, (label, placement, action)| {
+ let open = dock
+ .upgrade()
+ .is_some_and(|dock| dock.read(cx).is_dock_open(placement));
+ menu.menu_with_check(label, open, action)
+ })
+ });
+ update_notice::overflow_menu(menu, cx)
+ }));
// The library's menu bar, not a row of independent dropdowns: it holds the "a menu is open"
// state that makes hovering a sibling switch to it, and arrow keys walk between them.
@@ -89,3 +141,37 @@ pub fn build_title_bar_registry(cx: &mut App, dock: WeakEntity) -> Tit
registry
}
+
+/// Convert the same owned menus AppMenuBar reads, preserving action, check, and disabled state.
+fn append_menu_items(
+ mut menu: PopupMenu,
+ items: Vec,
+ window: &mut Window,
+ cx: &mut Context,
+ focus: Option,
+) -> PopupMenu {
+ if let Some(focus) = &focus {
+ menu = menu.action_context(focus.clone());
+ }
+ for item in items {
+ menu = match item {
+ OwnedMenuItem::Action {
+ name,
+ action,
+ checked,
+ disabled,
+ ..
+ } => menu.menu_with_check_and_disabled(name, checked, action.boxed_clone(), disabled),
+ OwnedMenuItem::Separator => menu.separator(),
+ OwnedMenuItem::Submenu(submenu) => {
+ let focus = focus.clone();
+ let child = PopupMenu::build(window, cx, move |menu, window, cx| {
+ append_menu_items(menu, submenu.items, window, cx, focus)
+ });
+ menu.item(PopupMenuItem::submenu(submenu.name, child).disabled(submenu.disabled))
+ }
+ OwnedMenuItem::SystemMenu(_) => menu,
+ };
+ }
+ menu.scrollable(true)
+}
diff --git a/crates/app/src/title_items/update_notice.rs b/crates/app/src/title_items/update_notice.rs
index ce662f55..64d67ce5 100644
--- a/crates/app/src/title_items/update_notice.rs
+++ b/crates/app/src/title_items/update_notice.rs
@@ -8,6 +8,48 @@ use gpui_component::{
};
use crate::update_check::{AutoUpdater, UpdateStatus};
+use gpui_component::menu::{PopupMenu, PopupMenuItem};
+
+pub(super) fn overflow_menu(menu: PopupMenu, cx: &mut Context) -> PopupMenu {
+ let Some(updater) = AutoUpdater::get(cx) else {
+ return menu;
+ };
+ if !updater.read(cx).visible() {
+ return menu;
+ }
+ let status = updater.read(cx).status().clone();
+ let menu = menu.separator();
+ let menu = match &status {
+ UpdateStatus::Downloading { version, .. } => menu.item(
+ PopupMenuItem::new(format!(
+ "Downloading qrate v{version}… {}%",
+ status.progress_percent().unwrap_or_default()
+ ))
+ .disabled(true),
+ ),
+ UpdateStatus::Ready { .. } => {
+ menu.item(PopupMenuItem::new("Restart to update").on_click(crate::restart_for_update))
+ }
+ UpdateStatus::Restarting => menu.item(PopupMenuItem::new("Restarting…").disabled(true)),
+ UpdateStatus::Error { .. } => menu.item(
+ PopupMenuItem::new("Update failed — open About")
+ .on_click(|_, _, cx| crate::about::open_about_window(cx)),
+ ),
+ _ => return menu,
+ };
+ if matches!(
+ status,
+ UpdateStatus::Ready { .. } | UpdateStatus::Error { .. }
+ ) {
+ menu.item(
+ PopupMenuItem::new("Dismiss update notice").on_click(move |_, _, cx| {
+ updater.update(cx, |updater, cx| updater.dismiss(cx));
+ }),
+ )
+ } else {
+ menu
+ }
+}
pub struct UpdateNotice {
updater: Option>,
diff --git a/crates/diagnostics/Cargo.toml b/crates/diagnostics/Cargo.toml
index fc86c49e..30880bd0 100644
--- a/crates/diagnostics/Cargo.toml
+++ b/crates/diagnostics/Cargo.toml
@@ -8,6 +8,7 @@ log.workspace = true
gpui.workspace = true
gpui-component.workspace = true
settings = { path = "../settings" }
+window-wrapper = { path = "../window-wrapper" }
[dev-dependencies]
# `#[gpui::test]`, TestAppContext, and run_test are all behind this feature.
diff --git a/crates/diagnostics/src/fixes.rs b/crates/diagnostics/src/fixes.rs
index e9411672..66f723a2 100644
--- a/crates/diagnostics/src/fixes.rs
+++ b/crates/diagnostics/src/fixes.rs
@@ -404,7 +404,7 @@ mod tests {
source: Source::Validator(source.into()),
message: "not a known term".into(),
group: None,
- filed: None,
+ note: None,
}],
cx,
);
@@ -516,7 +516,7 @@ mod tests {
source: Source::Validator("LCSH".into()),
message: "not a known term".into(),
group: None,
- filed: None,
+ note: None,
},
Diagnostic {
location: location("Subject"),
@@ -524,7 +524,7 @@ mod tests {
source: Source::Validator("LCSH".into()),
message: "also deprecated".into(),
group: None,
- filed: None,
+ note: None,
},
];
Diagnostics::set(
diff --git a/crates/diagnostics/src/lib.rs b/crates/diagnostics/src/lib.rs
index 7a609164..a005a4a8 100644
--- a/crates/diagnostics/src/lib.rs
+++ b/crates/diagnostics/src/lib.rs
@@ -6,6 +6,7 @@
//! panel asks the app to reveal a cell.
pub mod fixes;
+pub mod note_card;
mod panel;
mod validator;
pub use fixes::{Fix, FixProviders, GroupFix, GroupFixProviders, GroupMember, SourceActions};
@@ -20,7 +21,8 @@ use std::path::PathBuf;
use gpui::{App, Global, Hsla, SharedString};
use gpui_component::ActiveTheme as _;
-use settings::history::{Change, Entry, Origin};
+use settings::history::{Change, Entry, EntryId, Origin};
+pub use settings::project::{NoteId, NoteKind, Region};
/// The one dataset a project can hold today. `__notes` keys by name so a second sheet is new
/// rows rather than a new table.
@@ -176,9 +178,29 @@ pub struct Diagnostic {
pub source: Source,
pub message: SharedString,
pub group: Option,
- /// Who filed this and when, for authored notes. Always `None` on a computed finding — a
- /// validator's output is recomputed on open, so it has no history to carry.
+ /// Set on every authored note, never on a computed finding — a validator's output is
+ /// recomputed on open, so it has no identity or history to carry.
+ pub note: Option,
+}
+
+/// What an authored note carries beyond its text.
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct NoteMeta {
+ pub id: NoteId,
pub filed: Option,
+ /// Where on the row's file it points; `None` for a note on the data itself.
+ pub region: Option,
+ pub kind: Option,
+ /// When its words or kind last changed, and by whom.
+ pub edited: Option,
+}
+
+/// Everything a note write can change.
+#[derive(Clone, PartialEq, Eq, Debug)]
+struct Body {
+ message: SharedString,
+ region: Option,
+ kind: Option,
}
impl Diagnostic {
@@ -279,6 +301,11 @@ pub struct Diagnostics {
/// a key carrying the column name would allocate a `SharedString` on every lookup and give
/// the cost straight back.
by_row: HashMap, Vec>,
+ /// The `items` index of each authored note, by its id.
+ by_note: HashMap,
+ /// `items` indices of the notes on regions of each `dataset_main` row's file, by the row's
+ /// stable id — what the viewer asks for on every pointer move.
+ regions: HashMap>,
/// Which project's stored notes are loaded. `CurrentProject` is mutated by every
/// project-scoped setting write, so its observer fires far more often than the project
/// actually changes.
@@ -320,8 +347,20 @@ impl Diagnostics {
mut items: Vec,
columns: &settings::columns::ColumnSettingsMap,
) {
+ let mut next = self.next_note_id();
for diagnostic in &mut items {
if diagnostic.source == Source::Note {
+ // Every note in the store is addressable by id, whichever way it arrived.
+ diagnostic.note.get_or_insert_with(|| {
+ next += 1;
+ NoteMeta {
+ id: next - 1,
+ filed: None,
+ region: None,
+ kind: None,
+ edited: None,
+ }
+ });
continue;
}
if diagnostic.severity == Severity::Note {
@@ -367,11 +406,23 @@ impl Diagnostics {
fn reindex(&mut self) {
self.by_row.clear();
+ self.by_note.clear();
+ self.regions.clear();
for (ix, diagnostic) in self.items.iter().enumerate() {
self.by_row
.entry(diagnostic.location.row)
.or_default()
.push(ix);
+ let Some(note) = diagnostic.note.as_ref() else {
+ continue;
+ };
+ self.by_note.insert(note.id, ix);
+ if let Some(row_id) = diagnostic.location.row_id
+ && note.region.is_some()
+ && diagnostic.location.dataset == DATASET_MAIN
+ {
+ self.regions.entry(row_id).or_default().push(ix);
+ }
}
}
@@ -429,18 +480,26 @@ impl Diagnostics {
Self::at(dataset, row, column, cx).map(|d| d.severity).min()
}
- /// The note filed here, if any — what the `Notes ▸` menu offers to edit rather than add. The
- /// *first* of them: editing is how a single note is corrected, while a second observation
- /// about the same item is added rather than overwriting the first.
+ /// The region-less note filed here, if any — what the grid's `Notes ▸` menu offers to edit
+ /// rather than add. The *first* of them: editing is how a single note is corrected, while a
+ /// second observation about the same item is added rather than overwriting the first.
pub fn note_at(
dataset: &str,
row: Option,
column: Option<&str>,
cx: &App,
) -> Option {
- Self::at(dataset, row, column, cx)
- .find(|d| d.source == Source::Note)
- .map(|d| d.message.clone())
+ Self::plain_note_at(dataset, row, column, cx).map(|d| d.message.clone())
+ }
+
+ fn plain_note_at<'a>(
+ dataset: &'a str,
+ row: Option,
+ column: Option<&'a str>,
+ cx: &'a App,
+ ) -> Option<&'a Diagnostic> {
+ Self::notes_at(dataset, row, column, cx)
+ .find(|d| d.note.as_ref().is_none_or(|n| n.region.is_none()))
}
/// Every note filed here, oldest first — what the Notes panel lists. An item accumulates
@@ -476,97 +535,270 @@ impl Diagnostics {
.filter(move |d| d.location.dataset == dataset && d.source == Source::Note)
}
- /// File another note here without disturbing the ones already at this location. `set_note`'s
- /// counterpart: that one corrects, this one adds.
- #[cfg(test)]
- pub fn add_note(location: Location, message: SharedString, cx: &mut App) {
+ /// One note, by the id history and the note card address it by.
+ pub fn note(id: NoteId, cx: &App) -> Option<&Diagnostic> {
+ let this = cx.try_global::()?;
+ this.by_note.get(&id).map(|&ix| &this.items[ix])
+ }
+
+ /// The notes on regions of one item's file, by the item's stable id.
+ pub fn regions_in_row(
+ row_id: settings::project::RowId,
+ cx: &App,
+ ) -> impl Iterator- {
+ cx.try_global::().into_iter().flat_map(move |this| {
+ this.regions
+ .get(&row_id)
+ .map_or([].as_slice(), Vec::as_slice)
+ .iter()
+ .map(move |&ix| &this.items[ix])
+ })
+ }
+
+ fn next_note_id(&self) -> NoteId {
+ // ponytail: a timestamp, so an id a deleted note left in the log is never handed out again
+ // without storing a counter.
+ let now = std::time::SystemTime::now()
+ .duration_since(std::time::UNIX_EPOCH)
+ .map_or(0, |d| d.as_millis() as NoteId);
+ let last = self
+ .items
+ .iter()
+ .filter_map(|d| d.note.as_ref())
+ .map(|n| n.id)
+ .max();
+ now.max(last.unwrap_or(0) + 1)
+ }
+
+ /// File a new note beside whatever is already at `location`, on `region` of the row's file when
+ /// it is about part of the picture. An empty message files nothing.
+ pub fn file_note(
+ location: Location,
+ region: Option,
+ kind: Option,
+ message: SharedString,
+ origin: Origin,
+ cx: &mut App,
+ ) -> Option {
if message.trim().is_empty() {
- return;
+ return None;
}
- let filed = Self::filed_now(cx);
- let logged = Self::note_entry(&location, None, Some(&message), Origin::Typed, cx);
- let this = cx.default_global::();
- this.items.push(Diagnostic {
- location,
- severity: Severity::Note,
- source: Source::Note,
+ let id = cx.default_global::().next_note_id();
+ let body = Body {
message,
- group: None,
- filed,
+ region,
+ kind,
+ };
+ Self::put(id, location, Some(body), origin, cx);
+ Some(id)
+ }
+
+ /// Rewrite one note's text and kind, keeping where it points; empty text deletes it.
+ pub fn edit_note(
+ id: NoteId,
+ message: SharedString,
+ kind: Option,
+ origin: Origin,
+ cx: &mut App,
+ ) {
+ let Some((location, mut body)) = Self::body(id, cx) else {
+ return;
+ };
+ body.message = message;
+ body.kind = kind;
+ let after = (!body.message.trim().is_empty()).then_some(body);
+ Self::put(id, location, after, origin, cx);
+ }
+
+ /// Put a note back the way `change` found it, as a restore of entry `from`: its words, kind and
+ /// region, or gone if it did not exist yet. `row` and `column` are its current address.
+ pub fn restore_note(
+ change: &Change,
+ row: Option,
+ column: Option,
+ from: EntryId,
+ cx: &mut App,
+ ) {
+ let Change::Note {
+ row: row_id,
+ before,
+ id: Some(id),
+ region_before,
+ kind_before,
+ ..
+ } = change
+ else {
+ return;
+ };
+ let location = Location {
+ dataset: DATASET_MAIN.into(),
+ row,
+ row_id: *row_id,
+ column,
+ };
+ let body = before.as_ref().map(|message| Body {
+ message: message.clone().into(),
+ region: *region_before,
+ kind: *kind_before,
});
- this.reindex();
- this.persist(&logged);
+ Self::put(*id, location, body, Origin::Restore(from), cx);
}
- /// Stamp for a note being filed right now: today's date from the project file's own clock, and
- /// whoever the archivist has told the app they are. Either half may be missing.
- fn filed_now(cx: &App) -> Option {
- let date = cx
- .try_global::()
- .and_then(|p| settings::project::today(&p.file))
- .map(SharedString::from);
- let author = settings::history::author(cx).map(SharedString::from);
- (date.is_some() || author.is_some()).then_some(Filed { date, author })
+ /// Move or reshape the region one note points at.
+ pub fn move_note(id: NoteId, region: Region, origin: Origin, cx: &mut App) {
+ let Some((location, mut body)) = Self::body(id, cx) else {
+ return;
+ };
+ body.region = Some(region);
+ Self::put(id, location, Some(body), origin, cx);
}
- /// The log entry for one note going from `before` to `after`. Empty when nothing changed, or
- /// when no project is open to log it in.
- fn note_entry(
- location: &Location,
- before: Option<&SharedString>,
- after: Option<&SharedString>,
- origin: Origin,
- cx: &App,
- ) -> Vec {
- if before == after || location.dataset != DATASET_MAIN {
- return Vec::new();
- }
- let change = Change::Note {
- row: location.row_id,
- column: location.column.as_ref().map(|c| c.to_string()),
- before: before.map(|b| b.to_string()),
- after: after.map(|a| a.to_string()),
+ fn body(id: NoteId, cx: &App) -> Option<(Location, Body)> {
+ let d = Self::note(id, cx)?;
+ let meta = d.note.as_ref()?;
+ let body = Body {
+ message: d.message.clone(),
+ region: meta.region,
+ kind: meta.kind,
};
- vec![Entry::new(
- origin,
- vec![change],
- settings::history::author(cx),
- )]
+ Some((d.location.clone(), body))
}
- /// Attach a note here, replacing any note already at this location; an empty `message` deletes
- /// it. Writes straight through to `__notes` — this is a deliberate keystroke, not the hot path
- /// the debounced setting writer exists for.
+ /// Correct the region-less note at `location`, or file one if there is none; an empty
+ /// `message` deletes it. The grid's note editor, which only ever shows that one note.
pub fn set_note(location: Location, message: SharedString, origin: Origin, cx: &mut App) {
- let (before, filed) = Self::notes_at(
+ let existing = Self::plain_note_at(
&location.dataset,
location.row,
location.column.as_deref(),
cx,
)
- .next()
- .map(|d| (Some(d.message.clone()), d.filed.clone()))
- .unwrap_or_default();
- let after = (!message.trim().is_empty()).then_some(&message);
- let logged = Self::note_entry(&location, before.as_ref(), after, origin, cx);
- // Keeps the original filing stamp: correcting a transcription is not re-observing the
- // item, and re-dating it to today would erase when the observation was actually made.
- let filed = filed.or_else(|| Self::filed_now(cx));
+ .and_then(|d| d.note.as_ref())
+ .map(|n| (n.id, n.kind));
+ match existing {
+ Some((id, kind)) => Self::edit_note(id, message, kind, origin, cx),
+ None => {
+ Self::file_note(location, None, None, message, origin, cx);
+ }
+ }
+ }
+
+ /// Replay a logged note change, as a restore does: the note it names takes the change's
+ /// `after`, filed again at `location` if it has since been deleted. A change logged before notes
+ /// had ids names the region-less note at `location`.
+ pub fn apply_note(location: Location, change: &Change, origin: Origin, cx: &mut App) {
+ let Change::Note {
+ id,
+ after,
+ region_after,
+ kind_after,
+ ..
+ } = change
+ else {
+ return;
+ };
+ let id = id
+ .or_else(|| {
+ Self::plain_note_at(
+ &location.dataset,
+ location.row,
+ location.column.as_deref(),
+ cx,
+ )
+ .and_then(|d| d.note.as_ref())
+ .map(|n| n.id)
+ })
+ .unwrap_or_else(|| cx.default_global::().next_note_id());
+ let after = after.as_ref().map(|text| Body {
+ message: text.into(),
+ region: *region_after,
+ kind: *kind_after,
+ });
+ Self::put(id, location, after, origin, cx);
+ }
+
+ /// Stamp for a note being filed or reworded at `at`: the local time to the minute, and whoever
+ /// the archivist has told the app they are.
+ fn stamp(at: i64, cx: &App) -> Filed {
+ let date = settings::history::local_times(&[at])
+ .pop()
+ .map(|(day, time)| format!("{day} {time}").into());
+ let author = settings::history::author(cx).map(SharedString::from);
+ Filed { date, author }
+ }
+
+ /// Every note write ends here: note `id` becomes `after` — filed at `location` if it is new,
+ /// removed if `after` is `None` — then logged and saved together. Writes straight through to
+ /// `__notes`: this is a deliberate act, not the hot path the debounced setting writer exists for.
+ fn put(id: NoteId, location: Location, after: Option, origin: Origin, cx: &mut App) {
+ let author = settings::history::author(cx);
+ let before = Self::body(id, cx).map(|(_, body)| body);
+ if before == after {
+ return;
+ }
+ let entry = Entry::new(origin, Vec::new(), author);
+ let stamp = Self::stamp(entry.at, cx);
let this = cx.default_global::();
- this.items
- .retain(|d| d.source != Source::Note || d.location != location);
- if !message.trim().is_empty() {
- this.items.push(Diagnostic {
+ let at = this
+ .items
+ .iter()
+ .position(|d| d.note.as_ref().is_some_and(|n| n.id == id));
+ let logged = (location.dataset == DATASET_MAIN).then(|| {
+ let change = Change::Note {
+ row: location.row_id,
+ column: location.column.as_ref().map(|c| c.to_string()),
+ before: before.as_ref().map(|b| b.message.to_string()),
+ after: after.as_ref().map(|b| b.message.to_string()),
+ id: Some(id),
+ region_before: before.as_ref().and_then(|b| b.region),
+ region_after: after.as_ref().and_then(|b| b.region),
+ kind_before: before.as_ref().and_then(|b| b.kind),
+ kind_after: after.as_ref().and_then(|b| b.kind),
+ };
+ Entry {
+ changes: vec![change],
+ ..entry
+ }
+ });
+ let reworded = before
+ .as_ref()
+ .zip(after.as_ref())
+ .is_some_and(|(b, a)| b.message != a.message || b.kind != a.kind);
+ match (at, after) {
+ // In place, keeping its severity and its original filing stamp: correcting a
+ // transcription is not re-observing the item.
+ (Some(ix), Some(body)) => {
+ let d = &mut this.items[ix];
+ d.message = body.message;
+ if let Some(note) = d.note.as_mut() {
+ note.region = body.region;
+ note.kind = body.kind;
+ if reworded {
+ note.edited = Some(stamp);
+ }
+ }
+ }
+ (Some(ix), None) => {
+ this.items.remove(ix);
+ }
+ (None, Some(body)) => this.items.push(Diagnostic {
location,
severity: Severity::Note,
source: Source::Note,
- message,
+ message: body.message,
group: None,
- filed,
- });
+ note: Some(NoteMeta {
+ id,
+ filed: Some(stamp),
+ region: body.region,
+ kind: body.kind,
+ edited: None,
+ }),
+ }),
+ (None, None) => {}
}
this.reindex();
- this.persist(&logged);
+ this.persist(logged.as_slice());
}
/// Rebind authored notes to the current source positions after a structural edit or its undo.
@@ -576,7 +808,7 @@ impl Diagnostics {
row_ids: &[settings::project::RowId],
origin: Origin,
cx: &mut App,
- ) {
+ ) -> Vec {
let author = settings::history::author(cx);
let positions: HashMap<_, _> = row_ids
.iter()
@@ -601,6 +833,11 @@ impl Diagnostics {
column: item.location.column.as_ref().map(|c| c.to_string()),
before: Some(item.message.to_string()),
after: None,
+ id: item.note.as_ref().map(|n| n.id),
+ region_before: item.note.as_ref().and_then(|n| n.region),
+ region_after: None,
+ kind_before: item.note.as_ref().and_then(|n| n.kind),
+ kind_after: None,
});
return false;
};
@@ -611,11 +848,12 @@ impl Diagnostics {
if changed {
let logged = match dropped.is_empty() {
true => Vec::new(),
- false => vec![Entry::new(origin, dropped, author)],
+ false => vec![Entry::new(origin, dropped.clone(), author)],
};
this.reindex();
this.persist(&logged);
}
+ dropped
}
/// Follow a column rename, which re-keys every note addressed to the old name.
@@ -640,21 +878,25 @@ impl Diagnostics {
.items
.iter()
.filter(|d| d.source == Source::Note)
- .map(|d| settings::project::StoredNote {
+ .filter_map(|d| Some((d, d.note.as_ref()?)))
+ .map(|(d, note)| settings::project::StoredNote {
dataset: d.location.dataset.to_string(),
row: d.location.row,
row_id: d.location.row_id,
column: d.location.column.as_ref().map(|c| c.to_string()),
severity: d.severity.key().into(),
message: d.message.to_string(),
- created_at: d
+ created_at: note
.filed
.as_ref()
.and_then(|f| f.date.as_ref().map(SharedString::to_string)),
- author: d
+ author: note
.filed
.as_ref()
.and_then(|f| f.author.as_ref().map(SharedString::to_string)),
+ id: note.id,
+ region: note.region,
+ kind: note.kind,
})
.collect();
if let Err(err) = settings::project::write_notes(file, SOURCE_NOTE, ¬es, history) {
@@ -686,6 +928,9 @@ fn load_project_notes(cx: &mut App) {
}
let stored = settings::project::read_notes(&file).unwrap_or_default();
+ let edits = settings::history::note_edits(&file)
+ .inspect_err(|err| log::warn!("could not read when notes were last edited: {err}"))
+ .unwrap_or_default();
cx.default_global::().loaded = Some(file);
// Republished under `Source::Note`, exactly as if a note had just been attached, so the
@@ -703,13 +948,22 @@ fn load_project_notes(cx: &mut App) {
source: Source::Note,
message: n.message.clone().into(),
group: None,
- filed: match (&n.created_at, &n.author) {
- (None, None) => None,
- (date, author) => Some(Filed {
- date: date.clone().map(SharedString::from),
+ note: Some(NoteMeta {
+ id: n.id,
+ filed: match (&n.created_at, &n.author) {
+ (None, None) => None,
+ (date, author) => Some(Filed {
+ date: date.clone().map(SharedString::from),
+ author: author.clone().map(SharedString::from),
+ }),
+ },
+ region: n.region,
+ kind: n.kind,
+ edited: edits.get(&n.id).map(|(date, author)| Filed {
+ date: Some(date.clone().into()),
author: author.clone().map(SharedString::from),
}),
- },
+ }),
})
.collect();
Diagnostics::set(&Source::Note, DATASET_MAIN, items, cx);
@@ -740,7 +994,10 @@ mod tests {
// Never `use super::*` here: this module's parent has `use gpui::*` in scope transitively,
// and the chained glob makes gpui's `test` macro shadow the `#[test]` its own expansion
// emits, recursing until rustc's stack overflows.
- use crate::{DATASET_MAIN, Diagnostic, Diagnostics, Filed, Location, Severity, Source, init};
+ use crate::{
+ DATASET_MAIN, Diagnostic, Diagnostics, Filed, Location, NoteKind, Region, Severity, Source,
+ init,
+ };
use gpui::{App, SharedString, TestAppContext};
use settings::history::Origin;
use settings::project::{CurrentProject, ProjectData, ProjectSpec, StoredNote};
@@ -797,8 +1054,22 @@ mod tests {
row_id: None,
column: column.map(Into::into),
};
- Diagnostics::add_note(at(Some("Date taken")), "1962 is a guess".into(), cx);
- Diagnostics::add_note(at(None), "whole print is faded".into(), cx);
+ Diagnostics::file_note(
+ at(Some("Date taken")),
+ None,
+ None,
+ "1962 is a guess".into(),
+ Origin::Typed,
+ cx,
+ );
+ Diagnostics::file_note(
+ at(None),
+ None,
+ None,
+ "whole print is faded".into(),
+ Origin::Typed,
+ cx,
+ );
assert_eq!(
Diagnostics::notes_at(DATASET_MAIN, Some(3), None, cx).count(),
@@ -830,13 +1101,14 @@ mod tests {
source,
message: msg.into(),
group: None,
- filed: None,
+ note: None,
}
}
- /// An item accumulates observations over decades. `add_note` files another beside the ones
- /// already there; `set_note` corrects a single one and — the part worth pinning — keeps its
- /// original filing stamp, because fixing a typo is not re-observing the object in 2026.
+ /// An item accumulates observations over decades. `file_note` files another beside the ones
+ /// already there; `set_note` corrects a single one and — the part worth pinning — leaves the
+ /// others alone and keeps its original filing stamp, because fixing a typo is not re-observing
+ /// the object in 2026.
#[gpui::test]
fn notes_accumulate_and_a_correction_keeps_its_original_date(cx: &mut TestAppContext) {
cx.update(|cx| {
@@ -848,12 +1120,16 @@ mod tests {
};
let filed = |cx: &App| {
Diagnostics::notes_at(DATASET_MAIN, Some(1), None, cx)
- .map(|d| (d.message.to_string(), d.filed.clone()))
+ .map(|d| {
+ let filed = d.note.as_ref().and_then(|n| n.filed.clone());
+ (d.message.to_string(), filed)
+ })
.collect::>()
};
- Diagnostics::add_note(cell.clone(), "verso inscription".into(), cx);
- Diagnostics::add_note(cell.clone(), "same backdrop as row 12".into(), cx);
+ for text in ["verso inscription", "same backdrop as row 12"] {
+ Diagnostics::file_note(cell.clone(), None, None, text.into(), Origin::Typed, cx);
+ }
assert_eq!(
Diagnostics::notes_at(DATASET_MAIN, Some(1), None, cx).count(),
2,
@@ -865,9 +1141,12 @@ mod tests {
date: Some("1998-03-04".into()),
author: Some("MA".into()),
});
- cx.default_global::().items[0].filed = original.clone();
+ cx.default_global::().items[0]
+ .note
+ .as_mut()
+ .unwrap()
+ .filed = original.clone();
- // set_note collapses to one and keeps that stamp.
Diagnostics::set_note(
cell,
"verso inscription, in pencil".into(),
@@ -875,8 +1154,13 @@ mod tests {
cx,
);
let notes = filed(cx);
- assert_eq!(notes.len(), 1, "a correction replaces rather than adds");
+ assert_eq!(
+ notes.len(),
+ 2,
+ "a correction touches only the note it corrects"
+ );
assert_eq!(notes[0].0, "verso inscription, in pencil");
+ assert_eq!(notes[1].0, "same backdrop as row 12");
assert_eq!(
notes[0].1, original,
"the filing date is not moved to today"
@@ -884,6 +1168,88 @@ mod tests {
});
}
+ /// A note on part of the image shares its row's location with the row's own note, so the grid's
+ /// editor must never reach it: editing or deleting the row note leaves the region where it was.
+ /// Moving the region, deleting it, and restoring it all go by id, and each is logged.
+ #[gpui::test]
+ fn a_region_note_is_addressed_by_id_alone(cx: &mut TestAppContext) {
+ cx.update(|cx| {
+ let row = Location {
+ dataset: DATASET_MAIN.into(),
+ row: Some(2),
+ row_id: Some(3),
+ column: None,
+ };
+ let stamp = Region {
+ page: 1,
+ x: 6000,
+ y: 7000,
+ w: 1500,
+ h: 1200,
+ of: None,
+ };
+ let id = Diagnostics::file_note(
+ row.clone(),
+ Some(stamp),
+ Some(NoteKind::Transcription),
+ "customs stamp, Lisbon".into(),
+ Origin::Typed,
+ cx,
+ )
+ .unwrap();
+ Diagnostics::set_note(row.clone(), "faded".into(), Origin::Typed, cx);
+ Diagnostics::set_note(row.clone(), "".into(), Origin::Clear, cx);
+ assert_eq!(Diagnostics::note_at(DATASET_MAIN, Some(2), None, cx), None);
+ let region = |cx: &App| Diagnostics::note(id, cx).and_then(|d| d.note.as_ref()?.region);
+ assert_eq!(
+ region(cx),
+ Some(stamp),
+ "the row note's edits never touched it"
+ );
+
+ let moved = Region { x: 5000, ..stamp };
+ Diagnostics::move_note(id, moved, Origin::Drawn, cx);
+ assert_eq!(region(cx), Some(moved));
+ let edited =
+ |cx: &App| Diagnostics::note(id, cx).and_then(|d| d.note.as_ref()?.edited.clone());
+ assert_eq!(edited(cx), None, "a move is not a rewording");
+ Diagnostics::edit_note(
+ id,
+ "customs stamp, Lisbon 1931".into(),
+ Some(NoteKind::Transcription),
+ Origin::Typed,
+ cx,
+ );
+ assert!(edited(cx).is_some_and(|e| e.date.is_some()));
+
+ Diagnostics::edit_note(id, "".into(), None, Origin::Clear, cx);
+ assert!(Diagnostics::note(id, cx).is_none());
+
+ // The deletion's inverse, as a restore replays it, files it back under the same id.
+ let deleted = settings::history::Change::Note {
+ row: Some(3),
+ column: None,
+ before: Some("customs stamp, Lisbon".into()),
+ after: None,
+ id: Some(id),
+ region_before: Some(moved),
+ region_after: None,
+ kind_before: Some(NoteKind::Transcription),
+ kind_after: None,
+ };
+ Diagnostics::apply_note(row, &deleted.inverse(), Origin::Restore(1), cx);
+ assert_eq!(region(cx), Some(moved));
+ assert_eq!(
+ Diagnostics::note(id, cx).and_then(|d| d.note.as_ref()?.kind),
+ Some(NoteKind::Transcription)
+ );
+ assert_eq!(
+ Diagnostics::note(id, cx).map(|d| d.message.as_ref()),
+ Some("customs stamp, Lisbon")
+ );
+ });
+ }
+
/// Both halves are optional, and a note with neither must not render an empty byline.
#[test]
fn a_filing_stamp_reads_as_whichever_halves_exist() {
@@ -932,6 +1298,9 @@ mod tests {
message: "check this".into(),
created_at: None,
author: None,
+ id: 1,
+ region: None,
+ kind: None,
},
StoredNote {
dataset: DATASET_MAIN.into(),
@@ -942,6 +1311,9 @@ mod tests {
message: "whole row".into(),
created_at: None,
author: None,
+ id: 2,
+ region: None,
+ kind: None,
},
],
&[],
@@ -1050,7 +1422,7 @@ mod tests {
source: v.clone(),
message: "typo".into(),
group: None,
- filed: None,
+ note: None,
}],
cx,
);
@@ -1253,4 +1625,78 @@ mod tests {
assert!(Diagnostics::ignored(cx).is_empty());
});
}
+
+ /// Restoring an annotation's entry puts it back as the entry found it: a move undone, and a
+ /// deleted note back under its own id.
+ #[gpui::test]
+ fn restoring_a_note_change_puts_the_annotation_back(cx: &mut TestAppContext) {
+ cx.update(|cx| {
+ let location = Location {
+ dataset: DATASET_MAIN.into(),
+ row: Some(0),
+ row_id: Some(9),
+ column: None,
+ };
+ let stamp = Region {
+ page: 0,
+ x: 100,
+ y: 100,
+ w: 500,
+ h: 500,
+ of: None,
+ };
+ let id = Diagnostics::file_note(
+ location,
+ Some(stamp),
+ Some(NoteKind::Question),
+ "stamp".into(),
+ Origin::Drawn,
+ cx,
+ )
+ .unwrap();
+ let moved = Region { x: 900, ..stamp };
+ Diagnostics::move_note(id, moved, Origin::Drawn, cx);
+ let change =
+ |before: Option<&str>, region_before, after: Option<&str>, region_after| {
+ settings::history::Change::Note {
+ row: Some(9),
+ column: None,
+ before: before.map(Into::into),
+ after: after.map(Into::into),
+ id: Some(id),
+ region_before,
+ region_after,
+ kind_before: Some(NoteKind::Question),
+ kind_after: Some(NoteKind::Question),
+ }
+ };
+ let region = |cx: &App| Diagnostics::note(id, cx).and_then(|d| d.note.as_ref()?.region);
+
+ Diagnostics::restore_note(
+ &change(Some("stamp"), Some(stamp), Some("stamp"), Some(moved)),
+ Some(0),
+ None,
+ 1,
+ cx,
+ );
+ assert_eq!(region(cx), Some(stamp));
+
+ Diagnostics::edit_note(id, SharedString::default(), None, Origin::Drawn, cx);
+ assert!(Diagnostics::note(id, cx).is_none());
+ Diagnostics::restore_note(
+ &change(Some("stamp"), Some(stamp), None, None),
+ Some(0),
+ None,
+ 2,
+ cx,
+ );
+ let back = Diagnostics::note(id, cx).expect("the deleted note is back");
+ assert_eq!(back.message, SharedString::from("stamp"));
+ assert_eq!(
+ back.note.as_ref().and_then(|n| n.kind),
+ Some(NoteKind::Question)
+ );
+ assert_eq!(region(cx), Some(stamp));
+ });
+ }
}
diff --git a/crates/diagnostics/src/note_card.rs b/crates/diagnostics/src/note_card.rs
new file mode 100644
index 00000000..0f9985d1
--- /dev/null
+++ b/crates/diagnostics/src/note_card.rs
@@ -0,0 +1,192 @@
+//! The note hover card: one note whole, then who filed it and when. The viewer shows it on a region
+//! and the grid on a cell; each caller only decides where it goes.
+
+use std::rc::Rc;
+
+use gpui::prelude::FluentBuilder as _;
+use gpui::{
+ AnyElement, App, InteractiveElement as _, IntoElement, ParentElement, SharedString,
+ StatefulInteractiveElement as _, Styled, Window, div, px,
+};
+use gpui_component::{ActiveTheme, Icon, IconName, Sizable as _, h_flex, v_flex};
+
+use crate::{Diagnostic, NoteKind, Severity, severity_color};
+
+pub const WIDTH: f32 = 280.;
+
+/// The muted line under a note: its author or "Unsigned", when it was filed, and "edited" once it
+/// has been reworded.
+pub fn byline(note: &Diagnostic) -> SharedString {
+ let meta = note.note.as_ref();
+ let filed = meta.and_then(|n| n.filed.as_ref());
+ let author = filed
+ .and_then(|f| f.author.clone())
+ .unwrap_or_else(|| "Unsigned".into());
+ [
+ Some(author),
+ filed.and_then(|f| f.date.clone()),
+ meta.and_then(|n| n.edited.as_ref())
+ .map(|_| "edited".into()),
+ ]
+ .into_iter()
+ .flatten()
+ .collect::>()
+ .join(" · ")
+ .into()
+}
+
+/// The kinds a note can be, as chips with `current` lit. A note nobody gave a kind is a plain
+/// note, and picking that one hands `pick` `None` so it stays stored that way.
+pub fn kind_chips(
+ current: Option,
+ pick: impl Fn(Option, &mut Window, &mut App) + 'static,
+ cx: &App,
+) -> AnyElement {
+ let theme = cx.theme();
+ let pick = Rc::new(pick);
+ h_flex()
+ .gap_1()
+ .children(NoteKind::ALL.map(|kind| {
+ let pick = pick.clone();
+ div()
+ .id(kind.key())
+ .h(px(20.))
+ .px_2()
+ .flex()
+ .items_center()
+ .rounded(px(10.))
+ .border_1()
+ .text_xs()
+ .cursor_pointer()
+ .map(|chip| match current.unwrap_or(NoteKind::Note) == kind {
+ true => chip
+ .bg(theme.primary.opacity(0.14))
+ .text_color(theme.primary)
+ .border_color(theme.primary.opacity(0.5)),
+ false => chip
+ .text_color(theme.muted_foreground)
+ .border_color(theme.border),
+ })
+ .child(kind.label())
+ .on_click(move |_, window, cx| {
+ pick((kind != NoteKind::Note).then_some(kind), window, cx)
+ })
+ }))
+ .into_any_element()
+}
+
+/// `note` over its [`byline`]. What a cell's tooltip used to say — the column's `description` and
+/// the validators' `findings` — follows under a divider, so the note always reads first.
+pub fn note_card(
+ note: &Diagnostic,
+ description: Option,
+ findings: Vec<(Severity, SharedString)>,
+ cx: &App,
+) -> AnyElement {
+ let theme = cx.theme();
+ let extra = description.is_some() || !findings.is_empty();
+ v_flex()
+ .w(px(WIDTH))
+ .gap_1()
+ .px_2p5()
+ .py_2()
+ .bg(theme.popover)
+ .text_color(theme.popover_foreground)
+ .border_1()
+ .border_color(theme.border)
+ .rounded(px(6.))
+ .shadow_md()
+ .text_size(px(13.))
+ .line_height(px(18.))
+ .child(div().whitespace_normal().child(note.message.clone()))
+ .child(
+ div()
+ .text_xs()
+ .line_height(px(16.))
+ .text_color(theme.muted_foreground)
+ .child(byline(note)),
+ )
+ .when(extra, |card| {
+ card.child(
+ v_flex()
+ .gap_1()
+ .mt_1()
+ .pt_1p5()
+ .border_t_1()
+ .border_color(theme.border)
+ .text_xs()
+ .line_height(px(16.))
+ .children(description.map(|description| {
+ div().text_color(theme.muted_foreground).child(description)
+ }))
+ .children(findings.into_iter().map(|(severity, message)| {
+ h_flex()
+ .items_start()
+ .gap_1p5()
+ .child(
+ Icon::new(match severity {
+ Severity::Error => IconName::CircleX,
+ Severity::Warning => IconName::TriangleAlert,
+ Severity::Note => IconName::Info,
+ })
+ .small()
+ .flex_none()
+ .mt(px(1.))
+ .text_color(severity_color(severity, cx)),
+ )
+ .child(div().flex_1().min_w_0().child(message))
+ })),
+ )
+ })
+ .into_any_element()
+}
+
+#[cfg(test)]
+mod tests {
+ use gpui::SharedString;
+
+ use crate::note_card::byline;
+ use crate::{DATASET_MAIN, Diagnostic, Filed, Location, NoteMeta, Severity, Source};
+
+ fn note(author: Option<&str>, date: Option<&str>, edited: bool) -> Diagnostic {
+ Diagnostic {
+ location: Location {
+ dataset: DATASET_MAIN.into(),
+ row: Some(0),
+ row_id: Some(1),
+ column: None,
+ },
+ severity: Severity::Note,
+ source: Source::Note,
+ message: "Studio stamp".into(),
+ group: None,
+ note: Some(NoteMeta {
+ id: 1,
+ filed: Some(Filed {
+ date: date.map(SharedString::from),
+ author: author.map(SharedString::from),
+ }),
+ region: None,
+ kind: None,
+ edited: edited.then(|| Filed {
+ date: Some("2026-10-01 16:05".into()),
+ author: None,
+ }),
+ }),
+ }
+ }
+
+ /// Who, when, and whether it changed since — an unsigned note says so rather than leaving a
+ /// blank where a name would be.
+ #[test]
+ fn the_byline_names_the_author_or_says_unsigned() {
+ assert_eq!(
+ byline(¬e(Some("Ravi Kapoor"), Some("2026-09-30 10:12"), true)),
+ "Ravi Kapoor · 2026-09-30 10:12 · edited"
+ );
+ assert_eq!(
+ byline(¬e(None, Some("2026-10-02 09:30"), false)),
+ "Unsigned · 2026-10-02 09:30"
+ );
+ }
+}
diff --git a/crates/diagnostics/src/panel.rs b/crates/diagnostics/src/panel.rs
index 632edfe0..a07d1693 100644
--- a/crates/diagnostics/src/panel.rs
+++ b/crates/diagnostics/src/panel.rs
@@ -6,12 +6,16 @@ use gpui::*;
use gpui_component::button::{Button, ButtonVariants as _};
use gpui_component::combobox::{Combobox, ComboboxEvent, ComboboxState};
use gpui_component::dock::{BasePanel, Panel, PanelEvent};
-use gpui_component::menu::{ContextMenuExt as _, PopupMenuItem};
+use gpui_component::menu::{ContextMenuExt as _, PopupMenu, PopupMenuItem};
use gpui_component::searchable_list::{SearchableListDelegate, SearchableListItem};
use gpui_component::tab::{Tab, TabBar};
use gpui_component::{
ActiveTheme as _, Icon, IconName, IndexPath, Selectable as _, Sizable as _, h_flex, v_flex,
};
+use window_wrapper::{
+ panel_headers::{PanelHeaderRegistry, PanelHeaders},
+ responsive_header::{HeaderMenu, HeaderStage},
+};
use crate::{
Diagnostic, DiagnosticHooks, Diagnostics, Location, Scope, Severity, Source, severity_color,
@@ -387,6 +391,7 @@ pub struct ProblemsPanel {
impl ProblemsPanel {
pub fn new(_window: &mut Window, cx: &mut Context) -> Self {
+ PanelHeaderRegistry::register::("ProblemsPanel", cx);
let mut this = Self {
focus_handle: cx.focus_handle(),
active: false,
@@ -510,44 +515,195 @@ impl BasePanel for ProblemsPanel {
}
}
-impl Panel for ProblemsPanel {
+impl ProblemsPanel {
+ fn header_menu(
+ &mut self,
+ menu: PopupMenu,
+ window: &mut Window,
+ cx: &mut Context,
+ include_filters: bool,
+ ) -> PopupMenu {
+ let panel = cx.entity().downgrade();
+ let menu = menu.when(include_filters, |menu| {
+ let filters = PopupMenu::build(window, cx, |menu, _, _| {
+ Filter::ALL
+ .into_iter()
+ .zip(self.counts)
+ .fold(menu, |menu, (filter, count)| {
+ let panel = panel.clone();
+ menu.item(
+ PopupMenuItem::new(format!("{} ({count})", filter.label()))
+ .checked(self.filter == filter)
+ .on_click(move |_, _, cx| {
+ panel
+ .update(cx, |this, cx| {
+ this.filter = filter;
+ this.refresh(cx);
+ cx.notify();
+ })
+ .ok();
+ }),
+ )
+ })
+ });
+ menu.item(PopupMenuItem::submenu("Show", filters))
+ });
+ let menu = menu.when(
+ self.filter != Filter::Notes && self.sources.len() > 1,
+ |menu| {
+ let sources = PopupMenu::build(window, cx, |menu, _, _| {
+ self.sources.iter().fold(menu, |menu, source| {
+ let panel = panel.clone();
+ let source = source.clone();
+ menu.item(
+ PopupMenuItem::new(source.clone())
+ .checked(!self.excluded_sources.contains(&source))
+ .on_click(move |_, _, cx| {
+ panel
+ .update(cx, |this, cx| {
+ if !this.excluded_sources.remove(&source) {
+ this.excluded_sources.insert(source.clone());
+ }
+ this.refresh(cx);
+ cx.notify();
+ })
+ .ok();
+ }),
+ )
+ })
+ });
+ menu.item(PopupMenuItem::submenu("Sources", sources))
+ },
+ );
+ menu.when(
+ self.filter != Filter::Notes && (self.ignored_count > 0 || self.show_ignored),
+ |menu| {
+ menu.item(
+ PopupMenuItem::new(format!("Show ignored ({})", self.ignored_count))
+ .checked(self.show_ignored)
+ .on_click(move |_, _, cx| {
+ panel
+ .update(cx, |this, cx| {
+ this.show_ignored = !this.show_ignored;
+ this.refresh(cx);
+ cx.notify();
+ })
+ .ok();
+ }),
+ )
+ },
+ )
+ }
+
// The filter tabs sit in the title (the bar's stretching slot, so they stay left) and the
// source picker in the suffix, so the list starts right under the title bar.
- fn title(&mut self, _w: &mut Window, cx: &mut Context) -> impl IntoElement {
- h_flex().items_center().gap_3().child("Problems").child(
- TabBar::new("problems-filter")
- .segmented()
- .xsmall()
- .selected_index(
- Filter::ALL
- .iter()
- .position(|f| *f == self.filter)
- .unwrap_or(0),
- )
- .children(Filter::ALL.iter().zip(self.counts).map(|(f, n)| {
- // The same icon and colour the rows of that severity carry.
- let icon = match f {
- Filter::All => Icon::new(IconName::Menu),
- Filter::Errors => Icon::new(IconName::CircleX)
- .text_color(severity_color(Severity::Error, cx)),
- Filter::Warnings => Icon::new(IconName::TriangleAlert)
- .text_color(severity_color(Severity::Warning, cx)),
- Filter::Notes => Icon::new(IconName::Info),
- };
- Tab::new().aria_label(f.label()).child(
- h_flex()
- .items_center()
- .gap_1()
- .child(icon.xsmall())
- .child(format!("{} ({n})", f.label())),
+ fn header_tabs(&mut self, names: bool, cx: &mut Context) -> AnyElement {
+ h_flex()
+ .items_center()
+ .gap_3()
+ .child("Problems")
+ .child(
+ TabBar::new("problems-filter")
+ .segmented()
+ .xsmall()
+ .selected_index(
+ Filter::ALL
+ .iter()
+ .position(|f| *f == self.filter)
+ .unwrap_or(0),
)
- }))
- .on_click(cx.listener(|this, ix: &usize, _w, cx| {
- this.filter = Filter::ALL[*ix];
- this.refresh(cx);
- cx.notify();
- })),
- )
+ .children(Filter::ALL.iter().zip(self.counts).map(|(f, n)| {
+ // The same icon and colour the rows of that severity carry.
+ let icon = match f {
+ Filter::All => Icon::new(IconName::Menu),
+ Filter::Errors => Icon::new(IconName::CircleX)
+ .text_color(severity_color(Severity::Error, cx)),
+ Filter::Warnings => Icon::new(IconName::TriangleAlert)
+ .text_color(severity_color(Severity::Warning, cx)),
+ Filter::Notes => Icon::new(IconName::Info),
+ };
+ let label = f.label();
+ Tab::new().aria_label(label).child(
+ div()
+ .id(label)
+ .when(!names, |content| {
+ content.tooltip(move |window, cx| {
+ gpui_component::tooltip::Tooltip::new(label)
+ .build(window, cx)
+ })
+ })
+ .child(h_flex().items_center().gap_1().child(icon.xsmall()).child(
+ if names {
+ format!("{label} ({n})")
+ } else {
+ n.to_string()
+ },
+ )),
+ )
+ }))
+ .on_click(cx.listener(|this, ix: &usize, _w, cx| {
+ this.filter = Filter::ALL[*ix];
+ this.refresh(cx);
+ cx.notify();
+ })),
+ )
+ .into_any_element()
+ }
+}
+
+impl PanelHeaders for ProblemsPanel {
+ fn header_stages(
+ &mut self,
+ defaults: Vec,
+ common_menu: HeaderMenu,
+ cx: &mut Context,
+ ) -> Vec {
+ let panel = cx.entity().downgrade();
+ let secondary_menu: HeaderMenu = Rc::new(move |menu, window, cx, focus| {
+ let menu = match panel.upgrade() {
+ Some(panel) => {
+ panel.update(cx, |panel, cx| panel.header_menu(menu, window, cx, false))
+ }
+ None => menu,
+ };
+ common_menu(menu, window, cx, focus)
+ });
+ let mut stages = vec![defaults[0].clone()];
+ // First move the secondary controls into the menu, then remove the tab names.
+ for names in [true, false] {
+ let panel = cx.entity().downgrade();
+ stages.push(
+ HeaderStage::new(move |_, cx| match panel.upgrade() {
+ Some(panel) => panel.update(cx, |panel, cx| {
+ panel.header_tabs(names, cx).into_any_element()
+ }),
+ None => div().into_any_element(),
+ })
+ .with_menu(secondary_menu.clone()),
+ );
+ }
+ stages.push(
+ defaults
+ .last()
+ .expect("default header has a compact stage")
+ .clone(),
+ );
+ stages
+ }
+}
+
+impl Panel for ProblemsPanel {
+ fn dropdown_menu(
+ &mut self,
+ menu: PopupMenu,
+ window: &mut Window,
+ cx: &mut Context,
+ ) -> PopupMenu {
+ self.header_menu(menu, window, cx, true)
+ }
+
+ fn title(&mut self, _window: &mut Window, cx: &mut Context) -> impl IntoElement {
+ self.header_tabs(true, cx)
}
fn title_suffix(
@@ -988,7 +1144,7 @@ mod tests {
summary: "misspelled: recieve".into(),
subject: Some("recieve".into()),
}),
- filed: None,
+ note: None,
})
.collect()
}
@@ -1245,7 +1401,7 @@ mod tests {
source: Source::Note,
message: "m".into(),
group: None,
- filed: None,
+ note: None,
})
.collect(),
cx,
@@ -1263,7 +1419,7 @@ mod tests {
source: Source::Validator("test".into()),
message: "computed".into(),
group: None,
- filed: None,
+ note: None,
};
assert!(Filter::All.admits(&computed));
assert!(!Filter::Notes.admits(&computed));
@@ -1316,7 +1472,7 @@ mod tests {
source: Source::Validator(source.into()),
message: "m".into(),
group: None,
- filed: None,
+ note: None,
})
.collect(),
cx,
@@ -1331,7 +1487,7 @@ mod tests {
source: Source::Note,
message: "user note".into(),
group: None,
- filed: None,
+ note: None,
}],
cx,
);
diff --git a/crates/diagnostics/src/validator.rs b/crates/diagnostics/src/validator.rs
index 3c192f6e..b6ed883b 100644
--- a/crates/diagnostics/src/validator.rs
+++ b/crates/diagnostics/src/validator.rs
@@ -563,7 +563,7 @@ pub fn address(
source: Source::Validator(validator.clone()),
message: finding.message,
group: finding.group,
- filed: None,
+ note: None,
})
.collect()
}
diff --git a/crates/preview/src/crop.rs b/crates/preview/src/crop.rs
new file mode 100644
index 00000000..9e3cfd41
--- /dev/null
+++ b/crates/preview/src/crop.rs
@@ -0,0 +1,170 @@
+//! A note card's picture of its region: that part of the page, cut from the capped copy a card or
+//! the Details pane already decodes, and held only in memory.
+
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+use gpui::{App, Asset, ImageCacheError, ImageSource, RenderImage, Window};
+use image::Frame;
+
+/// The longest edge a crop is cut to: twice the largest card that draws one.
+const EDGE: u32 = 112;
+/// How much of the page's shorter side a pin's crop shows around it.
+const AROUND_PIN: f32 = 0.15;
+const SCALE: f32 = 10_000.;
+
+/// File, page, area, decoder generation, and file identity.
+type Key = (PathBuf, usize, [u16; 4], u64, Option);
+
+pub struct Crop;
+
+impl Asset for Crop {
+ type Source = Key;
+ type Output = Option>;
+
+ fn load(
+ (path, page, area, _, _): Self::Source,
+ cx: &mut App,
+ ) -> impl Future