Struct Props 

pub struct Props { /* private fields */ }

Typed component attributes.

Implementations

impl Props

pub fn new() -> Self

Creates an empty property collection.

Examples found in repository

examples/chat/demo.rs (line 281)

	fn new(editor: Rc<RefCell<Editor>>, outcome: Rc<RefCell<Option<EditOutcome>>>) -> Self {
		Self { props: Props::new(), slot: next_slot(), editor, outcome }
	}

	/// Cells before the editor text: the two-cell prompt plus a gap —
	/// identical on every tier.
	const fn input_offset() -> u16 {
		3
	}

	/// The `╰─` composer prompt composed from the tier's round border.
	fn input_prompt(charset: Charset) -> Str {
		let (_, _, bl, _, horizontal, _) = charset.border(Border::Round);
		fmts!("{bl}{horizontal}")
	}

	const fn input_width(width: u16) -> u16 {
		width.saturating_sub(Self::input_offset()).saturating_sub(1)
	}

	fn paint_picker(pc: &mut PaintCtx<'_>, rect: Rect, y: u16, editor: &Editor) {
		let Some(picker) = editor.picker() else {
			return;
		};
		let (start, suggestions) = picker.visible_suggestions();
		let overflow = picker.len() > suggestions.len();
		let row_right = rect
			.x
			.saturating_add(rect.width.saturating_sub(u16::from(overflow)));
		let primary_width = suggestions
			.iter()
			.filter_map(|suggestion| match suggestion.display() {
				SuggestionDisplay::Text(name) => Some(visible_width(name).saturating_add(2)),
				SuggestionDisplay::Emoji { .. } => None,
			})
			.max()
			.unwrap_or(12)
			.clamp(12, 32);

		for (offset, suggestion) in suggestions.iter().enumerate() {
			let Ok(offset) = u16::try_from(offset) else {
				break;
			};
			let row = y.saturating_add(offset);
			if row >= pc.clip {
				break;
			}
			let selected = start + usize::from(offset) == picker.selected();
			let label = if selected { ink(GREEN) } else { ink(TEXT) };
			let description = if selected { ink(GREEN) } else { ink(MUTED) };
			pc.frame.put(
				rect.x,
				row,
				if selected {
					pc.ctx.charset.cursor()
				} else {
					"  "
				},
				label,
			);
			match suggestion.display() {
				SuggestionDisplay::Text(name) => {
					draw_line(
						pc.frame,
						rect.x.saturating_add(2),
						row,
						row_right.saturating_sub(rect.x.saturating_add(2)),
						&[Span::new(name, label)],
					);
					if let Some(text) = suggestion.description()
						&& rect.width > 40
					{
						let description_x = rect
							.x
							.saturating_add(2)
							.saturating_add(primary_width)
							.min(row_right);
						draw_line(
							pc.frame,
							description_x,
							row,
							row_right.saturating_sub(description_x),
							&[Span::new(text, description)],
						);
					}
				},
				SuggestionDisplay::Emoji { emoji, shortcode } => {
					let mut column = pc.frame.put(rect.x.saturating_add(2), row, emoji, label);
					column = pc.frame.put(column, row, "  ", label);
					if shortcode.starts_with(':') {
						pc.frame.put(column, row, shortcode, label);
					} else {
						column = pc.frame.put(column, row, ":", label);
						column = pc.frame.put(column, row, shortcode, label);
						pc.frame.put(column, row, ":", label);
					}
				},
			}
		}

		if overflow && !suggestions.is_empty() {
			let (track, thumb_glyph) = pc.ctx.charset.scrollbar();
			let track_x = rect.x.saturating_add(rect.width.saturating_sub(1));
			for offset in 0..suggestions.len() {
				let Ok(offset) = u16::try_from(offset) else {
					break;
				};
				pc.frame
					.put(track_x, y.saturating_add(offset), track, ink(FAINT));
			}
			let thumb = picker
				.selected()
				.saturating_mul(suggestions.len().saturating_sub(1))
				/ picker.len().saturating_sub(1);
			pc.frame.put(
				track_x,
				y.saturating_add(u16::try_from(thumb).unwrap_or(u16::MAX)),
				thumb_glyph,
				ink(GREEN),
			);
		}
	}
}

