use uzor::input::{Sense, WidgetKind};
use uzor::ui::widgets::atomic::item::{draw_item, ItemRenderKind, ItemSettings, ItemView};
use uzor::ui::widgets::atomic::separator::{
draw_separator, DefaultSeparatorStyle, SeparatorOrientation, SeparatorSettings, SeparatorType,
SeparatorView,
};
use uzor::ui::widgets::atomic::tab::{draw_tab, register_tab_on_layer, TabConfig, TabSettings, TabView};
use uzor::ui::widgets::atomic::text_input::{
draw_input, draw_input_cursor, InputType, InputView, TextFieldConfig as InputConfig, TextInputSettings,
};
use uzor::ui::widgets::atomic::toast::{draw_toast_stack, ToastStackState};
use uzor::ui::widgets::composite::context_menu::{
draw_context_menu, register_input_coordinator_context_menu, ContextMenuItem,
ContextMenuRenderKind, ContextMenuSettings, ContextMenuState, ContextMenuView,
};
use uzor::ui::widgets::composite::modal::render::draw_modal;
use uzor::ui::widgets::composite::select::{draw_list, filter, place, room, SelectKey, SelectState};
pub use uzor::ui::widgets::composite::select::SelectStyle;
use uzor::ui::widgets::composite::modal::{
register_input_coordinator_modal, BackdropKind, FooterBtn, FooterBtnStyle, ModalRenderKind,
ModalSettings, ModalState, ModalView,
};
use uzor::ui::widgets::atomic::button::ButtonView;
use uzor::render::RenderContext;
use uzor::{Rect, WidgetId, WidgetState};
use crate::handle::VisualView;
use crate::KeyInput;
use crate::types::spec::Spec;
use super::button::{button_settings, paint_button};
use super::host::ContentCx;
use super::paint::{interaction_state, parts, theme_of};
use super::splitter::{grab_rect, register as register_splitter, Splitter, SplitterEvent};
pub use super::lm::{
button, checkbox, toggle as switch, tooltip, ButtonBuilder, CheckboxBuilder, ToggleBuilder as SwitchBuilder,
TooltipBuilder,
};
pub use super::splitter::Axis;
pub use uzor::ui::domkit;
pub use uzor::ui::widgets::atomic::toast::{ToastSeverity, ToastType};
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct Response {
pub hovered: bool,
pub pressed: bool,
pub focused: bool,
pub clicked: bool,
pub changed: bool,
pub index: Option<usize>,
pub column: Option<usize>,
pub checked: bool,
}
impl Response {
fn of<S: Spec>(v: &VisualView<S>, id: &WidgetId) -> Self {
Response {
hovered: v.is_hover_within(id) || v.is_hovered(id),
pressed: v.is_pressed(id),
focused: v.is_focus_within(id) || v.is_focused(id),
clicked: v.clicked(id),
..Default::default()
}
}
}
fn child(id: &WidgetId, part: &str, i: usize) -> WidgetId {
WidgetId::from(format!("{}:{}:{}", id.as_str(), part, i))
}
fn picked<S: Spec>(v: &VisualView<S>, id: &WidgetId, part: &str) -> Option<usize> {
let pre = format!("{}:{}:", id.as_str(), part);
v.clicks().iter().find_map(|(w, _)| w.as_str().strip_prefix(pre.as_str())?.parse().ok())
}
fn clicked_outside<S: Spec>(v: &VisualView<S>, id: &WidgetId) -> bool {
!v.clicks().is_empty() && !v.clicks().iter().any(|(w, _)| w.as_str().starts_with(id.as_str()))
}
fn focusable() -> Sense {
(Sense::CLICK | Sense::HOVER).with_focus()
}
impl<'a> ButtonBuilder<'a> {
pub fn build_response<'c, C: ContentCx<'c>>(self, cx: &mut C) -> Response {
let id = self.id_ref().clone();
self.build(cx);
cx.with_paint(|_, _, v, _| Response::of(v, &id))
}
}
impl<'a> CheckboxBuilder<'a> {
pub fn build_response<'c, C: ContentCx<'c>>(self, cx: &mut C) -> Response {
let (id, label) = self.id_label();
let (id, label) = (id.clone(), label.unwrap_or("").to_owned());
let on = self.build(cx);
cx.with_paint(|_, w, v, _| {
w.coord.set_a11y(&id, &label, Some(on));
let r = Response::of(v, &id);
Response { changed: r.clicked, checked: on, ..r }
})
}
}
impl<'a> SwitchBuilder<'a> {
pub fn build_response<'c, C: ContentCx<'c>>(self, cx: &mut C) -> Response {
let (id, label, disabled) = self.id_label();
let (id, label) = (id.clone(), label.unwrap_or("").to_owned());
let on = self.build(cx);
cx.with_paint(|_, w, v, _| {
w.coord.set_a11y(&id, &label, Some(on));
let r = Response::of(v, &id);
Response { changed: r.clicked && !disabled, checked: on, ..r }
})
}
}
pub struct InputBuilder<'a> {
id: WidgetId,
rect: Rect,
value: &'a mut String,
placeholder: &'a str,
label: Option<&'a str>,
kind: InputType,
disabled: bool,
max_len: Option<usize>,
}
pub fn input<'a>(id: impl Into<WidgetId>, rect: Rect, value: &'a mut String) -> InputBuilder<'a> {
InputBuilder {
id: id.into(),
rect,
value,
placeholder: "",
label: None,
kind: InputType::Text,
disabled: false,
max_len: None,
}
}
impl<'a> InputBuilder<'a> {
pub fn placeholder(mut self, p: &'a str) -> Self {
self.placeholder = p;
self
}
pub fn label(mut self, l: &'a str) -> Self {
self.label = Some(l);
self
}
pub fn kind(mut self, k: InputType) -> Self {
self.kind = k;
self
}
pub fn password(self) -> Self {
self.kind(InputType::Password)
}
pub fn max_len(mut self, n: usize) -> Self {
self.max_len = Some(n);
self
}
pub fn disabled(mut self, on: bool) -> Self {
self.disabled = on;
self
}
pub fn build<'c, C: ContentCx<'c>>(self, cx: &mut C) -> Response {
let now_ms = cx.time_ms();
let theme = theme_of(cx);
let InputBuilder { id, rect, value, placeholder, label, kind, disabled, max_len } = self;
let (r, ime) = cx.with_paint(|render, widgets, v, _| {
let mut r = Response::of(v, &id);
let settings = TextInputSettings::with_config(InputConfig::text()).with_theme(Box::new(theme));
let (coord, states, layer) = parts(widgets);
if disabled {
coord.register_atomic(id.clone(), WidgetKind::Custom, rect, Sense::HOVER, layer);
} else {
let mut config = if kind == InputType::Password { uzor::TextFieldConfig::password() } else { uzor::TextFieldConfig::text() };
if let Some(n) = max_len {
config = config.with_max_len(n);
}
coord.set_default_layer(Some(layer.clone()));
coord.register_text_field(id.clone(), rect, config);
coord.set_default_layer(None);
}
coord.set_a11y(&id, label.unwrap_or(placeholder), None);
let synced = states.get_or_insert_with(WidgetId::from(format!("{}:value", id.as_str())), String::new);
let fields = coord.text_fields_mut();
if fields.has_field(&id) {
let now = fields.text(&id).to_owned();
if now != *synced {
*value = now.clone();
*synced = now;
r.changed = true;
} else if *value != *synced {
fields.set_text(&id, value);
*synced = value.clone();
}
}
let (shown, caret, preedit, engaged, selection) = match fields.field_state(&id) {
Some(s) => {
let (text, caret, preedit) = s.display();
let selection = preedit.is_none().then(|| s.selection_range()).flatten();
(text, caret, preedit, s.engaged, selection)
}
None => (value.clone(), value.chars().count(), None, false, None),
};
let shown = if kind == InputType::Password { "\u{2022}".repeat(shown.chars().count()) } else { shown };
let focused = !disabled && (r.focused || fields.is_focused(&id));
r.focused = focused;
let view = InputView {
text: &shown,
placeholder,
cursor: caret,
selection,
focused,
disabled,
input_type: kind,
};
let ws = interaction_state(v, &id, disabled);
let res = draw_input(render, rect, ws, &view, &settings);
let tint = settings.theme.cursor();
let mut ime = None;
if focused {
ime = Some(Rect::new(res.cursor_x, res.cursor_y, 1.0, res.cursor_height));
if engaged && fields.cursor_visible(now_ms) {
draw_input_cursor(render, res.cursor_x, res.cursor_y, res.cursor_height, 1.0, tint);
}
}
if let Some((a, b)) = preedit {
let x = |i: usize| res.char_x_positions.get(i).copied().unwrap_or(res.cursor_x);
draw_input_cursor(render, x(a), res.cursor_y + res.cursor_height, (x(b) - x(a)).max(0.0), 1.0, tint);
}
let fields = coord.text_fields_mut();
if let Some(s) = fields.field_state(&id) {
let pos = s.buffer_positions(res.char_x_positions);
fields.update_field(&id, (rect.x, rect.y, rect.width, rect.height), pos);
}
(r, ime)
});
if let Some(at) = ime {
cx.ime_area(at);
}
r
}
}
pub struct FieldBuilder<'a> {
id: WidgetId,
rect: Rect,
text_rect: Option<Rect>,
config: uzor::TextFieldConfig,
name: &'a str,
placeholder: &'a str,
masked: bool,
clip: bool,
within: Option<Rect>,
px: f64,
family: &'a str,
color: Option<&'a str>,
placeholder_color: Option<&'a str>,
set: Option<&'a str>,
parent: Option<WidgetId>,
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct FieldResponse {
pub text: String,
pub focused: bool,
}
pub fn field<'a>(id: impl Into<WidgetId>, rect: Rect) -> FieldBuilder<'a> {
FieldBuilder {
id: id.into(),
rect,
text_rect: None,
config: uzor::TextFieldConfig::text(),
name: "",
placeholder: "",
masked: false,
clip: true,
within: None,
px: 13.0,
family: "sans-serif",
color: None,
placeholder_color: None,
set: None,
parent: None,
}
}
fn css_hex(c: [u8; 4]) -> String {
format!("#{:02x}{:02x}{:02x}{:02x}", c[0], c[1], c[2], c[3])
}
fn paint_field_selection(render: &mut dyn RenderContext, origin_x: f64, y: f64, h: f64, text: &str, range: (usize, usize), color: &str) {
let lo = range.0.min(range.1);
let hi = range.0.max(range.1);
if lo == hi {
return;
}
let before: String = text.chars().take(lo).collect();
let mid: String = text.chars().skip(lo).take(hi - lo).collect();
let x = origin_x + render.measure_text(&before);
let w = render.measure_text(&mid);
render.set_fill_color(color);
render.fill_rect(x, y, w.max(0.0), h);
}
impl<'a> FieldBuilder<'a> {
pub fn config(mut self, c: uzor::TextFieldConfig) -> Self {
self.config = c;
self
}
pub fn name(mut self, n: &'a str) -> Self {
self.name = n;
self
}
pub fn placeholder(mut self, p: &'a str) -> Self {
self.placeholder = p;
self
}
pub fn masked(mut self, on: bool) -> Self {
self.masked = on;
self
}
pub fn text_rect(mut self, r: Rect) -> Self {
self.text_rect = Some(r);
self
}
pub fn clip(mut self, on: bool) -> Self {
self.clip = on;
self
}
pub fn clip_to(mut self, r: Rect) -> Self {
self.within = Some(r);
self
}
pub fn font(mut self, px: f64, family: &'a str) -> Self {
self.px = px;
self.family = family;
self
}
pub fn colors(mut self, text: &'a str, placeholder: &'a str) -> Self {
self.color = Some(text);
self.placeholder_color = Some(placeholder);
self
}
pub fn set(mut self, text: Option<&'a str>) -> Self {
self.set = text;
self
}
pub fn parent(mut self, p: impl Into<WidgetId>) -> Self {
self.parent = Some(p.into());
self
}
pub fn build<'c, C: ContentCx<'c>>(self, cx: &mut C) -> FieldResponse {
use uzor::ui::widgets::atomic::text_input::TextInputTheme;
use uzor::ui::widgets::composite::dialog::draw_field_text_ime;
let now_ms = cx.time_ms();
let theme = theme_of(cx);
let color = self.color.map_or_else(|| css_hex(theme.text_normal()), str::to_owned);
let ph_color = self.placeholder_color.map_or_else(|| css_hex(theme.placeholder()), str::to_owned);
let sel_color = css_hex(theme.selection());
let FieldBuilder { id, rect, text_rect, config, name, placeholder, masked, clip, within, px, family, set, parent, .. } = self;
let fr = text_rect.unwrap_or(rect);
let hit = within.map_or(rect, |w| w.intersect(rect));
let (out, ime) = cx.with_paint(|render, widgets, v, _| {
let (coord, _, layer) = parts(widgets);
coord.set_default_layer(Some(layer.clone()));
coord.register_text_field(id.clone(), hit, config);
if let Some(p) = &parent {
coord.set_widget_parent(&id, p);
}
coord.set_a11y(&id, if name.is_empty() { placeholder } else { name }, None);
if masked {
coord.set_a11y_masked(&id);
}
coord.set_default_layer(None);
if let Some(t) = set {
let fields = coord.text_fields_mut();
fields.clear(&id);
if !t.is_empty() {
fields.set_text(&id, t);
}
}
let focused = v.is_focused(&id);
let (text, caret, preedit, engaged, selection, prev) = {
let fields = coord.text_fields();
match fields.field_state(&id) {
Some(s) => {
let (text, caret, preedit) = s.display();
let selection = preedit.is_none().then(|| s.selection_range()).flatten();
let prev = match (s.last_rect, s.last_char_positions.first()) {
(Some(r), Some(&x0)) => (r.0 - x0).max(0.0),
_ => 0.0,
};
(text, caret, preedit, s.engaged, selection, prev)
}
None => (String::new(), 0, None, false, None, 0.0),
}
};
let shown = if masked { "\u{2022}".repeat(text.chars().count()) } else { text.clone() };
let blink = focused && engaged && coord.text_fields().cursor_visible(now_ms);
render.set_font(&format!("400 {px}px {family}"));
let scroll = if clip && focused && !shown.is_empty() {
let at: String = shown.chars().take(caret).collect();
field_scroll(prev, render.measure_text(&at), render.measure_text(&shown), fr.width)
} else {
0.0
};
let tr = Rect::new(fr.x - scroll, fr.y, fr.width + scroll, fr.height);
let mut cut = clip.then(|| {
let (top, bot) = (fr.y.min(rect.y), (fr.y + fr.height).max(rect.y + rect.height));
Rect::new(fr.x, top, fr.width, bot - top)
});
if let Some(w) = within {
cut = Some(cut.map_or(w, |c| c.intersect(w)));
}
let pos = if cut.is_some_and(|c| c.width <= 0.0 || c.height <= 0.0) {
let mut pos = vec![tr.x];
let mut acc = String::new();
for ch in shown.chars() {
acc.push(ch);
pos.push(tr.x + render.measure_text(&acc));
}
pos
} else {
if let Some(c) = cut {
render.save();
render.begin_path();
render.rect(c.x, c.y, c.width, c.height);
render.clip();
}
if let Some(range) = selection {
paint_field_selection(render, tr.x, fr.y, fr.height, &shown, range, &sel_color);
}
let pos = draw_field_text_ime(render, tr, &shown, placeholder, blink.then_some(caret), preedit, px, &color, &ph_color, family);
if cut.is_some() {
render.restore();
}
pos
};
let ime = (focused && caret < pos.len()).then(|| Rect::new(pos[caret], fr.y, 1.0, fr.height));
let fields = coord.text_fields_mut();
let pos = match fields.field_state(&id) {
Some(s) => s.buffer_positions(pos),
None => pos,
};
fields.update_field(&id, (fr.x, fr.y, fr.width, fr.height), pos);
(FieldResponse { text, focused }, ime)
});
if let Some(at) = ime {
cx.ime_area(at);
}
out
}
}
pub(crate) fn field_scroll(prev: f64, caret_x: f64, text_w: f64, width: f64) -> f64 {
let room = (width - 1.0).max(0.0);
let s = prev.clamp(0.0, (text_w - room).max(0.0));
if caret_x < s {
caret_x
} else if caret_x > s + room {
caret_x - room
} else {
s
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct AreaLine {
pub start: usize,
pub end: usize,
pub hard: bool,
}
pub fn area_lines(render: &mut dyn RenderContext, text: &str, width: f64) -> Vec<AreaLine> {
let chars: Vec<char> = text.chars().collect();
let mut out = Vec::new();
let mut start = 0;
while start <= chars.len() {
let hard_end = chars[start..].iter().position(|c| *c == '\n').map_or(chars.len(), |i| start + i);
let mut ls = start;
let mut w = 0.0;
let mut brk: Option<usize> = None;
let mut i = start;
let mut buf = [0u8; 4];
while i < hard_end {
let c = chars[i];
let cw = render.measure_text(c.encode_utf8(&mut buf));
if w + cw > width && i > ls && !c.is_whitespace() {
let at = brk.filter(|b| *b > ls).unwrap_or(i);
out.push(AreaLine { start: ls, end: at, hard: false });
ls = at;
brk = None;
w = chars[ls..i].iter().map(|c| render.measure_text(c.encode_utf8(&mut buf))).sum();
continue;
}
w += cw;
if c.is_whitespace() {
brk = Some(i + 1);
}
i += 1;
}
let hard = hard_end < chars.len();
out.push(AreaLine { start: ls, end: hard_end, hard });
if !hard {
break;
}
start = hard_end + 1;
}
out
}
pub struct AreaBuilder<'a> {
id: WidgetId,
rect: Rect,
text_rect: Option<Rect>,
config: uzor::TextFieldConfig,
name: &'a str,
placeholder: &'a str,
within: Option<Rect>,
px: f64,
line_h: Option<f64>,
family: &'a str,
weight: u16,
color: Option<&'a str>,
placeholder_color: Option<&'a str>,
caret_color: Option<&'a str>,
set: Option<&'a str>,
parent: Option<WidgetId>,
scroll: f64,
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct AreaResponse {
pub text: String,
pub focused: bool,
pub lines: usize,
pub content_h: f64,
pub caret_top: f64,
pub line_h: f64,
}
pub fn area<'a>(id: impl Into<WidgetId>, rect: Rect) -> AreaBuilder<'a> {
AreaBuilder {
id: id.into(),
rect,
text_rect: None,
config: uzor::TextFieldConfig::text().multiline(),
name: "",
placeholder: "",
within: None,
px: 13.0,
line_h: None,
family: "sans-serif",
weight: 400,
color: None,
placeholder_color: None,
caret_color: None,
set: None,
parent: None,
scroll: 0.0,
}
}
impl<'a> AreaBuilder<'a> {
pub fn config(mut self, c: uzor::TextFieldConfig) -> Self {
self.config = c.multiline();
self
}
pub fn name(mut self, n: &'a str) -> Self {
self.name = n;
self
}
pub fn placeholder(mut self, p: &'a str) -> Self {
self.placeholder = p;
self
}
pub fn text_rect(mut self, r: Rect) -> Self {
self.text_rect = Some(r);
self
}
pub fn clip_to(mut self, r: Rect) -> Self {
self.within = Some(r);
self
}
pub fn font(mut self, px: f64, family: &'a str) -> Self {
self.px = px;
self.family = family;
self
}
pub fn weight(mut self, w: u16) -> Self {
self.weight = w;
self
}
pub fn line_height(mut self, h: f64) -> Self {
self.line_h = Some(h);
self
}
pub fn colors(mut self, text: &'a str, placeholder: &'a str) -> Self {
self.color = Some(text);
self.placeholder_color = Some(placeholder);
self
}
pub fn caret_color(mut self, c: &'a str) -> Self {
self.caret_color = Some(c);
self
}
pub fn set(mut self, text: Option<&'a str>) -> Self {
self.set = text;
self
}
pub fn parent(mut self, p: impl Into<WidgetId>) -> Self {
self.parent = Some(p.into());
self
}
pub fn scroll(mut self, y: f64) -> Self {
self.scroll = y;
self
}
pub fn build<'c, C: ContentCx<'c>>(self, cx: &mut C) -> AreaResponse {
use uzor::ui::css_text::{fill_text_css, INTER};
use uzor::ui::widgets::atomic::text_input::TextInputTheme;
let now_ms = cx.time_ms();
let theme = theme_of(cx);
let color = self.color.map_or_else(|| css_hex(theme.text_normal()), str::to_owned);
let ph_color = self.placeholder_color.map_or_else(|| css_hex(theme.placeholder()), str::to_owned);
let sel_color = css_hex(theme.selection());
let AreaBuilder { id, rect, text_rect, config, name, placeholder, within, px, line_h, family, weight, set, parent, scroll, caret_color, .. } = self;
let lh = line_h.unwrap_or((px * 1.45).round());
let fr = text_rect.unwrap_or(rect);
let hit = within.map_or(rect, |w| w.intersect(rect));
let (out, ime) = cx.with_paint(|render, widgets, v, _| {
let (coord, _, layer) = parts(widgets);
coord.set_default_layer(Some(layer.clone()));
coord.register_text_field(id.clone(), hit, config);
if let Some(p) = &parent {
coord.set_widget_parent(&id, p);
}
coord.set_a11y(&id, if name.is_empty() { placeholder } else { name }, None);
coord.set_default_layer(None);
if let Some(t) = set {
let fields = coord.text_fields_mut();
fields.clear(&id);
if !t.is_empty() {
fields.set_text(&id, t);
}
}
let focused = v.is_focused(&id);
let (text, caret, preedit, engaged, selection) = match coord.text_fields().field_state(&id) {
Some(s) => {
let (text, caret, preedit) = s.display();
let selection = preedit.is_none().then(|| s.selection_range()).flatten();
(text, caret, preedit, s.engaged, selection)
}
None => (String::new(), 0, None, false, None),
};
let blink = focused && engaged && coord.text_fields().cursor_visible(now_ms);
render.set_font(&format!("{weight} {px}px {family}"));
let lines = area_lines(render, &text, fr.width);
let chars: Vec<char> = text.chars().collect();
let n = chars.len();
let mut xs = vec![fr.x; n + 1];
let mut tops = vec![fr.y - scroll; n + 1];
let mut widths = Vec::with_capacity(lines.len());
for (li, l) in lines.iter().enumerate() {
let top = fr.y - scroll + li as f64 * lh;
let mut acc = String::new();
xs[l.start] = fr.x;
tops[l.start] = top;
for i in l.start..l.end {
acc.push(chars[i]);
xs[i + 1] = fr.x + render.measure_text(&acc);
tops[i + 1] = top;
}
widths.push(xs[l.end] - fr.x);
}
let cut = within.map_or(fr, |w| w.intersect(fr));
let caret_line = lines.iter().rposition(|l| l.start <= caret).unwrap_or(0);
if cut.width > 0.0 && cut.height > 0.0 {
render.save();
render.begin_path();
render.rect(cut.x - 2.0, cut.y, cut.width + 4.0, cut.height);
render.clip();
let visible = |top: f64| top + lh >= cut.y && top <= cut.y + cut.height;
if text.is_empty() {
if !placeholder.is_empty() {
render.set_fill_color(&ph_color);
fill_text_css(render, placeholder, fr.x, fr.y - scroll, px, lh, INTER, uzor::render::TextAlign::Left);
}
} else {
if let Some((lo, hi)) = selection {
render.set_fill_color(&sel_color);
for l in &lines {
let (a, b) = (lo.max(l.start), hi.min(l.end));
let top = tops[l.start];
if a > b || !visible(top) || (a == b && !(l.hard && hi > l.end)) {
continue;
}
let tail = if l.hard && hi > l.end && lo <= l.end { px * 0.33 } else { 0.0 };
render.fill_rect(xs[a], top, xs[b] - xs[a] + tail, lh);
}
}
render.set_fill_color(&color);
for l in &lines {
let top = tops[l.start];
if l.end > l.start && visible(top) {
let s: String = chars[l.start..l.end].iter().collect();
fill_text_css(render, &s, fr.x, top, px, lh, INTER, uzor::render::TextAlign::Left);
}
}
if let Some((a, b)) = preedit {
for i in a..b.min(n) {
if tops[i] == tops[i + 1] && visible(tops[i]) {
render.fill_rect(xs[i].round(), (tops[i] + lh - 2.0).round(), (xs[i + 1] - xs[i]).max(1.0), 1.0);
}
}
}
}
if blink && visible(tops[caret.min(n)]) {
let c = caret.min(n);
render.set_fill_color(caret_color.unwrap_or(&color));
let ch = (px * 1.25).min(lh).round();
render.fill_rect(xs[c].round(), (tops[c] + (lh - ch) / 2.0).round(), 1.0, ch);
}
render.restore();
}
let c = caret.min(n);
let ime = focused.then(|| Rect::new(xs[c], tops[c], 1.0, lh));
let fields = coord.text_fields_mut();
let (xs, tops) = match fields.field_state(&id) {
Some(s) => (s.buffer_positions(xs), s.buffer_positions(tops)),
None => (xs, tops),
};
fields.update_field_lines(&id, (fr.x, fr.y, fr.width, fr.height), xs, tops, lh);
let _ = widths;
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 };
(resp, ime)
});
if let Some(at) = ime {
cx.ime_area(at);
}
out
}
}
pub struct TabsBuilder<'a> {
id: WidgetId,
rect: Rect,
labels: &'a [&'a str],
selected: usize,
bind: Option<&'a mut usize>,
}
pub fn tabs<'a>(id: impl Into<WidgetId>, rect: Rect, labels: &'a [&'a str]) -> TabsBuilder<'a> {
TabsBuilder { id: id.into(), rect, labels, selected: 0, bind: None }
}
impl<'a> TabsBuilder<'a> {
pub fn selected(mut self, i: usize) -> Self {
self.selected = i;
self
}
pub fn bind(mut self, i: &'a mut usize) -> Self {
self.selected = *i;
self.bind = Some(i);
self
}
pub fn build<'c, C: ContentCx<'c>>(self, cx: &mut C) -> Response {
let theme = theme_of(cx);
let n = self.labels.len().max(1) as f64;
let w = self.rect.width / n;
let mut r = cx.with_paint(|render, widgets, v, _| {
let mut r = Response::of(v, &self.id);
r.index = picked(v, &self.id, "tab");
let settings = TabSettings { theme: Box::new(theme), ..Default::default() };
let (coord, _, layer) = parts(widgets);
let active = r.index.unwrap_or(self.selected);
for (i, label) in self.labels.iter().enumerate() {
let tid = child(&self.id, "tab", i);
let tr = Rect::new(self.rect.x + w * i as f64, self.rect.y, w, self.rect.height);
register_tab_on_layer(coord, tid.clone(), tr, focusable(), None, layer);
coord.set_a11y(&tid, *label, Some(i == active));
r.hovered |= v.is_hovered(&tid);
r.focused |= v.is_focused(&tid);
let mut cfg = TabConfig::new(tid.as_str(), *label);
cfg.active = i == active;
let view = TabView { tab: &cfg, hovered: v.is_hovered(&tid), pressed: v.is_pressed(&tid), close_btn_hovered: false };
draw_tab(render, tr, &view, &settings);
}
r
});
if let Some(i) = r.index {
r.changed = i != self.selected;
if let Some(b) = self.bind {
*b = i;
}
}
r
}
}
pub struct ListBuilder<'a> {
id: WidgetId,
rect: Rect,
rows: &'a [&'a str],
row_height: f64,
scroll: f64,
selected: Option<usize>,
bind: Option<&'a mut Option<usize>>,
}
pub fn list<'a>(id: impl Into<WidgetId>, rect: Rect, rows: &'a [&'a str]) -> ListBuilder<'a> {
ListBuilder { id: id.into(), rect, rows, row_height: 28.0, scroll: 0.0, selected: None, bind: None }
}
impl<'a> ListBuilder<'a> {
pub fn row_height(mut self, h: f64) -> Self {
self.row_height = h;
self
}
pub fn scroll(mut self, y: f64) -> Self {
self.scroll = y;
self
}
pub fn selected(mut self, i: Option<usize>) -> Self {
self.selected = i;
self
}
pub fn bind(mut self, i: &'a mut Option<usize>) -> Self {
self.selected = *i;
self.bind = Some(i);
self
}
pub fn content_height(&self) -> f64 {
self.rows.len() as f64 * self.row_height
}
pub fn build<'c, C: ContentCx<'c>>(self, cx: &mut C) -> Response {
let theme = theme_of(cx);
let mut r = cx.with_paint(|render, widgets, v, _| {
let mut r = Response::of(v, &self.id);
r.index = picked(v, &self.id, "row");
let settings = ItemSettings::default().with_theme(Box::new(theme));
let (coord, _, layer) = parts(widgets);
let sel = r.index.or(self.selected);
let (top, bottom) = (self.rect.y, self.rect.y + self.rect.height);
for (i, row) in self.rows.iter().enumerate() {
let y = top + i as f64 * self.row_height - self.scroll;
if y < top || y + self.row_height > bottom {
continue;
}
let rid = child(&self.id, "row", i);
let rr = Rect::new(self.rect.x, y, self.rect.width, self.row_height);
coord.register_atomic(rid.clone(), WidgetKind::Item, rr, focusable(), layer);
coord.set_a11y(&rid, *row, Some(sel == Some(i)));
r.hovered |= v.is_hovered(&rid);
r.focused |= v.is_focused(&rid);
let ws = if sel == Some(i) { WidgetState::Active } else { interaction_state(v, &rid, false) };
let view = ItemView { label: Some(row), icon: None, svg: None };
draw_item(render, rr, ws, &view, &settings, &ItemRenderKind::Label, |_, _, _, _| {}, |_, _, _, _| {});
}
r
});
if let Some(i) = r.index {
r.changed = Some(i) != self.selected;
if let Some(b) = self.bind {
*b = Some(i);
}
}
r
}
}
pub struct TableBuilder<'a> {
id: WidgetId,
rect: Rect,
columns: &'a [&'a str],
rows: &'a [Vec<String>],
tracks: Option<&'a str>,
row_height: f64,
scroll: f64,
selected: Option<usize>,
bind: Option<&'a mut Option<usize>>,
font: &'a str,
}
pub fn table<'a>(id: impl Into<WidgetId>, rect: Rect, columns: &'a [&'a str], rows: &'a [Vec<String>]) -> TableBuilder<'a> {
TableBuilder {
id: id.into(),
rect,
columns,
rows,
tracks: None,
row_height: 28.0,
scroll: 0.0,
selected: None,
bind: None,
font: "13px sans-serif",
}
}
impl<'a> TableBuilder<'a> {
pub fn columns(mut self, tracks: &'a str) -> Self {
self.tracks = Some(tracks);
self
}
pub fn row_height(mut self, h: f64) -> Self {
self.row_height = h;
self
}
pub fn scroll(mut self, y: f64) -> Self {
self.scroll = y;
self
}
pub fn selected(mut self, i: Option<usize>) -> Self {
self.selected = i;
self
}
pub fn bind(mut self, i: &'a mut Option<usize>) -> Self {
self.selected = *i;
self.bind = Some(i);
self
}
pub fn font(mut self, f: &'a str) -> Self {
self.font = f;
self
}
pub fn content_height(&self) -> f64 {
self.rows.len() as f64 * self.row_height
}
pub fn build<'c, C: ContentCx<'c>>(self, cx: &mut C) -> Response {
use uzor::ui::widgets::atomic::text::theme::TextTheme;
use uzor::ui::widgets::composite::panel::theme::PanelTheme;
let theme = theme_of(cx);
let Self { id, rect, columns, rows, tracks, row_height, scroll, selected, bind, font } = self;
let mut r = cx.with_paint(|render, widgets, v, _| {
let mut r = Response::of(v, &id);
r.index = picked(v, &id, "row");
r.column = picked(v, &id, "col");
let (coord, _, layer) = parts(widgets);
let even = vec!["1fr"; columns.len().max(1)].join(" ");
let spec = tracks.unwrap_or(&even);
let cols = uzor::ui::flow::grid_tracks(rect.width, &uzor::ui::flow::parse_tracks(spec, rect.width, 0.0), 0.0);
let sel = r.index.or(selected);
render.set_font(font);
render.set_text_align(uzor::render::TextAlign::Left);
render.set_text_baseline(uzor::render::TextBaseline::Middle);
let cells = |render: &mut dyn RenderContext, y: f64, texts: &mut dyn Iterator<Item = &str>, color: &str| {
render.set_fill_color(color);
for ((x, w), t) in cols.iter().zip(texts) {
render.save();
render.clip_rect(rect.x + x, y, *w, row_height);
render.fill_text(t, rect.x + x + 8.0, y + row_height / 2.0);
render.restore();
}
};
render.set_fill_color(theme.column_header_bg());
render.fill_rect(rect.x, rect.y, rect.width, row_height);
for (j, (x, w)) in cols.iter().enumerate().take(columns.len()) {
let cid = child(&id, "col", j);
coord.register_atomic(cid.clone(), WidgetKind::Item, Rect::new(rect.x + x, rect.y, *w, row_height), focusable(), layer);
coord.set_a11y(&cid, columns[j], None);
r.hovered |= v.is_hovered(&cid);
r.focused |= v.is_focused(&cid);
}
cells(render, rect.y, &mut columns.iter().copied(), theme.column_header_text());
let (top, bottom) = (rect.y + row_height, rect.y + rect.height);
for (i, row) in rows.iter().enumerate() {
let y = top + i as f64 * row_height - scroll;
if y < top || y + row_height > bottom {
continue;
}
let rid = child(&id, "row", i);
let rr = Rect::new(rect.x, y, rect.width, row_height);
coord.register_atomic(rid.clone(), WidgetKind::Item, rr, focusable(), layer);
coord.set_a11y(&rid, &row.join(", "), Some(sel == Some(i)));
let hov = v.is_hovered(&rid);
r.hovered |= hov;
r.focused |= v.is_focused(&rid);
let bg = if sel == Some(i) { theme.row_bg_selected() } else if hov { theme.row_bg_hover() } else { theme.row_bg_normal() };
render.set_fill_color(bg);
render.fill_rect(rr.x, rr.y, rr.width, rr.height);
render.set_fill_color(theme.divider());
render.fill_rect(rr.x, rr.y + rr.height - 1.0, rr.width, 1.0);
cells(render, y, &mut row.iter().map(String::as_str), theme.text_color());
}
r
});
if let Some(i) = r.index {
r.changed = Some(i) != selected;
if let Some(b) = bind {
*b = Some(i);
}
}
r
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum Side {
Left,
#[default]
Right,
}
pub struct DrawerBuilder<'a> {
id: WidgetId,
area: Rect,
open: &'a mut bool,
side: Side,
width: f64,
title: Option<&'a str>,
progress: f64,
dim: bool,
}
pub fn drawer<'a>(id: impl Into<WidgetId>, area: Rect, open: &'a mut bool) -> DrawerBuilder<'a> {
DrawerBuilder { id: id.into(), area, open, side: Side::Right, width: 320.0, title: None, progress: 1.0, dim: true }
}
impl<'a> DrawerBuilder<'a> {
pub fn side(mut self, s: Side) -> Self {
self.side = s;
self
}
pub fn width(mut self, w: f64) -> Self {
self.width = w;
self
}
pub fn title(mut self, t: &'a str) -> Self {
self.title = Some(t);
self
}
pub fn progress(mut self, t: f64) -> Self {
self.progress = t.clamp(0.0, 1.0);
self
}
pub fn dim(mut self, on: bool) -> Self {
self.dim = on;
self
}
pub fn body_rect(&self) -> Rect {
let w = self.width.min(self.area.width);
let shown = w * self.progress;
let x = match self.side {
Side::Left => self.area.x - w + shown,
Side::Right => self.area.x + self.area.width - shown,
};
Rect::new(x, self.area.y, w, self.area.height)
}
pub fn build<'c, C: ContentCx<'c>>(self, cx: &mut C) -> Response {
use uzor::ui::widgets::composite::modal::theme::ModalTheme;
use uzor::ui::widgets::composite::panel::theme::PanelTheme;
if !*self.open {
return Response::default();
}
let theme = theme_of(cx);
let body = self.body_rect();
let scrim = WidgetId::from(format!("{}:scrim", self.id.as_str()));
let r = cx.with_paint(|render, widgets, v, _| {
let (coord, _, layer) = parts(widgets);
coord.register_atomic(scrim.clone(), WidgetKind::Custom, self.area, Sense::CLICK, layer);
coord.register_atomic(self.id.clone(), WidgetKind::Custom, body, Sense::CLICK | Sense::HOVER, layer);
coord.set_a11y(&self.id, self.title.unwrap_or(""), None);
if self.dim {
render.set_global_alpha(self.progress);
render.set_fill_color(ModalTheme::backdrop_dim(&theme));
render.fill_rect(self.area.x, self.area.y, self.area.width, self.area.height);
render.set_global_alpha(1.0);
}
render.set_fill_color(PanelTheme::bg(&theme));
render.fill_rect(body.x, body.y, body.width, body.height);
let edge = if self.side == Side::Right { body.x } else { body.x + body.width - 1.0 };
render.set_fill_color(PanelTheme::border(&theme));
render.fill_rect(edge, body.y, 1.0, body.height);
let mut r = Response::of(v, &self.id);
r.clicked = v.clicked(&scrim);
r
});
if r.clicked {
*self.open = false;
return Response { changed: true, ..r };
}
r
}
}
#[derive(Default)]
struct SelectOpen {
open: bool,
list: SelectState,
}
pub struct SelectBuilder<'a> {
id: WidgetId,
rect: Rect,
options: &'a [&'a str],
selected: usize,
bind: Option<&'a mut usize>,
disabled: bool,
searchable: Option<bool>,
within: Option<Rect>,
style: Option<SelectStyle>,
key: Option<&'a KeyInput>,
}
pub fn select<'a>(id: impl Into<WidgetId>, rect: Rect, options: &'a [&'a str]) -> SelectBuilder<'a> {
SelectBuilder { id: id.into(), rect, options, selected: 0, bind: None, disabled: false, searchable: None, within: None, style: None, key: None }
}
pub fn select_is_open<'c, C: ContentCx<'c>>(cx: &mut C, id: &str) -> bool {
cx.with_paint(|_, widgets, _, _| widgets.states.get_or_insert_with(WidgetId::from(format!("{id}:open")), SelectOpen::default).open)
}
impl<'a> SelectBuilder<'a> {
pub fn selected(mut self, i: usize) -> Self {
self.selected = i;
self
}
pub fn bind(mut self, i: &'a mut usize) -> Self {
self.selected = *i;
self.bind = Some(i);
self
}
pub fn disabled(mut self, on: bool) -> Self {
self.disabled = on;
self
}
pub fn searchable(mut self, on: bool) -> Self {
self.searchable = Some(on);
self
}
pub fn within(mut self, container: Rect) -> Self {
self.within = Some(container);
self
}
pub fn style(mut self, s: SelectStyle) -> Self {
self.style = Some(s);
self
}
pub fn key(mut self, k: Option<&'a KeyInput>) -> Self {
self.key = k.filter(|k| k.state != crate::KeyState::Up);
self
}
pub fn build<'c, C: ContentCx<'c>>(self, cx: &mut C) -> Response {
let theme = theme_of(cx);
let ls = self.style.unwrap_or_default();
let searchable = self.searchable.unwrap_or(self.options.len() > ls.window());
let ls = match self.within {
Some(w) => ls.fit(room(self.rect, w, ls.gap), searchable),
None => ls,
};
let win = ls.window();
let labels: Vec<(&str, &str)> = self.options.iter().map(|o| (*o, *o)).collect();
let mut r = cx.with_paint(|render, widgets, v, tokens| {
let mut r = Response::of(v, &self.id);
let sid = WidgetId::from(format!("{}:open", self.id.as_str()));
let mut key_used = false;
let mut close = false;
let (open, list) = {
let st = widgets.states.get_or_insert_with(sid, SelectOpen::default);
r.index = picked(v, &self.id, "list:item");
let was = st.open;
if self.disabled || r.index.is_some() || (st.open && clicked_outside(v, &self.id)) {
st.open = false;
} else if r.clicked {
st.open = !st.open;
} else if let Some(k) = self.key {
use uzor::input::keyboard::KeyCode as K;
if st.open {
let rows = filter(&labels, &st.list.query);
match st.list.key(k.code, k.text.as_deref(), k.mods.ctrl || k.mods.meta, rows.len(), searchable, win) {
SelectKey::Changed => key_used = true,
SelectKey::Pick(i) => {
r.index = rows.get(i).copied();
st.open = false;
key_used = true;
}
SelectKey::Close => {
close = true;
key_used = true;
}
SelectKey::Ignored => {}
}
} else if r.focused && matches!(k.code, K::Enter | K::Space | K::ArrowDown) {
st.open = true;
key_used = true;
}
}
if close {
st.open = false;
}
if st.open && !was {
st.list = SelectState::open_at(Some(self.selected), win);
}
(st.open, st.list.clone())
};
r.pressed = key_used;
let label = self.options.get(r.index.unwrap_or(self.selected)).copied().unwrap_or("");
let view = ButtonView {
icon: None,
text: Some(label),
active: open,
disabled: self.disabled,
active_border: None,
hover_chevron: None,
};
let mut bs = button_settings(tokens);
bs.theme = Box::new(theme.clone());
paint_button(render, widgets, v, self.id.clone(), self.rect, &view, &bs);
widgets.coord.set_a11y(&self.id, label, None);
if open {
let rows = filter(&labels, &list.query);
let (w, h) = ls.list_size(rows.len(), searchable, self.rect.width);
let within = self.within.unwrap_or(Rect::new(-1.0e6, -1.0e6, 2.0e6, 2.0e6));
let b = place(self.rect, w, h, within, ls.gap);
let shown: Vec<(&str, bool)> = rows.iter().map(|&i| (self.options[i], i == self.selected)).collect();
let pre = format!("{}:list:item:", self.id.as_str());
let hovered: Option<usize> = v.hovered().and_then(|w| w.as_str().strip_prefix(pre.as_str())?.parse().ok());
let hover = |k: usize| hovered.is_some() && rows.get(k).copied() == hovered;
let painted = draw_list(render, b, &shown, &list, searchable.then_some(list.query.as_str()), &hover, &ls);
let (coord, _, layer) = parts(widgets);
coord.register_atomic(WidgetId::from(format!("{}:list", self.id.as_str())), WidgetKind::Custom, b, Sense::CLICK | Sense::HOVER, layer);
for (k, rr) in painted {
let oi = rows[k];
let rid = child(&self.id, "list:item", oi);
coord.register_atomic(rid.clone(), WidgetKind::Item, rr, Sense::CLICK | Sense::HOVER, layer);
coord.set_a11y(&rid, self.options[oi], Some(oi == self.selected));
}
}
r.checked = open;
r
});
if let Some(i) = r.index {
r.changed = i != self.selected;
if let Some(b) = self.bind {
*b = i;
}
}
r
}
}
pub struct MenuBuilder<'a> {
id: WidgetId,
at: (f64, f64),
items: &'a [&'a str],
open: &'a mut bool,
title: Option<&'a str>,
danger: Option<usize>,
}
pub fn menu<'a>(id: impl Into<WidgetId>, at: (f64, f64), items: &'a [&'a str], open: &'a mut bool) -> MenuBuilder<'a> {
MenuBuilder { id: id.into(), at, items, open, title: None, danger: None }
}
impl<'a> MenuBuilder<'a> {
pub fn title(mut self, t: &'a str) -> Self {
self.title = Some(t);
self
}
pub fn danger(mut self, i: usize) -> Self {
self.danger = Some(i);
self
}
pub fn build<'c, C: ContentCx<'c>>(self, cx: &mut C) -> Response {
if !*self.open {
return Response::default();
}
let theme = theme_of(cx);
let r = cx.with_paint(|render, widgets, v, _| {
let mut r = Response::of(v, &self.id);
r.index = picked(v, &self.id, "item");
if r.index.is_some() || clicked_outside(v, &self.id) {
return (r, false);
}
let items: Vec<ContextMenuItem<'_>> = self
.items
.iter()
.enumerate()
.map(|(i, l)| ContextMenuItem { action: l, label: l, icon: None, danger: self.danger == Some(i), separator_after: false, enabled: true })
.collect();
let state = ContextMenuState { is_open: true, x: self.at.0, y: self.at.1, ..Default::default() };
let view = ContextMenuView { items: &items, target_id: None, title: self.title };
let settings = ContextMenuSettings { theme: Box::new(theme), ..Default::default() };
let (coord, _, layer) = parts(widgets);
register_input_coordinator_context_menu(coord, self.id.clone(), &state, &view, &settings, &ContextMenuRenderKind::Default, layer);
for (i, l) in self.items.iter().enumerate() {
coord.set_a11y(&child(&self.id, "item", i), *l, None);
}
draw_context_menu(render, &state, &view, &settings, &ContextMenuRenderKind::Default);
(r, true)
});
*self.open = r.1;
let mut r = r.0;
r.changed = r.index.is_some();
r
}
}
pub struct DialogBuilder<'a> {
id: WidgetId,
rect: Rect,
title: Option<&'a str>,
footer: &'a [&'a str],
dim: bool,
}
pub fn dialog<'a>(id: impl Into<WidgetId>, rect: Rect) -> DialogBuilder<'a> {
DialogBuilder { id: id.into(), rect, title: None, footer: &[], dim: true }
}
impl<'a> DialogBuilder<'a> {
pub fn title(mut self, t: &'a str) -> Self {
self.title = Some(t);
self
}
pub fn footer(mut self, labels: &'a [&'a str]) -> Self {
self.footer = labels;
self
}
pub fn dim(mut self, on: bool) -> Self {
self.dim = on;
self
}
pub fn build<'c, C: ContentCx<'c>>(self, cx: &mut C) -> Response {
let theme = theme_of(cx);
cx.with_paint(|render, widgets, v, _| {
let mut r = Response::of(v, &self.id);
r.clicked = v.clicked(&WidgetId::from(format!("{}:close", self.id.as_str())));
r.index = picked(v, &self.id, "footer");
r.changed = r.clicked || r.index.is_some();
let buttons: Vec<FooterBtn<'_>> = self
.footer
.iter()
.enumerate()
.map(|(i, l)| FooterBtn { label: l, style: if i == 0 { FooterBtnStyle::Primary } else { FooterBtnStyle::Ghost } })
.collect();
let mut view = ModalView {
title: self.title,
tabs: &[],
footer_buttons: &buttons,
wizard_pages: &[],
backdrop: if self.dim { BackdropKind::Dim } else { BackdropKind::None },
overflow: Default::default(),
resizable: false,
};
let kind = if buttons.is_empty() { ModalRenderKind::WithHeader } else { ModalRenderKind::WithHeaderFooter };
let settings = ModalSettings { theme: Box::new(theme), ..Default::default() };
let (coord, states, layer) = parts(widgets);
let state = states.get_or_insert_with(self.id.clone(), ModalState::default);
register_input_coordinator_modal(coord, self.id.clone(), self.rect, state, &mut view, &settings, &kind, layer);
if let Some(t) = self.title {
coord.set_a11y(&self.id, t, None);
}
for (i, l) in self.footer.iter().enumerate() {
coord.set_a11y(&child(&self.id, "footer", i), *l, None);
}
coord.set_a11y(&WidgetId::from(format!("{}:close", self.id.as_str())), "Close", None);
draw_modal(render, self.rect, state, &mut view, &settings, &kind);
r
})
}
}
pub struct SplitterBuilder<'a> {
id: WidgetId,
axis: Axis,
span: Rect,
pos: &'a mut f64,
min: f64,
max: f64,
grab: f64,
}
pub fn splitter<'a>(id: impl Into<WidgetId>, axis: Axis, span: Rect, pos: &'a mut f64) -> SplitterBuilder<'a> {
SplitterBuilder { id: id.into(), axis, span, pos, min: f64::MIN, max: f64::MAX, grab: 9.0 }
}
impl<'a> SplitterBuilder<'a> {
pub fn range(mut self, min: f64, max: f64) -> Self {
self.min = min;
self.max = max;
self
}
pub fn grab(mut self, px: f64) -> Self {
self.grab = px;
self
}
pub fn build<'c, C: ContentCx<'c>>(self, cx: &mut C) -> Response {
let theme = theme_of(cx);
cx.with_paint(|render, widgets, v, _| {
let mut r = Response::of(v, &self.id);
let (coord, states, layer) = parts(widgets);
let s = states.get_or_insert_with(self.id.clone(), Splitter::default);
if let SplitterEvent::Drag(p) = s.update(v, &self.id, self.axis) {
let p = p.clamp(self.min, self.max);
r.changed = (p - *self.pos).abs() > f64::EPSILON;
*self.pos = p;
}
r.pressed = s.dragging();
let hot = s.hot(v, &self.id);
register_splitter(coord, self.id.clone(), grab_rect(self.axis, *self.pos, self.span, self.grab), layer);
let (line, orientation) = match self.axis {
Axis::X => (Rect::new(*self.pos, self.span.y, 1.0, self.span.height), SeparatorOrientation::Vertical),
Axis::Y => (Rect::new(self.span.x, *self.pos, self.span.width, 1.0), SeparatorOrientation::Horizontal),
};
let view = SeparatorView { kind: SeparatorType::Divider { orientation }, hovered: hot, dragging: r.pressed };
let settings = SeparatorSettings { theme: Box::new(theme), style: Box::new(DefaultSeparatorStyle) };
draw_separator(render, line, &view, &settings);
r
})
}
}
pub struct ToastsBuilder<'a> {
id: WidgetId,
area: Rect,
stack: &'a mut ToastStackState,
now_ms: u64,
}
pub fn toasts<'a>(id: impl Into<WidgetId>, area: Rect, stack: &'a mut ToastStackState, now_ms: u64) -> ToastsBuilder<'a> {
ToastsBuilder { id: id.into(), area, stack, now_ms }
}
impl<'a> ToastsBuilder<'a> {
pub fn build<'c, C: ContentCx<'c>>(self, cx: &mut C) -> Response {
let theme = theme_of(cx);
let live = self.stack.tick(self.now_ms);
cx.with_paint(|render, _widgets, v, _| {
let mut r = Response::of(v, &self.id);
r.changed = !live.is_empty();
if r.changed {
render.save();
render.translate(self.area.x, self.area.y);
draw_toast_stack(render, live, &theme, self.area.width, self.area.height, self.now_ms);
render.restore();
}
r
})
}
}
#[cfg(test)]
#[path = "kit_tests.rs"]
mod tests;
fn paint_slot_sense() -> Sense {
Sense::CLICK_AND_DRAG.union(Sense::SCROLL).with_touch().with_gesture()
}
fn slot_mouse(v: &dyn crate::handle::VisualQuery, wid: &WidgetId) -> (Option<(f64, f64)>, (f64, f64)) {
let pressed = if v.is_pressed(wid) && !v.coarse_pointer() { v.raw_pointer() } else { None };
let wheel = if v.scroll_touch() { (0.0, 0.0) } else { v.scroll_over(wid) };
(pressed, wheel)
}
pub struct DomBuilder<'a> {
rect: Rect,
sheet: &'a uzor::ui::style::Sheet,
root: uzor::ui::dom::El,
scroll: f64,
viewport: Option<Rect>,
slots: Option<&'a mut dyn FnMut(&mut dyn RenderContext, &SlotFrame<'_>)>,
numbers: Vec<(String, uzor::ui::domkit::NumberSpec)>,
key: Option<&'a KeyInput>,
own_scroll: bool,
}
fn number_char(c: char) -> bool {
uzor::ui::domkit::NumberSpec::new().accepts(c)
}
fn integer_char(c: char) -> bool {
uzor::ui::domkit::NumberSpec::integer().accepts(c)
}
#[derive(Default)]
struct NumberFocus(bool);
#[derive(Clone, Debug)]
pub struct SlotFrame<'k> {
pub key: &'k str,
pub rect: Rect,
pub gestures: Vec<crate::types::gesture::Gesture>,
pub pointer: Option<(f64, f64)>,
pub clicked: bool,
pub pressed: Option<(f64, f64)>,
pub wheel: (f64, f64),
}
impl SlotFrame<'_> {
pub fn local(&self, x: f64, y: f64) -> (f64, f64) {
(x - self.rect.x, y - self.rect.y)
}
}
impl Default for SlotFrame<'static> {
fn default() -> Self {
Self {
key: "",
rect: Rect::default(),
gestures: Vec::new(),
pointer: None,
clicked: false,
pressed: None,
wheel: (0.0, 0.0),
}
}
}
#[derive(Clone, Debug, Default)]
pub struct DomResponse {
pub dom: uzor::ui::dom::Dom,
pub clicked: Option<String>,
pub captured: Vec<(String, crate::types::gesture::Gesture)>,
pub hovered: Option<String>,
pub focused: Option<String>,
pub edited: Vec<(String, String)>,
pub scrolls: Vec<(String, f64)>,
pub key_used: bool,
}
#[derive(Default)]
struct DomScroll {
sv: crate::types::scroll::ScrollView,
}
fn dom_scroll_key(id: &str) -> WidgetId {
WidgetId::from(format!("{id}:dom-scroll"))
}
pub fn dom_scroll_to<'c, C: ContentCx<'c>>(cx: &mut C, id: &str, y: f64, smooth: bool) {
cx.with_paint(|_, widgets, _, _| {
let st = widgets.states.get_or_insert_with(dom_scroll_key(id), DomScroll::default);
if smooth {
st.sv.scroll_into_view(y, 0.0, crate::types::scroll::ScrollAlign::Start, true);
} else {
st.sv.scroll_to(y.max(0.0));
}
});
cx.request_frame();
}
pub fn dom_scroll_top<'c, C: ContentCx<'c>>(cx: &mut C, id: &str) -> f64 {
cx.with_paint(|_, widgets, _, _| widgets.states.get::<DomScroll>(&dom_scroll_key(id)).map_or(0.0, |s| s.sv.offset))
}
pub fn dom<'a>(rect: Rect, sheet: &'a uzor::ui::style::Sheet, root: uzor::ui::dom::El) -> DomBuilder<'a> {
DomBuilder { rect, sheet, root, scroll: 0.0, viewport: None, slots: None, numbers: Vec::new(), key: None, own_scroll: false }
}
impl<'a> DomBuilder<'a> {
pub fn scroll(mut self, y: f64) -> Self {
self.scroll = y;
self
}
pub fn viewport(mut self, r: Rect) -> Self {
self.viewport = Some(r);
self
}
pub fn paint_slots(mut self, paint: &'a mut dyn FnMut(&mut dyn RenderContext, &SlotFrame<'_>)) -> Self {
self.slots = Some(paint);
self
}
pub fn number(mut self, id: impl Into<String>, spec: uzor::ui::domkit::NumberSpec) -> Self {
self.numbers.push((id.into(), spec));
self
}
pub fn key(mut self, k: Option<&'a KeyInput>) -> Self {
self.key = k.filter(|k| k.state != crate::KeyState::Up);
self
}
pub fn dom_scroll(mut self) -> Self {
self.own_scroll = true;
self
}
pub fn build<'c, C: ContentCx<'c>>(self, cx: &mut C) -> DomResponse {
let now_ms = cx.time_ms();
let frame_now = cx.frame_now_ms();
let overlay = cx.is_overlay();
let DomBuilder { rect, sheet, mut root, scroll, viewport, slots, numbers, key, own_scroll } = self;
let (resp, ime, more) = cx.with_paint(|render, widgets, v, _| {
build_paint(render, widgets, v, now_ms, frame_now, overlay, rect, sheet, &mut root, scroll, viewport, slots, &numbers, key, own_scroll)
});
if let Some(at) = ime {
cx.ime_area(at);
}
if more {
cx.request_frame();
}
resp
}
}
#[inline(never)]
fn build_paint(
render: &mut dyn RenderContext,
widgets: &mut crate::handle::Widgets<'_>,
v: &dyn crate::handle::VisualQuery,
now_ms: u64,
frame_now: f64,
overlay: bool,
rect: Rect,
sheet: &uzor::ui::style::Sheet,
root: &mut uzor::ui::dom::El,
scroll: f64,
viewport: Option<Rect>,
mut slots: Option<&mut dyn FnMut(&mut dyn RenderContext, &SlotFrame<'_>)>,
numbers: &[(String, uzor::ui::domkit::NumberSpec)],
key: Option<&KeyInput>,
own_scroll: bool,
) -> (DomResponse, Option<Rect>, bool) {
use uzor::ui::dom::{Control, El};
use uzor::ui::style::State;
let mut key_used = false;
let mut num_edits: Vec<(String, String)> = Vec::new();
if !numbers.is_empty() {
for (id, spec) in numbers {
let wid = WidgetId::from(id.as_str());
let Some(text) = widgets.coord.text_fields().field_state(&wid).map(|s| s.text.clone()) else { continue };
let focused = v.is_focused(&wid);
let mut n = 0i32;
if v.clicked(&WidgetId::from(format!("{id}:inc"))) {
n += 1;
}
if v.clicked(&WidgetId::from(format!("{id}:dec"))) {
n -= 1;
}
if focused {
use uzor::input::keyboard::KeyCode as Kc;
match key.map(|k| k.code) {
Some(Kc::ArrowUp) => {
n += 1;
key_used = true;
}
Some(Kc::ArrowDown) => {
n -= 1;
key_used = true;
}
_ => {}
}
let dy = v.scroll_over(&wid).1;
if dy != 0.0 && !v.scroll_touch() {
n += if dy > 0.0 { 1 } else { -1 };
}
}
let was = std::mem::replace(&mut widgets.states.get_or_insert_with(WidgetId::from(format!("{id}:num-focus")), NumberFocus::default).0, focused);
let next = if n != 0 {
spec.stepped(&text, n)
} else if was && !focused {
spec.normalized(&text)
} else {
spec.sanitize(&text)
};
if next != text {
widgets.coord.text_fields_mut().set_text(&wid, &next);
num_edits.push((id.clone(), next));
}
}
}
fn app_scrolled(e: &El, out: &mut Vec<String>) {
if let (Some(id), true) = (e.id.as_deref(), e.scroll_top != 0.0) {
out.push(id.to_string());
}
for c in &e.children {
app_scrolled(c, out);
}
}
fn apply(e: &mut El, offs: &[(String, f64)]) {
if let Some(id) = e.id.as_deref() {
if let Some((_, y)) = offs.iter().find(|(i, _)| i == id) {
e.scroll_top = *y;
}
}
for c in &mut e.children {
apply(c, offs);
}
}
let mut app_owned = Vec::new();
let mut offs: Vec<(String, f64)> = Vec::new();
if own_scroll {
app_scrolled(root, &mut app_owned);
fn ids(e: &El, out: &mut Vec<String>) {
if let Some(id) = &e.id {
out.push(id.clone());
}
for c in &e.children {
ids(c, out);
}
}
let mut all = Vec::new();
ids(root, &mut all);
for id in all.into_iter().filter(|i| !app_owned.contains(i)) {
if let Some(st) = widgets.states.get::<DomScroll>(&dom_scroll_key(&id)) {
offs.push((id, st.sv.offset));
}
}
apply(root, &offs);
}
let mut edited = Vec::new();
let mut seed: Vec<(WidgetId, String)> = Vec::new();
fn walk(e: &mut El, f: &mut dyn FnMut(&str, &mut uzor::ui::dom::Edit)) {
if let (Some(id), Some(Control::Input(ed))) = (e.id.as_deref(), e.control.as_mut()) {
f(id, ed);
}
for c in &mut e.children {
walk(c, f);
}
}
walk(root, &mut |id, ed| {
let wid = WidgetId::from(id);
if widgets.coord.text_fields().field_state(&wid).is_none() {
seed.push((wid.clone(), ed.value.clone()));
}
let focused = v.is_focused(&wid);
if let Some(s) = widgets.coord.text_fields().field_state(&wid) {
let text = s.text.clone();
if text != ed.value {
edited.push((id.to_string(), text.clone()));
ed.value = text;
}
let caret = s.cursor.min(ed.value.chars().count());
let composing = !s.preedit.is_empty();
let sel = (!composing).then(|| s.selection_range()).flatten();
ed.caret = focused.then_some(caret);
ed.anchor = sel.filter(|_| focused).map(|(a, b)| if b == caret { a } else { b });
ed.preedit = (focused && composing).then(|| s.preedit.clone());
ed.caret_on = focused && s.engaged && widgets.coord.text_fields().cursor_visible(now_ms);
} else {
ed.caret = None;
}
});
let state = |id: &str| {
let w = WidgetId::from(id);
let mut s = State::NONE;
if v.is_hovered(&w) {
s = s | State::HOVER;
}
if v.is_pressed(&w) {
s = s | State::ACTIVE;
}
if v.is_focused(&w) {
s = s | State::FOCUS;
if v.focus_visible() {
s = s | State::FOCUS_VISIBLE;
}
}
s
};
let vp = viewport.unwrap_or(rect);
let lay = |render: &mut dyn RenderContext, root: &El| {
let d = uzor::ui::dom::lay_out_in(render, sheet, root, rect.x, rect.y, rect.width, Some(vp), &state);
if scroll != 0.0 { d.moved(0.0, -scroll) } else { d }
};
let mut d = lay(render, root);
let mut more = false;
let mut scrollers: Vec<(String, Rect, crate::types::scroll::ScrollView)> = Vec::new();
let sst = crate::types::scroll::ScrollStyle::default();
if own_scroll {
for b in &d.boxes {
let Some(id) = b.id.as_deref() else { continue };
if !matches!(b.style.overflow.as_deref(), Some("auto" | "scroll")) || app_owned.iter().any(|a| a == id) {
continue;
}
let e = b.style.border_edges();
let pad = Rect::new(b.rect.x + e[3], b.rect.y + e[0], (b.rect.width - e[1] - e[3]).max(0.0), (b.rect.height - e[0] - e[2]).max(0.0));
let mut vis = b.clip.map_or(pad, |c| c.intersect(pad));
if !b.fixed {
vis = vis.intersect(rect);
}
let mut sv = widgets.states.get_or_insert_with(dom_scroll_key(id), DomScroll::default).sv.clone();
let wheel = vis.width > 0.0 && vis.height > 0.0;
more |= crate::widgets::scroll::begin_parts(widgets.states, v, frame_now, id, vis, &mut sv, b.scroll_height, wheel, &sst);
sv.set_extent(b.scroll_height, pad.height);
sv.offset = sv.offset.clamp(0.0, sv.max());
widgets.states.get_or_insert_with(dom_scroll_key(id), DomScroll::default).sv = sv.clone();
scrollers.push((id.to_string(), vis, sv));
}
let now_offs: Vec<(String, f64)> = scrollers.iter().map(|(i, _, sv)| (i.clone(), sv.offset)).collect();
let changed = now_offs.iter().any(|(i, y)| offs.iter().find(|(j, _)| j == i).map_or(*y != 0.0, |(_, o)| (o - y).abs() > 0.01));
if changed {
apply(root, &now_offs);
d = lay(render, root);
}
}
let (coord, _, layer) = parts(widgets);
render.save();
render.begin_path();
render.rect(rect.x, rect.y, rect.width, rect.height);
render.clip();
match slots.as_mut() {
Some(paint) => {
uzor::ui::dom::paint_slots(render, &d, &mut |ctx, key, content| {
let id = d.boxes.iter().find(|b| b.slot.as_deref() == Some(key)).and_then(|b| b.id.as_deref()).unwrap_or(key);
let wid = WidgetId::from(id);
let (pressed, wheel) = slot_mouse(v, &wid);
let frame = SlotFrame { key, rect: content, gestures: v.captured_gestures(&wid), pointer: v.pointer_over(&wid), clicked: v.clicked(&wid), pressed, wheel };
ctx.save();
ctx.begin_path();
ctx.rect(content.x, content.y, content.width, content.height);
ctx.clip();
paint(ctx, &frame);
ctx.restore();
});
}
None => uzor::ui::dom::paint(render, &d),
}
render.restore();
coord.set_default_layer(Some(layer.clone()));
let mut ime = None;
for b in &d.boxes {
let Some(id) = b.id.as_deref() else { continue };
let mut vis = b.clip.map_or(b.rect, |c| c.intersect(b.rect));
if !b.fixed {
vis = vis.intersect(rect);
}
if vis.width <= 0.0 || vis.height <= 0.0 {
continue;
}
let wid = WidgetId::from(id);
let name = b.accessible_name().unwrap_or_default().to_string();
if let Some(Control::Input(e)) = &b.control {
let cfg = match numbers.iter().find(|(n, _)| n == id) {
Some((_, spec)) => uzor::TextFieldConfig::text().with_filter(if spec.decimals == Some(0) { integer_char } else { number_char }),
None if e.masked => uzor::TextFieldConfig::password(),
None => uzor::TextFieldConfig::text(),
};
coord.register_text_field(wid.clone(), vis, cfg);
if let Some((_, v)) = seed.iter().find(|(s, _)| *s == wid) {
coord.text_fields_mut().set_text(&wid, v);
}
coord.set_a11y(&wid, &name, None);
let c = uzor::ui::dom::content_box(b);
let sx = c.x - b.input_scroll();
let pos: Vec<f64> = b.bounds.iter().map(|x| sx + x).collect();
let _ = e;
let fields = coord.text_fields_mut();
let pos = match fields.field_state(&wid) {
Some(s) => s.buffer_positions(pos),
None => pos,
};
fields.update_field(&wid, (c.x, c.y, c.width, c.height), pos);
if e.caret.is_some() {
ime = b.caret_rect();
}
} else if b.tab || b.id.is_some() {
let mut sense = if b.tab { focusable() } else { Sense::CLICK | Sense::HOVER };
if b.slot.is_some() && b.captures_touch() {
sense = sense.union(paint_slot_sense());
} else if b.captures_touch() {
sense = sense.with_touch().with_gesture();
}
if scrollers.iter().any(|(i, _, _)| i == id) {
sense = sense.union(Sense::SCROLL);
}
coord.register_atomic(wid.clone(), WidgetKind::Button, vis, sense, layer);
coord.set_a11y(&wid, &name, b.control.as_ref().and_then(Control::checked));
}
}
coord.set_default_layer(None);
render.save();
render.begin_path();
render.rect(rect.x, rect.y, rect.width, rect.height);
render.clip();
for (id, vis, sv) in &scrollers {
crate::widgets::scroll::end_parts(widgets, render, v, frame_now, id, *vis, sv, &sst, overlay);
}
render.restore();
let ids: Vec<&str> = d.boxes.iter().rev().filter_map(|b| b.id.as_deref()).collect();
let clicked = ids.iter().find(|i| v.clicked(&WidgetId::from(**i))).map(|s| s.to_string());
let hovered = ids.iter().find(|i| v.is_hovered(&WidgetId::from(**i))).map(|s| s.to_string());
let focused = ids.iter().find(|i| v.is_focused(&WidgetId::from(**i))).map(|s| s.to_string());
let captured = d
.touch_targets()
.flat_map(|(id, _)| v.captured_gestures(&WidgetId::from(id)).into_iter().map(move |g| (id.to_string(), g)))
.collect();
let scrolls = scrollers.into_iter().map(|(i, _, sv)| (i, sv.offset)).collect();
for (id, text) in num_edits {
match edited.iter_mut().find(|(i, _)| *i == id) {
Some(e) => e.1 = text,
None => edited.push((id, text)),
}
}
(DomResponse { dom: d, clicked, captured, hovered, focused, edited, scrolls, key_used }, ime, more)
}
pub struct PaintSlot<'k> {
id: &'k str,
rect: Rect,
}
#[derive(Clone, Debug, Default)]
pub struct SlotResponse {
pub gestures: Vec<crate::types::gesture::Gesture>,
pub pointer: Option<(f64, f64)>,
pub clicked: bool,
pub pressed: Option<(f64, f64)>,
pub wheel: (f64, f64),
}
pub fn paint_slot(id: &str, rect: Rect) -> PaintSlot<'_> {
PaintSlot { id, rect }
}
impl PaintSlot<'_> {
pub fn paint<'c, C: ContentCx<'c>>(self, cx: &mut C, paint: impl FnOnce(&mut dyn RenderContext, &SlotFrame<'_>)) -> SlotResponse {
let PaintSlot { id, rect } = self;
cx.with_paint(|render, widgets, v, _| {
let (coord, _, layer) = parts(widgets);
let wid = WidgetId::from(id);
coord.register_atomic(wid.clone(), WidgetKind::Button, rect, paint_slot_sense(), layer);
let (pressed, wheel) = slot_mouse(v, &wid);
let frame = SlotFrame { key: id, rect, gestures: v.captured_gestures(&wid), pointer: v.pointer_over(&wid), clicked: v.clicked(&wid), pressed, wheel };
render.save();
render.begin_path();
render.rect(rect.x, rect.y, rect.width, rect.height);
render.clip();
paint(render, &frame);
render.restore();
SlotResponse { gestures: frame.gestures, pointer: frame.pointer, clicked: frame.clicked, pressed: frame.pressed, wheel: frame.wheel }
})
}
}