Skip to main content

sui_widgets/
selection.rs

1use std::{any::Any, cell::RefCell, collections::BTreeMap, fmt, ops::Range, rc::Rc, sync::Arc};
2
3use sui_core::{ImageHandle, Rect, WidgetId};
4
5#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
6pub struct SelectionOwnerId(u64);
7
8impl SelectionOwnerId {
9    pub const fn new(raw: u64) -> Self {
10        Self(raw)
11    }
12
13    pub const fn get(self) -> u64 {
14        self.0
15    }
16}
17
18impl From<WidgetId> for SelectionOwnerId {
19    fn from(value: WidgetId) -> Self {
20        Self(value.get())
21    }
22}
23
24impl From<u64> for SelectionOwnerId {
25    fn from(value: u64) -> Self {
26        Self(value)
27    }
28}
29
30#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
31pub struct SelectionOrder(u64);
32
33impl SelectionOrder {
34    pub const fn new(raw: u64) -> Self {
35        Self(raw)
36    }
37
38    pub const fn get(self) -> u64 {
39        self.0
40    }
41}
42
43impl From<SelectionOwnerId> for SelectionOrder {
44    fn from(value: SelectionOwnerId) -> Self {
45        Self(value.get())
46    }
47}
48
49impl From<WidgetId> for SelectionOrder {
50    fn from(value: WidgetId) -> Self {
51        Self(value.get())
52    }
53}
54
55impl From<u64> for SelectionOrder {
56    fn from(value: u64) -> Self {
57        Self(value)
58    }
59}
60
61#[derive(Debug, Clone, Copy, PartialEq, Eq)]
62pub enum SelectionIntent {
63    Replace,
64    Extend,
65    Toggle,
66}
67
68#[derive(Clone)]
69pub enum SelectionPayload {
70    Text(String),
71    Image {
72        handle: ImageHandle,
73        region: Option<Rect>,
74    },
75    Custom {
76        kind: Arc<str>,
77        data: Arc<dyn Any + Send + Sync>,
78    },
79}
80
81impl SelectionPayload {
82    pub fn text(text: impl Into<String>) -> Self {
83        Self::Text(text.into())
84    }
85
86    pub fn image(handle: ImageHandle) -> Self {
87        Self::Image {
88            handle,
89            region: None,
90        }
91    }
92
93    pub fn image_region(handle: ImageHandle, region: Rect) -> Self {
94        Self::Image {
95            handle,
96            region: Some(region),
97        }
98    }
99
100    pub fn custom<T>(kind: impl Into<Arc<str>>, data: T) -> Self
101    where
102        T: Any + Send + Sync + 'static,
103    {
104        Self::Custom {
105            kind: kind.into(),
106            data: Arc::new(data),
107        }
108    }
109
110    pub fn as_text(&self) -> Option<&str> {
111        match self {
112            Self::Text(text) => Some(text),
113            Self::Image { .. } | Self::Custom { .. } => None,
114        }
115    }
116
117    pub fn custom_kind(&self) -> Option<&str> {
118        match self {
119            Self::Custom { kind, .. } => Some(kind.as_ref()),
120            Self::Text(_) | Self::Image { .. } => None,
121        }
122    }
123
124    pub fn custom_data<T>(&self) -> Option<&T>
125    where
126        T: Any + Send + Sync + 'static,
127    {
128        match self {
129            Self::Custom { data, .. } => data.downcast_ref(),
130            Self::Text(_) | Self::Image { .. } => None,
131        }
132    }
133}
134
135impl fmt::Debug for SelectionPayload {
136    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
137        match self {
138            Self::Text(text) => f.debug_tuple("Text").field(text).finish(),
139            Self::Image { handle, region } => f
140                .debug_struct("Image")
141                .field("handle", handle)
142                .field("region", region)
143                .finish(),
144            Self::Custom { kind, .. } => f
145                .debug_struct("Custom")
146                .field("kind", kind)
147                .finish_non_exhaustive(),
148        }
149    }
150}
151
152#[derive(Debug, Clone)]
153pub struct SelectionEntry {
154    pub owner: SelectionOwnerId,
155    pub order: SelectionOrder,
156    pub payload: SelectionPayload,
157}
158
159#[derive(Debug, Clone, PartialEq, Eq, Default)]
160pub struct SelectionChange {
161    affected_owners: Vec<SelectionOwnerId>,
162}
163
164impl SelectionChange {
165    pub fn new(affected_owners: Vec<SelectionOwnerId>) -> Self {
166        Self { affected_owners }
167    }
168
169    pub fn is_empty(&self) -> bool {
170        self.affected_owners.is_empty()
171    }
172
173    pub fn affected_owners(&self) -> &[SelectionOwnerId] {
174        &self.affected_owners
175    }
176}
177
178impl SelectionEntry {
179    pub fn new(
180        owner: impl Into<SelectionOwnerId>,
181        order: impl Into<SelectionOrder>,
182        payload: SelectionPayload,
183    ) -> Self {
184        Self {
185            owner: owner.into(),
186            order: order.into(),
187            payload,
188        }
189    }
190}
191
192#[derive(Debug, Clone, Copy, PartialEq, Eq)]
193pub struct SelectionPoint {
194    pub owner: SelectionOwnerId,
195    pub offset: usize,
196    pub order: SelectionOrder,
197}
198
199impl SelectionPoint {
200    pub fn new(
201        owner: impl Into<SelectionOwnerId>,
202        offset: usize,
203        order: impl Into<SelectionOrder>,
204    ) -> Self {
205        Self {
206            owner: owner.into(),
207            offset,
208            order: order.into(),
209        }
210    }
211}
212
213#[derive(Debug, Clone, PartialEq, Eq)]
214pub struct TextSelectionInfo {
215    pub owner: SelectionOwnerId,
216    pub range: Range<usize>,
217    pub text_len: usize,
218}
219
220#[derive(Debug, Clone)]
221struct OwnerSelection {
222    entries: Vec<SelectionEntry>,
223    text: Option<TextSelectionInfo>,
224}
225
226#[derive(Debug, Default)]
227struct SelectionState {
228    revision: u64,
229    active_owner: Option<SelectionOwnerId>,
230    anchor: Option<SelectionPoint>,
231    focus: Option<SelectionPoint>,
232    owners: BTreeMap<SelectionOwnerId, OwnerSelection>,
233}
234
235#[derive(Clone, Debug, Default)]
236pub struct SelectionScope {
237    inner: Rc<RefCell<SelectionState>>,
238}
239
240impl SelectionScope {
241    pub fn new() -> Self {
242        Self::default()
243    }
244
245    pub fn revision(&self) -> u64 {
246        self.inner.borrow().revision
247    }
248
249    pub fn active_owner(&self) -> Option<SelectionOwnerId> {
250        self.inner.borrow().active_owner
251    }
252
253    pub fn anchor(&self) -> Option<SelectionPoint> {
254        self.inner.borrow().anchor
255    }
256
257    pub fn focus(&self) -> Option<SelectionPoint> {
258        self.inner.borrow().focus
259    }
260
261    pub fn set_points(
262        &self,
263        anchor: Option<SelectionPoint>,
264        focus: Option<SelectionPoint>,
265    ) -> SelectionChange {
266        let mut affected = Vec::new();
267        if let Some(point) = anchor {
268            affected.push(point.owner);
269        }
270        if let Some(point) = focus {
271            affected.push(point.owner);
272        }
273        affected.sort();
274        affected.dedup();
275
276        let mut state = self.inner.borrow_mut();
277        state.anchor = anchor;
278        state.focus = focus;
279        state.revision = state.revision.saturating_add(1);
280        SelectionChange::new(affected)
281    }
282
283    pub fn selected_items(&self) -> Vec<SelectionEntry> {
284        let mut entries = self
285            .inner
286            .borrow()
287            .owners
288            .values()
289            .flat_map(|owner| owner.entries.iter().cloned())
290            .collect::<Vec<_>>();
291        entries.sort_by_key(|entry| (entry.order, entry.owner));
292        entries
293    }
294
295    pub fn selected_items_for_owner(
296        &self,
297        owner: impl Into<SelectionOwnerId>,
298    ) -> Vec<SelectionEntry> {
299        let owner = owner.into();
300        self.inner
301            .borrow()
302            .owners
303            .get(&owner)
304            .map(|selection| selection.entries.clone())
305            .unwrap_or_default()
306    }
307
308    pub fn selected_text(&self) -> Option<String> {
309        let text = self
310            .selected_items()
311            .into_iter()
312            .filter_map(|entry| match entry.payload {
313                SelectionPayload::Text(text) => Some(text),
314                SelectionPayload::Image { .. } | SelectionPayload::Custom { .. } => None,
315            })
316            .collect::<String>();
317        (!text.is_empty()).then_some(text)
318    }
319
320    pub fn text_selection_for_owner(
321        &self,
322        owner: impl Into<SelectionOwnerId>,
323    ) -> Option<TextSelectionInfo> {
324        let owner = owner.into();
325        self.inner
326            .borrow()
327            .owners
328            .get(&owner)
329            .and_then(|selection| selection.text.clone())
330    }
331
332    pub fn has_owner_selection(&self, owner: impl Into<SelectionOwnerId>) -> bool {
333        let owner = owner.into();
334        self.inner.borrow().owners.contains_key(&owner)
335    }
336
337    pub fn replace(
338        &self,
339        owner: impl Into<SelectionOwnerId>,
340        entries: Vec<SelectionEntry>,
341    ) -> SelectionChange {
342        self.select(owner, SelectionIntent::Replace, entries, None)
343    }
344
345    pub fn replace_text(
346        &self,
347        owner: impl Into<SelectionOwnerId>,
348        order: impl Into<SelectionOrder>,
349        range: Range<usize>,
350        text_len: usize,
351        text: impl Into<String>,
352    ) -> SelectionChange {
353        let owner = owner.into();
354        let order = order.into();
355        let selected_text = text.into();
356        let entries = (!selected_text.is_empty()).then(|| {
357            vec![SelectionEntry::new(
358                owner,
359                order,
360                SelectionPayload::Text(selected_text),
361            )]
362        });
363        self.select(
364            owner,
365            SelectionIntent::Replace,
366            entries.unwrap_or_default(),
367            Some(TextSelectionInfo {
368                owner,
369                range,
370                text_len,
371            }),
372        )
373    }
374
375    pub fn extend(
376        &self,
377        owner: impl Into<SelectionOwnerId>,
378        entries: Vec<SelectionEntry>,
379    ) -> SelectionChange {
380        self.select(owner, SelectionIntent::Extend, entries, None)
381    }
382
383    pub fn toggle(
384        &self,
385        owner: impl Into<SelectionOwnerId>,
386        entries: Vec<SelectionEntry>,
387    ) -> SelectionChange {
388        self.select(owner, SelectionIntent::Toggle, entries, None)
389    }
390
391    pub fn clear_owner(&self, owner: impl Into<SelectionOwnerId>) -> SelectionChange {
392        let owner = owner.into();
393        let mut state = self.inner.borrow_mut();
394        let had_owner = state.owners.remove(&owner).is_some();
395        let had_active_owner = state.active_owner == Some(owner);
396        let had_anchor = state.anchor.is_some_and(|point| point.owner == owner);
397        let had_focus = state.focus.is_some_and(|point| point.owner == owner);
398        if had_owner || had_active_owner || had_anchor || had_focus {
399            if had_active_owner {
400                state.active_owner = None;
401            }
402            if had_anchor {
403                state.anchor = None;
404            }
405            if had_focus {
406                state.focus = None;
407            }
408            state.revision = state.revision.saturating_add(1);
409            SelectionChange::new(vec![owner])
410        } else {
411            SelectionChange::default()
412        }
413    }
414
415    pub fn clear(&self) -> SelectionChange {
416        let mut state = self.inner.borrow_mut();
417        let affected = state.owners.keys().copied().collect::<Vec<_>>();
418        if !state.owners.is_empty()
419            || state.active_owner.is_some()
420            || state.anchor.is_some()
421            || state.focus.is_some()
422        {
423            state.owners.clear();
424            state.active_owner = None;
425            state.anchor = None;
426            state.focus = None;
427            state.revision = state.revision.saturating_add(1);
428            SelectionChange::new(affected)
429        } else {
430            SelectionChange::default()
431        }
432    }
433
434    fn select(
435        &self,
436        owner: impl Into<SelectionOwnerId>,
437        intent: SelectionIntent,
438        entries: Vec<SelectionEntry>,
439        text: Option<TextSelectionInfo>,
440    ) -> SelectionChange {
441        let owner = owner.into();
442        let mut state = self.inner.borrow_mut();
443        let affected = match intent {
444            SelectionIntent::Replace => state
445                .owners
446                .keys()
447                .copied()
448                .chain(std::iter::once(owner))
449                .collect::<Vec<_>>(),
450            SelectionIntent::Extend | SelectionIntent::Toggle => vec![owner],
451        };
452        match intent {
453            SelectionIntent::Replace => {
454                state.owners.clear();
455                insert_owner_selection(&mut state, owner, entries, text);
456            }
457            SelectionIntent::Extend => {
458                insert_owner_selection(&mut state, owner, entries, text);
459            }
460            SelectionIntent::Toggle => {
461                if state.owners.contains_key(&owner) {
462                    state.owners.remove(&owner);
463                    if state.active_owner == Some(owner) {
464                        state.active_owner = None;
465                    }
466                } else {
467                    insert_owner_selection(&mut state, owner, entries, text);
468                }
469            }
470        }
471        state.revision = state.revision.saturating_add(1);
472        let mut affected = affected;
473        affected.sort();
474        affected.dedup();
475        SelectionChange::new(affected)
476    }
477}
478
479fn insert_owner_selection(
480    state: &mut SelectionState,
481    owner: SelectionOwnerId,
482    entries: Vec<SelectionEntry>,
483    text: Option<TextSelectionInfo>,
484) {
485    state.active_owner = Some(owner);
486    if entries.is_empty() && text.as_ref().is_none_or(|text| text.range.is_empty()) {
487        state.owners.remove(&owner);
488    } else {
489        state.owners.insert(owner, OwnerSelection { entries, text });
490    }
491}
492
493#[cfg(test)]
494mod tests {
495    use super::*;
496
497    #[test]
498    fn replace_text_updates_selected_text_and_clears_previous_owner() {
499        let scope = SelectionScope::new();
500        let first = SelectionOwnerId::new(1);
501        let second = SelectionOwnerId::new(2);
502
503        let change = scope.replace_text(first, first, 0..5, 5, "hello");
504        assert_eq!(change.affected_owners(), &[first]);
505        assert_eq!(scope.selected_text().as_deref(), Some("hello"));
506        assert!(scope.has_owner_selection(first));
507
508        let change = scope.replace_text(second, second, 0..5, 5, "world");
509        assert_eq!(change.affected_owners(), &[first, second]);
510        assert_eq!(scope.selected_text().as_deref(), Some("world"));
511        assert!(!scope.has_owner_selection(first));
512        assert!(scope.has_owner_selection(second));
513    }
514
515    #[test]
516    fn extend_keeps_multiple_payload_kinds_in_order() {
517        let scope = SelectionScope::new();
518        let first = SelectionOwnerId::new(10);
519        let second = SelectionOwnerId::new(20);
520
521        scope.extend(
522            second,
523            vec![SelectionEntry::new(
524                second,
525                SelectionOrder::new(2),
526                SelectionPayload::text("B"),
527            )],
528        );
529        scope.extend(
530            first,
531            vec![SelectionEntry::new(
532                first,
533                SelectionOrder::new(1),
534                SelectionPayload::text("A"),
535            )],
536        );
537
538        assert_eq!(scope.selected_text().as_deref(), Some("AB"));
539        assert_eq!(
540            scope
541                .selected_items()
542                .iter()
543                .map(|entry| entry.owner)
544                .collect::<Vec<_>>(),
545            vec![first, second]
546        );
547    }
548}