impl Component for DemoInput {
	fn props(&self) -> &Props {
		&self.props
	}

	fn props_mut(&mut self) -> &mut Props {
		&mut self.props
	}

	fn slot(&self) -> Slot {
		self.slot
	}

	fn measure(&mut self, _ctx: &UiContext) -> (u16, u16) {
		(6, 40)
	}

	fn height(&mut self, _ctx: &UiContext, width: u16) -> u16 {
		let editor = self.editor.borrow();
		editor
			.input_height_for(Self::input_width(width))
			.saturating_add(editor.picker_height())
	}

	fn paint(&mut self, pc: &mut PaintCtx<'_>, rect: Rect) {
		pc.hits
			.push(Hit { rect, slot: self.slot, tag: HitTag::Press });
		let editor = self.editor.borrow();
		let input_x = rect.x.saturating_add(Self::input_offset());
		let input_width = Self::input_width(rect.width);
		let input_height = editor.input_height_for(input_width);
		let theme = Theme::default();
		let mut in_comment = false;
		for (offset, row) in editor.view(input_width).iter().enumerate() {
			let row_y = rect
				.y
				.saturating_add(u16::try_from(offset).unwrap_or(u16::MAX));
			if row_y >= pc.clip {
				break;
			}
			if offset == 0 {
				pc.frame
					.put(rect.x, row_y, &Self::input_prompt(pc.ctx.charset), ink(FAINT));
			}
			let mut spans: SmallVec<Span<'_>, 16> = SmallVec::new();
			if editor.options().xml {
				let (runs, next) = highlight_xml(row.text, &theme, in_comment);
				in_comment = next;
				push_row_spans(&editor, row.text, &runs, &mut spans);
			} else {
				push_row_spans(&editor, row.text, &[], &mut spans);
			}
			draw_line(pc.frame, input_x, row_y, input_width, &spans);
			if let Some(cursor_column) = row.cursor_column {
				if cursor_column >= visible_width(row.text)
					&& let Some(hint) = editor.inline_hint()
				{
					let hint_x = input_x.saturating_add(cursor_column).saturating_add(1);
					let width = input_width.saturating_sub(cursor_column.saturating_add(1));
					draw_line(pc.frame, hint_x, row_y, width, &[Span::new(
						hint.as_str(),
						ink(MUTED).dim(),
					)]);
				}
				pc.frame.set_cursor(
					input_x
						.saturating_add(cursor_column)
						.min(rect.x.saturating_add(rect.width.saturating_sub(2))),
					row_y,
				);
			}
		}
		Self::paint_picker(pc, rect, rect.y.saturating_add(input_height), &editor);
	}

	fn focusable(&self) -> bool {
		true
	}

	fn key(&mut self, _ec: &mut EventCtx<'_>, key: Key) -> Flow {
		let outcome = self.editor.borrow_mut().handle(key);
		*self.outcome.borrow_mut() = Some(outcome);
		// The editor owns every key while focused. In particular, an ignored
		// picker key must not escape into `Ui`'s focus-ring navigation; the
		// demo applies its quit policy from the recorded `EditOutcome`.
		Flow::Consumed
	}

	fn mouse(
		&mut self,
		_ec: &mut EventCtx<'_>,
		_tag: HitTag,
		at: (u16, u16),
		rect: Rect,
		mouse: Mouse,
	) -> Flow {
		let width = Self::input_width(rect.width);
		match mouse {
			Mouse::Click => {
				self.editor.borrow_mut().set_cursor_visual_row(
					usize::from(at.1.saturating_sub(rect.y)),
					at.0
						.saturating_sub(rect.x.saturating_add(Self::input_offset())),
					width,
				);
				Flow::Consumed
			},
			Mouse::WheelUp | Mouse::WheelDown => {
				let delta = if mouse == Mouse::WheelUp { -1 } else { 1 };
				if self
					.editor
					.borrow()
					.scroll_rows(delta, width, usize::from(rect.height))
				{
					Flow::Consumed
				} else {
					Flow::Skip
				}
			},
			_ => Flow::Skip,
		}
	}

