use std::cell::Cell;
use crate::anim::Easing;
use crate::canvas::{Canvas, TextStyle};
use crate::component::{ComponentId, ControlState};
use crate::geometry::{PointF, RectF};
use crate::theme::{ResolvedStyle, Theme};
use crate::ui::Ui;
pub struct PaintCtx<'a> {
pub ui: &'a Ui,
pub id: ComponentId,
pub rect: RectF,
pub state: ControlState,
pub style: &'a ResolvedStyle,
pub theme: &'a Theme,
pub time: f64,
pub design: bool,
pub colors: crate::ColorOverride,
frame_request: &'a Cell<bool>,
wake_at: &'a Cell<Option<f64>>,
resources: Option<&'a dyn crate::platform::ResourceService>,
}
impl PaintCtx<'_> {
pub fn with_style<'b>(&'b self, style: &'b ResolvedStyle) -> PaintCtx<'b> {
PaintCtx { style, ..*self }
}
pub fn resource(&self, path: &str) -> Option<Vec<u8>> {
self.resources?.read(path)
}
pub fn draw_icon(&self, canvas: &mut dyn crate::Canvas, name: &str, rect: RectF, color: crate::Color) {
if let Some(icon) = self.ui.icon(name) {
icon.draw(canvas, rect, color);
}
}
pub fn look(&self) -> crate::theme::Look {
self.theme.look
}
pub fn variant(&self) -> &str {
self.ui.control(self.id).map_or("", |c| c.style())
}
pub fn text_style(&self) -> TextStyle {
TextStyle { font: self.style.font.clone(), color: self.style.text, ..Default::default() }
}
pub fn font(&self, size: f32) -> crate::FontSpec {
let cb = self.ui.control(self.id);
let own = cb.and_then(|c| c.font().size);
let scale = cb.map_or(1.0, |c| c.text_scale());
crate::FontSpec { size: own.unwrap_or(size) * scale, ..self.style.font.clone() }
}
pub fn monospace_font(&self, size: f32) -> crate::FontSpec {
let mut font = self.font(size);
let mut current = Some(self.id);
while let Some(id) = current {
if self.ui.control(id).is_some_and(|c| !c.font().family.is_empty()) {
return font;
}
current = self.ui.parent(id);
}
font.family = "monospace".into();
font
}
pub fn request_frame_at(&self, time: f64) {
let next = self.wake_at.get().map_or(time, |t| t.min(time));
self.wake_at.set(Some(next));
let mut timed = self.ui.timed_frames.borrow_mut();
let at = timed.get(&self.id).map_or(time, |t| t.min(time));
timed.insert(self.id, at);
}
pub fn request_frame(&self) {
self.frame_request.set(true);
self.ui.frame_ids.borrow_mut().push(self.id);
}
pub fn overlay(&self, draw: impl FnOnce(&mut dyn Canvas)) {
let mut rec = crate::pages::RecordingCanvas::new(None);
draw(&mut rec);
let at = self.ui.absolute_rect(self.id).map_or(PointF::default(), |r| r.origin());
self.ui.overlays.borrow_mut().push((at, crate::pages::Page { ops: rec.ops }));
self.ui.overlay_users.borrow_mut().insert(self.id);
}
}
#[derive(Clone, Debug, Default)]
pub(crate) struct Visual {
state: Option<ControlState>,
pub(crate) shown: Option<ResolvedStyle>,
from: Option<ResolvedStyle>,
start: f64,
pub(crate) reach: Option<f32>,
pub(crate) ink: Option<RectF>,
pub(crate) drawing: Option<u64>,
pub(crate) shift: PointF,
pub(crate) version: u64,
pub(crate) covers: bool,
pub(crate) layer_key: Option<u64>,
}
const SPILL_SLACK: f32 = 0.01;
#[derive(Clone, Copy, Debug)]
pub(crate) struct Backdrop {
parent: Option<ComponentId>,
version: u64,
builds: u32,
}
const BACKDROP_BUILDS: u32 = 2;
struct Look<'t> {
enabled: bool,
state: ControlState,
inherited: &'t Theme,
mixed: &'t Theme,
recolored: Option<std::rc::Rc<Theme>>,
colors: crate::component::ColorOverride,
style: ResolvedStyle,
transitioning: bool,
paint_fill: bool,
font: crate::component::FontOverride,
reach: f32,
}
impl Look<'_> {
fn theme(&self) -> &Theme {
self.recolored.as_deref().unwrap_or(self.mixed)
}
}
impl Visual {
fn update(&mut self, state: ControlState, target: ResolvedStyle, now: f64) -> (ResolvedStyle, bool) {
let duration = target.transition_ms as f64 / 1000.0;
if self.state.is_some_and(|s| s != state) && duration > 0.0 && self.shown.as_ref().is_some_and(|s| *s != target) {
if let Some(shown) = self.shown.take() {
self.from = Some(shown);
self.start = now;
}
}
self.state = Some(state);
let (style, running) = match &self.from {
Some(from) if duration > 0.0 => {
let t = ((now - self.start) / duration) as f32;
if t >= 1.0 {
(target, false)
} else {
(from.lerp(&target, Easing::OutQuad.apply(t)), true)
}
}
_ => (target, false),
};
if !running {
self.from = None;
}
self.shown = Some(style.clone());
(style, running)
}
}
impl Ui {
pub fn render_png(&mut self, id: ComponentId, width: f32, height: f32, scale: f32) -> Option<Vec<u8>> {
let service = self.services_mut().offscreen.take()?;
if let Some(cb) = self.control_mut(id) {
cb.set_position(0.0, 0.0).set_size(width, height);
}
self.layout();
for _ in 0..4 {
if !self.needs_layout() {
break;
}
self.layout();
}
let background = self.theme().color("background");
let png = service.render_png(width.ceil() as u32, height.ceil() as u32, scale, background, &mut |canvas| self.paint(id, canvas));
self.services_mut().offscreen = Some(service);
png
}
pub fn snapshot(&self, id: ComponentId, scale: f32) -> Option<crate::Image> {
let service = self.services().offscreen.as_ref()?;
let cb = self.cb(id)?;
let (place, size) = {
let b = cb.bounds();
let t = cb.translate();
(PointF::new(b.x + t.x, b.y + t.y), (b.width.ceil().max(1.0) as u32, b.height.ceil().max(1.0) as u32))
};
let enabled = self.ancestors_enabled(id);
let png = service.render_png(size.0, size.1, scale, crate::Color::TRANSPARENT, &mut |canvas| {
canvas.translate(-place.x, -place.y);
let mut classes = Vec::new();
self.paint_node(id, canvas, enabled, &mut classes, &self.theme, &Default::default(), None);
})?;
Some(crate::Image::encoded(png))
}
fn ancestors_enabled(&self, id: ComponentId) -> bool {
let mut cur = self.parent(id);
while let Some(c) = cur {
if self.cb(c).is_some_and(|cb| !cb.enabled()) {
return false;
}
cur = self.parent(c);
}
true
}
pub fn paint(&mut self, root: ComponentId, canvas: &mut dyn Canvas) {
self.paint_region(root, canvas, None);
}
pub fn paint_region(&mut self, root: ComponentId, canvas: &mut dyn Canvas, area: Option<RectF>) {
match area {
Some(a) => self.paint_regions(root, canvas, &[a]),
None => self.paint_regions(root, canvas, &[]),
}
}
pub fn paint_regions(&mut self, root: ComponentId, canvas: &mut dyn Canvas, areas: &[RectF]) {
let area = areas.iter().copied().reduce(|a, b| a.union(b));
let _profile = crate::profile::scope(crate::profile::Lane::Paint, || format!("pintura {}", self.path_of(root)));
self.update_layout();
self.style_animating.set(false);
self.wake_at.set(None);
let mut classes = Vec::new();
self.overlays.borrow_mut().clear();
if area.is_none() {
self.overlay_users.borrow_mut().clear();
self.layer_epoch.set(self.layer_epoch.get() + 1);
}
for key in self.dead_layers.borrow_mut().drain(..) {
canvas.forget_cached(key);
}
{
let mut movers = self.movers.borrow_mut();
movers.clear();
movers.extend(self.placement_movers().filter_map(|m| self.parent(m).map(|p| (p, m))));
if !self.backdrops.borrow().is_empty() {
self.backdrops.borrow_mut().retain(|&id, b| {
let keep = movers.iter().any(|&(p, _)| Some(p) == b.parent);
if !keep {
let own = self.control(id).is_some_and(|cb| cb.cache_layer()) || self.in_transition(id);
if let Some(key) = self.entry(id).filter(|_| !own).and_then(|e| e.visual.borrow_mut().layer_key.take()) {
canvas.forget_cached(key);
}
}
keep
});
}
}
self.backdrop_next.set(false);
let caching = match self.get_prop(root, "layer_cache") {
Ok(crate::PropValue::Enum(name)) => <crate::LayerCaching as crate::prop::PropEnum>::from_name(&name).unwrap_or_default(),
_ => crate::LayerCaching::Project,
};
self.auto_layers.set(caching.enabled());
let visible: Option<Vec<RectF>> = self.control(root).map(|cb| match area {
Some(_) => areas.iter().map(|a| intersection(cb.bounds(), *a)).filter(|r| r.width > 0.0 && r.height > 0.0).collect(),
None => vec![cb.bounds()],
});
let visible = visible.as_deref();
self.spilled.set(false);
self.paint_area.set(area);
self.paint_form.set(self.control(root).map(|cb| cb.bounds()));
self.paint_count.set(0);
let mut ink = crate::ink::InkCanvas::new(&mut *canvas, &self.ink);
if self.text_mode == crate::textcore::TextMode::Native {
self.paint_node(root, &mut ink, true, &mut classes, &self.theme, &Default::default(), visible);
} else {
let mut text = crate::textcore::TextCanvas { inner: &mut ink, mode: self.text_mode };
self.paint_node(root, &mut text, true, &mut classes, &self.theme, &Default::default(), visible);
}
self.flush_paint_failures();
let origin = self.absolute_rect(root).map_or(PointF::default(), |r| r.origin());
for (at, page) in self.overlays.borrow_mut().drain(..) {
canvas.save();
canvas.translate(at.x - origin.x, at.y - origin.y);
page.replay(canvas);
canvas.restore();
}
self.paint_drag(root, canvas);
self.paint_hint(root, canvas);
self.paint_busy(root, canvas);
self.frame_requests.borrow_mut().insert(root, (self.style_animating.get(), self.wake_at.get()));
crate::profile::sample("controles pintados", self.paint_count.get() as f64);
self.repaint_requested = false;
if area.is_some() && self.spilled.get() {
self.request_repaint();
}
}
pub fn last_paint_count(&self) -> usize {
self.paint_count.get()
}
pub fn paint_overflow(&mut self, root: ComponentId, canvas: &mut dyn Canvas) {
self.update_layout();
let Some(cb) = self.cb(root) else { return };
let inherited = match cb.theme_name() {
"" => &self.theme,
name => self.theme_named(name).unwrap_or(&self.theme),
};
let enabled = cb.enabled();
let size = self.form_area(root);
let mut classes = Vec::new();
let children: Vec<ComponentId> = self.children(root).iter().copied().filter(|&c| self.sticks_out(c, size)).collect();
for child in children {
self.paint_node(child, canvas, enabled, &mut classes, inherited, &cb.font, None);
}
}
pub fn overflows(&self, root: ComponentId) -> bool {
let area = self.form_area(root);
self.children(root).iter().any(|&c| self.sticks_out(c, area))
}
fn form_area(&self, root: ComponentId) -> RectF {
let origin = self.absolute_rect(root).unwrap_or_default();
RectF::new(origin.x, origin.y, self.cb(root).map_or(0.0, |cb| cb.width()), self.cb(root).map_or(0.0, |cb| cb.height()))
}
fn sticks_out(&self, id: ComponentId, area: RectF) -> bool {
let Some(cb) = self.cb(id) else { return false };
if !cb.visible() {
return false;
}
let Some(r) = self.absolute_rect(id) else { return false };
let outside = r.x < area.x - 1.0 || r.y < area.y - 1.0 || r.right() > area.right() + 1.0 || r.bottom() > area.bottom() + 1.0 || cb.rotation() != 0.0;
outside || (!cb.clip_children() && self.children(id).iter().any(|&c| self.sticks_out(c, area)))
}
fn paint_drag(&self, root: ComponentId, canvas: &mut dyn Canvas) {
let Some((label, at, target)) = self.drag_view(root) else { return };
let origin = self.absolute_rect(root).map_or(PointF::default(), |r| r.origin());
let data = self.drag_data(root).unwrap_or_default();
let target = target.filter(|&t| self.root_of(t) == root && !self.component(t).is_some_and(|c| c.drop_accepts(self, t, data)));
if let Some(r) = target.and_then(|t| self.absolute_rect(t)) {
let r = RectF::new(r.x - origin.x, r.y - origin.y, r.width, r.height);
canvas.stroke_rect(r.inflate(1.0), 6.0, &crate::canvas::Stroke::new(self.theme.color("primary"), 2.0));
}
let visual = self.drag_visual(root).map(|(v, _)| v);
let mut label_at = PointF::new(at.x + 14.0, at.y + 14.0);
if let Some(v) = visual {
let r = RectF::new(at.x - v.hotspot.x, at.y - v.hotspot.y, v.size.width, v.size.height);
if !self.native_drag_image {
if let Some(size) = canvas.image_size(&v.image) {
canvas.save();
canvas.clip_round_rect(r, 6.0);
let (src, dest) = crate::ImageFit::Cover.place(size, r);
canvas.draw_image(&v.image, src, dest, v.opacity);
canvas.restore();
}
}
label_at = PointF::new(r.x, r.bottom() + 4.0);
}
if label.is_empty() {
return;
}
let style = self.theme.resolve(&["Hint"], "", ControlState::default());
let mut ts = crate::canvas::TextStyle { font: style.font.clone(), color: style.text, ..Default::default() };
ts.trimming = crate::text::Trimming::Character;
let pad = style.padding;
let w = canvas.measure_text(&label, &ts).width.min(320.0) + pad.left + pad.right + 1.0;
let h = (ts.font.size * 1.4).round() + pad.top + pad.bottom;
let rect = RectF::new(label_at.x, label_at.y, w, h);
if let Some(shadow) = &style.shadow {
canvas.draw_shadow(rect, style.radius, shadow);
}
canvas.fill_rect(rect, style.radius, &crate::canvas::Brush::Solid(style.fill.with_opacity(0.92)));
canvas.draw_text(&label, RectF::new(rect.x + pad.left, rect.y + pad.top, w - pad.left - pad.right, h - pad.top - pad.bottom), &ts);
}
fn paint_hint(&self, root: ComponentId, canvas: &mut dyn Canvas) {
let Some((text, at)) = self.visible_hint(root) else { return };
let Some(form) = self.control(root).map(|cb| cb.bounds()) else { return };
let style = self.theme.resolve(&["Hint"], "", ControlState::default());
let mut ts = crate::canvas::TextStyle { font: style.font.clone(), color: style.text, ..Default::default() };
ts.v_align = crate::canvas::TextAlign::Leading;
let max = 280.0f32.min(form.width - 16.0).max(40.0);
let mut measure = |s: &str| canvas.measure_text(s, &ts).width;
let lines = crate::text::layout_lines(&text, max, 12, true, crate::text::Trimming::Word, &mut measure);
let width = lines.iter().map(|l| measure(l)).fold(0.0f32, f32::max);
let lh = (ts.font.size * 1.4).round();
let pad = style.padding;
let w = width + pad.left + pad.right + 1.0;
let h = lines.len() as f32 * lh + pad.top + pad.bottom;
let mut x = at.x + 4.0;
let mut y = at.y + 22.0;
if x + w > form.width - 4.0 {
x = (form.width - 4.0 - w).max(4.0);
}
if y + h > form.height - 4.0 {
y = (at.y - h - 8.0).max(4.0);
}
let rect = RectF::new(x, y, w, h);
if let Some(shadow) = &style.shadow {
canvas.draw_shadow(rect, style.radius, shadow);
}
canvas.fill_rect(rect, style.radius, &crate::canvas::Brush::Solid(style.fill));
if style.border_width > 0.0 && !style.border_color.is_transparent() {
canvas.stroke_rect(rect, style.radius, &style.border_stroke(style.border_color, style.border_width));
}
let mut ly = y + pad.top;
for line in &lines {
canvas.draw_text(line, RectF::new(x + pad.left, ly, width + 1.0, lh), &ts);
ly += lh;
}
}
#[allow(clippy::too_many_arguments)]
fn look<'t>(
&'t self,
id: ComponentId,
component: &dyn crate::Component,
cb: &crate::ControlBase,
visual: &std::cell::RefCell<Visual>,
parent_enabled: bool,
classes: &mut Vec<&'static str>,
inherited: &'t Theme,
parent_font: &crate::component::FontOverride,
peek: bool,
) -> Look<'t> {
let enabled = parent_enabled && cb.enabled();
let mut state = cb.state();
state.disabled = !enabled;
if let Some(checked) = component.checked_state() {
state.checked = checked;
}
if self.still_picture {
state.hover = false;
state.pressed = false;
state.focused = false;
}
if cb.inherit_state() {
let mut up = self.parent(id);
while let Some(p) = up {
let Some(pcb) = self.cb(p) else { break };
if !pcb.inherit_state() {
let ps = pcb.state();
state.hover |= ps.hover;
state.pressed |= ps.pressed;
state.checked |= self.component(p).and_then(|c| c.checked_state()).unwrap_or(ps.checked);
break;
}
up = self.parent(p);
}
}
if state.focused && !component.accepts_text() && self.focus_from_pointer(self.root_of(id)) {
state.focused = false;
}
classes.clear();
component.class_chain(classes);
let inherited = match cb.theme_name() {
"" => inherited,
name => self.theme_named(name).unwrap_or(inherited),
};
let mixed = self.mixed_theme(inherited, classes);
let colors = cb.colors;
let recolored = colors.recolors_theme().then(|| {
let key = (mixed.name.clone(), colors);
self.recolored.borrow_mut().entry(key).or_insert_with(|| std::rc::Rc::new(colors.apply_theme(mixed))).clone()
});
let (target, reach) = {
let theme: &Theme = recolored.as_deref().unwrap_or(mixed);
(theme.resolve(classes, cb.style(), state), theme.reach(classes, cb.style()).max(cb.shadow().map_or(0.0, |s| s.reach())))
};
let (mut style, transitioning) = if self.design_mode {
(target, false)
} else if peek {
visual.borrow().clone().update(state, target, self.time)
} else {
visual.borrow_mut().update(state, target, self.time)
};
let font = if cb.font.is_empty() { parent_font.clone() } else { cb.font.over(parent_font) };
if !font.is_empty() {
font.apply(&mut style.font);
}
if cb.text_scale() != 1.0 {
style.font.size *= cb.text_scale();
}
if !self.font_names().is_empty() {
style.font.family = self.resolve_font(&style.font.family);
}
let paint_fill = colors.fill.is_some() && component.transparent_background();
if let Some(fill) = colors.fill {
let toward = if crate::component::luminance(fill) < 0.5 { crate::Color::WHITE } else { crate::Color::BLACK };
let amount = if !cb.can_focus() { 0.0 } else if state.pressed { 0.2 } else if state.hover || state.checked { 0.1 } else { 0.0 };
style.fill = fill.lerp(toward.with_opacity(fill.a as f32 / 255.0), amount);
}
if let Some(border) = colors.border {
style.border_color = border;
style.border_width = style.border_width.max(1.0);
}
if let Some(text) = colors.text {
style.text = text;
}
Look { enabled, state, inherited, mixed, recolored, colors, style, transitioning, paint_fill, font, reach }
}
pub(crate) fn drawing_unchanged(&self, id: ComponentId) -> bool {
let Some(entry) = self.entry(id) else { return false };
let Some(component) = entry.component.as_deref() else { return false };
let Some(cb) = component.control() else { return false };
let Some(before) = entry.visual.borrow().drawing else { return false };
if !component.paint_is_pure() || entry.paint_hook.is_some() || self.paint_failed(id) || self.flips_content(id) || cb.rotation() != 0.0 {
return false;
}
let mut chain = Vec::new();
let mut current = self.parent(id);
while let Some(p) = current {
chain.push(p);
current = self.parent(p);
}
let (mut enabled, mut inherited, mut font) = (true, &*self.theme, crate::component::FontOverride::default());
for &a in chain.iter().rev() {
let Some(acb) = self.control(a) else { continue };
enabled &= acb.enabled();
if !acb.theme_name().is_empty() {
inherited = self.theme_named(acb.theme_name()).unwrap_or(inherited);
}
if !acb.font.is_empty() {
font = acb.font.over(&font);
}
}
let mut classes = Vec::new();
let look = self.look(id, component, cb, &entry.visual, enabled, &mut classes, inherited, &font, true);
if look.transitioning {
return false;
}
let (requested, wake) = (Cell::new(false), Cell::new(None));
let ctx = PaintCtx {
ui: self,
id,
rect: RectF::from_size(cb.bounds().size()),
state: look.state,
style: &look.style,
theme: look.theme(),
time: self.time,
design: self.design_mode,
colors: look.colors,
frame_request: &requested,
wake_at: &wake,
resources: self.services().resources.as_deref(),
};
let ghost = if self.design_mode && cb.design_hidden { 0.35 } else { 1.0 };
let opacity = cb.opacity() * look.style.opacity * ghost;
if opacity <= 0.0 {
return false;
}
let mut hasher = std::hash::DefaultHasher::new();
std::hash::Hash::hash(&opacity.to_bits(), &mut hasher);
std::hash::Hash::hash(&cb.blend_mode(), &mut hasher);
let text = self.services().text.as_deref();
let mut trace = crate::trace::TraceCanvas::new(None, text, &mut hasher);
let painted = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
self.paint_own(&mut trace, component, &ctx, look.paint_fill, cb.shadow().as_ref());
component.paint_after(&mut trace, &ctx);
}));
let volatile = trace.volatile;
painted.is_ok() && !volatile && !requested.get() && std::hash::Hasher::finish(&hasher) == before
}
fn paint_own(&self, canvas: &mut dyn Canvas, component: &dyn crate::Component, ctx: &PaintCtx<'_>, paint_fill: bool, shadow: Option<&crate::Shadow>) {
let style = ctx.style;
if let Some(shadow) = shadow.or(style.shadow.as_ref()) {
canvas.draw_shadow(ctx.rect, style.radius, shadow);
}
if let Some(fill) = ctx.colors.fill.filter(|_| paint_fill) {
canvas.fill_rect(ctx.rect, style.radius, &crate::Brush::Solid(fill));
}
if style.material != crate::theme::Material::None {
canvas.backdrop_blur(ctx.rect, style.radius, style.material.blur());
}
component.paint(canvas, ctx);
if style.material == crate::theme::Material::Glass {
paint_glass_light(canvas, ctx.rect, style.radius, ctx.theme.dark);
}
}
#[allow(clippy::too_many_arguments)]
fn paint_own_with_hook(
&self,
canvas: &mut dyn Canvas,
id: ComponentId,
entry: &crate::ui::Entry,
component: &dyn crate::Component,
ctx: &PaintCtx<'_>,
paint_fill: bool,
shadow: Option<&crate::Shadow>,
flip: bool,
) {
let style = ctx.style;
if let Some(shadow) = shadow.or(style.shadow.as_ref()) {
canvas.draw_shadow(ctx.rect, style.radius, shadow);
}
if let Some(fill) = ctx.colors.fill.filter(|_| paint_fill) {
canvas.fill_rect(ctx.rect, style.radius, &crate::Brush::Solid(fill));
}
if style.material != crate::theme::Material::None {
canvas.backdrop_blur(ctx.rect, style.radius, style.material.blur());
}
if flip {
canvas.save();
canvas.translate(ctx.rect.width, 0.0);
}
{
let mut mirror;
let target: &mut dyn Canvas = if flip {
mirror = Mirror { inner: &mut *canvas };
&mut mirror
} else {
&mut *canvas
};
if self.paint_failed(id) {
paint_failure(target, ctx.rect);
} else {
let painted = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| match &entry.paint_hook {
Some(hook) => hook(target, ctx, &|c: &mut dyn Canvas, x: &PaintCtx<'_>| component.paint(c, x)),
None => component.paint(target, ctx),
}));
if let Err(payload) = painted {
self.note_paint_failure(id, payload.as_ref());
}
}
}
if flip {
canvas.restore();
}
if style.material == crate::theme::Material::Glass {
paint_glass_light(canvas, ctx.rect, style.radius, ctx.theme.dark);
}
}
fn paint_node(
&self,
id: ComponentId,
canvas: &mut dyn Canvas,
parent_enabled: bool,
classes: &mut Vec<&'static str>,
inherited: &Theme,
parent_font: &crate::component::FontOverride,
visible: Option<&[RectF]>,
) {
let behind_mover = self.backdrop_next.replace(false);
let Some(entry) = self.entry(id) else { return };
let Some(component) = entry.component.as_deref() else { return };
let Some(cb) = component.control() else { return };
if !cb.visible() || (cb.design_only && !self.design_mode) {
return;
}
let place = {
let b = cb.bounds();
let t = cb.translate();
RectF::new(b.x + t.x, b.y + t.y, b.width, b.height)
};
let contained = cb.clip_children() || entry.children.is_empty();
if contained && cb.rotation() == 0.0 && visible.is_some_and(|v| !v.iter().any(|r| place.inflate(CULL_MARGIN).intersects(*r))) {
let ink = entry.visual.borrow().ink;
let reaches = ink.zip(self.absolute_rect(id)).zip(visible).is_some_and(|((ink, abs), v)| v.iter().any(|r| ink.offset(place.x - abs.x, place.y - abs.y).intersects(*r)));
if !reaches {
return;
}
}
self.paint_count.set(self.paint_count.get() + 1);
let look = self.look(id, component, cb, &entry.visual, parent_enabled, classes, inherited, parent_font, false);
entry.visual.borrow_mut().reach = Some(look.reach);
let (enabled, state, inherited, colors, paint_fill) = (look.enabled, look.state, look.inherited, look.colors, look.paint_fill);
let (theme, style, font) = (look.theme(), &look.style, &look.font);
if look.transitioning {
self.style_animating.set(true);
self.frame_ids.borrow_mut().push(id);
}
let ghost = if self.design_mode && cb.design_hidden { 0.35 } else { 1.0 };
let opacity = cb.opacity() * style.opacity * ghost;
if opacity <= 0.0 {
entry.visual.borrow_mut().drawing = None;
return;
}
let outer_ink = self.ink.borrow_mut().take();
let bounds = cb.bounds();
{
let mut timed = self.timed_frames.borrow_mut();
if !timed.is_empty() {
timed.remove(&id);
}
}
let scale = cb.scale();
let ctx = PaintCtx {
ui: self,
id,
rect: RectF::from_size(cb.inner_size()),
state,
style: &style,
theme,
time: self.time,
design: self.design_mode,
colors,
frame_request: &self.style_animating,
wake_at: &self.wake_at,
resources: self.services().resources.as_deref(),
};
let flip = self.flips_content(id);
let automatic = self.auto_layers.get()
&& !entry.children.is_empty()
&& ((cb.clip_children() && (self.animates_placement(id) || (behind_mover && self.backdrop_worth(id, entry.visual.borrow().version)))) || self.in_transition(id));
let blend = cb.blend_mode();
let cached = !flip && blend == crate::BlendMode::Normal && (cb.cache_layer() || automatic);
canvas.save();
let shift = cb.translate();
let drawn = if cached && shift != PointF::ZERO {
let s = canvas.device_scale().max(f32::EPSILON);
PointF::new((shift.x * s).round() / s, (shift.y * s).round() / s)
} else {
shift
};
canvas.translate(bounds.x + drawn.x, bounds.y + drawn.y);
let rotation = cb.rotation();
if rotation != 0.0 {
canvas.translate(bounds.width / 2.0, bounds.height / 2.0);
canvas.rotate(rotation);
canvas.translate(-bounds.width / 2.0, -bounds.height / 2.0);
}
if scale != 1.0 {
canvas.scale(scale, scale);
}
let layer = opacity < 1.0 || blend != crate::BlendMode::Normal;
if blend != crate::BlendMode::Normal {
canvas.save_layer_blend(opacity, blend, ctx.rect.inflate(look.reach + 1.0));
} else if layer {
canvas.save_layer(opacity);
}
let traced = component.paint_is_pure() && entry.paint_hook.is_none() && !flip && rotation == 0.0 && !self.paint_failed(id);
let mut hasher = std::hash::DefaultHasher::new();
std::hash::Hash::hash(&opacity.to_bits(), &mut hasher);
std::hash::Hash::hash(&blend, &mut hasher);
let mut volatile = false;
let layer_key = cached.then(|| {
let mut key = std::hash::DefaultHasher::new();
let version = entry.visual.borrow().version;
std::hash::Hash::hash(&(id, version, self.layer_epoch.get(), self.design_mode), &mut key);
std::hash::Hasher::finish(&key)
});
let old_key = std::mem::replace(&mut entry.visual.borrow_mut().layer_key, layer_key);
if let Some(old) = old_key.filter(|old| Some(*old) != layer_key) {
canvas.forget_cached(old);
}
let cache_hit = layer_key.is_some_and(|key| canvas.begin_cached(key, ctx.rect.inflate(look.reach + 1.0)));
if !cache_hit {
if traced {
let mut trace = crate::trace::TraceCanvas::new(Some(&mut *canvas), None, &mut hasher);
let painted = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| self.paint_own(&mut trace, component, &ctx, paint_fill, cb.shadow().as_ref())));
volatile |= trace.volatile;
if let Err(payload) = painted {
self.note_paint_failure(id, payload.as_ref());
}
} else {
self.paint_own_with_hook(canvas, id, entry, component, &ctx, paint_fill, cb.shadow().as_ref(), flip);
}
let scrolled_form = cb.scroll_offset().y > 0.0 && self.parent(id).is_none();
let clip = cb.clip_children() || scrolled_form;
if clip {
canvas.save();
let r = if scrolled_form {
let s = cb.safe_area;
crate::RectF::new(ctx.rect.x, ctx.rect.y + s.top, ctx.rect.width, (ctx.rect.height - s.top - s.bottom).max(0.0))
} else {
ctx.rect
};
canvas.clip_rect(r);
}
let inner: Option<Vec<RectF>> = match visible.filter(|_| rotation == 0.0 && !cached) {
Some(v) => Some(
v.iter()
.map(|r| r.offset(-place.x, -place.y))
.map(|r| if scale == 1.0 { r } else { RectF::new(r.x / scale, r.y / scale, r.width / scale, r.height / scale) })
.map(|local| if clip { intersection(local, ctx.rect) } else { local })
.filter(|r| r.width > 0.0 && r.height > 0.0)
.collect(),
),
None if clip && rotation == 0.0 => Some(vec![ctx.rect]),
None => None,
};
let hidden = self.covered_children(&entry.children, inner.as_deref());
let mover_at = if self.auto_layers.get() {
self.movers.borrow().iter().filter(|&&(p, _)| p == id).filter_map(|&(_, m)| entry.children.iter().position(|&c| c == m)).max()
} else {
None
};
for (k, &child) in entry.children.iter().enumerate() {
if hidden.get(k).copied().unwrap_or(false) {
continue;
}
self.backdrop_next.set(mover_at.is_some_and(|m| k < m));
self.paint_node(child, canvas, enabled, classes, inherited, &font, inner.as_deref());
}
if clip {
canvas.restore();
}
if self.paint_failed(id) {
} else if flip {
canvas.save();
canvas.translate(ctx.rect.width, 0.0);
let after = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| component.paint_after(&mut Mirror { inner: &mut *canvas }, &ctx)));
canvas.restore();
if let Err(payload) = after {
self.note_paint_failure(id, payload.as_ref());
}
} else if traced {
let mut trace = crate::trace::TraceCanvas::new(Some(&mut *canvas), None, &mut hasher);
let after = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| component.paint_after(&mut trace, &ctx)));
volatile |= trace.volatile;
if let Err(payload) = after {
self.note_paint_failure(id, payload.as_ref());
}
} else if let Err(payload) = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| component.paint_after(canvas, &ctx))) {
self.note_paint_failure(id, payload.as_ref());
}
if cached {
canvas.end_cached();
}
}
if layer {
canvas.restore();
}
canvas.restore();
let ink = std::mem::replace(&mut *self.ink.borrow_mut(), outer_ink);
let mut visual = entry.visual.borrow_mut();
if let (Some(new), Some(area)) = (ink, self.paint_area.get()) {
let seen = self.paint_form.get().map_or(new, |form| intersection(new, form));
let outside = seen.width > 0.0 && seen.height > 0.0 && !area.inflate(SPILL_SLACK).contains_rect(seen);
if outside && !visual.ink.is_some_and(|old| old.inflate(SPILL_SLACK).contains_rect(seen)) {
self.spilled.set(true);
}
}
visual.ink = ink;
visual.shift = shift;
visual.drawing = (traced && !cache_hit && !volatile && !self.paint_failed(id)).then(|| std::hash::Hasher::finish(&hasher));
let whole = opacity >= 1.0 && rotation == 0.0 && !flip && !self.paint_failed(id);
drop(visual);
let own = component.opaque(&style) || paint_fill && colors.fill.is_some_and(|f| f.a == 255) && style.radius <= 0.0;
let by_child = || {
entry.children.iter().any(|&c| {
self.entry(c).is_some_and(|e| {
e.visual.borrow().covers
&& e.component.as_deref().and_then(|c| c.control()).is_some_and(|ccb| ccb.visible() && place_of(ccb).contains_rect(ctx.rect))
})
})
};
let covers = whole && (own || by_child());
let was = std::mem::replace(&mut entry.visual.borrow_mut().covers, covers);
if was && !covers {
self.style_animating.set(true);
self.frame_ids.borrow_mut().push(id);
}
}
fn backdrop_worth(&self, id: ComponentId, version: u64) -> bool {
let parent = self.parent(id);
let mut backdrops = self.backdrops.borrow_mut();
let b = backdrops.entry(id).or_insert(Backdrop { parent, version, builds: 1 });
if b.version != version {
b.version = version;
b.builds += 1;
}
b.builds <= BACKDROP_BUILDS
}
fn covered_children(&self, children: &[ComponentId], inner: Option<&[RectF]>) -> Vec<bool> {
let mut hidden = Vec::new();
let mut covers: Vec<RectF> = Vec::new();
for (k, &child) in children.iter().enumerate().rev() {
let Some(entry) = self.entry(child) else { continue };
let Some(cb) = entry.component.as_deref().and_then(|c| c.control()) else { continue };
if !cb.visible() {
continue;
}
let place = place_of(cb);
if !covers.is_empty() {
let reach = entry.visual.borrow().reach.unwrap_or(CULL_MARGIN);
let own = place.inflate(reach);
let contained = !entry.children.is_empty() && !cb.clip_children();
let gone = covers.iter().any(|c| {
c.contains_rect(own) && (!contained || inner.is_some_and(|areas| !areas.is_empty() && areas.iter().all(|a| c.contains_rect(*a))))
});
if gone {
if hidden.is_empty() {
hidden = vec![false; children.len()];
}
hidden[k] = true;
continue;
}
}
if entry.visual.borrow().covers {
covers.push(place);
if covers.len() > 4 {
covers.sort_by(|a, b| (b.width * b.height).total_cmp(&(a.width * a.height)));
covers.truncate(4);
}
}
}
hidden
}
}
fn place_of(cb: &crate::component::ControlBase) -> RectF {
let b = cb.bounds();
let t = cb.translate();
RectF::new(b.x + t.x, b.y + t.y, b.width, b.height)
}
fn paint_failure(canvas: &mut dyn Canvas, rect: RectF) {
let red = crate::color::Color::rgb(220, 38, 38);
canvas.fill_rect(rect, 0.0, &crate::canvas::Brush::Solid(red.with_opacity(0.12)));
let stroke = crate::canvas::Stroke::new(red, 2.0);
canvas.stroke_rect(rect.inflate(-1.0), 0.0, &stroke);
canvas.draw_line(rect.origin(), PointF::new(rect.right(), rect.bottom()), &stroke);
canvas.draw_line(PointF::new(rect.right(), rect.y), PointF::new(rect.x, rect.bottom()), &stroke);
}
pub fn paint_glass_light(canvas: &mut dyn Canvas, rect: crate::RectF, radius: f32, dark: bool) {
use crate::canvas::{Brush, GradientStop, Stroke};
use crate::{Color, PointF};
if rect.width <= 2.0 || rect.height <= 2.0 {
return;
}
let shine = if dark { 0.16 } else { 0.42 };
canvas.fill_rect(
rect,
radius,
&Brush::Linear {
start: PointF::new(0.0, rect.y),
end: PointF::new(0.0, rect.y + rect.height * 0.6),
stops: vec![GradientStop::new(0.0, Color::WHITE.with_opacity(shine)), GradientStop::new(1.0, Color::WHITE.with_opacity(0.0))],
},
);
let edge = Brush::Linear {
start: PointF::new(rect.x, rect.y),
end: PointF::new(rect.x + rect.width * 0.35, rect.bottom()),
stops: vec![
GradientStop::new(0.0, Color::WHITE.with_opacity(if dark { 0.45 } else { 0.95 })),
GradientStop::new(0.55, Color::WHITE.with_opacity(if dark { 0.10 } else { 0.35 })),
GradientStop::new(1.0, if dark { Color::WHITE.with_opacity(0.18) } else { Color::BLACK.with_opacity(0.10) }),
],
};
let r = (radius - 0.5).max(0.0);
canvas.stroke_rect(rect.inflate(-0.5), r, &Stroke::new(edge, 1.0));
}
pub(crate) struct Mirror<'a> {
pub(crate) inner: &'a mut dyn Canvas,
}
impl Mirror<'_> {
fn x(x: f32) -> f32 {
-x
}
fn point(p: crate::PointF) -> crate::PointF {
crate::PointF::new(-p.x, p.y)
}
fn rect(r: crate::RectF) -> crate::RectF {
crate::RectF::new(-r.right(), r.y, r.width, r.height)
}
fn path(p: &crate::Path) -> crate::Path {
p.map_points(Self::point)
}
fn brush(b: &crate::Brush) -> crate::Brush {
use crate::Brush;
match b {
Brush::Solid(c) => Brush::Solid(*c),
Brush::Linear { start, end, stops } => Brush::Linear { start: Self::point(*start), end: Self::point(*end), stops: stops.clone() },
Brush::Radial { center, radius, stops } => Brush::Radial { center: Self::point(*center), radius: *radius, stops: stops.clone() },
Brush::Sweep { center, start_angle, stops } => Brush::Sweep {
center: Self::point(*center),
start_angle: 180.0 - start_angle,
stops: stops.iter().rev().map(|s| crate::GradientStop::new(1.0 - s.offset, s.color)).collect(),
},
}
}
fn stroke(s: &crate::Stroke) -> crate::Stroke {
crate::Stroke { brush: Self::brush(&s.brush), ..s.clone() }
}
}
impl Canvas for Mirror<'_> {
fn save(&mut self) {
self.inner.save();
}
fn restore(&mut self) {
self.inner.restore();
}
fn translate(&mut self, dx: f32, dy: f32) {
self.inner.translate(Self::x(dx), dy);
}
fn scale(&mut self, sx: f32, sy: f32) {
self.inner.scale(sx, sy);
}
fn rotate(&mut self, degrees: f32) {
self.inner.rotate(-degrees);
}
fn clip_rect(&mut self, rect: crate::RectF) {
self.inner.clip_rect(Self::rect(rect));
}
fn save_layer(&mut self, opacity: f32) {
self.inner.save_layer(opacity);
}
fn save_layer_blend(&mut self, opacity: f32, mode: crate::BlendMode, bounds: crate::RectF) {
self.inner.save_layer_blend(opacity, mode, Self::rect(bounds));
}
fn fill_rect(&mut self, rect: crate::RectF, radius: f32, brush: &crate::Brush) {
self.inner.fill_rect(Self::rect(rect), radius, &Self::brush(brush));
}
fn stroke_rect(&mut self, rect: crate::RectF, radius: f32, stroke: &crate::Stroke) {
self.inner.stroke_rect(Self::rect(rect), radius, &Self::stroke(stroke));
}
fn fill_ellipse(&mut self, rect: crate::RectF, brush: &crate::Brush) {
self.inner.fill_ellipse(Self::rect(rect), &Self::brush(brush));
}
fn stroke_ellipse(&mut self, rect: crate::RectF, stroke: &crate::Stroke) {
self.inner.stroke_ellipse(Self::rect(rect), &Self::stroke(stroke));
}
fn draw_line(&mut self, from: crate::PointF, to: crate::PointF, stroke: &crate::Stroke) {
self.inner.draw_line(Self::point(from), Self::point(to), &Self::stroke(stroke));
}
fn draw_text(&mut self, text: &str, rect: crate::RectF, style: &TextStyle) {
use crate::TextAlign;
let mut style = style.clone();
style.h_align = match style.h_align {
TextAlign::Leading => TextAlign::Trailing,
TextAlign::Trailing => TextAlign::Leading,
other => other,
};
self.inner.draw_text(text, Self::rect(rect), &style);
}
fn measure_text(&mut self, text: &str, style: &TextStyle) -> crate::SizeF {
self.inner.measure_text(text, style)
}
fn draw_image(&mut self, image: &crate::Image, src: crate::RectF, dest: crate::RectF, opacity: f32) {
self.inner.draw_image(image, src, Self::rect(dest), opacity);
}
fn image_size(&mut self, image: &crate::Image) -> Option<crate::SizeF> {
self.inner.image_size(image)
}
fn clip_round_rect(&mut self, rect: crate::RectF, radius: f32) {
self.inner.clip_round_rect(Self::rect(rect), radius);
}
fn fill_path(&mut self, path: &crate::Path, brush: &crate::Brush) {
self.inner.fill_path(&Self::path(path), &Self::brush(brush));
}
fn clip_path(&mut self, path: &crate::Path, inverse: bool) {
self.inner.clip_path(&Self::path(path), inverse);
}
fn backdrop_blur(&mut self, rect: crate::RectF, radius: f32, blur: f32) -> bool {
self.inner.backdrop_blur(Self::rect(rect), radius, blur)
}
fn begin_masked(&mut self, inverse: bool) -> bool {
self.inner.begin_masked(inverse)
}
fn begin_mask(&mut self) {
self.inner.begin_mask();
}
fn end_mask(&mut self) {
self.inner.end_mask();
}
fn stroke_path(&mut self, path: &crate::Path, stroke: &crate::Stroke) {
self.inner.stroke_path(&Self::path(path), &Self::stroke(stroke));
}
fn draw_shadow(&mut self, rect: crate::RectF, radius: f32, shadow: &crate::Shadow) {
let mut shadow = shadow.clone();
shadow.offset.x = -shadow.offset.x;
self.inner.draw_shadow(Self::rect(rect), radius, &shadow);
}
fn device_scale(&self) -> f32 {
self.inner.device_scale()
}
fn gpu_device(&self) -> Option<crate::GpuDevice> {
self.inner.gpu_device()
}
fn draw_gpu_surface(&mut self, dest: crate::RectF, surface: &crate::GpuSurface) -> bool {
self.inner.draw_gpu_surface(Self::rect(dest), surface)
}
}
const CULL_MARGIN: f32 = 48.0;
fn intersection(a: RectF, b: RectF) -> RectF {
let x = a.x.max(b.x);
let y = a.y.max(b.y);
RectF::new(x, y, (a.right().min(b.right()) - x).max(0.0), (a.bottom().min(b.bottom()) - y).max(0.0))
}