use std::ops::Range;
use super::*;
use crate::components::{
InlineObject, LinkClick, ParagraphKind, ParagraphStyles, RichText, SelectionStyle, SpanStyle, StyledChange,
StyledEdit, StyledSpan, StyledText, TextMark, styled_text as spans_ops,
};
type ChangeHandler = Arc<dyn Fn(&StyledChange) + Send + Sync>;
type CopyFormat = Arc<dyn Fn(&StyledText) -> String + Send + Sync>;
type LinkHandler = Arc<dyn Fn(&LinkClick) + Send + Sync>;
#[derive(Clone)]
struct SpansCache {
value_version: u64,
spans_version: u64,
spans: Arc<Vec<StyledSpan>>,
}
#[derive(Clone, Default)]
pub(super) struct StyledState {
spans: Option<Signal<Vec<StyledSpan>>>,
synced_version: u64,
cache: Option<SpansCache>,
paragraphs: Option<Signal<Vec<ParagraphKind>>>,
paragraph_styles: Option<Arc<ParagraphStyles>>,
paragraphs_synced: u64,
objects: Option<Signal<Vec<InlineObject>>>,
objects_synced: u64,
object_nodes: Arc<[InlineObject]>,
pending: Option<(usize, SpanStyle)>,
resizable_objects: bool,
resize: Option<ObjectResize>,
handle_hovered: bool,
on_change: Vec<ChangeHandler>,
copy_format: Option<CopyFormat>,
rich_clipboard: bool,
on_link_click: Vec<LinkHandler>,
}
impl StyledState {
pub(super) fn is_bound(&self) -> bool {
self.spans.is_some()
}
pub(super) fn copy_runtime_state_from(&mut self, old: &Self) {
if let (Some(new), Some(previous)) = (&self.spans, &old.spans)
&& new.id() == previous.id()
{
self.synced_version = old.synced_version;
self.cache = old.cache.clone();
}
if let (Some(new), Some(previous)) = (&self.paragraphs, &old.paragraphs)
&& new.id() == previous.id()
{
self.paragraphs_synced = old.paragraphs_synced;
}
if let (Some(new), Some(previous)) = (&self.objects, &old.objects)
&& new.id() == previous.id()
{
self.objects_synced = old.objects_synced;
}
self.pending = old.pending.clone();
self.resize = old.resize.clone();
self.handle_hovered = old.handle_hovered;
}
}
const OBJECT_HANDLE_REACH: f32 = 8.0;
const OBJECT_LEAST_WIDTH: f32 = 16.0;
#[derive(Clone)]
struct ObjectResize {
at: usize,
from_x: f32,
from_width: f32,
most: f32,
changed: bool,
}
pub(super) struct SpansBeforeEdit {
spans: Arc<Vec<StyledSpan>>,
style: SpanStyle,
paragraphs: Option<(SnapshotParagraphs, Vec<Range<usize>>)>,
objects: Option<SnapshotObjects>,
}
pub(super) type SnapshotSpans = Arc<Vec<StyledSpan>>;
pub(super) type SnapshotParagraphs = Arc<Vec<ParagraphKind>>;
pub(super) type SnapshotObjects = Arc<Vec<InlineObject>>;
pub(super) struct InsertedText<'a> {
pub(super) styled: &'a StyledText,
pub(super) kinds: Option<&'a [ParagraphKind]>,
pub(super) objects: &'a [InlineObject],
}
impl TextInputState {
pub(crate) fn set_spans_signal(&self, spans: Signal<Vec<StyledSpan>>) {
let mut inner = self.inner.lock();
if inner
.styled
.spans
.as_ref()
.is_some_and(|bound| bound.id() == spans.id())
{
return;
}
inner.styled.synced_version = spans.version();
inner.styled.cache = None;
inner.styled.spans = Some(spans);
drop(inner);
self.mark_layout_dirty_keeping_scroll();
}
pub(crate) fn set_paragraphs(&self, kinds: Signal<Vec<ParagraphKind>>, styles: ParagraphStyles) {
let mut inner = self.inner.lock();
let same_signal = inner
.styled
.paragraphs
.as_ref()
.is_some_and(|bound| bound.id() == kinds.id());
let same_styles = inner
.styled
.paragraph_styles
.as_ref()
.is_some_and(|held| **held == styles);
if same_signal && same_styles {
return;
}
if !same_signal {
inner.styled.paragraphs_synced = kinds.version();
inner.styled.paragraphs = Some(kinds);
}
if !same_styles {
inner.styled.paragraph_styles = Some(Arc::new(styles));
}
drop(inner);
self.mark_layout_dirty_keeping_scroll();
}
pub(crate) fn set_objects(&self, objects: Signal<Vec<InlineObject>>, built: Vec<InlineObject>) {
let mut inner = self.inner.lock();
let same_signal = inner
.styled
.objects
.as_ref()
.is_some_and(|bound| bound.id() == objects.id());
let same_nodes = inner.styled.object_nodes.as_ref() == built.as_slice();
if !same_signal {
inner.styled.objects_synced = objects.version();
inner.styled.objects = Some(objects);
}
if !same_nodes {
inner.styled.object_nodes = built.into();
}
drop(inner);
if !(same_signal && same_nodes) {
self.mark_layout_dirty_keeping_scroll();
}
}
pub(crate) fn current_objects(&self) -> Option<SnapshotObjects> {
let signal = {
let inner = self.inner.lock();
if inner.mask.is_some() || inner.styled.spans.is_none() {
return None;
}
inner.styled.objects.clone()?
};
let value = self.shared_value();
Some(Arc::new(signal.with_untracked(|objects| {
spans_ops::normalize_objects(&value, objects.clone())
})))
}
pub(crate) fn shown_objects(&self) -> Option<SnapshotObjects> {
let objects = self.current_objects()?;
let Some(composed) = self.composed_text() else {
return Some(objects);
};
let value = self.shared_value();
let (start, end) = self.selection_or_caret(&value);
let inserted = composed.len() + (end - start) - value.len();
Some(Arc::new(spans_ops::splice_objects(&objects, start..end, inserted)))
}
pub(crate) fn object_children(&self) -> Vec<Option<usize>> {
let Some(objects) = self.shown_objects() else {
return Vec::new();
};
let built = self.inner.lock().styled.object_nodes.clone();
let mut next = 0;
objects
.iter()
.map(|object| {
let found = next + built[next..].iter().position(|node| node.same_thing(object))?;
next = found + 1;
Some(found)
})
.collect()
}
pub(super) fn object_ranges(&self) -> Vec<Range<usize>> {
self
.current_objects()
.map(|objects| objects.iter().map(InlineObject::range).collect())
.unwrap_or_default()
}
pub(super) fn object_at_point(&self, x: f32, y: f32) -> Option<Range<usize>> {
let objects = self.current_objects().filter(|objects| !objects.is_empty())?;
let layout = self.token_layout()?;
let (x, y) = {
let inner = self.inner.lock();
(x + inner.scroll_x, y + inner.scroll_y())
};
let room = layout
.objects
.iter()
.find(|room| x >= room.x && x < room.x + room.width && y >= room.y && y < room.y + room.height)?;
objects
.iter()
.find(|object| object.at == room.byte)
.map(InlineObject::range)
}
pub(crate) fn set_resizable_objects(&self, resizable: bool) {
self.inner.lock().styled.resizable_objects = resizable;
}
pub(crate) fn resized_object(
&self,
) -> Option<(crate::app::glyph_engine::input_tokens::InputObjectBox, InlineObject)> {
if !self.inner.lock().styled.resizable_objects {
return None;
}
let (start, end) = self.selection_bounds()?;
let objects = self.current_objects()?;
let object = objects
.iter()
.find(|object| object.at == start && object.range().end == end)?
.clone();
let layout = self.token_layout()?;
let room = *layout.objects.iter().find(|room| room.byte == object.at)?;
Some((room, object))
}
fn object_handle_at(
&self,
x: f32,
y: f32,
) -> Option<(crate::app::glyph_engine::input_tokens::InputObjectBox, InlineObject)> {
let (room, object) = self.resized_object()?;
let (x, y) = {
let inner = self.inner.lock();
(x + inner.scroll_x, y + inner.scroll_y())
};
let near = |point: f32, corner: f32| (point - corner).abs() <= OBJECT_HANDLE_REACH;
(near(x, room.x + room.width) && near(y, room.y + room.height)).then_some((room, object))
}
pub(super) fn begin_object_resize(&self, x: f32, y: f32) -> bool {
self.inner.lock().styled.resize = None;
let Some((room, object)) = self.object_handle_at(x, y) else {
return false;
};
let most = self
.token_layout()
.map(|layout| layout.config.width)
.filter(|width| width.is_finite() && *width < 100_000.0)
.unwrap_or(f32::MAX);
let mut inner = self.inner.lock();
inner.styled.resize = Some(ObjectResize {
at: object.at,
from_x: x + inner.scroll_x,
from_width: room.width,
most,
changed: false,
});
true
}
pub(super) fn drag_object_resize(&self, x: f32) -> bool {
let (resize, scroll_x) = {
let inner = self.inner.lock();
let Some(resize) = inner.styled.resize.clone() else {
return false;
};
(resize, inner.scroll_x)
};
let least = OBJECT_LEAST_WIDTH.min(resize.most);
let width = (resize.from_width + x + scroll_x - resize.from_x).clamp(least, resize.most.max(least));
let width = width.round() as u32;
let Some(objects) = self.current_objects() else {
return true;
};
let Some(index) = objects.iter().position(|object| object.at == resize.at) else {
return true;
};
let held = objects[index].width.unwrap_or(resize.from_width.round() as u32);
if held == width {
return true;
}
if !resize.changed {
self.push_undo_snapshot();
if let Some(resize) = self.inner.lock().styled.resize.as_mut() {
resize.changed = true;
}
}
let mut changed = objects.to_vec();
changed[index].width = Some(width);
self.write_objects(changed);
self.mark_layout_dirty_keeping_scroll();
true
}
pub(crate) fn end_object_resize(&self) {
let Some(resize) = self.inner.lock().styled.resize.take() else {
return;
};
if !resize.changed {
return;
}
if let Some(spans) = self.current_spans() {
let range = resize.at..resize.at + crate::components::OBJECT_CHARACTER.len_utf8();
self.commit_spans(spans.to_vec(), StyledEdit::Style { range });
}
}
pub(super) fn hover_object_handle(&self, point: Option<(f32, f32)>) {
let on = point.is_some_and(|(x, y)| self.object_handle_at(x, y).is_some());
self.inner.lock().styled.handle_hovered = on;
}
pub(crate) fn object_handle_hovered(&self) -> bool {
let inner = self.inner.lock();
inner.styled.handle_hovered || inner.styled.resize.is_some()
}
fn write_objects(&self, objects: Vec<InlineObject>) {
let Some(signal) = self.inner.lock().styled.objects.clone() else {
return;
};
if signal.with_untracked(|current| *current != objects) {
signal.set(objects);
}
self.inner.lock().styled.objects_synced = signal.version();
}
pub(super) fn restore_objects(&self, objects: SnapshotObjects) {
self.write_objects(objects.to_vec());
}
fn splice_objects(&self, edit: &SpansBeforeEdit, range: &Range<usize>, inserted: usize, added: &[InlineObject]) {
let Some(objects) = &edit.objects else {
return;
};
let moved = spans_ops::splice_objects(objects, range.clone(), inserted);
let moved = spans_ops::place_objects(moved, range.start, added);
self.write_objects(spans_ops::normalize_objects(&self.shared_value(), moved));
}
pub(crate) fn insert_object(&self, object: &InlineObject, keyboard: &KeyboardEvent) -> bool {
if self.current_objects().is_none() {
return false;
}
let text = StyledText::plain(crate::components::OBJECT_CHARACTER.to_string());
let object = InlineObject {
at: 0,
..object.clone()
};
let insert = InsertedText {
styled: &text,
kinds: None,
objects: std::slice::from_ref(&object),
};
self.replace_selection_inserting(&insert, keyboard)
}
pub(crate) fn current_paragraphs(&self) -> Option<SnapshotParagraphs> {
let signal = {
let inner = self.inner.lock();
if inner.mask.is_some() || inner.styled.spans.is_none() {
return None;
}
inner.styled.paragraphs.clone()?
};
let count = spans_ops::paragraph_ranges(&self.shared_value()).len();
Some(Arc::new(
signal.with_untracked(|kinds| spans_ops::normalize_kinds(kinds.clone(), count)),
))
}
pub(crate) fn paragraph_display(&self) -> Option<(SnapshotParagraphs, Arc<ParagraphStyles>)> {
let styles = self.inner.lock().styled.paragraph_styles.clone()?;
let kinds = self.current_paragraphs()?;
let Some(composed) = self.composed_text() else {
return Some((kinds, styles));
};
let value = self.shared_value();
let (start, end) = self.selection_or_caret(&value);
let inserted = composed.len() + (end - start) - value.len();
let shown = spans_ops::splice_kinds(
&kinds,
&spans_ops::paragraph_ranges(&value),
&spans_ops::paragraph_ranges(&composed),
start..end,
inserted,
);
Some((Arc::new(shown), styles))
}
fn write_paragraphs(&self, kinds: Vec<ParagraphKind>) {
let Some(signal) = self.inner.lock().styled.paragraphs.clone() else {
return;
};
if signal.with_untracked(|current| *current != kinds) {
signal.set(kinds);
}
self.inner.lock().styled.paragraphs_synced = signal.version();
}
pub(super) fn restore_paragraphs(&self, kinds: SnapshotParagraphs) {
self.write_paragraphs(kinds.to_vec());
}
fn selected_paragraph_range(&self) -> (Range<usize>, Vec<Range<usize>>) {
let value = self.shared_value();
let ranges = spans_ops::paragraph_ranges(&value);
let (start, end) = self.selection_or_caret(&value);
let first = spans_ops::paragraph_of(&ranges, start);
let last = spans_ops::paragraph_of(&ranges, end);
(first..last + 1, ranges)
}
pub(crate) fn selected_paragraphs(&self) -> Option<Vec<ParagraphKind>> {
let kinds = self.current_paragraphs()?;
let (range, _) = self.selected_paragraph_range();
Some(kinds[range].to_vec())
}
pub(crate) fn caret_paragraph(&self) -> Option<(usize, ParagraphKind, Range<usize>)> {
let kinds = self.current_paragraphs()?;
let value = self.shared_value();
let ranges = spans_ops::paragraph_ranges(&value);
let caret = clamp_to_char_boundary(&value, self.inner.lock().caret);
let index = spans_ops::paragraph_of(&ranges, caret);
Some((index, kinds[index], ranges[index].clone()))
}
pub(crate) fn set_paragraph_kind(&self, kind: ParagraphKind) -> bool {
let Some(kinds) = self.current_paragraphs() else {
return false;
};
let kind = kind.canonical();
let (range, _) = self.selected_paragraph_range();
if kinds[range.clone()].iter().all(|held| *held == kind) {
return false;
}
let mut changed = kinds.to_vec();
changed[range.clone()].fill(kind);
self.push_undo_snapshot();
self.write_paragraphs(changed);
if let Some(spans) = self.current_spans() {
self.commit_spans(spans.to_vec(), StyledEdit::Paragraphs { range });
}
self.mark_layout_dirty();
true
}
fn splice_paragraphs(&self, edit: &SpansBeforeEdit, range: &Range<usize>, inserted: usize) {
let Some((kinds, before)) = &edit.paragraphs else {
return;
};
let after = spans_ops::paragraph_ranges(&self.shared_value());
self.write_paragraphs(spans_ops::splice_kinds(kinds, before, &after, range.clone(), inserted));
}
pub(crate) fn add_styled_change_handler(&self, handler: impl Fn(&StyledChange) + Send + Sync + 'static) {
self.inner.lock().styled.on_change.push(Arc::new(handler));
}
pub(crate) fn set_copy_format(&self, format: impl Fn(&StyledText) -> String + Send + Sync + 'static) {
self.inner.lock().styled.copy_format = Some(Arc::new(format));
}
pub(crate) fn add_link_click_handler(&self, handler: impl Fn(&LinkClick) + Send + Sync + 'static) {
self.inner.lock().styled.on_link_click.push(Arc::new(handler));
}
pub(crate) fn is_styled(&self) -> bool {
let inner = self.inner.lock();
inner.styled.spans.is_some() && inner.mask.is_none()
}
fn shared_value(&self) -> String {
self.value()
}
pub(crate) fn current_spans(&self) -> Option<SnapshotSpans> {
let (signal, cache) = {
let inner = self.inner.lock();
if inner.mask.is_some() {
return None;
}
(inner.styled.spans.clone()?, inner.styled.cache.clone())
};
let versions = (self.value.version(), signal.version());
if let Some(cache) = cache.filter(|cache| (cache.value_version, cache.spans_version) == versions) {
return Some(cache.spans);
}
let value = self.shared_value();
let spans = Arc::new(signal.with_untracked(|spans| spans_ops::normalize(&value, spans.clone())));
self.inner.lock().styled.cache = Some(SpansCache {
value_version: versions.0,
spans_version: versions.1,
spans: spans.clone(),
});
Some(spans)
}
pub(crate) fn styled_text(&self) -> Option<StyledText> {
let spans = self.current_spans()?;
Some(StyledText {
text: self.value(),
spans: spans.to_vec(),
})
}
pub(crate) fn styled_display(&self, empty: bool) -> Option<(Arc<str>, SnapshotSpans)> {
let spans = self.current_spans()?;
let Some(composed) = self.composed_text() else {
if self.is_showing_placeholder() && !(empty && self.current_paragraphs().is_some()) {
return None;
}
return Some((self.shared_value().into(), spans));
};
let value = self.shared_value();
let (start, end) = self.selection_or_caret(&value);
let inserted = composed.len() + (end - start) - value.len();
let style = self.typing_style_for(&value, &spans);
let spans = spans_ops::splice(&spans, start..end, inserted, &style);
Some((composed.into(), Arc::new(spans)))
}
fn sync_external_objects(&self) {
let mut inner = self.inner.lock();
let Some(version) = inner.styled.objects.as_ref().map(Signal::version) else {
return;
};
if version == inner.styled.objects_synced {
return;
}
inner.styled.objects_synced = version;
drop(inner);
self.mark_layout_dirty_keeping_scroll();
}
pub(super) fn sync_external_spans(&self) {
self.sync_external_paragraphs();
self.sync_external_objects();
let mut inner = self.inner.lock();
let Some(version) = inner.styled.spans.as_ref().map(Signal::version) else {
return;
};
if version == inner.styled.synced_version {
return;
}
inner.styled.synced_version = version;
inner.styled.pending = None;
drop(inner);
self.mark_layout_dirty_keeping_scroll();
}
fn sync_external_paragraphs(&self) {
let mut inner = self.inner.lock();
let Some(version) = inner.styled.paragraphs.as_ref().map(Signal::version) else {
return;
};
if version == inner.styled.paragraphs_synced {
return;
}
inner.styled.paragraphs_synced = version;
drop(inner);
self.mark_layout_dirty_keeping_scroll();
}
pub(super) fn styled_before_edit(&self) -> Option<SpansBeforeEdit> {
let spans = self.current_spans()?;
let value = self.shared_value();
let style = self.typing_style_for(&value, &spans);
let paragraphs = self
.current_paragraphs()
.map(|kinds| (kinds, spans_ops::paragraph_ranges(&value)));
Some(SpansBeforeEdit {
spans,
style,
paragraphs,
objects: self.current_objects(),
})
}
pub(super) fn styled_after_edit(&self, edit: Option<SpansBeforeEdit>, range: Range<usize>, inserted: usize) {
let Some(edit) = edit else {
return;
};
self.splice_paragraphs(&edit, &range, inserted);
self.splice_objects(&edit, &range, inserted, &[]);
let spans = spans_ops::splice(&edit.spans, range.clone(), inserted, &edit.style);
self.commit_spans(
spans,
StyledEdit::Text {
replaced: range,
inserted,
},
);
}
pub(super) fn styled_after_insert(
&self,
edit: Option<SpansBeforeEdit>,
range: Range<usize>,
inserted: &InsertedText<'_>,
) {
let Some(edit) = edit else {
return;
};
let (inserted, pasted, objects) = (inserted.styled, inserted.kinds, inserted.objects);
self.splice_paragraphs(&edit, &range, inserted.text.len());
self.splice_objects(&edit, &range, inserted.text.len(), objects);
if let (Some(pasted), Some(kinds)) = (pasted, self.current_paragraphs()) {
let after = spans_ops::paragraph_ranges(&self.shared_value());
self.write_paragraphs(spans_ops::place_kinds(
kinds.to_vec(),
&after,
range.start,
inserted.text.len(),
pasted,
));
}
let start = range.start;
let mut spans = spans_ops::splice(&edit.spans, range.clone(), inserted.text.len(), &SpanStyle::default());
spans.extend(
inserted
.spans
.iter()
.map(|span| StyledSpan::new(span.range.start + start..span.range.end + start, span.style.clone())),
);
let spans = spans_ops::normalize(&self.shared_value(), spans);
self.commit_spans(
spans,
StyledEdit::Text {
replaced: range,
inserted: inserted.text.len(),
},
);
}
pub(super) fn restore_spans(&self, spans: SnapshotSpans) {
self.commit_spans(spans.to_vec(), StyledEdit::Replaced);
}
fn commit_spans(&self, spans: Vec<StyledSpan>, edit: StyledEdit) {
let (signal, handlers) = {
let mut inner = self.inner.lock();
let Some(signal) = inner.styled.spans.clone() else {
return;
};
inner.styled.pending = None;
(signal, inner.styled.on_change.clone())
};
let shared = Arc::new(spans);
if signal.with_untracked(|current| current != shared.as_ref()) {
signal.set(shared.to_vec());
}
{
let mut inner = self.inner.lock();
inner.styled.synced_version = signal.version();
inner.styled.cache = Some(SpansCache {
value_version: self.value.version(),
spans_version: signal.version(),
spans: shared.clone(),
});
}
if handlers.is_empty() {
return;
}
let change = StyledChange {
value: self.value.clone(),
spans: shared,
paragraphs: self.current_paragraphs(),
objects: self.current_objects(),
edit,
};
for handler in handlers {
handler(&change);
}
}
pub(crate) fn selection_style(&self) -> Option<SelectionStyle> {
let spans = self.current_spans()?;
let value = self.shared_value();
let (start, end) = self.selection_or_caret(&value);
if start < end {
return Some(spans_ops::summarize(&spans, value.len(), start..end));
}
Some(SelectionStyle::of_style(&self.typing_style_for(&value, &spans)))
}
pub(crate) fn toggle_mark(&self, mark: TextMark) -> bool {
let Some(style) = self.selection_style() else {
return false;
};
let on = style.mark(mark) != crate::components::MarkPresence::All;
self.set_mark(mark, on)
}
pub(crate) fn set_mark(&self, mark: TextMark, on: bool) -> bool {
self.restyle_selection(|style| *style = std::mem::take(style).with(mark, on))
}
pub(crate) fn set_link(&self, target: Option<Arc<str>>) -> bool {
let Some(spans) = self.current_spans() else {
return false;
};
let value = self.shared_value();
let (start, end) = self.selection_or_caret(&value);
if start == end
&& let Some(range) = link_range(&spans, start).filter(|range| range.start < start && start < range.end)
{
return self.restyle_range(&spans, range, |style| style.link = target.clone());
}
self.restyle_selection(|style| style.link = target.clone())
}
pub(crate) fn set_pending_style(&self, style: Option<SpanStyle>) -> bool {
if !self.is_styled() {
return false;
}
let mut inner = self.inner.lock();
inner.styled.pending = style.map(|style| (inner.caret, style));
true
}
pub(crate) fn selected_styled_text(&self) -> Option<StyledText> {
let spans = self.current_spans()?;
let value = self.shared_value();
let (start, end) = self.selection_or_caret(&value);
Some(StyledText {
text: value[start..end].to_owned(),
spans: spans_ops::slice(&spans, start..end),
})
}
fn selected_objects(&self) -> Vec<InlineObject> {
let Some(objects) = self.current_objects() else {
return Vec::new();
};
let (start, end) = self.selection_or_caret(&self.shared_value());
spans_ops::slice_objects(&objects, start..end)
}
pub(crate) fn clipboard_selection(&self) -> Option<String> {
if self.is_masked() {
return None;
}
let selected = self.selected_text()?;
let format = self.inner.lock().styled.copy_format.clone();
match (format, self.selected_styled_text()) {
(Some(format), Some(styled)) => Some(format(&styled)),
_ => Some(spans_ops::text_with_labels(&selected, &self.selected_objects())),
}
}
pub(crate) fn set_rich_clipboard(&self, on: bool) {
self.inner.lock().styled.rich_clipboard = on;
}
pub(crate) fn clipboard_markdown(&self) -> Option<String> {
if !self.inner.lock().styled.rich_clipboard || self.is_masked() {
return None;
}
let kinds = self.current_paragraphs()?;
let selected = self.selected_styled_text()?;
if selected.text.is_empty() {
return None;
}
let (range, _) = self.selected_paragraph_range();
let rich =
RichText::new(selected.text, selected.spans, kinds[range].to_vec()).with_objects(self.selected_objects());
Some(rich.to_markdown())
}
pub(crate) fn paste_rich(&self, text: &str, markdown: Option<&str>, keyboard: &KeyboardEvent) -> Option<bool> {
if !self.inner.lock().styled.rich_clipboard || self.is_masked() {
return None;
}
let kinds = self.current_paragraphs()?;
let (touched, _) = self.selected_paragraph_range();
if kinds[touched.start] == ParagraphKind::Code {
return None;
}
let source = match markdown {
Some(markdown) => markdown,
None if RichText::reads_as_markdown(text) => text,
None => return None,
};
let rich = RichText::from_markdown(source);
if rich.is_empty() {
return None;
}
Some(self.replace_selection_rich(&rich, keyboard))
}
pub(crate) fn click_link_at_point(&self, x: f32, y: f32) -> bool {
let handlers = self.inner.lock().styled.on_link_click.clone();
if handlers.is_empty() {
return false;
}
let Some(click) = self.link_at_point(x, y) else {
return false;
};
for handler in handlers {
handler(&click);
}
true
}
fn link_at_point(&self, x: f32, y: f32) -> Option<LinkClick> {
let spans = self.current_spans()?;
let layout = self.token_layout()?;
let (scroll_x, scroll_y) = {
let inner = self.inner.lock();
(inner.scroll_x, inner.scroll_y())
};
let cluster = layout.cluster_at(x + scroll_x, y + scroll_y)?;
let range = link_range(&spans, cluster.start)?;
let target = spans_ops::style_at(&spans, cluster.start).link?;
Some(LinkClick { target, range })
}
fn restyle_selection(&self, change: impl Fn(&mut SpanStyle)) -> bool {
let Some(spans) = self.current_spans() else {
return false;
};
let value = self.shared_value();
let (start, end) = self.selection_or_caret(&value);
if start == end {
let mut style = self.typing_style_for(&value, &spans);
change(&mut style);
let mut inner = self.inner.lock();
inner.styled.pending = Some((inner.caret, style));
return true;
}
self.restyle_range(&spans, start..end, change)
}
fn restyle_range(&self, spans: &[StyledSpan], range: Range<usize>, change: impl Fn(&mut SpanStyle)) -> bool {
let restyled = spans_ops::restyle(spans, self.shared_value().len(), range.clone(), change);
if restyled.as_slice() == spans {
return false;
}
self.push_undo_snapshot();
self.commit_spans(restyled, StyledEdit::Style { range });
self.mark_layout_dirty();
true
}
fn typing_style_for(&self, value: &str, spans: &[StyledSpan]) -> SpanStyle {
let (start, end) = self.selection_or_caret(value);
let inner = self.inner.lock();
if let Some((caret, style)) = &inner.styled.pending
&& start == end
&& *caret == start
{
return style.clone();
}
drop(inner);
spans_ops::insertion_style(value, spans, start, end)
}
fn selection_or_caret(&self, value: &str) -> (usize, usize) {
let inner = self.inner.lock();
selection_range_indices(value, inner.selection_anchor, inner.caret).unwrap_or_else(|| {
let caret = clamp_to_char_boundary(value, inner.caret);
(caret, caret)
})
}
}
fn link_range(spans: &[StyledSpan], offset: usize) -> Option<Range<usize>> {
let index = spans
.iter()
.position(|span| span.range.start <= offset && offset < span.range.end && span.style.link.is_some())
.or_else(|| {
spans
.iter()
.position(|span| span.range.end == offset && span.style.link.is_some())
})?;
let target = spans[index].style.link.clone();
let mut first = index;
while first > 0 && spans[first - 1].range.end == spans[first].range.start && spans[first - 1].style.link == target {
first -= 1;
}
let mut last = index;
while last + 1 < spans.len()
&& spans[last + 1].range.start == spans[last].range.end
&& spans[last + 1].style.link == target
{
last += 1;
}
Some(spans[first].range.start..spans[last].range.end)
}