	fn paste(&mut self, _ec: &mut EventCtx<'_>, text: &str) -> Flow {
		if matches!(self.editor.borrow_mut().insert_text(text), EditOutcome::Changed) {
			Flow::Consumed
		} else {
			Flow::Skip
		}
	}
}
/// Whether the demo is working, and how the status bar's brand segment
/// blends between its two states.
struct WorkState {
	working: bool,
	/// When the current mode began; the working timer counts from here.
	since:   Duration,
	/// Brand foreground: [`GREEN`] while working, [`MUTED`] at rest.
	fade:    Tween<Color>,
}

/// Powerline status split into a left brand group — spinner and session
/// timer while working, the omp brand at rest, the foreground tweening
/// between the two so neither swap ever snaps — and a right-docked
/// session group (branch, context, cost). Panes too narrow for both
/// groups fall back to one left-anchored band that sheds from the tail.
struct DemoStatus {
	props:   Props,
	slot:    Slot,
	work:    Rc<RefCell<WorkState>>,
	model:   Rc<RefCell<Str>>,
	charset: Charset,
	right:   Status,
}

impl DemoStatus {
	fn new(work: Rc<RefCell<WorkState>>, model: Rc<RefCell<Str>>, charset: Charset) -> Self {
		let mut props = Props::new();
		props.set(Prop::Id, STATUS_ID);
		let right = Self::right_group(charset);
		Self { props, slot: next_slot(), work, model, charset, right }
	}

pub fn with(self, prop: Prop, value: impl Into<PropValue>) -> Self

Returns this collection with a known property assigned.

Panics

Panics when a textual value is invalid for the selected property.

pub fn set(&mut self, prop: Prop, value: impl Into<PropValue>)

Assigns a known property.

Panics

Panics when a textual value is invalid for the selected property.

Examples found in repository

examples/chat/demo.rs (line 562)

