Struct PaintCtx 

pub struct PaintCtx<'a> {
    pub frame: &'a mut Frame,
    pub clip: u16,
    pub ctx: &'a UiContext,
    pub hits: &'a mut Vec<Hit>,
    pub focus: Option<Slot>,
    pub hover: Option<(Slot, HitTag)>,
    pub pointer: Option<(u16, u16)>,
    pub keyboard: bool,
    pub now: Duration,
    /* private fields */
}

State shared by component painters for one frame.

Fields

frame: &'a mut Frame

Destination frame.

clip: u16

First document row outside the paint region.

ctx: &'a UiContext

Immutable presentation context.

hits: &'a mut Vec<Hit>

Mouse hit regions produced during paint.

focus: Option<Slot>

Focused component slot.

hover: Option<(Slot, HitTag)>

Hovered component slot and hit tag.

pointer: Option<(u16, u16)>

Last pointer cell in this frame’s coordinates, for chrome that tracks the mouse between hit changes.

keyboard: bool

Whether the keyboard was the most recent input modality. The chrome cursor is singular: focus renders hover/lift chrome only while the keyboard owns it, and pointer motion takes it back.

now: Duration

Presentation clock: time since the UI’s epoch for this paint pass.

Implementations

impl<'a> PaintCtx<'a>

pub fn wake(&mut self, slot: Slot, at: Duration)

Schedules a repaint of slot at time at; the earliest request per slot wins. Requests are consumed by crate::Ui::tick and rebuilt on every paint, so a component that stops asking stops animating.

Examples found in repository

examples/chat/demo.rs (line 693)

	fn paint(&mut self, pc: &mut PaintCtx<'_>, rect: Rect) {
		let mut left = self.left_group(pc.now);
		let (_, left_width) = left.measure(pc.ctx);
		let (_, right_width) = self.right.measure(pc.ctx);
		if left_width.saturating_add(2).saturating_add(right_width) <= rect.width {
			left.paint(pc, Rect::new(rect.x, rect.y, left_width, 1));
			let dock = rect
				.x
				.saturating_add(rect.width)
				.saturating_sub(right_width);
			self
				.right
				.paint(pc, Rect::new(dock, rect.y, right_width, 1));
		} else {
			let mut combined = self.combined(pc.now);
			combined.paint(pc, rect);
		}
		let work = self.work.borrow();
		let fade_frame = work
			.fade
			.settles_at()
			.min(pc.now.saturating_add(FADE_FRAME));
		let deadline = match (work.working, work.fade.is_settled(pc.now)) {
			(true, true) => Some(pc.ctx.charset.spinner().next_change(pc.now)),
			(true, false) => Some(pc.ctx.charset.spinner().next_change(pc.now).min(fade_frame)),
			(false, false) => Some(fade_frame),
			(false, true) => None,
		};
		if let Some(at) = deadline {
			pc.wake(self.slot, at);
		}
	}