pub mod widgets;
pub mod panels;
pub mod layout;
pub mod framework;
pub use layout::{
UiLayout, Anchor, UiRect, AutoLayout,
Constraint, FlexLayout, GridLayout, AbsoluteLayout,
StackLayout, FlowLayout, LayoutNode, ResponsiveBreakpoints,
SafeAreaInsets, Breakpoint, Axis, JustifyContent,
CrossAlign, FlexWrap,
};
pub use widgets::{
UiLabel, UiProgressBar, UiButton, UiPanel, UiPulseRing,
};
pub use panels::{
Window, SplitPane, TabBar, TabPanel, Toolbar, StatusBar,
ContextMenu, Notification, Modal, DragDropContext,
NotificationSeverity, Toast, ToolbarItem,
};
use std::collections::HashMap;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct UiId(pub u64);
impl UiId {
pub fn new(label: &str) -> Self {
let mut hash: u64 = 14695981039346656037;
for byte in label.bytes() {
hash ^= byte as u64;
hash = hash.wrapping_mul(1099511628211);
}
Self(hash)
}
pub fn with_index(self, idx: usize) -> Self {
let mut h = self.0 ^ idx as u64;
h = h.wrapping_mul(1099511628211);
Self(h)
}
pub fn child(self, child: UiId) -> Self {
let mut h = self.0 ^ child.0;
h = h.wrapping_mul(1099511628211);
Self(h)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub struct Rect {
pub x: f32, pub y: f32, pub w: f32, pub h: f32,
}
impl Rect {
pub fn new(x: f32, y: f32, w: f32, h: f32) -> Self { Self { x, y, w, h } }
pub fn zero() -> Self { Default::default() }
pub fn from_min_max(x0: f32, y0: f32, x1: f32, y1: f32) -> Self {
Self { x: x0, y: y0, w: x1 - x0, h: y1 - y0 }
}
pub fn min_x(&self) -> f32 { self.x }
pub fn min_y(&self) -> f32 { self.y }
pub fn max_x(&self) -> f32 { self.x + self.w }
pub fn max_y(&self) -> f32 { self.y + self.h }
pub fn center_x(&self) -> f32 { self.x + self.w * 0.5 }
pub fn center_y(&self) -> f32 { self.y + self.h * 0.5 }
pub fn center(&self) -> (f32, f32) { (self.center_x(), self.center_y()) }
pub fn contains(&self, px: f32, py: f32) -> bool {
px >= self.x && px <= self.x + self.w && py >= self.y && py <= self.y + self.h
}
pub fn intersect(&self, other: &Rect) -> Option<Rect> {
let x = self.x.max(other.x);
let y = self.y.max(other.y);
let x2 = (self.x + self.w).min(other.x + other.w);
let y2 = (self.y + self.h).min(other.y + other.h);
if x2 > x && y2 > y { Some(Self::new(x, y, x2-x, y2-y)) } else { None }
}
pub fn expand(&self, m: f32) -> Self {
Self { x: self.x-m, y: self.y-m, w: (self.w+m*2.0).max(0.0), h: (self.h+m*2.0).max(0.0) }
}
pub fn shrink(&self, p: f32) -> Self {
Self { x: self.x+p, y: self.y+p, w: (self.w-p*2.0).max(0.0), h: (self.h-p*2.0).max(0.0) }
}
pub fn split_left(&self, a: f32) -> (Rect, Rect) {
let a = a.min(self.w);
(Self::new(self.x, self.y, a, self.h), Self::new(self.x+a, self.y, self.w-a, self.h))
}
pub fn split_right(&self, a: f32) -> (Rect, Rect) {
let a = a.min(self.w);
(Self::new(self.x, self.y, self.w-a, self.h), Self::new(self.x+self.w-a, self.y, a, self.h))
}
pub fn split_top(&self, a: f32) -> (Rect, Rect) {
let a = a.min(self.h);
(Self::new(self.x, self.y, self.w, a), Self::new(self.x, self.y+a, self.w, self.h-a))
}
pub fn split_bottom(&self, a: f32) -> (Rect, Rect) {
let a = a.min(self.h);
(Self::new(self.x, self.y+self.h-a, self.w, a), Self::new(self.x, self.y, self.w, self.h-a))
}
pub fn center_rect(&self, w: f32, h: f32) -> Rect {
Self::new(self.x+(self.w-w)*0.5, self.y+(self.h-h)*0.5, w, h)
}
pub fn translate(&self, dx: f32, dy: f32) -> Self {
Self { x: self.x+dx, y: self.y+dy, w: self.w, h: self.h }
}
}
#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub struct Color { pub r: f32, pub g: f32, pub b: f32, pub a: f32 }
impl Color {
pub const WHITE: Self = Self { r: 1.0, g: 1.0, b: 1.0, a: 1.0 };
pub const BLACK: Self = Self { r: 0.0, g: 0.0, b: 0.0, a: 1.0 };
pub const TRANSPARENT: Self = Self { r: 0.0, g: 0.0, b: 0.0, a: 0.0 };
pub const RED: Self = Self { r: 1.0, g: 0.0, b: 0.0, a: 1.0 };
pub const GREEN: Self = Self { r: 0.0, g: 1.0, b: 0.0, a: 1.0 };
pub const BLUE: Self = Self { r: 0.0, g: 0.0, b: 1.0, a: 1.0 };
pub const YELLOW: Self = Self { r: 1.0, g: 1.0, b: 0.0, a: 1.0 };
pub const CYAN: Self = Self { r: 0.0, g: 1.0, b: 1.0, a: 1.0 };
pub const MAGENTA: Self = Self { r: 1.0, g: 0.0, b: 1.0, a: 1.0 };
pub const GRAY: Self = Self { r: 0.5, g: 0.5, b: 0.5, a: 1.0 };
pub fn new(r: f32, g: f32, b: f32, a: f32) -> Self { Self { r, g, b, a } }
pub fn rgb(r: f32, g: f32, b: f32) -> Self { Self { r, g, b, a: 1.0 } }
pub fn from_u8(r: u8, g: u8, b: u8, a: u8) -> Self {
Self { r: r as f32/255.0, g: g as f32/255.0, b: b as f32/255.0, a: a as f32/255.0 }
}
pub fn from_hex(s: &str) -> Option<Self> {
let s = s.trim_start_matches('#');
match s.len() {
6 => {
let r = u8::from_str_radix(&s[0..2], 16).ok()?;
let g = u8::from_str_radix(&s[2..4], 16).ok()?;
let b = u8::from_str_radix(&s[4..6], 16).ok()?;
Some(Self::from_u8(r, g, b, 255))
}
8 => {
let r = u8::from_str_radix(&s[0..2], 16).ok()?;
let g = u8::from_str_radix(&s[2..4], 16).ok()?;
let b = u8::from_str_radix(&s[4..6], 16).ok()?;
let a = u8::from_str_radix(&s[6..8], 16).ok()?;
Some(Self::from_u8(r, g, b, a))
}
_ => None,
}
}
pub fn lerp(&self, other: Color, t: f32) -> Self {
Self { r: self.r+(other.r-self.r)*t, g: self.g+(other.g-self.g)*t,
b: self.b+(other.b-self.b)*t, a: self.a+(other.a-self.a)*t }
}
pub fn with_alpha(&self, a: f32) -> Self { Self { r: self.r, g: self.g, b: self.b, a } }
pub fn to_hex(&self) -> String {
format!("#{:02X}{:02X}{:02X}{:02X}",
(self.r*255.0) as u8, (self.g*255.0) as u8,
(self.b*255.0) as u8, (self.a*255.0) as u8)
}
pub fn to_hsv(&self) -> (f32, f32, f32) {
let max = self.r.max(self.g).max(self.b);
let min = self.r.min(self.g).min(self.b);
let d = max - min;
let v = max;
let s = if max > 0.0 { d / max } else { 0.0 };
let h = if d < 1e-6 { 0.0 }
else if max == self.r { 60.0 * (((self.g - self.b) / d) % 6.0) }
else if max == self.g { 60.0 * ((self.b - self.r) / d + 2.0) }
else { 60.0 * ((self.r - self.g) / d + 4.0) };
let h = if h < 0.0 { h + 360.0 } else { h };
(h, s, v)
}
pub fn from_hsv(h: f32, s: f32, v: f32) -> Self {
let h = h % 360.0;
let c = v * s;
let x = c * (1.0 - ((h / 60.0) % 2.0 - 1.0).abs());
let m = v - c;
let (r1,g1,b1) = match (h / 60.0) as u32 {
0 => (c,x,0.0), 1 => (x,c,0.0), 2 => (0.0,c,x),
3 => (0.0,x,c), 4 => (x,0.0,c), _ => (c,0.0,x),
};
Self::rgb(r1+m, g1+m, b1+m)
}
}
#[derive(Debug, Clone)]
pub struct UiStyle {
pub font_size: f32, pub fg: Color, pub bg: Color,
pub border: Color, pub hover: Color, pub active: Color,
pub disabled: Color, pub padding: f32, pub margin: f32,
pub border_width: f32, pub border_radius: f32,
pub opacity: f32, pub z_index: i32,
}
impl Default for UiStyle {
fn default() -> Self {
Self {
font_size: 14.0,
fg: Color::new(0.9, 0.9, 0.9, 1.0),
bg: Color::new(0.15, 0.15, 0.18, 1.0),
border: Color::new(0.35, 0.35, 0.4, 1.0),
hover: Color::new(0.25, 0.25, 0.3, 1.0),
active: Color::new(0.35, 0.35, 0.5, 1.0),
disabled: Color::new(0.4, 0.4, 0.4, 0.5),
padding: 6.0, margin: 4.0, border_width: 1.0,
border_radius: 4.0, opacity: 1.0, z_index: 0,
}
}
}
impl UiStyle {
pub fn fg_with_opacity(&self) -> Color { self.fg.with_alpha(self.fg.a * self.opacity) }
pub fn bg_with_opacity(&self) -> Color { self.bg.with_alpha(self.bg.a * self.opacity) }
pub fn warning(&self) -> Color { Color::new(0.9, 0.6, 0.1, 1.0) }
pub fn disabled_color(&self) -> Color { self.fg.with_alpha(0.4) }
}
#[derive(Debug, Clone)]
pub enum DrawCmd {
FillRect { rect: Rect, color: Color },
StrokeRect { rect: Rect, color: Color, width: f32 },
RoundedRect { rect: Rect, radius: f32, color: Color },
RoundedRectStroke { rect: Rect, radius: f32, color: Color, width: f32 },
Text { text: String, x: f32, y: f32, font_size: f32, color: Color, clip: Option<Rect> },
Line { x0: f32, y0: f32, x1: f32, y1: f32, color: Color, width: f32 },
Circle { cx: f32, cy: f32, radius: f32, color: Color },
CircleStroke { cx: f32, cy: f32, radius: f32, color: Color, width: f32 },
Scissor(Rect),
PopScissor,
Image { id: u64, rect: Rect, tint: Color },
}
#[derive(Debug, Clone, Default)]
pub struct WidgetStateRetained {
pub hovered: bool, pub focused: bool, pub active: bool,
pub last_rect: Rect, pub payload: Vec<f32>,
}
#[derive(Debug, Clone)]
pub enum InputEvent {
MouseMove { x: f32, y: f32 },
MouseDown { x: f32, y: f32, button: u8 },
MouseUp { x: f32, y: f32, button: u8 },
MouseWheel { delta_x: f32, delta_y: f32 },
KeyDown { key: KeyCode },
KeyUp { key: KeyCode },
Char { ch: char },
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum KeyCode {
Tab, Enter, Escape, Backspace, Delete,
Left, Right, Up, Down, Home, End, PageUp, PageDown,
Shift, Ctrl, Alt,
A, C, V, X, Z, Y,
F1, F2, F3, F4,
Other(u32),
}
pub struct UiContext {
pub states: HashMap<UiId, WidgetStateRetained>,
pub focused_id: Option<UiId>,
pub hovered_id: Option<UiId>,
pub active_id: Option<UiId>,
pub events: Vec<InputEvent>,
layout_stack: Vec<Rect>,
pub draw_cmds: Vec<DrawCmd>,
pub mouse_x: f32,
pub mouse_y: f32,
pub mouse_down: bool,
pub mouse_just_pressed: bool,
pub mouse_just_released: bool,
held_keys: std::collections::HashSet<KeyCode>,
just_pressed: Vec<KeyCode>,
pub typed_chars: Vec<char>,
pub viewport_w: f32,
pub viewport_h: f32,
pub animators: HashMap<UiId, Animator>,
}
impl UiContext {
pub fn new(vw: f32, vh: f32) -> Self {
Self {
states: HashMap::new(), focused_id: None, hovered_id: None, active_id: None,
events: Vec::new(), layout_stack: Vec::new(), draw_cmds: Vec::new(),
mouse_x: 0.0, mouse_y: 0.0, mouse_down: false,
mouse_just_pressed: false, mouse_just_released: false,
held_keys: std::collections::HashSet::new(), just_pressed: Vec::new(),
typed_chars: Vec::new(), viewport_w: vw, viewport_h: vh,
animators: HashMap::new(),
}
}
pub fn push_event(&mut self, event: InputEvent) { self.events.push(event); }
pub fn begin_frame(&mut self) {
self.mouse_just_pressed = false;
self.mouse_just_released = false;
self.just_pressed.clear();
self.typed_chars.clear();
self.draw_cmds.clear();
let events = std::mem::take(&mut self.events);
for ev in events {
match ev {
InputEvent::MouseMove { x, y } => { self.mouse_x = x; self.mouse_y = y; }
InputEvent::MouseDown { button: 0, .. } => { self.mouse_down = true; self.mouse_just_pressed = true; }
InputEvent::MouseUp { button: 0, .. } => { self.mouse_down = false; self.mouse_just_released = true; self.active_id = None; }
InputEvent::KeyDown { key } => { self.held_keys.insert(key); self.just_pressed.push(key); }
InputEvent::KeyUp { key } => { self.held_keys.remove(&key); }
InputEvent::Char { ch } => { self.typed_chars.push(ch); }
_ => {}
}
}
}
pub fn end_frame(&mut self) -> Vec<DrawCmd> { std::mem::take(&mut self.draw_cmds) }
pub fn key_pressed(&self, key: KeyCode) -> bool { self.just_pressed.contains(&key) }
pub fn key_held(&self, key: KeyCode) -> bool { self.held_keys.contains(&key) }
pub fn shift(&self) -> bool { self.key_held(KeyCode::Shift) }
pub fn ctrl(&self) -> bool { self.key_held(KeyCode::Ctrl) }
pub fn alt(&self) -> bool { self.key_held(KeyCode::Alt) }
pub fn push_layout(&mut self, rect: Rect) { self.layout_stack.push(rect); }
pub fn pop_layout(&mut self) -> Option<Rect> { self.layout_stack.pop() }
pub fn current_layout(&self) -> Rect {
self.layout_stack.last().copied().unwrap_or(Rect::new(0.0, 0.0, self.viewport_w, self.viewport_h))
}
pub fn get_state(&mut self, id: UiId) -> &mut WidgetStateRetained { self.states.entry(id).or_default() }
pub fn is_hovered(&self, rect: &Rect) -> bool { rect.contains(self.mouse_x, self.mouse_y) }
pub fn is_focused(&self, id: UiId) -> bool { self.focused_id == Some(id) }
pub fn set_focus(&mut self, id: UiId) { self.focused_id = Some(id); }
pub fn clear_focus(&mut self) { self.focused_id = None; }
pub fn emit(&mut self, cmd: DrawCmd) { self.draw_cmds.push(cmd); }
pub fn push_scissor(&mut self, rect: Rect) { self.emit(DrawCmd::Scissor(rect)); }
pub fn pop_scissor(&mut self) { self.emit(DrawCmd::PopScissor); }
pub fn fill_rect(&mut self, rect: Rect, color: Color) { self.emit(DrawCmd::FillRect { rect, color }); }
pub fn rounded_rect(&mut self, rect: Rect, radius: f32, color: Color) { self.emit(DrawCmd::RoundedRect { rect, radius, color }); }
pub fn text(&mut self, s: &str, x: f32, y: f32, font_size: f32, color: Color) {
self.emit(DrawCmd::Text { text: s.to_string(), x, y, font_size, color, clip: None });
}
pub fn line(&mut self, x0: f32, y0: f32, x1: f32, y1: f32, color: Color, width: f32) {
self.emit(DrawCmd::Line { x0, y0, x1, y1, color, width });
}
pub fn animator(&mut self, id: UiId) -> &mut Animator { self.animators.entry(id).or_insert_with(Animator::new) }
pub fn tick_animators(&mut self, dt: f32) { for a in self.animators.values_mut() { a.tick(dt); } }
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Direction { Row, Column }
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Align { Start, Center, End, Stretch }
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Justify { Start, End, Center, SpaceBetween, SpaceAround, SpaceEvenly }
#[derive(Debug, Clone)]
pub struct LayoutItem {
pub id: UiId, pub min_size: f32, pub max_size: f32,
pub flex_grow: f32, pub cross_size: f32,
}
impl LayoutItem {
pub fn new(id: UiId, min_size: f32) -> Self {
Self { id, min_size, max_size: f32::MAX, flex_grow: 0.0, cross_size: 0.0 }
}
pub fn with_flex(mut self, g: f32) -> Self { self.flex_grow = g; self }
pub fn with_max(mut self, m: f32) -> Self { self.max_size = m; self }
}
#[derive(Debug, Clone, Copy)]
pub struct LayoutResult { pub id: UiId, pub rect: Rect }
pub struct LayoutEngine {
pub direction: Direction, pub align: Align, pub justify: Justify,
pub wrap: bool, pub gap: f32,
}
impl LayoutEngine {
pub fn row() -> Self { Self { direction: Direction::Row, align: Align::Start, justify: Justify::Start, wrap: false, gap: 0.0 } }
pub fn column() -> Self { Self { direction: Direction::Column, align: Align::Start, justify: Justify::Start, wrap: false, gap: 0.0 } }
pub fn with_align(mut self, a: Align) -> Self { self.align = a; self }
pub fn with_justify(mut self, j: Justify) -> Self { self.justify = j; self }
pub fn with_gap(mut self, g: f32) -> Self { self.gap = g; self }
pub fn with_wrap(mut self) -> Self { self.wrap = true; self }
pub fn arrange(&self, container: Rect, items: &[LayoutItem]) -> Vec<LayoutResult> {
if items.is_empty() { return Vec::new(); }
let is_row = self.direction == Direction::Row;
let main = if is_row { container.w } else { container.h };
let cross = if is_row { container.h } else { container.w };
let n = items.len();
let gaps = self.gap * n.saturating_sub(1) as f32;
let mut sizes: Vec<f32> = items.iter().map(|i| i.min_size).collect();
let total_min: f32 = sizes.iter().sum::<f32>() + gaps;
let leftover = (main - total_min).max(0.0);
let total_flex: f32 = items.iter().map(|i| i.flex_grow).sum();
if total_flex > 0.0 && leftover > 0.0 {
for (i, item) in items.iter().enumerate() {
if item.flex_grow > 0.0 {
sizes[i] = (sizes[i] + leftover * item.flex_grow / total_flex).min(item.max_size);
}
}
}
let total_used: f32 = sizes.iter().sum::<f32>() + gaps;
let mut cursor = match self.justify {
Justify::Start => 0.0,
Justify::End => main - total_used,
Justify::Center => (main - total_used) * 0.5,
Justify::SpaceBetween => 0.0,
Justify::SpaceAround => if n > 0 { (main-total_used)/(n as f32*2.0) } else { 0.0 },
Justify::SpaceEvenly => if n > 0 { (main-total_used)/(n as f32+1.0) } else { 0.0 },
};
let gap_between = match self.justify {
Justify::SpaceBetween => if n > 1 { (main-total_used)/(n-1) as f32 } else { 0.0 },
Justify::SpaceAround => (main-total_used)/n as f32,
Justify::SpaceEvenly => (main-total_used)/(n as f32+1.0),
_ => self.gap,
};
let mut results = Vec::with_capacity(n);
for (i, item) in items.iter().enumerate() {
let im = sizes[i];
let ic = if item.cross_size > 0.0 { item.cross_size } else { cross };
let co = match self.align {
Align::Start | Align::Stretch => 0.0,
Align::End => cross - ic,
Align::Center => (cross - ic) * 0.5,
};
let (x, y, w, h) = if is_row { (container.x+cursor, container.y+co, im, ic) }
else { (container.x+co, container.y+cursor, ic, im) };
results.push(LayoutResult { id: item.id, rect: Rect::new(x, y, w, h) });
cursor += im;
if i + 1 < n { cursor += gap_between; }
}
results
}
}
#[derive(Debug, Clone)]
pub struct UiTheme {
pub background: Color, pub surface: Color, pub surface_variant: Color,
pub border: Color, pub text_primary: Color, pub text_secondary: Color,
pub text_disabled: Color, pub accent: Color, pub accent_hover: Color,
pub accent_active: Color, pub error: Color, pub warning: Color,
pub success: Color, pub info: Color, pub hover_overlay: Color,
pub focus_outline: Color, pub shadow: Color,
}
impl UiTheme {
pub fn apply_to_style(&self, style: &mut UiStyle) {
style.fg = self.text_primary; style.bg = self.surface;
style.border = self.border; style.hover = self.hover_overlay;
style.active = self.accent_active;
}
pub fn dark_theme() -> Self {
Self {
background: Color::from_u8(18,18,21,255), surface: Color::from_u8(30,30,35,255),
surface_variant: Color::from_u8(40,40,48,255), border: Color::from_u8(60,60,72,255),
text_primary: Color::from_u8(220,220,225,255), text_secondary: Color::from_u8(150,150,160,255),
text_disabled: Color::from_u8(90,90,100,140), accent: Color::from_u8(80,120,240,255),
accent_hover: Color::from_u8(100,140,255,255), accent_active: Color::from_u8(60,100,220,255),
error: Color::from_u8(220,60,60,255), warning: Color::from_u8(230,160,40,255),
success: Color::from_u8(60,200,100,255), info: Color::from_u8(80,160,230,255),
hover_overlay: Color::from_u8(255,255,255,20), focus_outline: Color::from_u8(80,120,240,200),
shadow: Color::from_u8(0,0,0,80),
}
}
pub fn light_theme() -> Self {
Self {
background: Color::from_u8(245,245,248,255), surface: Color::from_u8(255,255,255,255),
surface_variant: Color::from_u8(235,235,240,255), border: Color::from_u8(200,200,210,255),
text_primary: Color::from_u8(20,20,25,255), text_secondary: Color::from_u8(90,90,100,255),
text_disabled: Color::from_u8(160,160,170,200), accent: Color::from_u8(50,100,220,255),
accent_hover: Color::from_u8(30,80,200,255), accent_active: Color::from_u8(20,60,180,255),
error: Color::from_u8(200,40,40,255), warning: Color::from_u8(200,130,20,255),
success: Color::from_u8(30,160,70,255), info: Color::from_u8(40,130,210,255),
hover_overlay: Color::from_u8(0,0,0,15), focus_outline: Color::from_u8(50,100,220,200),
shadow: Color::from_u8(0,0,0,30),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Easing {
Linear, EaseIn, EaseOut, EaseInOut,
Spring { stiffness: f32, damping: f32 },
}
impl Easing {
pub fn apply(&self, t: f32) -> f32 {
let t = t.clamp(0.0, 1.0);
match self {
Easing::Linear => t,
Easing::EaseIn => t * t,
Easing::EaseOut => 1.0 - (1.0-t)*(1.0-t),
Easing::EaseInOut => if t < 0.5 { 2.0*t*t } else { 1.0 - (-2.0*t+2.0).powi(2)*0.5 },
Easing::Spring { .. } => { let c = 1.70158; let t2 = t-1.0; t2*t2*((c+1.0)*t2+c)+1.0 }
}
}
}
#[derive(Debug, Clone)]
pub struct Animator {
pub value: f32, pub target: f32, pub duration: f32,
elapsed: f32, start: f32, pub easing: Easing,
}
impl Animator {
pub fn new() -> Self {
Self { value: 0.0, target: 0.0, duration: 0.15, elapsed: 0.0, start: 0.0, easing: Easing::EaseOut }
}
pub fn with_duration(mut self, s: f32) -> Self { self.duration = s; self }
pub fn with_easing(mut self, e: Easing) -> Self { self.easing = e; self }
pub fn set_target(&mut self, t: f32) {
if (self.target - t).abs() > 1e-5 {
self.start = self.value; self.target = t; self.elapsed = 0.0;
}
}
pub fn tick(&mut self, dt: f32) {
if (self.value - self.target).abs() < 1e-5 { self.value = self.target; return; }
self.elapsed += dt;
let t = (self.elapsed / self.duration.max(1e-6)).min(1.0);
self.value = self.start + (self.target - self.start) * self.easing.apply(t);
}
pub fn get(&self) -> f32 { self.value }
pub fn is_done(&self) -> bool { (self.value - self.target).abs() < 1e-4 }
pub fn snap(&mut self, v: f32) { self.value = v; self.target = v; self.elapsed = self.duration; }
}
impl Default for Animator { fn default() -> Self { Self::new() } }
pub struct TooltipSystem {
hover_id: Option<UiId>, hover_time: f32,
pub delay: f32, pub max_width: f32, pub font_size: f32,
pub bg: Color, pub fg: Color, pub border: Color, pub padding: f32,
}
impl TooltipSystem {
pub fn new() -> Self {
Self {
hover_id: None, hover_time: 0.0, delay: 0.5, max_width: 200.0, font_size: 12.0,
bg: Color::from_u8(40,40,48,240), fg: Color::WHITE,
border: Color::from_u8(80,80,100,255), padding: 6.0,
}
}
pub fn update(&mut self, id: Option<UiId>, dt: f32) {
if self.hover_id == id { self.hover_time += dt; } else { self.hover_id = id; self.hover_time = 0.0; }
}
pub fn should_show(&self, id: UiId) -> bool {
self.hover_id == Some(id) && self.hover_time >= self.delay
}
pub fn compute_rect(&self, mx: f32, my: f32, text: &str, vw: f32, vh: f32) -> Rect {
let cw = self.font_size * 0.6;
let tw = (text.len() as f32 * cw).min(self.max_width);
let w = tw + self.padding * 2.0;
let h = self.font_size + 4.0 + self.padding * 2.0;
let mut x = mx + 8.0; let mut y = my + 20.0;
if x + w > vw { x = vw - w - 4.0; }
if x < 0.0 { x = 4.0; }
if y + h > vh { y = my - h - 4.0; }
if y < 0.0 { y = my + 20.0; }
Rect::new(x, y, w, h)
}
pub fn render(&self, ctx: &mut UiContext, id: UiId, text: &str) {
if !self.should_show(id) { return; }
let rect = self.compute_rect(ctx.mouse_x, ctx.mouse_y, text, ctx.viewport_w, ctx.viewport_h);
ctx.emit(DrawCmd::RoundedRect { rect: rect.expand(1.0), radius: 4.0, color: self.border });
ctx.emit(DrawCmd::RoundedRect { rect, radius: 4.0, color: self.bg });
ctx.emit(DrawCmd::Text {
text: text.to_string(), x: rect.x + self.padding, y: rect.y + self.padding,
font_size: self.font_size, color: self.fg, clip: Some(rect),
});
}
}
impl Default for TooltipSystem { fn default() -> Self { Self::new() } }
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn uid_hashing_is_stable() { assert_eq!(UiId::new("button_ok"), UiId::new("button_ok")); }
#[test]
fn uid_different_labels() { assert_ne!(UiId::new("foo"), UiId::new("bar")); }
#[test]
fn rect_contains_basic() {
let r = Rect::new(10.0, 10.0, 100.0, 50.0);
assert!(r.contains(50.0, 30.0));
assert!(!r.contains(5.0, 30.0));
}
#[test]
fn rect_split_left() {
let (left, right) = Rect::new(0.0, 0.0, 200.0, 100.0).split_left(60.0);
assert!((left.w - 60.0).abs() < 1e-4);
assert!((right.w - 140.0).abs() < 1e-4);
}
#[test]
fn rect_split_top() {
let (top, bot) = Rect::new(0.0, 0.0, 200.0, 100.0).split_top(40.0);
assert!((top.h - 40.0).abs() < 1e-4);
assert!((bot.h - 60.0).abs() < 1e-4);
}
#[test]
fn rect_intersect_overlap() {
let a = Rect::new(0.0, 0.0, 100.0, 100.0);
let b = Rect::new(50.0, 50.0, 100.0, 100.0);
assert!(a.intersect(&b).is_some());
}
#[test]
fn rect_intersect_no_overlap() {
let a = Rect::new(0.0, 0.0, 10.0, 10.0);
let b = Rect::new(20.0, 20.0, 10.0, 10.0);
assert!(a.intersect(&b).is_none());
}
#[test]
fn color_lerp() { assert!((Color::BLACK.lerp(Color::WHITE, 0.5).r - 0.5).abs() < 1e-5); }
#[test]
fn color_hsv_roundtrip() {
let c = Color::rgb(0.8, 0.3, 0.1);
let (h, s, v) = c.to_hsv();
let c2 = Color::from_hsv(h, s, v);
assert!((c.r - c2.r).abs() < 0.01);
}
#[test]
fn animator_reaches_target() {
let mut a = Animator::new();
a.set_target(1.0);
for _ in 0..100 { a.tick(0.01); }
assert!((a.get() - 1.0).abs() < 0.01);
}
#[test]
fn easing_linear() { assert!((Easing::Linear.apply(0.5) - 0.5).abs() < 1e-5); }
#[test]
fn easing_ease_in_out_midpoint() { assert!((Easing::EaseInOut.apply(0.5) - 0.5).abs() < 0.01); }
#[test]
fn layout_engine_row_fills() {
let engine = LayoutEngine::row().with_gap(4.0);
let container = Rect::new(0.0, 0.0, 200.0, 50.0);
let items = vec![
LayoutItem::new(UiId::new("a"), 40.0).with_flex(1.0),
LayoutItem::new(UiId::new("b"), 40.0).with_flex(1.0),
];
let results = engine.arrange(container, &items);
assert_eq!(results.len(), 2);
assert!((results[0].rect.w + results[1].rect.w - 196.0).abs() < 1.0);
}
#[test]
fn theme_dark_distinct() {
let t = UiTheme::dark_theme();
assert!(t.background.r + t.background.g + t.background.b
<= t.surface.r + t.surface.g + t.surface.b + 0.01);
}
#[test]
fn tooltip_avoids_right_edge() {
let tt = TooltipSystem::new();
let rect = tt.compute_rect(1900.0, 100.0, "Some tooltip text here", 1920.0, 1080.0);
assert!(rect.x + rect.w <= 1920.0);
}
#[test]
fn ui_context_mouse_move() {
let mut ctx = UiContext::new(800.0, 600.0);
ctx.push_event(InputEvent::MouseMove { x: 100.0, y: 200.0 });
ctx.begin_frame();
assert!((ctx.mouse_x - 100.0).abs() < 1e-4);
}
}