	fn new(work: Rc<RefCell<WorkState>>, model: Rc<RefCell<Str>>, charset: Charset) -> Self {
		let mut props = Props::new();
		props.set(Prop::Id, STATUS_ID);
		let right = Self::right_group(charset);
		Self { props, slot: next_slot(), work, model, charset, right }
	}

pub fn try_set(&mut self, prop: Prop, value: PropValue) -> Result<(), PropError>

Validates and assigns a known property.

Errors

Returns PropError when a textual value cannot be parsed for the selected property.

pub fn get(&self, prop: Prop) -> Option<&PropValue>

Returns the typed value assigned to a known property.

pub fn unset(&mut self, prop: Prop)

Removes a known property, restoring its unset default.

pub fn get_str(&self, prop: Prop) -> Option<Str>

Formats a known property value using its markup representation.

pub fn with_custom( self, name: impl Into<Str>, value: impl Into<PropValue>, ) -> Self

Returns this collection with a custom property assigned.

pub fn set_custom(&mut self, name: impl Into<Str>, value: impl Into<PropValue>)

Assigns or replaces a custom property.

pub fn custom(&self, name: &str) -> Option<&PropValue>

Returns a custom property by its literal name.

pub fn named(&self, name: &str) -> Option<&PropValue>

Returns either a known or custom property by markup name.

pub fn prop_of(name: &str) -> Option<Prop>

Resolves a markup attribute name to its well-known property — the kebab-cased variant ident derived on Prop.

pub fn gap(&self) -> u16

Returns the inter-child spacing, defaulting to zero.

pub fn pad(&self) -> (u16, u16)

Returns vertical and horizontal padding, defaulting to zero.

pub fn grow(&self) -> Option<f32>

Returns the flexible growth weight, with a bare flag meaning one.

pub fn w(&self) -> Option<Dim>

Returns the preferred width as a cell or percentage dimension.

pub fn min(&self) -> Option<u16>

Returns the minimum width or numeric value.

pub fn max(&self) -> Option<u16>

Returns the maximum width or numeric value.

pub fn h(&self) -> Option<u16>

Returns the preferred height in rows.

pub fn truncate(&self) -> Option<Truncate>

Returns the truncation mode: a bare truncate flag clips the end, truncate=start clips the beginning; None disables truncation.

pub fn wrap_chars(&self) -> bool

Whether text flows grapheme-exact to the width (wrap=char) like a bare terminal: every break is a byte-preserving soft wrap the renderer re-joins for native copy. Defaults to word wrapping.

pub fn border(&self) -> Option<Border>

Returns the selected border glyph family.

pub fn guides(&self) -> Option<Border>

Returns the tree guide connector family; a bare flag means square.

pub fn bleed(&self) -> bool

Reports whether the background extends through the border.

pub fn align(&self) -> Align

Returns horizontal alignment, defaulting to the start edge.

pub fn title_align(&self) -> Align

Returns the border-title placement, defaulting to the start edge.

pub fn footer_align(&self) -> Align

Returns the border-footer placement, defaulting to the start edge.

pub fn valign(&self) -> Option<VAlign>

Returns the configured vertical alignment.

pub fn id(&self) -> Option<&Str>

Returns the stable component identifier.

pub fn title(&self) -> Option<&Str>

Returns the user-facing component title.

pub fn footer(&self) -> Option<&Str>

Returns the footer shown on a framed container’s bottom border.

pub fn angle(&self) -> u16

Normalized gradient direction in screen degrees.

pub fn anim(&self) -> Option<Duration>

Transition duration for animatable properties, when anim is set. A bare anim flag selects 200ms.

pub fn ease(&self) -> Easing

Easing curve for anim transitions, defaulting to ease-out — the natural shape for state changes that should land softly.

pub fn spin(&self) -> Option<Duration>

Gradient rotation period, when spin is set. A bare spin flag selects one revolution every 3 seconds.

pub fn shimmer(&self) -> Option<Duration>

Brightness-crest sweep period, when shimmer is set. A bare shimmer flag selects one sweep every 2 seconds.

pub fn reveal(&self) -> Option<Duration>

Streamed-text reveal catch-up horizon, when reveal is set. A bare reveal flag selects 250ms; reveal=0 shows new text immediately.

pub fn lift(&self) -> u16

Rows of hover elevation, with a bare flag meaning one.

pub fn flag(&self, prop: Prop) -> bool

Reports whether a boolean property is enabled.

pub fn str_of(&self, prop: Prop) -> Option<&Str>

Returns the textual payload of a property.

Examples found in repository

examples/companies.rs (line 117)

fn build_ui(viewport: Size, context: UiContext) -> Ui {
	let ids = PROVIDERS
		.iter()
		.enumerate()
		.map(|(index, provider)| {
			(format!("{ASSET_DIR}/{}.png", provider.id), u32::try_from(index + 1).unwrap())
		})
		.collect::<HashMap<_, _>>();
	let elements = Elements::builder()
		.with("logo", move |_: &str, props: Props, _: Vec<Cached>| {
			let source = props.str_of(Prop::Src).map_or("", |value| value.as_str());
			let id = ids.get(source).copied().unwrap_or(1);
			Box::new(
				Img::new()
					.with_str(Prop::Src, source)
					.with(Prop::W, 4_u16)
					.kitty(id, 2, 4),
			) as Box<dyn omp_tui::Component>
		})
		.build();
	let root = dom! {
		<col gap=1>
			<row gap=1>
				<i:log-in/>
				<text bold fg="accent..info">{"Choose a provider"}</text>
				<text dim>{format!("{} providers", PROVIDERS.len())}</text>
			</row>
			<scroll id={SCROLL_ID} h={scroll_height(viewport)}>
				<row wrap gap=1 justify=center>
					for provider in PROVIDERS.iter() {
						<box focus id={provider.id} w={CARD_W} border=round bc="muted..muted"
							hover="#38bdf8..#c084fc" lift=1 anim=220 ease=in-out
							align=center pad-x=1>
							<logo src={format!("{ASSET_DIR}/{}.png", provider.id)}/>
							<text bold truncate align=center>{provider.name}</text>
						</box>
					}
				</row>
			</scroll>
			<row gap=2>
				<text dim>{"↹/←→/↑↓ pick · ↵ login · wheel scroll · Ctrl-C quit"}</text>
				<text id={HUD_ID} dim>{"repaint: 0 cells"}</text>
			</row>
		</col>
	};
	let context = UiContext { elements, ..context };
	Ui::from_root(root, viewport.width, context)
}

pub fn style(&self, theme: &Theme) -> Style

Resolves colors and text attributes into a render style.

pub fn edge(&self, theme: &Theme) -> Option<Color>

Resolves the border color from either supported attribute name.

Trait Implementations

impl Clone for Props

fn clone(&self) -> Props

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Props

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Props

fn default() -> Props

Returns the “default value” for a type.