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}