256 lines
8.6 KiB
Rust
256 lines
8.6 KiB
Rust
use std::rc::Rc;
|
|
|
|
use gpui::{App, ClipboardItem, Entity, KeyDownEvent, Pixels, SharedString, Window};
|
|
|
|
use super::{
|
|
formula::filled,
|
|
grid::{Face, Metrics, OnCells, Sheet, Text, range},
|
|
};
|
|
use crate::forms::Editing;
|
|
|
|
/// Scrolls just enough that the cursor shows, past the frozen rows and columns.
|
|
pub(crate) fn reveal(sheet: &mut Sheet, metrics: Metrics, frozen: (usize, usize)) {
|
|
let (row, col) = sheet.cursor;
|
|
let room_x = sheet.bounds.size.width - metrics.label - metrics.frozen.x;
|
|
let room_y = sheet.bounds.size.height - metrics.tall - metrics.frozen.y;
|
|
if col >= frozen.1 {
|
|
let x = metrics.wide * col as f32 - metrics.frozen.x;
|
|
sheet.offset.x = sheet
|
|
.offset
|
|
.x
|
|
.min(x)
|
|
.max(x + metrics.wide - room_x)
|
|
.max(Pixels::ZERO);
|
|
}
|
|
if row >= frozen.0 {
|
|
let y = metrics.tall * row as f32 - metrics.frozen.y;
|
|
sheet.offset.y = sheet
|
|
.offset
|
|
.y
|
|
.min(y)
|
|
.max(y + metrics.tall - room_y)
|
|
.max(Pixels::ZERO);
|
|
}
|
|
}
|
|
|
|
/// Opens the cursor's cell with `text`; a kept edit reports and moves down.
|
|
pub(crate) fn begin(
|
|
sheet: &Entity<Sheet>,
|
|
editor: &Entity<Editing>,
|
|
on_change: Option<OnCells>,
|
|
text: String,
|
|
at_end: bool,
|
|
window: &mut Window,
|
|
cx: &mut App,
|
|
) {
|
|
let (cell, rows) = (sheet.read(cx).cursor, sheet.read(cx).rows);
|
|
let moved = sheet.clone();
|
|
editor.update(cx, |editing, _| {
|
|
editing.on_commit = Some(Rc::new(move |text, window, cx| {
|
|
log::info!("grid: {cell:?} is now {text}");
|
|
if let Some(on_change) = &on_change {
|
|
on_change(&[(cell.0, cell.1, text.clone())], window, cx);
|
|
}
|
|
moved.update(cx, |sheet, _| {
|
|
sheet.cursor.0 = (cell.0 + 1).min(rows.saturating_sub(1));
|
|
sheet.anchor = sheet.cursor;
|
|
});
|
|
}))
|
|
});
|
|
sheet.update(cx, |sheet, _| sheet.editing = true);
|
|
let end = text.len();
|
|
Editing::begin(editor, text, window, cx);
|
|
if at_end && let Some(field) = editor.read(cx).field() {
|
|
field.update(cx, |field, cx| field.select(end..end, cx));
|
|
}
|
|
}
|
|
|
|
/// Text for the clipboard: the range's cells as they show, tabs between, lines below.
|
|
fn copied(shown: &Text, sheet: &Sheet) -> String {
|
|
let ((top, left), (bottom, right)) = range(sheet);
|
|
(top..=bottom)
|
|
.map(|row| {
|
|
(left..=right)
|
|
.map(|col| shown(row, col).to_string())
|
|
.collect::<Vec<_>>()
|
|
.join("\t")
|
|
})
|
|
.collect::<Vec<_>>()
|
|
.join("\n")
|
|
}
|
|
|
|
/// Pasted text as cell edits from the cursor on, clipped to the grid.
|
|
pub(crate) fn pasted(
|
|
text: &str,
|
|
from: (usize, usize),
|
|
size: (usize, usize),
|
|
) -> Vec<(usize, usize, SharedString)> {
|
|
text.lines()
|
|
.enumerate()
|
|
.flat_map(|(dr, line)| {
|
|
line.split('\t').enumerate().map(move |(dc, cell)| {
|
|
(
|
|
from.0 + dr,
|
|
from.1 + dc,
|
|
SharedString::from(cell.to_string()),
|
|
)
|
|
})
|
|
})
|
|
.filter(|(row, col, _)| *row < size.0 && *col < size.1)
|
|
.collect()
|
|
}
|
|
|
|
/// The key handler: arrows walk and Shift stretches the range, Tab and Enter step, typing or F2 edits, Delete clears, Cmd-C and Cmd-V copy and paste.
|
|
pub(crate) fn keys(
|
|
face: Face,
|
|
metrics: Metrics,
|
|
sheet: Entity<Sheet>,
|
|
editor: Entity<Editing>,
|
|
) -> impl Fn(&KeyDownEvent, &mut Window, &mut App) + 'static {
|
|
move |event, window, cx| {
|
|
if sheet.read(cx).editing {
|
|
return;
|
|
}
|
|
let (rows, cols) = (face.rows, face.cols);
|
|
if rows == 0 || cols == 0 {
|
|
return;
|
|
}
|
|
let stroke = &event.keystroke;
|
|
let held = &stroke.modifiers;
|
|
let (row, col) = sheet.read(cx).cursor;
|
|
let to = match stroke.key.as_str() {
|
|
"up" => Some((row.saturating_sub(1), col)),
|
|
"down" | "enter" => Some(((row + 1).min(rows - 1), col)),
|
|
"left" => Some((row, col.saturating_sub(1))),
|
|
"right" => Some((row, (col + 1).min(cols - 1))),
|
|
"tab" if held.shift => Some((row, col.saturating_sub(1))),
|
|
"tab" => Some((row, (col + 1).min(cols - 1))),
|
|
"home" => Some((row, 0)),
|
|
"end" => Some((row, cols - 1)),
|
|
_ => None,
|
|
};
|
|
if let Some(to) = to {
|
|
cx.stop_propagation();
|
|
let stretch = held.shift && !matches!(stroke.key.as_str(), "tab" | "enter");
|
|
sheet.update(cx, |sheet, cx| {
|
|
sheet.cursor = to;
|
|
if !stretch {
|
|
sheet.anchor = to;
|
|
}
|
|
reveal(sheet, metrics, face.frozen);
|
|
cx.notify();
|
|
});
|
|
return;
|
|
}
|
|
match (stroke.key.as_str(), held.platform) {
|
|
("escape", _) => sheet.update(cx, |sheet, cx| {
|
|
sheet.anchor = sheet.cursor;
|
|
cx.notify();
|
|
}),
|
|
("f2", _) => begin(
|
|
&sheet,
|
|
&editor,
|
|
face.on_change.clone(),
|
|
(face.raw)(row, col).to_string(),
|
|
true,
|
|
window,
|
|
cx,
|
|
),
|
|
("backspace" | "delete", false) => {
|
|
let ((top, left), (bottom, right)) = range(sheet.read(cx));
|
|
let cleared: Vec<_> = (top..=bottom)
|
|
.flat_map(|row| {
|
|
(left..=right).map(move |col| (row, col, SharedString::default()))
|
|
})
|
|
.collect();
|
|
if let Some(on_change) = &face.on_change {
|
|
on_change(&cleared, window, cx);
|
|
}
|
|
}
|
|
("c", true) => cx.write_to_clipboard(ClipboardItem::new_string(copied(
|
|
&face.shown,
|
|
sheet.read(cx),
|
|
))),
|
|
("v", true) => {
|
|
let Some(text) = cx.read_from_clipboard().and_then(|item| item.text()) else {
|
|
return;
|
|
};
|
|
let edits = pasted(&text, (row, col), (rows, cols));
|
|
log::info!("grid: pasted {} cells", edits.len());
|
|
if let Some(on_change) = &face.on_change {
|
|
on_change(&edits, window, cx);
|
|
}
|
|
}
|
|
_ => {
|
|
let typed = stroke.key_char.clone().filter(|typed| {
|
|
!held.platform && !held.control && !typed.chars().any(char::is_control)
|
|
});
|
|
let Some(typed) = typed else {
|
|
return;
|
|
};
|
|
begin(
|
|
&sheet,
|
|
&editor,
|
|
face.on_change.clone(),
|
|
typed,
|
|
true,
|
|
window,
|
|
cx,
|
|
);
|
|
}
|
|
}
|
|
cx.stop_propagation();
|
|
}
|
|
}
|
|
|
|
/// Applies a fill: the range's runs carry on down, or across, to where the handle was dropped.
|
|
pub(crate) fn fill(
|
|
sheet: &Entity<Sheet>,
|
|
raw: &Text,
|
|
on_change: &Option<OnCells>,
|
|
window: &mut Window,
|
|
cx: &mut App,
|
|
) {
|
|
let Some((row, col)) = sheet.update(cx, |sheet, cx| {
|
|
cx.notify();
|
|
sheet.fill.take()
|
|
}) else {
|
|
return;
|
|
};
|
|
let ((top, left), (bottom, right)) = range(sheet.read(cx));
|
|
let mut edits = Vec::new();
|
|
if row > bottom {
|
|
for c in left..=right {
|
|
let run: Vec<SharedString> = (top..=bottom).map(|r| raw(r, c)).collect();
|
|
for (ix, text) in filled(&run, row - bottom, false).into_iter().enumerate() {
|
|
edits.push((bottom + 1 + ix, c, text));
|
|
}
|
|
}
|
|
} else if col > right {
|
|
for r in top..=bottom {
|
|
let run: Vec<SharedString> = (left..=right).map(|c| raw(r, c)).collect();
|
|
for (ix, text) in filled(&run, col - right, true).into_iter().enumerate() {
|
|
edits.push((r, right + 1 + ix, text));
|
|
}
|
|
}
|
|
}
|
|
log::info!("grid: filled {} cells", edits.len());
|
|
if let Some(on_change) = on_change.as_ref().filter(|_| !edits.is_empty()) {
|
|
on_change(&edits, window, cx);
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::pasted;
|
|
|
|
#[test]
|
|
fn pasted_text_lands_from_the_cursor_and_stops_at_the_edge() {
|
|
let edits: Vec<(usize, usize, String)> = pasted("a\tb\nc\td", (1, 1), (3, 2))
|
|
.into_iter()
|
|
.map(|(row, col, text)| (row, col, text.to_string()))
|
|
.collect();
|
|
assert_eq!(edits, [(1, 1, "a".into()), (2, 1, "c".into())]);
|
|
}
|
|
}
|