137 lines
4.7 KiB
Rust
137 lines
4.7 KiB
Rust
//! The speaker notes under the slide (SHOW-08).
|
|
|
|
use ely_gpui_component::{
|
|
feedback::InlineMessage,
|
|
forms::{Input, InputEvent, TextInput},
|
|
primitives::Severity,
|
|
theme::ActiveTheme as _,
|
|
};
|
|
use ely_office::prelude::*;
|
|
use gpui::{
|
|
AnyElement, AppContext as _, Context, Entity, Focusable as _, IntoElement, ParentElement as _,
|
|
Styled as _, Window, div, px,
|
|
};
|
|
|
|
use crate::deck::Deck;
|
|
|
|
/// The notes field and its last tab, slide, text.
|
|
#[derive(Default)]
|
|
pub struct NotesField {
|
|
field: Option<Entity<TextInput>>,
|
|
shown: Option<(u64, usize, String)>,
|
|
/// The state the shown slide number was read in.
|
|
pub(crate) at: Option<ely_lok::Doc>,
|
|
_events: Option<gpui::Subscription>,
|
|
}
|
|
|
|
impl Deck {
|
|
fn notes_field(&mut self, window: &mut Window, cx: &mut Context<Self>) -> Entity<TextInput> {
|
|
if let Some(field) = &self.notes.field {
|
|
return field.clone();
|
|
}
|
|
let (label, hint) = (
|
|
Deck::text(cx, "show.notes.label", &[]),
|
|
Deck::text(cx, "show.notes.hint", &[]),
|
|
);
|
|
let field = cx.new(|cx| {
|
|
TextInput::new(window, cx)
|
|
.multi_line(3, 5)
|
|
.label(label)
|
|
.placeholder(hint)
|
|
});
|
|
let events = cx.subscribe(&field, |deck, _, event: &InputEvent, cx| {
|
|
if matches!(event, InputEvent::Blur) {
|
|
deck.commit_notes(cx)
|
|
}
|
|
});
|
|
self.notes = NotesField {
|
|
field: Some(field.clone()),
|
|
shown: None,
|
|
at: None,
|
|
_events: Some(events),
|
|
};
|
|
field
|
|
}
|
|
|
|
/// Sends typed notes to the slide they came from.
|
|
pub(crate) fn commit_notes(&mut self, cx: &mut Context<Self>) {
|
|
let (Some(field), Some((tab, part, shown))) = (&self.notes.field, &self.notes.shown) else {
|
|
return;
|
|
};
|
|
let (tab, part, text) = (*tab, *part, field.read(cx).text().to_string());
|
|
if &text == shown {
|
|
return;
|
|
}
|
|
let Some(at) = self.notes.at.clone() else {
|
|
return log::warn!("show: notes for slide {part} have no read state");
|
|
};
|
|
log::info!("show: notes for slide {part} changed");
|
|
// `shown` stays the kernel's until a read confirms the send.
|
|
self.run_on(tab, &at, "notes.set", &[&text, &part.to_string()], cx);
|
|
self.force_reread(tab, cx);
|
|
}
|
|
|
|
/// The notes field, showing the read notes unless typing.
|
|
pub(crate) fn notes_input(
|
|
&mut self,
|
|
window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) -> Option<Entity<TextInput>> {
|
|
let tab = self.active_tab()?;
|
|
let notes = tab.extra.notes.clone()?;
|
|
let (id, part) = (tab.id, notes.part?);
|
|
let field = self.notes_field(window, cx);
|
|
let typing = field.focus_handle(cx).is_focused(window);
|
|
// Typing keeps the state the slide number was read in.
|
|
if !typing {
|
|
self.notes.at = self.read_at(id, cx);
|
|
}
|
|
let read = (id, part, notes.text.clone());
|
|
if !typing && self.notes.shown.as_ref() != Some(&read) {
|
|
field.update(cx, |field, cx| field.set_text(notes.text, cx));
|
|
self.notes.shown = Some(read);
|
|
} else if let Some(shown) = self.notes.shown.as_mut().filter(|shown| (shown.0, shown.1) == (id, part)) {
|
|
// A read while typing moves the base, not the draft.
|
|
shown.2 = notes.text;
|
|
}
|
|
Some(field)
|
|
}
|
|
|
|
/// The notes pane: the field, or why it cannot edit.
|
|
pub fn notes_pane(
|
|
&mut self,
|
|
window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) -> Option<AnyElement> {
|
|
let notes = self.active_tab()?.extra.notes.clone()?;
|
|
let pane = div()
|
|
.h(px(120.0))
|
|
.flex_none()
|
|
.p_2()
|
|
.border_t_1()
|
|
.border_color(cx.theme().colors.border);
|
|
if !notes.editable {
|
|
let why = Deck::text(cx, "show.notes.none", &[]);
|
|
return Some(
|
|
pane.child(InlineMessage::new(Severity::Info, why))
|
|
.into_any_element(),
|
|
);
|
|
}
|
|
if notes.rich {
|
|
let why = Deck::text(cx, "show.notes.rich", &[]);
|
|
let text = div()
|
|
.text_color(cx.theme().colors.fg_muted)
|
|
.child(notes.text);
|
|
let column = div()
|
|
.flex()
|
|
.flex_col()
|
|
.gap_1()
|
|
.child(InlineMessage::new(Severity::Info, why))
|
|
.child(text);
|
|
return Some(pane.child(column).into_any_element());
|
|
}
|
|
let field = self.notes_input(window, cx)?;
|
|
Some(pane.child(Input::new(&field)).into_any_element())
|
|
}
|
|
}
|