1use uzor::input::{Sense, WidgetKind};
55use uzor::ui::widgets::atomic::item::{draw_item, ItemRenderKind, ItemSettings, ItemView};
56use uzor::ui::widgets::atomic::separator::{
57 draw_separator, DefaultSeparatorStyle, SeparatorOrientation, SeparatorSettings, SeparatorType,
58 SeparatorView,
59};
60use uzor::ui::widgets::atomic::tab::{draw_tab, register_tab_on_layer, TabConfig, TabSettings, TabView};
61use uzor::ui::widgets::atomic::text_input::{
62 draw_input, draw_input_cursor, InputType, InputView, TextFieldConfig as InputConfig, TextInputSettings,
63};
64use uzor::ui::widgets::atomic::toast::{draw_toast_stack, ToastStackState};
65use uzor::ui::widgets::composite::context_menu::{
66 draw_context_menu, register_input_coordinator_context_menu, ContextMenuItem,
67 ContextMenuRenderKind, ContextMenuSettings, ContextMenuState, ContextMenuView,
68};
69use uzor::ui::widgets::composite::modal::render::draw_modal;
70use uzor::ui::widgets::composite::select::{draw_list, filter, place, room, SelectKey, SelectState};
71pub use uzor::ui::widgets::composite::select::SelectStyle;
72use uzor::ui::widgets::composite::modal::{
73 register_input_coordinator_modal, BackdropKind, FooterBtn, FooterBtnStyle, ModalRenderKind,
74 ModalSettings, ModalState, ModalView,
75};
76use uzor::ui::widgets::atomic::button::ButtonView;
77use uzor::render::RenderContext;
78use uzor::{Rect, WidgetId, WidgetState};
79
80use crate::handle::VisualView;
81use crate::KeyInput;
82use crate::types::spec::Spec;
83
84use super::button::{button_settings, paint_button};
85use super::host::ContentCx;
86use super::paint::{interaction_state, parts, theme_of};
87use super::splitter::{grab_rect, register as register_splitter, Splitter, SplitterEvent};
88
89pub use super::lm::{
90 button, checkbox, toggle as switch, tooltip, ButtonBuilder, CheckboxBuilder, ToggleBuilder as SwitchBuilder,
91 TooltipBuilder,
92};
93pub use super::splitter::Axis;
94pub use uzor::ui::domkit;
96pub use uzor::ui::widgets::atomic::toast::{ToastSeverity, ToastType};
97
98#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
100pub struct Response {
101 pub hovered: bool,
103 pub pressed: bool,
105 pub focused: bool,
107 pub clicked: bool,
109 pub changed: bool,
111 pub index: Option<usize>,
113 pub column: Option<usize>,
115 pub checked: bool,
117}
118
119impl Response {
120 fn of<S: Spec>(v: &VisualView<S>, id: &WidgetId) -> Self {
121 Response {
122 hovered: v.is_hover_within(id) || v.is_hovered(id),
123 pressed: v.is_pressed(id),
124 focused: v.is_focus_within(id) || v.is_focused(id),
125 clicked: v.clicked(id),
126 ..Default::default()
127 }
128 }
129}
130
131fn child(id: &WidgetId, part: &str, i: usize) -> WidgetId {
132 WidgetId::from(format!("{}:{}:{}", id.as_str(), part, i))
133}
134
135fn picked<S: Spec>(v: &VisualView<S>, id: &WidgetId, part: &str) -> Option<usize> {
137 let pre = format!("{}:{}:", id.as_str(), part);
138 v.clicks().iter().find_map(|(w, _)| w.as_str().strip_prefix(pre.as_str())?.parse().ok())
139}
140
141fn clicked_outside<S: Spec>(v: &VisualView<S>, id: &WidgetId) -> bool {
143 !v.clicks().is_empty() && !v.clicks().iter().any(|(w, _)| w.as_str().starts_with(id.as_str()))
144}
145
146fn focusable() -> Sense {
147 (Sense::CLICK | Sense::HOVER).with_focus()
148}
149
150impl<'a> ButtonBuilder<'a> {
153 pub fn build_response<'c, C: ContentCx<'c>>(self, cx: &mut C) -> Response {
155 let id = self.id_ref().clone();
156 self.build(cx);
157 cx.with_paint(|_, _, v, _| Response::of(v, &id))
158 }
159}
160
161impl<'a> CheckboxBuilder<'a> {
164 pub fn build_response<'c, C: ContentCx<'c>>(self, cx: &mut C) -> Response {
167 let (id, label) = self.id_label();
168 let (id, label) = (id.clone(), label.unwrap_or("").to_owned());
169 let on = self.build(cx);
170 cx.with_paint(|_, w, v, _| {
171 w.coord.set_a11y(&id, &label, Some(on));
172 let r = Response::of(v, &id);
173 Response { changed: r.clicked, checked: on, ..r }
174 })
175 }
176}
177
178impl<'a> SwitchBuilder<'a> {
179 pub fn build_response<'c, C: ContentCx<'c>>(self, cx: &mut C) -> Response {
182 let (id, label, disabled) = self.id_label();
183 let (id, label) = (id.clone(), label.unwrap_or("").to_owned());
184 let on = self.build(cx);
185 cx.with_paint(|_, w, v, _| {
186 w.coord.set_a11y(&id, &label, Some(on));
187 let r = Response::of(v, &id);
188 Response { changed: r.clicked && !disabled, checked: on, ..r }
189 })
190 }
191}
192
193pub struct InputBuilder<'a> {
205 id: WidgetId,
206 rect: Rect,
207 value: &'a mut String,
208 placeholder: &'a str,
209 label: Option<&'a str>,
210 kind: InputType,
211 disabled: bool,
212 max_len: Option<usize>,
213}
214
215pub fn input<'a>(id: impl Into<WidgetId>, rect: Rect, value: &'a mut String) -> InputBuilder<'a> {
217 InputBuilder {
218 id: id.into(),
219 rect,
220 value,
221 placeholder: "",
222 label: None,
223 kind: InputType::Text,
224 disabled: false,
225 max_len: None,
226 }
227}
228
229impl<'a> InputBuilder<'a> {
230 pub fn placeholder(mut self, p: &'a str) -> Self {
232 self.placeholder = p;
233 self
234 }
235 pub fn label(mut self, l: &'a str) -> Self {
237 self.label = Some(l);
238 self
239 }
240 pub fn kind(mut self, k: InputType) -> Self {
242 self.kind = k;
243 self
244 }
245 pub fn password(self) -> Self {
247 self.kind(InputType::Password)
248 }
249 pub fn max_len(mut self, n: usize) -> Self {
251 self.max_len = Some(n);
252 self
253 }
254 pub fn disabled(mut self, on: bool) -> Self {
256 self.disabled = on;
257 self
258 }
259
260 pub fn build<'c, C: ContentCx<'c>>(self, cx: &mut C) -> Response {
262 let now_ms = cx.time_ms();
263 let theme = theme_of(cx);
264 let InputBuilder { id, rect, value, placeholder, label, kind, disabled, max_len } = self;
265 let (r, ime) = cx.with_paint(|render, widgets, v, _| {
266 let mut r = Response::of(v, &id);
267 let settings = TextInputSettings::with_config(InputConfig::text()).with_theme(Box::new(theme));
268 let (coord, states, layer) = parts(widgets);
269 if disabled {
270 coord.register_atomic(id.clone(), WidgetKind::Custom, rect, Sense::HOVER, layer);
271 } else {
272 let mut config = if kind == InputType::Password { uzor::TextFieldConfig::password() } else { uzor::TextFieldConfig::text() };
273 if let Some(n) = max_len {
274 config = config.with_max_len(n);
275 }
276 coord.set_default_layer(Some(layer.clone()));
277 coord.register_text_field(id.clone(), rect, config);
278 coord.set_default_layer(None);
279 }
280 coord.set_a11y(&id, label.unwrap_or(placeholder), None);
281 let synced = states.get_or_insert_with(WidgetId::from(format!("{}:value", id.as_str())), String::new);
283 let fields = coord.text_fields_mut();
284 if fields.has_field(&id) {
285 let now = fields.text(&id).to_owned();
286 if now != *synced {
287 *value = now.clone();
288 *synced = now;
289 r.changed = true;
290 } else if *value != *synced {
291 fields.set_text(&id, value);
292 *synced = value.clone();
293 }
294 }
295 let (shown, caret, preedit, engaged, selection) = match fields.field_state(&id) {
296 Some(s) => {
297 let (text, caret, preedit) = s.display();
298 let selection = preedit.is_none().then(|| s.selection_range()).flatten();
299 (text, caret, preedit, s.engaged, selection)
300 }
301 None => (value.clone(), value.chars().count(), None, false, None),
302 };
303 let shown = if kind == InputType::Password { "\u{2022}".repeat(shown.chars().count()) } else { shown };
304 let focused = !disabled && (r.focused || fields.is_focused(&id));
305 r.focused = focused;
306 let view = InputView {
307 text: &shown,
308 placeholder,
309 cursor: caret,
310 selection,
311 focused,
312 disabled,
313 input_type: kind,
314 };
315 let ws = interaction_state(v, &id, disabled);
316 let res = draw_input(render, rect, ws, &view, &settings);
317 let tint = settings.theme.cursor();
318 let mut ime = None;
319 if focused {
320 ime = Some(Rect::new(res.cursor_x, res.cursor_y, 1.0, res.cursor_height));
321 if engaged && fields.cursor_visible(now_ms) {
322 draw_input_cursor(render, res.cursor_x, res.cursor_y, res.cursor_height, 1.0, tint);
323 }
324 }
325 if let Some((a, b)) = preedit {
326 let x = |i: usize| res.char_x_positions.get(i).copied().unwrap_or(res.cursor_x);
328 draw_input_cursor(render, x(a), res.cursor_y + res.cursor_height, (x(b) - x(a)).max(0.0), 1.0, tint);
329 }
330 let fields = coord.text_fields_mut();
331 if let Some(s) = fields.field_state(&id) {
332 let pos = s.buffer_positions(res.char_x_positions);
333 fields.update_field(&id, (rect.x, rect.y, rect.width, rect.height), pos);
334 }
335 (r, ime)
336 });
337 if let Some(at) = ime {
338 cx.ime_area(at);
339 }
340 r
341 }
342}
343
344pub struct FieldBuilder<'a> {
348 id: WidgetId,
349 rect: Rect,
350 text_rect: Option<Rect>,
351 config: uzor::TextFieldConfig,
352 name: &'a str,
353 placeholder: &'a str,
354 masked: bool,
355 clip: bool,
356 within: Option<Rect>,
357 px: f64,
358 family: &'a str,
359 color: Option<&'a str>,
360 placeholder_color: Option<&'a str>,
361 set: Option<&'a str>,
362 parent: Option<WidgetId>,
363}
364
365#[derive(Clone, Debug, Default, PartialEq)]
367pub struct FieldResponse {
368 pub text: String,
370 pub focused: bool,
372}
373
374pub fn field<'a>(id: impl Into<WidgetId>, rect: Rect) -> FieldBuilder<'a> {
384 FieldBuilder {
385 id: id.into(),
386 rect,
387 text_rect: None,
388 config: uzor::TextFieldConfig::text(),
389 name: "",
390 placeholder: "",
391 masked: false,
392 clip: true,
393 within: None,
394 px: 13.0,
395 family: "sans-serif",
396 color: None,
397 placeholder_color: None,
398 set: None,
399 parent: None,
400 }
401}
402
403fn css_hex(c: [u8; 4]) -> String {
404 format!("#{:02x}{:02x}{:02x}{:02x}", c[0], c[1], c[2], c[3])
405}
406
407fn paint_field_selection(render: &mut dyn RenderContext, origin_x: f64, y: f64, h: f64, text: &str, range: (usize, usize), color: &str) {
411 let lo = range.0.min(range.1);
412 let hi = range.0.max(range.1);
413 if lo == hi {
414 return;
415 }
416 let before: String = text.chars().take(lo).collect();
417 let mid: String = text.chars().skip(lo).take(hi - lo).collect();
418 let x = origin_x + render.measure_text(&before);
419 let w = render.measure_text(&mid);
420 render.set_fill_color(color);
421 render.fill_rect(x, y, w.max(0.0), h);
422}
423
424impl<'a> FieldBuilder<'a> {
425 pub fn config(mut self, c: uzor::TextFieldConfig) -> Self {
427 self.config = c;
428 self
429 }
430 pub fn name(mut self, n: &'a str) -> Self {
432 self.name = n;
433 self
434 }
435 pub fn placeholder(mut self, p: &'a str) -> Self {
437 self.placeholder = p;
438 self
439 }
440 pub fn masked(mut self, on: bool) -> Self {
442 self.masked = on;
443 self
444 }
445 pub fn text_rect(mut self, r: Rect) -> Self {
447 self.text_rect = Some(r);
448 self
449 }
450 pub fn clip(mut self, on: bool) -> Self {
453 self.clip = on;
454 self
455 }
456 pub fn clip_to(mut self, r: Rect) -> Self {
460 self.within = Some(r);
461 self
462 }
463 pub fn font(mut self, px: f64, family: &'a str) -> Self {
465 self.px = px;
466 self.family = family;
467 self
468 }
469 pub fn colors(mut self, text: &'a str, placeholder: &'a str) -> Self {
471 self.color = Some(text);
472 self.placeholder_color = Some(placeholder);
473 self
474 }
475
476 pub fn set(mut self, text: Option<&'a str>) -> Self {
479 self.set = text;
480 self
481 }
482 pub fn parent(mut self, p: impl Into<WidgetId>) -> Self {
484 self.parent = Some(p.into());
485 self
486 }
487
488 pub fn build<'c, C: ContentCx<'c>>(self, cx: &mut C) -> FieldResponse {
490 use uzor::ui::widgets::atomic::text_input::TextInputTheme;
491 use uzor::ui::widgets::composite::dialog::draw_field_text_ime;
492 let now_ms = cx.time_ms();
493 let theme = theme_of(cx);
494 let color = self.color.map_or_else(|| css_hex(theme.text_normal()), str::to_owned);
495 let ph_color = self.placeholder_color.map_or_else(|| css_hex(theme.placeholder()), str::to_owned);
496 let sel_color = css_hex(theme.selection());
497 let FieldBuilder { id, rect, text_rect, config, name, placeholder, masked, clip, within, px, family, set, parent, .. } = self;
498 let fr = text_rect.unwrap_or(rect);
499 let hit = within.map_or(rect, |w| w.intersect(rect));
500 let (out, ime) = cx.with_paint(|render, widgets, v, _| {
501 let (coord, _, layer) = parts(widgets);
502 coord.set_default_layer(Some(layer.clone()));
503 coord.register_text_field(id.clone(), hit, config);
504 if let Some(p) = &parent {
505 coord.set_widget_parent(&id, p);
506 }
507 coord.set_a11y(&id, if name.is_empty() { placeholder } else { name }, None);
508 if masked {
509 coord.set_a11y_masked(&id);
510 }
511 coord.set_default_layer(None);
512 if let Some(t) = set {
513 let fields = coord.text_fields_mut();
514 fields.clear(&id);
515 if !t.is_empty() {
516 fields.set_text(&id, t);
517 }
518 }
519 let focused = v.is_focused(&id);
520 let (text, caret, preedit, engaged, selection, prev) = {
521 let fields = coord.text_fields();
522 match fields.field_state(&id) {
523 Some(s) => {
524 let (text, caret, preedit) = s.display();
525 let selection = preedit.is_none().then(|| s.selection_range()).flatten();
526 let prev = match (s.last_rect, s.last_char_positions.first()) {
528 (Some(r), Some(&x0)) => (r.0 - x0).max(0.0),
529 _ => 0.0,
530 };
531 (text, caret, preedit, s.engaged, selection, prev)
532 }
533 None => (String::new(), 0, None, false, None, 0.0),
534 }
535 };
536 let shown = if masked { "\u{2022}".repeat(text.chars().count()) } else { text.clone() };
537 let blink = focused && engaged && coord.text_fields().cursor_visible(now_ms);
538 render.set_font(&format!("400 {px}px {family}"));
539 let scroll = if clip && focused && !shown.is_empty() {
540 let at: String = shown.chars().take(caret).collect();
541 field_scroll(prev, render.measure_text(&at), render.measure_text(&shown), fr.width)
542 } else {
543 0.0
544 };
545 let tr = Rect::new(fr.x - scroll, fr.y, fr.width + scroll, fr.height);
548 let mut cut = clip.then(|| {
549 let (top, bot) = (fr.y.min(rect.y), (fr.y + fr.height).max(rect.y + rect.height));
550 Rect::new(fr.x, top, fr.width, bot - top)
551 });
552 if let Some(w) = within {
553 cut = Some(cut.map_or(w, |c| c.intersect(w)));
554 }
555 let pos = if cut.is_some_and(|c| c.width <= 0.0 || c.height <= 0.0) {
556 let mut pos = vec![tr.x];
558 let mut acc = String::new();
559 for ch in shown.chars() {
560 acc.push(ch);
561 pos.push(tr.x + render.measure_text(&acc));
562 }
563 pos
564 } else {
565 if let Some(c) = cut {
566 render.save();
567 render.begin_path();
568 render.rect(c.x, c.y, c.width, c.height);
569 render.clip();
570 }
571 if let Some(range) = selection {
572 paint_field_selection(render, tr.x, fr.y, fr.height, &shown, range, &sel_color);
573 }
574 let pos = draw_field_text_ime(render, tr, &shown, placeholder, blink.then_some(caret), preedit, px, &color, &ph_color, family);
575 if cut.is_some() {
576 render.restore();
577 }
578 pos
579 };
580 let ime = (focused && caret < pos.len()).then(|| Rect::new(pos[caret], fr.y, 1.0, fr.height));
581 let fields = coord.text_fields_mut();
582 let pos = match fields.field_state(&id) {
583 Some(s) => s.buffer_positions(pos),
584 None => pos,
585 };
586 fields.update_field(&id, (fr.x, fr.y, fr.width, fr.height), pos);
587 (FieldResponse { text, focused }, ime)
588 });
589 if let Some(at) = ime {
590 cx.ime_area(at);
591 }
592 out
593 }
594}
595
596pub(crate) fn field_scroll(prev: f64, caret_x: f64, text_w: f64, width: f64) -> f64 {
600 let room = (width - 1.0).max(0.0);
601 let s = prev.clamp(0.0, (text_w - room).max(0.0));
602 if caret_x < s {
603 caret_x
604 } else if caret_x > s + room {
605 caret_x - room
606 } else {
607 s
608 }
609}
610
611#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
616pub struct AreaLine {
617 pub start: usize,
619 pub end: usize,
621 pub hard: bool,
623}
624
625pub fn area_lines(render: &mut dyn RenderContext, text: &str, width: f64) -> Vec<AreaLine> {
630 let chars: Vec<char> = text.chars().collect();
631 let mut out = Vec::new();
632 let mut start = 0;
633 while start <= chars.len() {
634 let hard_end = chars[start..].iter().position(|c| *c == '\n').map_or(chars.len(), |i| start + i);
635 let mut ls = start;
638 let mut w = 0.0;
639 let mut brk: Option<usize> = None;
640 let mut i = start;
641 let mut buf = [0u8; 4];
642 while i < hard_end {
643 let c = chars[i];
644 let cw = render.measure_text(c.encode_utf8(&mut buf));
645 if w + cw > width && i > ls && !c.is_whitespace() {
646 let at = brk.filter(|b| *b > ls).unwrap_or(i);
647 out.push(AreaLine { start: ls, end: at, hard: false });
648 ls = at;
649 brk = None;
650 w = chars[ls..i].iter().map(|c| render.measure_text(c.encode_utf8(&mut buf))).sum();
651 continue;
652 }
653 w += cw;
654 if c.is_whitespace() {
655 brk = Some(i + 1);
656 }
657 i += 1;
658 }
659 let hard = hard_end < chars.len();
660 out.push(AreaLine { start: ls, end: hard_end, hard });
661 if !hard {
662 break;
663 }
664 start = hard_end + 1;
665 }
666 out
667}
668
669pub struct AreaBuilder<'a> {
675 id: WidgetId,
676 rect: Rect,
677 text_rect: Option<Rect>,
678 config: uzor::TextFieldConfig,
679 name: &'a str,
680 placeholder: &'a str,
681 within: Option<Rect>,
682 px: f64,
683 line_h: Option<f64>,
684 family: &'a str,
685 weight: u16,
686 color: Option<&'a str>,
687 placeholder_color: Option<&'a str>,
688 caret_color: Option<&'a str>,
689 set: Option<&'a str>,
690 parent: Option<WidgetId>,
691 scroll: f64,
692}
693
694#[derive(Clone, Debug, Default, PartialEq)]
696pub struct AreaResponse {
697 pub text: String,
699 pub focused: bool,
701 pub lines: usize,
703 pub content_h: f64,
705 pub caret_top: f64,
707 pub line_h: f64,
709}
710
711pub fn area<'a>(id: impl Into<WidgetId>, rect: Rect) -> AreaBuilder<'a> {
714 AreaBuilder {
715 id: id.into(),
716 rect,
717 text_rect: None,
718 config: uzor::TextFieldConfig::text().multiline(),
719 name: "",
720 placeholder: "",
721 within: None,
722 px: 13.0,
723 line_h: None,
724 family: "sans-serif",
725 weight: 400,
726 color: None,
727 placeholder_color: None,
728 caret_color: None,
729 set: None,
730 parent: None,
731 scroll: 0.0,
732 }
733}
734
735impl<'a> AreaBuilder<'a> {
736 pub fn config(mut self, c: uzor::TextFieldConfig) -> Self {
738 self.config = c.multiline();
739 self
740 }
741 pub fn name(mut self, n: &'a str) -> Self {
743 self.name = n;
744 self
745 }
746 pub fn placeholder(mut self, p: &'a str) -> Self {
748 self.placeholder = p;
749 self
750 }
751 pub fn text_rect(mut self, r: Rect) -> Self {
753 self.text_rect = Some(r);
754 self
755 }
756 pub fn clip_to(mut self, r: Rect) -> Self {
758 self.within = Some(r);
759 self
760 }
761 pub fn font(mut self, px: f64, family: &'a str) -> Self {
763 self.px = px;
764 self.family = family;
765 self
766 }
767 pub fn weight(mut self, w: u16) -> Self {
769 self.weight = w;
770 self
771 }
772 pub fn line_height(mut self, h: f64) -> Self {
774 self.line_h = Some(h);
775 self
776 }
777 pub fn colors(mut self, text: &'a str, placeholder: &'a str) -> Self {
779 self.color = Some(text);
780 self.placeholder_color = Some(placeholder);
781 self
782 }
783 pub fn caret_color(mut self, c: &'a str) -> Self {
785 self.caret_color = Some(c);
786 self
787 }
788 pub fn set(mut self, text: Option<&'a str>) -> Self {
790 self.set = text;
791 self
792 }
793 pub fn parent(mut self, p: impl Into<WidgetId>) -> Self {
795 self.parent = Some(p.into());
796 self
797 }
798 pub fn scroll(mut self, y: f64) -> Self {
800 self.scroll = y;
801 self
802 }
803
804 pub fn build<'c, C: ContentCx<'c>>(self, cx: &mut C) -> AreaResponse {
806 use uzor::ui::css_text::{fill_text_css, INTER};
807 use uzor::ui::widgets::atomic::text_input::TextInputTheme;
808 let now_ms = cx.time_ms();
809 let theme = theme_of(cx);
810 let color = self.color.map_or_else(|| css_hex(theme.text_normal()), str::to_owned);
811 let ph_color = self.placeholder_color.map_or_else(|| css_hex(theme.placeholder()), str::to_owned);
812 let sel_color = css_hex(theme.selection());
813 let AreaBuilder { id, rect, text_rect, config, name, placeholder, within, px, line_h, family, weight, set, parent, scroll, caret_color, .. } = self;
814 let lh = line_h.unwrap_or((px * 1.45).round());
815 let fr = text_rect.unwrap_or(rect);
816 let hit = within.map_or(rect, |w| w.intersect(rect));
817 let (out, ime) = cx.with_paint(|render, widgets, v, _| {
818 let (coord, _, layer) = parts(widgets);
819 coord.set_default_layer(Some(layer.clone()));
820 coord.register_text_field(id.clone(), hit, config);
821 if let Some(p) = &parent {
822 coord.set_widget_parent(&id, p);
823 }
824 coord.set_a11y(&id, if name.is_empty() { placeholder } else { name }, None);
825 coord.set_default_layer(None);
826 if let Some(t) = set {
827 let fields = coord.text_fields_mut();
828 fields.clear(&id);
829 if !t.is_empty() {
830 fields.set_text(&id, t);
831 }
832 }
833 let focused = v.is_focused(&id);
834 let (text, caret, preedit, engaged, selection) = match coord.text_fields().field_state(&id) {
835 Some(s) => {
836 let (text, caret, preedit) = s.display();
837 let selection = preedit.is_none().then(|| s.selection_range()).flatten();
838 (text, caret, preedit, s.engaged, selection)
839 }
840 None => (String::new(), 0, None, false, None),
841 };
842 let blink = focused && engaged && coord.text_fields().cursor_visible(now_ms);
843 render.set_font(&format!("{weight} {px}px {family}"));
844 let lines = area_lines(render, &text, fr.width);
845 let chars: Vec<char> = text.chars().collect();
846 let n = chars.len();
848 let mut xs = vec![fr.x; n + 1];
849 let mut tops = vec![fr.y - scroll; n + 1];
850 let mut widths = Vec::with_capacity(lines.len());
851 for (li, l) in lines.iter().enumerate() {
852 let top = fr.y - scroll + li as f64 * lh;
853 let mut acc = String::new();
854 xs[l.start] = fr.x;
855 tops[l.start] = top;
856 for i in l.start..l.end {
857 acc.push(chars[i]);
858 xs[i + 1] = fr.x + render.measure_text(&acc);
859 tops[i + 1] = top;
860 }
861 widths.push(xs[l.end] - fr.x);
862 }
863 let cut = within.map_or(fr, |w| w.intersect(fr));
864 let caret_line = lines.iter().rposition(|l| l.start <= caret).unwrap_or(0);
865 if cut.width > 0.0 && cut.height > 0.0 {
866 render.save();
867 render.begin_path();
868 render.rect(cut.x - 2.0, cut.y, cut.width + 4.0, cut.height);
870 render.clip();
871 let visible = |top: f64| top + lh >= cut.y && top <= cut.y + cut.height;
872 if text.is_empty() {
873 if !placeholder.is_empty() {
874 render.set_fill_color(&ph_color);
875 fill_text_css(render, placeholder, fr.x, fr.y - scroll, px, lh, INTER, uzor::render::TextAlign::Left);
876 }
877 } else {
878 if let Some((lo, hi)) = selection {
879 render.set_fill_color(&sel_color);
880 for l in &lines {
881 let (a, b) = (lo.max(l.start), hi.min(l.end));
882 let top = tops[l.start];
883 if a > b || !visible(top) || (a == b && !(l.hard && hi > l.end)) {
884 continue;
885 }
886 let tail = if l.hard && hi > l.end && lo <= l.end { px * 0.33 } else { 0.0 };
888 render.fill_rect(xs[a], top, xs[b] - xs[a] + tail, lh);
889 }
890 }
891 render.set_fill_color(&color);
892 for l in &lines {
893 let top = tops[l.start];
894 if l.end > l.start && visible(top) {
895 let s: String = chars[l.start..l.end].iter().collect();
896 fill_text_css(render, &s, fr.x, top, px, lh, INTER, uzor::render::TextAlign::Left);
897 }
898 }
899 if let Some((a, b)) = preedit {
900 for i in a..b.min(n) {
901 if tops[i] == tops[i + 1] && visible(tops[i]) {
902 render.fill_rect(xs[i].round(), (tops[i] + lh - 2.0).round(), (xs[i + 1] - xs[i]).max(1.0), 1.0);
903 }
904 }
905 }
906 }
907 if blink && visible(tops[caret.min(n)]) {
908 let c = caret.min(n);
909 render.set_fill_color(caret_color.unwrap_or(&color));
910 let ch = (px * 1.25).min(lh).round();
911 render.fill_rect(xs[c].round(), (tops[c] + (lh - ch) / 2.0).round(), 1.0, ch);
912 }
913 render.restore();
914 }
915 let c = caret.min(n);
916 let ime = focused.then(|| Rect::new(xs[c], tops[c], 1.0, lh));
917 let fields = coord.text_fields_mut();
918 let (xs, tops) = match fields.field_state(&id) {
919 Some(s) => (s.buffer_positions(xs), s.buffer_positions(tops)),
920 None => (xs, tops),
921 };
922 fields.update_field_lines(&id, (fr.x, fr.y, fr.width, fr.height), xs, tops, lh);
923 let _ = widths;
924 let resp = AreaResponse { text, focused, lines: lines.len(), content_h: lines.len() as f64 * lh, caret_top: caret_line as f64 * lh, line_h: lh };
925 (resp, ime)
926 });
927 if let Some(at) = ime {
928 cx.ime_area(at);
929 }
930 out
931 }
932}
933
934pub struct TabsBuilder<'a> {
938 id: WidgetId,
939 rect: Rect,
940 labels: &'a [&'a str],
941 selected: usize,
942 bind: Option<&'a mut usize>,
943}
944
945pub fn tabs<'a>(id: impl Into<WidgetId>, rect: Rect, labels: &'a [&'a str]) -> TabsBuilder<'a> {
947 TabsBuilder { id: id.into(), rect, labels, selected: 0, bind: None }
948}
949
950impl<'a> TabsBuilder<'a> {
951 pub fn selected(mut self, i: usize) -> Self {
953 self.selected = i;
954 self
955 }
956 pub fn bind(mut self, i: &'a mut usize) -> Self {
958 self.selected = *i;
959 self.bind = Some(i);
960 self
961 }
962
963 pub fn build<'c, C: ContentCx<'c>>(self, cx: &mut C) -> Response {
965 let theme = theme_of(cx);
966 let n = self.labels.len().max(1) as f64;
967 let w = self.rect.width / n;
968 let mut r = cx.with_paint(|render, widgets, v, _| {
969 let mut r = Response::of(v, &self.id);
970 r.index = picked(v, &self.id, "tab");
971 let settings = TabSettings { theme: Box::new(theme), ..Default::default() };
972 let (coord, _, layer) = parts(widgets);
973 let active = r.index.unwrap_or(self.selected);
974 for (i, label) in self.labels.iter().enumerate() {
975 let tid = child(&self.id, "tab", i);
976 let tr = Rect::new(self.rect.x + w * i as f64, self.rect.y, w, self.rect.height);
977 register_tab_on_layer(coord, tid.clone(), tr, focusable(), None, layer);
978 coord.set_a11y(&tid, *label, Some(i == active));
979 r.hovered |= v.is_hovered(&tid);
980 r.focused |= v.is_focused(&tid);
981 let mut cfg = TabConfig::new(tid.as_str(), *label);
982 cfg.active = i == active;
983 let view = TabView { tab: &cfg, hovered: v.is_hovered(&tid), pressed: v.is_pressed(&tid), close_btn_hovered: false };
984 draw_tab(render, tr, &view, &settings);
985 }
986 r
987 });
988 if let Some(i) = r.index {
989 r.changed = i != self.selected;
990 if let Some(b) = self.bind {
991 *b = i;
992 }
993 }
994 r
995 }
996}
997
998pub struct ListBuilder<'a> {
1002 id: WidgetId,
1003 rect: Rect,
1004 rows: &'a [&'a str],
1005 row_height: f64,
1006 scroll: f64,
1007 selected: Option<usize>,
1008 bind: Option<&'a mut Option<usize>>,
1009}
1010
1011pub fn list<'a>(id: impl Into<WidgetId>, rect: Rect, rows: &'a [&'a str]) -> ListBuilder<'a> {
1014 ListBuilder { id: id.into(), rect, rows, row_height: 28.0, scroll: 0.0, selected: None, bind: None }
1015}
1016
1017impl<'a> ListBuilder<'a> {
1018 pub fn row_height(mut self, h: f64) -> Self {
1020 self.row_height = h;
1021 self
1022 }
1023 pub fn scroll(mut self, y: f64) -> Self {
1025 self.scroll = y;
1026 self
1027 }
1028 pub fn selected(mut self, i: Option<usize>) -> Self {
1030 self.selected = i;
1031 self
1032 }
1033 pub fn bind(mut self, i: &'a mut Option<usize>) -> Self {
1035 self.selected = *i;
1036 self.bind = Some(i);
1037 self
1038 }
1039 pub fn content_height(&self) -> f64 {
1041 self.rows.len() as f64 * self.row_height
1042 }
1043
1044 pub fn build<'c, C: ContentCx<'c>>(self, cx: &mut C) -> Response {
1046 let theme = theme_of(cx);
1047 let mut r = cx.with_paint(|render, widgets, v, _| {
1048 let mut r = Response::of(v, &self.id);
1049 r.index = picked(v, &self.id, "row");
1050 let settings = ItemSettings::default().with_theme(Box::new(theme));
1051 let (coord, _, layer) = parts(widgets);
1052 let sel = r.index.or(self.selected);
1053 let (top, bottom) = (self.rect.y, self.rect.y + self.rect.height);
1054 for (i, row) in self.rows.iter().enumerate() {
1055 let y = top + i as f64 * self.row_height - self.scroll;
1056 if y < top || y + self.row_height > bottom {
1057 continue;
1058 }
1059 let rid = child(&self.id, "row", i);
1060 let rr = Rect::new(self.rect.x, y, self.rect.width, self.row_height);
1061 coord.register_atomic(rid.clone(), WidgetKind::Item, rr, focusable(), layer);
1062 coord.set_a11y(&rid, *row, Some(sel == Some(i)));
1063 r.hovered |= v.is_hovered(&rid);
1064 r.focused |= v.is_focused(&rid);
1065 let ws = if sel == Some(i) { WidgetState::Active } else { interaction_state(v, &rid, false) };
1066 let view = ItemView { label: Some(row), icon: None, svg: None };
1067 draw_item(render, rr, ws, &view, &settings, &ItemRenderKind::Label, |_, _, _, _| {}, |_, _, _, _| {});
1068 }
1069 r
1070 });
1071 if let Some(i) = r.index {
1072 r.changed = Some(i) != self.selected;
1073 if let Some(b) = self.bind {
1074 *b = Some(i);
1075 }
1076 }
1077 r
1078 }
1079}
1080
1081pub struct TableBuilder<'a> {
1085 id: WidgetId,
1086 rect: Rect,
1087 columns: &'a [&'a str],
1088 rows: &'a [Vec<String>],
1089 tracks: Option<&'a str>,
1090 row_height: f64,
1091 scroll: f64,
1092 selected: Option<usize>,
1093 bind: Option<&'a mut Option<usize>>,
1094 font: &'a str,
1095}
1096
1097pub fn table<'a>(id: impl Into<WidgetId>, rect: Rect, columns: &'a [&'a str], rows: &'a [Vec<String>]) -> TableBuilder<'a> {
1101 TableBuilder {
1102 id: id.into(),
1103 rect,
1104 columns,
1105 rows,
1106 tracks: None,
1107 row_height: 28.0,
1108 scroll: 0.0,
1109 selected: None,
1110 bind: None,
1111 font: "13px sans-serif",
1112 }
1113}
1114
1115impl<'a> TableBuilder<'a> {
1116 pub fn columns(mut self, tracks: &'a str) -> Self {
1118 self.tracks = Some(tracks);
1119 self
1120 }
1121 pub fn row_height(mut self, h: f64) -> Self {
1123 self.row_height = h;
1124 self
1125 }
1126 pub fn scroll(mut self, y: f64) -> Self {
1128 self.scroll = y;
1129 self
1130 }
1131 pub fn selected(mut self, i: Option<usize>) -> Self {
1133 self.selected = i;
1134 self
1135 }
1136 pub fn bind(mut self, i: &'a mut Option<usize>) -> Self {
1138 self.selected = *i;
1139 self.bind = Some(i);
1140 self
1141 }
1142 pub fn font(mut self, f: &'a str) -> Self {
1144 self.font = f;
1145 self
1146 }
1147 pub fn content_height(&self) -> f64 {
1149 self.rows.len() as f64 * self.row_height
1150 }
1151
1152 pub fn build<'c, C: ContentCx<'c>>(self, cx: &mut C) -> Response {
1154 use uzor::ui::widgets::atomic::text::theme::TextTheme;
1155 use uzor::ui::widgets::composite::panel::theme::PanelTheme;
1156 let theme = theme_of(cx);
1157 let Self { id, rect, columns, rows, tracks, row_height, scroll, selected, bind, font } = self;
1158 let mut r = cx.with_paint(|render, widgets, v, _| {
1159 let mut r = Response::of(v, &id);
1160 r.index = picked(v, &id, "row");
1161 r.column = picked(v, &id, "col");
1162 let (coord, _, layer) = parts(widgets);
1163 let even = vec!["1fr"; columns.len().max(1)].join(" ");
1164 let spec = tracks.unwrap_or(&even);
1165 let cols = uzor::ui::flow::grid_tracks(rect.width, &uzor::ui::flow::parse_tracks(spec, rect.width, 0.0), 0.0);
1166 let sel = r.index.or(selected);
1167 render.set_font(font);
1168 render.set_text_align(uzor::render::TextAlign::Left);
1169 render.set_text_baseline(uzor::render::TextBaseline::Middle);
1170 let cells = |render: &mut dyn RenderContext, y: f64, texts: &mut dyn Iterator<Item = &str>, color: &str| {
1171 render.set_fill_color(color);
1172 for ((x, w), t) in cols.iter().zip(texts) {
1173 render.save();
1174 render.clip_rect(rect.x + x, y, *w, row_height);
1175 render.fill_text(t, rect.x + x + 8.0, y + row_height / 2.0);
1176 render.restore();
1177 }
1178 };
1179 render.set_fill_color(theme.column_header_bg());
1181 render.fill_rect(rect.x, rect.y, rect.width, row_height);
1182 for (j, (x, w)) in cols.iter().enumerate().take(columns.len()) {
1183 let cid = child(&id, "col", j);
1184 coord.register_atomic(cid.clone(), WidgetKind::Item, Rect::new(rect.x + x, rect.y, *w, row_height), focusable(), layer);
1185 coord.set_a11y(&cid, columns[j], None);
1186 r.hovered |= v.is_hovered(&cid);
1187 r.focused |= v.is_focused(&cid);
1188 }
1189 cells(render, rect.y, &mut columns.iter().copied(), theme.column_header_text());
1190 let (top, bottom) = (rect.y + row_height, rect.y + rect.height);
1192 for (i, row) in rows.iter().enumerate() {
1193 let y = top + i as f64 * row_height - scroll;
1194 if y < top || y + row_height > bottom {
1195 continue;
1196 }
1197 let rid = child(&id, "row", i);
1198 let rr = Rect::new(rect.x, y, rect.width, row_height);
1199 coord.register_atomic(rid.clone(), WidgetKind::Item, rr, focusable(), layer);
1200 coord.set_a11y(&rid, &row.join(", "), Some(sel == Some(i)));
1201 let hov = v.is_hovered(&rid);
1202 r.hovered |= hov;
1203 r.focused |= v.is_focused(&rid);
1204 let bg = if sel == Some(i) { theme.row_bg_selected() } else if hov { theme.row_bg_hover() } else { theme.row_bg_normal() };
1205 render.set_fill_color(bg);
1206 render.fill_rect(rr.x, rr.y, rr.width, rr.height);
1207 render.set_fill_color(theme.divider());
1208 render.fill_rect(rr.x, rr.y + rr.height - 1.0, rr.width, 1.0);
1209 cells(render, y, &mut row.iter().map(String::as_str), theme.text_color());
1210 }
1211 r
1212 });
1213 if let Some(i) = r.index {
1214 r.changed = Some(i) != selected;
1215 if let Some(b) = bind {
1216 *b = Some(i);
1217 }
1218 }
1219 r
1220 }
1221}
1222
1223#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
1227pub enum Side {
1228 Left,
1230 #[default]
1232 Right,
1233}
1234
1235pub struct DrawerBuilder<'a> {
1237 id: WidgetId,
1238 area: Rect,
1239 open: &'a mut bool,
1240 side: Side,
1241 width: f64,
1242 title: Option<&'a str>,
1243 progress: f64,
1244 dim: bool,
1245}
1246
1247pub fn drawer<'a>(id: impl Into<WidgetId>, area: Rect, open: &'a mut bool) -> DrawerBuilder<'a> {
1251 DrawerBuilder { id: id.into(), area, open, side: Side::Right, width: 320.0, title: None, progress: 1.0, dim: true }
1252}
1253
1254impl<'a> DrawerBuilder<'a> {
1255 pub fn side(mut self, s: Side) -> Self {
1257 self.side = s;
1258 self
1259 }
1260 pub fn width(mut self, w: f64) -> Self {
1262 self.width = w;
1263 self
1264 }
1265 pub fn title(mut self, t: &'a str) -> Self {
1267 self.title = Some(t);
1268 self
1269 }
1270 pub fn progress(mut self, t: f64) -> Self {
1273 self.progress = t.clamp(0.0, 1.0);
1274 self
1275 }
1276 pub fn dim(mut self, on: bool) -> Self {
1278 self.dim = on;
1279 self
1280 }
1281 pub fn body_rect(&self) -> Rect {
1283 let w = self.width.min(self.area.width);
1284 let shown = w * self.progress;
1285 let x = match self.side {
1286 Side::Left => self.area.x - w + shown,
1287 Side::Right => self.area.x + self.area.width - shown,
1288 };
1289 Rect::new(x, self.area.y, w, self.area.height)
1290 }
1291
1292 pub fn build<'c, C: ContentCx<'c>>(self, cx: &mut C) -> Response {
1294 use uzor::ui::widgets::composite::modal::theme::ModalTheme;
1295 use uzor::ui::widgets::composite::panel::theme::PanelTheme;
1296 if !*self.open {
1297 return Response::default();
1298 }
1299 let theme = theme_of(cx);
1300 let body = self.body_rect();
1301 let scrim = WidgetId::from(format!("{}:scrim", self.id.as_str()));
1302 let r = cx.with_paint(|render, widgets, v, _| {
1303 let (coord, _, layer) = parts(widgets);
1304 coord.register_atomic(scrim.clone(), WidgetKind::Custom, self.area, Sense::CLICK, layer);
1305 coord.register_atomic(self.id.clone(), WidgetKind::Custom, body, Sense::CLICK | Sense::HOVER, layer);
1306 coord.set_a11y(&self.id, self.title.unwrap_or(""), None);
1307 if self.dim {
1308 render.set_global_alpha(self.progress);
1309 render.set_fill_color(ModalTheme::backdrop_dim(&theme));
1310 render.fill_rect(self.area.x, self.area.y, self.area.width, self.area.height);
1311 render.set_global_alpha(1.0);
1312 }
1313 render.set_fill_color(PanelTheme::bg(&theme));
1314 render.fill_rect(body.x, body.y, body.width, body.height);
1315 let edge = if self.side == Side::Right { body.x } else { body.x + body.width - 1.0 };
1316 render.set_fill_color(PanelTheme::border(&theme));
1317 render.fill_rect(edge, body.y, 1.0, body.height);
1318 let mut r = Response::of(v, &self.id);
1319 r.clicked = v.clicked(&scrim);
1320 r
1321 });
1322 if r.clicked {
1323 *self.open = false;
1324 return Response { changed: true, ..r };
1325 }
1326 r
1327 }
1328}
1329
1330#[derive(Default)]
1333struct SelectOpen {
1334 open: bool,
1335 list: SelectState,
1336}
1337
1338pub struct SelectBuilder<'a> {
1340 id: WidgetId,
1341 rect: Rect,
1342 options: &'a [&'a str],
1343 selected: usize,
1344 bind: Option<&'a mut usize>,
1345 disabled: bool,
1346 searchable: Option<bool>,
1347 within: Option<Rect>,
1348 style: Option<SelectStyle>,
1349 key: Option<&'a KeyInput>,
1350}
1351
1352pub fn select<'a>(id: impl Into<WidgetId>, rect: Rect, options: &'a [&'a str]) -> SelectBuilder<'a> {
1363 SelectBuilder { id: id.into(), rect, options, selected: 0, bind: None, disabled: false, searchable: None, within: None, style: None, key: None }
1364}
1365
1366pub fn select_is_open<'c, C: ContentCx<'c>>(cx: &mut C, id: &str) -> bool {
1369 cx.with_paint(|_, widgets, _, _| widgets.states.get_or_insert_with(WidgetId::from(format!("{id}:open")), SelectOpen::default).open)
1370}
1371
1372impl<'a> SelectBuilder<'a> {
1373 pub fn selected(mut self, i: usize) -> Self {
1375 self.selected = i;
1376 self
1377 }
1378 pub fn bind(mut self, i: &'a mut usize) -> Self {
1380 self.selected = *i;
1381 self.bind = Some(i);
1382 self
1383 }
1384 pub fn disabled(mut self, on: bool) -> Self {
1386 self.disabled = on;
1387 self
1388 }
1389 pub fn searchable(mut self, on: bool) -> Self {
1391 self.searchable = Some(on);
1392 self
1393 }
1394 pub fn within(mut self, container: Rect) -> Self {
1396 self.within = Some(container);
1397 self
1398 }
1399 pub fn style(mut self, s: SelectStyle) -> Self {
1401 self.style = Some(s);
1402 self
1403 }
1404 pub fn key(mut self, k: Option<&'a KeyInput>) -> Self {
1406 self.key = k.filter(|k| k.state != crate::KeyState::Up);
1407 self
1408 }
1409
1410 pub fn build<'c, C: ContentCx<'c>>(self, cx: &mut C) -> Response {
1414 let theme = theme_of(cx);
1415 let ls = self.style.unwrap_or_default();
1416 let searchable = self.searchable.unwrap_or(self.options.len() > ls.window());
1417 let ls = match self.within {
1418 Some(w) => ls.fit(room(self.rect, w, ls.gap), searchable),
1419 None => ls,
1420 };
1421 let win = ls.window();
1422 let labels: Vec<(&str, &str)> = self.options.iter().map(|o| (*o, *o)).collect();
1423 let mut r = cx.with_paint(|render, widgets, v, tokens| {
1424 let mut r = Response::of(v, &self.id);
1425 let sid = WidgetId::from(format!("{}:open", self.id.as_str()));
1426 let mut key_used = false;
1427 let mut close = false;
1428 let (open, list) = {
1429 let st = widgets.states.get_or_insert_with(sid, SelectOpen::default);
1430 r.index = picked(v, &self.id, "list:item");
1431 let was = st.open;
1432 if self.disabled || r.index.is_some() || (st.open && clicked_outside(v, &self.id)) {
1433 st.open = false;
1434 } else if r.clicked {
1435 st.open = !st.open;
1436 } else if let Some(k) = self.key {
1437 use uzor::input::keyboard::KeyCode as K;
1438 if st.open {
1439 let rows = filter(&labels, &st.list.query);
1440 match st.list.key(k.code, k.text.as_deref(), k.mods.ctrl || k.mods.meta, rows.len(), searchable, win) {
1441 SelectKey::Changed => key_used = true,
1442 SelectKey::Pick(i) => {
1443 r.index = rows.get(i).copied();
1444 st.open = false;
1445 key_used = true;
1446 }
1447 SelectKey::Close => {
1448 close = true;
1449 key_used = true;
1450 }
1451 SelectKey::Ignored => {}
1452 }
1453 } else if r.focused && matches!(k.code, K::Enter | K::Space | K::ArrowDown) {
1454 st.open = true;
1455 key_used = true;
1456 }
1457 }
1458 if close {
1459 st.open = false;
1460 }
1461 if st.open && !was {
1462 st.list = SelectState::open_at(Some(self.selected), win);
1463 }
1464 (st.open, st.list.clone())
1465 };
1466 r.pressed = key_used;
1467 let label = self.options.get(r.index.unwrap_or(self.selected)).copied().unwrap_or("");
1468 let view = ButtonView {
1469 icon: None,
1470 text: Some(label),
1471 active: open,
1472 disabled: self.disabled,
1473 active_border: None,
1474 hover_chevron: None,
1475 };
1476 let mut bs = button_settings(tokens);
1477 bs.theme = Box::new(theme.clone());
1478 paint_button(render, widgets, v, self.id.clone(), self.rect, &view, &bs);
1479 widgets.coord.set_a11y(&self.id, label, None);
1480 if open {
1481 let rows = filter(&labels, &list.query);
1482 let (w, h) = ls.list_size(rows.len(), searchable, self.rect.width);
1483 let within = self.within.unwrap_or(Rect::new(-1.0e6, -1.0e6, 2.0e6, 2.0e6));
1484 let b = place(self.rect, w, h, within, ls.gap);
1485 let shown: Vec<(&str, bool)> = rows.iter().map(|&i| (self.options[i], i == self.selected)).collect();
1486 let pre = format!("{}:list:item:", self.id.as_str());
1487 let hovered: Option<usize> = v.hovered().and_then(|w| w.as_str().strip_prefix(pre.as_str())?.parse().ok());
1488 let hover = |k: usize| hovered.is_some() && rows.get(k).copied() == hovered;
1489 let painted = draw_list(render, b, &shown, &list, searchable.then_some(list.query.as_str()), &hover, &ls);
1490 let (coord, _, layer) = parts(widgets);
1491 coord.register_atomic(WidgetId::from(format!("{}:list", self.id.as_str())), WidgetKind::Custom, b, Sense::CLICK | Sense::HOVER, layer);
1492 for (k, rr) in painted {
1493 let oi = rows[k];
1494 let rid = child(&self.id, "list:item", oi);
1495 coord.register_atomic(rid.clone(), WidgetKind::Item, rr, Sense::CLICK | Sense::HOVER, layer);
1496 coord.set_a11y(&rid, self.options[oi], Some(oi == self.selected));
1497 }
1498 }
1499 r.checked = open;
1500 r
1501 });
1502 if let Some(i) = r.index {
1503 r.changed = i != self.selected;
1504 if let Some(b) = self.bind {
1505 *b = i;
1506 }
1507 }
1508 r
1509 }
1510}
1511
1512pub struct MenuBuilder<'a> {
1516 id: WidgetId,
1517 at: (f64, f64),
1518 items: &'a [&'a str],
1519 open: &'a mut bool,
1520 title: Option<&'a str>,
1521 danger: Option<usize>,
1522}
1523
1524pub fn menu<'a>(id: impl Into<WidgetId>, at: (f64, f64), items: &'a [&'a str], open: &'a mut bool) -> MenuBuilder<'a> {
1527 MenuBuilder { id: id.into(), at, items, open, title: None, danger: None }
1528}
1529
1530impl<'a> MenuBuilder<'a> {
1531 pub fn title(mut self, t: &'a str) -> Self {
1533 self.title = Some(t);
1534 self
1535 }
1536 pub fn danger(mut self, i: usize) -> Self {
1538 self.danger = Some(i);
1539 self
1540 }
1541
1542 pub fn build<'c, C: ContentCx<'c>>(self, cx: &mut C) -> Response {
1544 if !*self.open {
1545 return Response::default();
1546 }
1547 let theme = theme_of(cx);
1548 let r = cx.with_paint(|render, widgets, v, _| {
1549 let mut r = Response::of(v, &self.id);
1550 r.index = picked(v, &self.id, "item");
1551 if r.index.is_some() || clicked_outside(v, &self.id) {
1552 return (r, false);
1553 }
1554 let items: Vec<ContextMenuItem<'_>> = self
1555 .items
1556 .iter()
1557 .enumerate()
1558 .map(|(i, l)| ContextMenuItem { action: l, label: l, icon: None, danger: self.danger == Some(i), separator_after: false, enabled: true })
1559 .collect();
1560 let state = ContextMenuState { is_open: true, x: self.at.0, y: self.at.1, ..Default::default() };
1561 let view = ContextMenuView { items: &items, target_id: None, title: self.title };
1562 let settings = ContextMenuSettings { theme: Box::new(theme), ..Default::default() };
1563 let (coord, _, layer) = parts(widgets);
1564 register_input_coordinator_context_menu(coord, self.id.clone(), &state, &view, &settings, &ContextMenuRenderKind::Default, layer);
1565 for (i, l) in self.items.iter().enumerate() {
1566 coord.set_a11y(&child(&self.id, "item", i), *l, None);
1567 }
1568 draw_context_menu(render, &state, &view, &settings, &ContextMenuRenderKind::Default);
1569 (r, true)
1570 });
1571 *self.open = r.1;
1572 let mut r = r.0;
1573 r.changed = r.index.is_some();
1574 r
1575 }
1576}
1577
1578pub struct DialogBuilder<'a> {
1582 id: WidgetId,
1583 rect: Rect,
1584 title: Option<&'a str>,
1585 footer: &'a [&'a str],
1586 dim: bool,
1587}
1588
1589pub fn dialog<'a>(id: impl Into<WidgetId>, rect: Rect) -> DialogBuilder<'a> {
1593 DialogBuilder { id: id.into(), rect, title: None, footer: &[], dim: true }
1594}
1595
1596impl<'a> DialogBuilder<'a> {
1597 pub fn title(mut self, t: &'a str) -> Self {
1599 self.title = Some(t);
1600 self
1601 }
1602 pub fn footer(mut self, labels: &'a [&'a str]) -> Self {
1604 self.footer = labels;
1605 self
1606 }
1607 pub fn dim(mut self, on: bool) -> Self {
1609 self.dim = on;
1610 self
1611 }
1612
1613 pub fn build<'c, C: ContentCx<'c>>(self, cx: &mut C) -> Response {
1616 let theme = theme_of(cx);
1617 cx.with_paint(|render, widgets, v, _| {
1618 let mut r = Response::of(v, &self.id);
1619 r.clicked = v.clicked(&WidgetId::from(format!("{}:close", self.id.as_str())));
1620 r.index = picked(v, &self.id, "footer");
1621 r.changed = r.clicked || r.index.is_some();
1622 let buttons: Vec<FooterBtn<'_>> = self
1623 .footer
1624 .iter()
1625 .enumerate()
1626 .map(|(i, l)| FooterBtn { label: l, style: if i == 0 { FooterBtnStyle::Primary } else { FooterBtnStyle::Ghost } })
1627 .collect();
1628 let mut view = ModalView {
1629 title: self.title,
1630 tabs: &[],
1631 footer_buttons: &buttons,
1632 wizard_pages: &[],
1633 backdrop: if self.dim { BackdropKind::Dim } else { BackdropKind::None },
1634 overflow: Default::default(),
1635 resizable: false,
1636 };
1637 let kind = if buttons.is_empty() { ModalRenderKind::WithHeader } else { ModalRenderKind::WithHeaderFooter };
1638 let settings = ModalSettings { theme: Box::new(theme), ..Default::default() };
1639 let (coord, states, layer) = parts(widgets);
1640 let state = states.get_or_insert_with(self.id.clone(), ModalState::default);
1641 register_input_coordinator_modal(coord, self.id.clone(), self.rect, state, &mut view, &settings, &kind, layer);
1642 if let Some(t) = self.title {
1643 coord.set_a11y(&self.id, t, None);
1644 }
1645 for (i, l) in self.footer.iter().enumerate() {
1646 coord.set_a11y(&child(&self.id, "footer", i), *l, None);
1647 }
1648 coord.set_a11y(&WidgetId::from(format!("{}:close", self.id.as_str())), "Close", None);
1649 draw_modal(render, self.rect, state, &mut view, &settings, &kind);
1650 r
1651 })
1652 }
1653}
1654
1655pub struct SplitterBuilder<'a> {
1659 id: WidgetId,
1660 axis: Axis,
1661 span: Rect,
1662 pos: &'a mut f64,
1663 min: f64,
1664 max: f64,
1665 grab: f64,
1666}
1667
1668pub fn splitter<'a>(id: impl Into<WidgetId>, axis: Axis, span: Rect, pos: &'a mut f64) -> SplitterBuilder<'a> {
1670 SplitterBuilder { id: id.into(), axis, span, pos, min: f64::MIN, max: f64::MAX, grab: 9.0 }
1671}
1672
1673impl<'a> SplitterBuilder<'a> {
1674 pub fn range(mut self, min: f64, max: f64) -> Self {
1676 self.min = min;
1677 self.max = max;
1678 self
1679 }
1680 pub fn grab(mut self, px: f64) -> Self {
1682 self.grab = px;
1683 self
1684 }
1685
1686 pub fn build<'c, C: ContentCx<'c>>(self, cx: &mut C) -> Response {
1689 let theme = theme_of(cx);
1690 cx.with_paint(|render, widgets, v, _| {
1691 let mut r = Response::of(v, &self.id);
1692 let (coord, states, layer) = parts(widgets);
1693 let s = states.get_or_insert_with(self.id.clone(), Splitter::default);
1694 if let SplitterEvent::Drag(p) = s.update(v, &self.id, self.axis) {
1695 let p = p.clamp(self.min, self.max);
1696 r.changed = (p - *self.pos).abs() > f64::EPSILON;
1697 *self.pos = p;
1698 }
1699 r.pressed = s.dragging();
1700 let hot = s.hot(v, &self.id);
1701 register_splitter(coord, self.id.clone(), grab_rect(self.axis, *self.pos, self.span, self.grab), layer);
1702 let (line, orientation) = match self.axis {
1703 Axis::X => (Rect::new(*self.pos, self.span.y, 1.0, self.span.height), SeparatorOrientation::Vertical),
1704 Axis::Y => (Rect::new(self.span.x, *self.pos, self.span.width, 1.0), SeparatorOrientation::Horizontal),
1705 };
1706 let view = SeparatorView { kind: SeparatorType::Divider { orientation }, hovered: hot, dragging: r.pressed };
1707 let settings = SeparatorSettings { theme: Box::new(theme), style: Box::new(DefaultSeparatorStyle) };
1708 draw_separator(render, line, &view, &settings);
1709 r
1710 })
1711 }
1712}
1713
1714pub struct ToastsBuilder<'a> {
1718 id: WidgetId,
1719 area: Rect,
1720 stack: &'a mut ToastStackState,
1721 now_ms: u64,
1722}
1723
1724pub fn toasts<'a>(id: impl Into<WidgetId>, area: Rect, stack: &'a mut ToastStackState, now_ms: u64) -> ToastsBuilder<'a> {
1727 ToastsBuilder { id: id.into(), area, stack, now_ms }
1728}
1729
1730impl<'a> ToastsBuilder<'a> {
1731 pub fn build<'c, C: ContentCx<'c>>(self, cx: &mut C) -> Response {
1734 let theme = theme_of(cx);
1735 let live = self.stack.tick(self.now_ms);
1736 cx.with_paint(|render, _widgets, v, _| {
1737 let mut r = Response::of(v, &self.id);
1738 r.changed = !live.is_empty();
1739 if r.changed {
1740 render.save();
1741 render.translate(self.area.x, self.area.y);
1742 draw_toast_stack(render, live, &theme, self.area.width, self.area.height, self.now_ms);
1743 render.restore();
1744 }
1745 r
1746 })
1747 }
1748}
1749
1750#[cfg(test)]
1751#[path = "kit_tests.rs"]
1752mod tests;
1753
1754pub struct DomBuilder<'a> {
1758 rect: Rect,
1759 sheet: &'a uzor::ui::style::Sheet,
1760 root: uzor::ui::dom::El,
1761 scroll: f64,
1762 viewport: Option<Rect>,
1763 slots: Option<&'a mut dyn FnMut(&mut dyn RenderContext, &SlotFrame<'_>)>,
1764}
1765
1766#[derive(Clone, Debug)]
1769pub struct SlotFrame<'k> {
1770 pub key: &'k str,
1772 pub rect: Rect,
1775 pub gestures: Vec<crate::types::gesture::Gesture>,
1778 pub pointer: Option<(f64, f64)>,
1781 pub clicked: bool,
1783}
1784
1785impl SlotFrame<'_> {
1786 pub fn local(&self, x: f64, y: f64) -> (f64, f64) {
1788 (x - self.rect.x, y - self.rect.y)
1789 }
1790}
1791
1792#[derive(Clone, Debug, Default)]
1794pub struct DomResponse {
1795 pub dom: uzor::ui::dom::Dom,
1797 pub clicked: Option<String>,
1799 pub captured: Vec<(String, crate::types::gesture::Gesture)>,
1802 pub hovered: Option<String>,
1804 pub focused: Option<String>,
1806 pub edited: Vec<(String, String)>,
1808}
1809
1810pub fn dom<'a>(rect: Rect, sheet: &'a uzor::ui::style::Sheet, root: uzor::ui::dom::El) -> DomBuilder<'a> {
1823 DomBuilder { rect, sheet, root, scroll: 0.0, viewport: None, slots: None }
1824}
1825
1826impl<'a> DomBuilder<'a> {
1827 pub fn scroll(mut self, y: f64) -> Self {
1829 self.scroll = y;
1830 self
1831 }
1832 pub fn viewport(mut self, r: Rect) -> Self {
1834 self.viewport = Some(r);
1835 self
1836 }
1837 pub fn paint_slots(mut self, paint: &'a mut dyn FnMut(&mut dyn RenderContext, &SlotFrame<'_>)) -> Self {
1842 self.slots = Some(paint);
1843 self
1844 }
1845
1846 pub fn build<'c, C: ContentCx<'c>>(self, cx: &mut C) -> DomResponse {
1848 use uzor::ui::dom::{Control, El};
1849 use uzor::ui::style::State;
1850 let now_ms = cx.time_ms();
1851 let DomBuilder { rect, sheet, mut root, scroll, viewport, mut slots } = self;
1852 let (resp, ime) = cx.with_paint(|render, widgets, v, _| {
1853 let (coord, _, layer) = parts(widgets);
1854 let mut edited = Vec::new();
1855 let mut seed: Vec<(WidgetId, String)> = Vec::new();
1856 fn walk(e: &mut El, f: &mut dyn FnMut(&str, &mut uzor::ui::dom::Edit)) {
1858 if let (Some(id), Some(Control::Input(ed))) = (e.id.as_deref(), e.control.as_mut()) {
1859 f(id, ed);
1860 }
1861 for c in &mut e.children {
1862 walk(c, f);
1863 }
1864 }
1865 walk(&mut root, &mut |id, ed| {
1866 let wid = WidgetId::from(id);
1867 if coord.text_fields().field_state(&wid).is_none() {
1868 seed.push((wid.clone(), ed.value.clone()));
1869 }
1870 let focused = v.is_focused(&wid);
1871 if let Some(s) = coord.text_fields().field_state(&wid) {
1872 let text = s.text.clone();
1873 if text != ed.value {
1874 edited.push((id.to_string(), text.clone()));
1875 ed.value = text;
1876 }
1877 let caret = s.cursor.min(ed.value.chars().count());
1878 let composing = !s.preedit.is_empty();
1879 let sel = (!composing).then(|| s.selection_range()).flatten();
1880 ed.caret = focused.then_some(caret);
1881 ed.anchor = sel.filter(|_| focused).map(|(a, b)| if b == caret { a } else { b });
1882 ed.preedit = (focused && composing).then(|| s.preedit.clone());
1883 ed.caret_on = focused && s.engaged && coord.text_fields().cursor_visible(now_ms);
1884 } else {
1885 ed.caret = None;
1886 }
1887 });
1888 let state = |id: &str| {
1889 let w = WidgetId::from(id);
1890 let mut s = State::NONE;
1891 if v.is_hovered(&w) {
1892 s = s | State::HOVER;
1893 }
1894 if v.is_pressed(&w) {
1895 s = s | State::ACTIVE;
1896 }
1897 if v.is_focused(&w) {
1898 s = s | State::FOCUS;
1900 if v.focus_visible() {
1901 s = s | State::FOCUS_VISIBLE;
1902 }
1903 }
1904 s
1905 };
1906 let vp = viewport.unwrap_or(rect);
1907 let d = uzor::ui::dom::lay_out_in(render, sheet, &root, rect.x, rect.y, rect.width, Some(vp), &state);
1908 let d = if scroll != 0.0 { d.moved(0.0, -scroll) } else { d };
1909 render.save();
1910 render.begin_path();
1911 render.rect(rect.x, rect.y, rect.width, rect.height);
1912 render.clip();
1913 match slots.as_mut() {
1914 Some(paint) => {
1915 uzor::ui::dom::paint_slots(render, &d, &mut |ctx, key, content| {
1916 let id = d.boxes.iter().find(|b| b.slot.as_deref() == Some(key)).and_then(|b| b.id.as_deref()).unwrap_or(key);
1917 let wid = WidgetId::from(id);
1918 let frame = SlotFrame { key, rect: content, gestures: v.captured_gestures(&wid), pointer: v.pointer_over(&wid), clicked: v.clicked(&wid) };
1919 ctx.save();
1920 ctx.begin_path();
1921 ctx.rect(content.x, content.y, content.width, content.height);
1922 ctx.clip();
1923 paint(ctx, &frame);
1924 ctx.restore();
1925 });
1926 }
1927 None => uzor::ui::dom::paint(render, &d),
1928 }
1929 render.restore();
1930 coord.set_default_layer(Some(layer.clone()));
1931 let mut ime = None;
1932 for b in &d.boxes {
1933 let Some(id) = b.id.as_deref() else { continue };
1934 let mut vis = b.clip.map_or(b.rect, |c| c.intersect(b.rect));
1936 if !b.fixed {
1937 vis = vis.intersect(rect);
1938 }
1939 if vis.width <= 0.0 || vis.height <= 0.0 {
1940 continue;
1941 }
1942 let wid = WidgetId::from(id);
1943 let name = b.accessible_name().unwrap_or_default().to_string();
1944 if let Some(Control::Input(e)) = &b.control {
1945 let cfg = if e.masked { uzor::TextFieldConfig::password() } else { uzor::TextFieldConfig::text() };
1946 coord.register_text_field(wid.clone(), vis, cfg);
1947 if let Some((_, v)) = seed.iter().find(|(s, _)| *s == wid) {
1948 coord.text_fields_mut().set_text(&wid, v);
1949 }
1950 coord.set_a11y(&wid, &name, None);
1951 let c = uzor::ui::dom::content_box(b);
1952 let sx = c.x - b.input_scroll();
1953 let pos: Vec<f64> = b.bounds.iter().map(|x| sx + x).collect();
1955 let _ = e;
1956 let fields = coord.text_fields_mut();
1957 let pos = match fields.field_state(&wid) {
1958 Some(s) => s.buffer_positions(pos),
1959 None => pos,
1960 };
1961 fields.update_field(&wid, (c.x, c.y, c.width, c.height), pos);
1962 if e.caret.is_some() {
1963 ime = b.caret_rect();
1964 }
1965 } else if b.tab || b.id.is_some() {
1966 let mut sense = if b.tab { focusable() } else { Sense::CLICK | Sense::HOVER };
1967 if b.captures_touch() {
1968 sense = sense.with_touch().with_gesture();
1971 }
1972 coord.register_atomic(wid.clone(), WidgetKind::Button, vis, sense, layer);
1973 coord.set_a11y(&wid, &name, b.control.as_ref().and_then(Control::checked));
1974 }
1975 }
1976 coord.set_default_layer(None);
1977 let ids: Vec<&str> = d.boxes.iter().rev().filter_map(|b| b.id.as_deref()).collect();
1978 let clicked = ids.iter().find(|i| v.clicked(&WidgetId::from(**i))).map(|s| s.to_string());
1979 let hovered = ids.iter().find(|i| v.is_hovered(&WidgetId::from(**i))).map(|s| s.to_string());
1980 let focused = ids.iter().find(|i| v.is_focused(&WidgetId::from(**i))).map(|s| s.to_string());
1981 let captured = d
1982 .touch_targets()
1983 .flat_map(|(id, _)| v.captured_gestures(&WidgetId::from(id)).into_iter().map(move |g| (id.to_string(), g)))
1984 .collect();
1985 (DomResponse { dom: d, clicked, captured, hovered, focused, edited }, ime)
1986 });
1987 if let Some(at) = ime {
1988 cx.ime_area(at);
1989 }
1990 resp
1991 }
1992}
1993
1994pub struct PaintSlot<'k> {
2000 id: &'k str,
2001 rect: Rect,
2002}
2003
2004#[derive(Clone, Debug, Default)]
2006pub struct SlotResponse {
2007 pub gestures: Vec<crate::types::gesture::Gesture>,
2009 pub pointer: Option<(f64, f64)>,
2011 pub clicked: bool,
2013}
2014
2015pub fn paint_slot(id: &str, rect: Rect) -> PaintSlot<'_> {
2020 PaintSlot { id, rect }
2021}
2022
2023impl PaintSlot<'_> {
2024 pub fn paint<'c, C: ContentCx<'c>>(self, cx: &mut C, paint: impl FnOnce(&mut dyn RenderContext, &SlotFrame<'_>)) -> SlotResponse {
2026 let PaintSlot { id, rect } = self;
2027 cx.with_paint(|render, widgets, v, _| {
2028 let (coord, _, layer) = parts(widgets);
2029 let wid = WidgetId::from(id);
2030 coord.register_atomic(wid.clone(), WidgetKind::Button, rect, (Sense::CLICK | Sense::HOVER).with_touch().with_gesture(), layer);
2031 let frame = SlotFrame { key: id, rect, gestures: v.captured_gestures(&wid), pointer: v.pointer_over(&wid), clicked: v.clicked(&wid) };
2032 render.save();
2033 render.begin_path();
2034 render.rect(rect.x, rect.y, rect.width, rect.height);
2035 render.clip();
2036 paint(render, &frame);
2037 render.restore();
2038 SlotResponse { gestures: frame.gestures, pointer: frame.pointer, clicked: frame.clicked }
2039 })
2040 }
2041}