ltk: introduce viewport-relative Length so any size, padding, spacing or font height can scale with the surface instead of being frozen at a px constant, fix text::preferred_size to honour the font-declared line gap, and add a responsive typographic scale

The motivating bug was a lockscreen in a downstream app (eydos-loginmanager) where the clock at 87 px overlapped the date at 24 px on a Pinephone but not on a winit dev screen. The root cause split in two: the layout was wired with a single `f32` spacing constant that worked at the dev resolution and broke at the smaller one, and `text::Text::preferred_size` was returning `ascent - descent` for the line height — fontdue's terminology for "the minimum bounding box of an unaccented line", which deliberately drops the `line_gap` that every typographic renderer (Pango, CoreText, DirectWrite) reserves between adjacent rows. At Sora's 200/em line gap, an 87 px row was visually 17 px taller than the rect the column allocated for it; stacked tight against the row above, the descenders bled into the row below. This commit fixes both halves at the toolkit level so every consumer benefits without bolting on a per-screen `Sizing` helper in their own view code.
`types::Length` (with the `LengthBase` enum behind it) is the new currency for any "how big" or "how far apart" parameter. Six variants — `Px`, `Vw`, `Vh`, `Vmin`, `Vmax`, `Em` — cover the cases a real UI hits: absolute pixels for fixed-chrome decisions, viewport-relative percentages for sizes that have to survive a portrait/landscape rotation, and root-font-size multiples for typographic hierarchy. Optional `min_px` / `max_px` bounds attach to the same `Length` value via `.clamp( lo, hi )` (both ends), `.at_least( lo )` and `.at_most( hi )` (one-sided); the names are intentionally divergent from `f32::min`/`f32::max` to avoid being read with the opposite semantics (`x.min(24)` in std means "the smaller of x and 24", which is the inverse of what a min bound expresses). The bounds are stored as raw `f32` rather than nested `Length` values, which keeps `Length` `Copy` and avoids a `Box` allocation per widget per frame — the bounded-by-relative case (`Vmin(20).clamp(Vmin(10), Vmin(40))`) is rare enough that the trade is the right one. `From<f32>`, `From<i32>` and `From<u32>` are implemented so every legacy `.size( 24.0 )` / `.padding( 8.0 )` / `.spacing( 4.0 )` call keeps compiling unchanged; the migration is opt-in per call site. The `EM_BASE_DEFAULT = 16.0` constant matches `theme::typography::BODY` so `Length::em( 2.0 )` resolves consistently with the body-text default; a future change can thread a theme-supplied em base through without breaking the resolver shape.
The resolver — `Length::resolve( viewport: ( f32, f32 ), em_base: f32 ) -> f32` — runs at layout time against a viewport supplied by the renderer. `Canvas::viewport_logical()` is the new helper that exposes that viewport: it divides the canvas's physical size by `dpi_scale` and falls back to physical size when `dpi_scale <= 0.0`, guarding the misconfigured-canvas path so a Vmin call doesn't poison every downstream measurement with `NaN` or `inf`. The viewport is in **logical** pixels — matching what every wayland `xdg_toplevel.configure` event already hands the client — so `Length::vmin( 18.0 )` on a 360×720-logical Librem 5 portrait surface resolves to 64.8 px and the same expression on a 1600×900 dev screen resolves to 162 px, automatically.
Every widget setter that took an `f32` size, padding, spacing, max-width, or fixed dimension now takes `impl Into<Length>` and stores the value as `Length`:
- `widget::text::Text::size( impl Into<Length> )`; the `size` field is now `Length`. `Text::resolved_size( &Canvas )` is the internal accessor that every measurement / drawing path routes through, so the field can stay `Length` without churning the call sites. `preferred_size` and `draw` now read `new_line_size = ascent - descent + line_gap` from fontdue's `LineMetrics` (the fix for the original bug) — the baseline placement is unchanged, only the row height grows by the font's declared leading, which is what every stacked layout was implicitly relying on.
- `layout::Spacer::height( impl Into<Length> )` / `.width( impl Into<Length> )`; `fixed_height` / `fixed_width` are now `Option<Length>`. New `resolved_height( &Canvas )` / `resolved_width( &Canvas )` helpers replace the direct `s.fixed_height.unwrap_or( 0.0 )` reads in `layout::column`, `layout::row` and `layout::stack`. `Spacer::preferred_size` grows a `&Canvas` parameter for the same reason; `Element::preferred_size` passes the canvas through.
- `layout::Column::spacing` / `.padding` / `.max_width`, `layout::Row::spacing` / `.padding` — all take `impl Into<Length>` and store `Length`. Internal `resolved_spacing( &Canvas )`, `resolved_padding( &Canvas )`, `resolved_max_width( &Canvas )` helpers funnel every read, so the layout code paths stay readable. The column's `inner_w` private helper picks up a `&Canvas` argument; the test that used it directly is updated.
`theme::typography` keeps its historic `f32` constants (`H0`…`BODY_XS`, plus `LINE_HEIGHT`) so the migration is gradual, and adds a parallel responsive scale exposed as functions returning `Length`: `h0()`, `h1()`, `h2()`, `h3()`, `body()`, `body_s()`, `body_xs()`. Each is a `Length::vmin( pct ).clamp( min_px, max_px )` whose percentage is calibrated against a 1000-px smaller side reproducing the legacy px constant exactly, and whose px clamps protect both ends of the spectrum — a 360-px Pinephone hits the lower clamp on the larger headings, a 4K desktop hits the upper one. The tests in `theme::typography` exercise all three regimes (narrow phone, calibration point, large display) so future drift in the percentages or clamps is caught immediately.
`Canvas::viewport_logical` is the only render-surface API touched. None of the existing per-frame paths (`draw_text`, `measure_text`, `font_line_metrics`) change shape, so backends and external embedders aren't disturbed. The `dpi_scale` accessor already existed; this commit only adds the convenience that ratios it against the surface size to return the unit layout actually wants.
Test coverage rounds out the addition rather than just smoke-testing the happy path: 22 new tests, broken down as `types::length_tests` (7 — every variant, clamp with relative value, clamp with swapped bounds, `From<f32>`), `render::viewport_tests` (3 — scale 1, scale 2, scale 0 fallback), `theme::typography::tests` (3 — phone-clamped, calibrated, 4K-clamped), `layout::spacer::tests` (4 — px height, vmin height, vw width, flex spacer reports `None`), `layout::column::tests` (3 new — vmin spacing accumulates, vmin padding, vmin max-width caps inner-w), `layout::row::tests` (2 new — vmin padding, vmin spacing produces correct visible gap between non-flex children regardless of the row's centering anchor), and `widget::text::tests` (3 updated/new — defaults compare against `Length::px(16.0)`, `.size( f32 )` and `.size( Length )` both verified). The existing integration test in `tests/layout_stack_spacer.rs` is updated to call `Spacer::preferred_size( &canvas )` and compare `fixed_height` / `fixed_width` against `Some( Length::px( n ) )`.
Documentation is updated end-to-end so the new API is discoverable from `cargo doc` without grepping the source: `lib.rs` gets a new entry for `Length` under the **Types** section and a new **Designing for multiple resolutions** section that lists the three patterns (relative `Length` for sizing, responsive typography for hierarchy, `view()`-level branching on surface dimensions only when the structure itself must change). `Canvas::viewport_logical` ships with a runnable `assert_eq!` example covering the scale-2 case. The module-level docstrings for `Spacer`, `Column` and `Row` now show both an `f32` example (legacy, still valid) and a `Length::vmin( ... ).clamp( ... )` example for the responsive variant — `cargo doc` renders both side by side so the upgrade path is obvious.
Out of scope for this commit, deliberate: `WrapGrid::spacing_x` / `spacing_y` / `padding`, `widget::text_edit::TextEdit::font_size`, and `widget::image::Image::size` still take `f32`. None of them are on a critical responsive path right now, the `From<f32>` shim means migrating later is a one-line setter signature change per widget, and keeping this commit focused on the widgets the lockscreen actually uses keeps the diff reviewable. The line-gap fix in `text::preferred_size` already benefits `TextEdit` indirectly because its caret/row math reads from the same metrics helpers.

src/widget/element.rs

@@ -56,7 +56,7 @@ impl<Msg: Clone> Element<Msg>
 			Element::Row( r )         => r.preferred_size( max_width, canvas ),
 			Element::Stack( s )       => s.preferred_size( max_width, canvas ),
 			Element::Text( t )        => t.preferred_size( max_width, canvas ),
-			Element::Spacer( s )      => s.preferred_size(),
+			Element::Spacer( s )      => s.preferred_size( canvas ),
 			Element::Scroll( s )      => s.preferred_size( max_width, canvas ),
 			Element::Viewport( v )    => v.preferred_size( max_width, canvas ),
 			Element::WrapGrid( g )    => g.preferred_size( max_width, canvas ),

src/widget/text/mod.rs

@@ -6,7 +6,7 @@ use std::sync::Arc;
 use fontdue::Font;
 
 use crate::theme::FontStyle;
-use crate::types::{ Color, Rect };
+use crate::types::{ Color, Length, Rect };
 use crate::render::Canvas;
 use super::Element;
 
@@ -24,7 +24,10 @@ pub enum TextAlign
 pub struct Text
 {
 	pub content:  String,
-	pub size:     f32,
+	/// Font size as a [`Length`]. Resolved against the surface's logical
+	/// viewport at layout time, so a `Length::Vmin( 5.0 )` heading scales
+	/// with the screen instead of being frozen at a px constant.
+	pub size:     Length,
 	pub color:    Color,
 	pub align:    TextAlign,
 	pub wrap:     bool,
@@ -47,7 +50,7 @@ impl Text
 		Self
 		{
 			content:  content.into(),
-			size:     16.0,
+			size:     Length::px( 16.0 ),
 			color:    Color::WHITE,
 			align:    TextAlign::Left,
 			wrap:     false,
@@ -56,6 +59,15 @@ impl Text
 		}
 	}
 
+	/// Resolve the font size against the canvas viewport. Internal
+	/// helper: every method that needs an `f32` size for a `fontdue`
+	/// call routes through this so the field can stay a `Length`.
+	#[ inline ]
+	fn resolved_size( &self, canvas: &Canvas ) -> f32
+	{
+		self.size.resolve( canvas.viewport_logical(), Length::EM_BASE_DEFAULT )
+	}
+
 	pub fn no_truncate( mut self ) -> Self
 	{
 		self.truncate = false;
@@ -81,9 +93,9 @@ impl Text
 		self
 	}
 
-	pub fn size( mut self, s: f32 ) -> Self
+	pub fn size( mut self, s: impl Into<Length> ) -> Self
 	{
-		self.size = s;
+		self.size = s.into();
 		self
 	}
 
@@ -126,41 +138,49 @@ impl Text
 
 	fn measure( &self, text: &str, canvas: &Canvas, font: Option<&Arc<Font>> ) -> f32
 	{
+		let size = self.resolved_size( canvas );
 		match font
 		{
-			Some( f ) => canvas.measure_text_with_font( text, self.size, f ),
-			None      => canvas.measure_text( text, self.size ),
+			Some( f ) => canvas.measure_text_with_font( text, size, f ),
+			None      => canvas.measure_text( text, size ),
 		}
 	}
 
 	fn measure_char( &self, ch: char, canvas: &Canvas, font: Option<&Arc<Font>> ) -> f32
 	{
+		let size = self.resolved_size( canvas );
 		match font
 		{
-			Some( f ) => f.metrics( ch, self.size * canvas.dpi_scale() ).advance_width,
-			None      => canvas.font_metrics( ch, self.size ).advance_width,
+			Some( f ) => f.metrics( ch, size * canvas.dpi_scale() ).advance_width,
+			None      => canvas.font_metrics( ch, size ).advance_width,
 		}
 	}
 
 	fn paint( &self, canvas: &mut Canvas, text: &str, x: f32, y: f32, font: Option<&Arc<Font>> )
 	{
+		let size = self.resolved_size( canvas );
 		match font
 		{
-			Some( f ) => canvas.draw_text_with_font( text, x, y, self.size, self.color, f ),
-			None      => canvas.draw_text( text, x, y, self.size, self.color ),
+			Some( f ) => canvas.draw_text_with_font( text, x, y, size, self.color, f ),
+			None      => canvas.draw_text( text, x, y, size, self.color ),
 		}
 	}
 
 	pub fn preferred_size( &self, max_width: f32, canvas: &Canvas ) -> ( f32, f32 )
 	{
-		let line_h = canvas.font_line_metrics( self.size )
-			.map( |m| m.ascent - m.descent )
-			.unwrap_or( self.size );
+		let size   = self.resolved_size( canvas );
+		// `new_line_size = ascent - descent + line_gap` is the standard
+		// typographic line height; the previous `ascent - descent` discarded
+		// the font-declared leading and at large sizes left adjacent rows
+		// visibly overlapping when stacked tight in a column.
+		let line_h = canvas.font_line_metrics( size )
+			.map( |m| m.new_line_size )
+			.unwrap_or( size );
 		let font = self.resolve_font( canvas );
 
 		if self.wrap
 		{
-			let lines = wrap_lines( &self.content, self.size, max_width, canvas, font.as_ref() );
+			let lines = wrap_lines( &self.content, size, max_width, canvas, font.as_ref() );
 			let h = line_h * lines.len().max( 1 ) as f32;
 			( max_width, h )
 		}
@@ -173,17 +193,18 @@ impl Text
 
 	pub fn draw( &self, canvas: &mut Canvas, rect: Rect, _focused: bool )
 	{
-		let ascent = canvas.font_line_metrics( self.size )
+		let size   = self.resolved_size( canvas );
+		let ascent = canvas.font_line_metrics( size )
 			.map( |m| m.ascent )
-			.unwrap_or( self.size * 0.8 );
-		let line_h = canvas.font_line_metrics( self.size )
-			.map( |m| m.ascent - m.descent )
-			.unwrap_or( self.size );
+			.unwrap_or( size * 0.8 );
+		let line_h = canvas.font_line_metrics( size )
+			.map( |m| m.new_line_size )
+			.unwrap_or( size );
 		let font = self.resolve_font( canvas );
 
 		if self.wrap
 		{
-			let lines = wrap_lines( &self.content, self.size, rect.width, canvas, font.as_ref() );
+			let lines = wrap_lines( &self.content, size, rect.width, canvas, font.as_ref() );
 			for ( i, line ) in lines.iter().enumerate()
 			{
 				let line_w = self.measure( line, canvas, font.as_ref() );

src/widget/text/tests.rs

@@ -11,7 +11,7 @@ fn new_uses_documented_defaults()
 {
 	let t = Text::new( "hello" );
 	assert_eq!( t.content, "hello" );
-	assert_eq!( t.size,    16.0 );
+	assert_eq!( t.size,    crate::Length::px( 16.0 ) );
 	assert_eq!( t.color,   Color::WHITE );
 	assert_eq!( t.align,   TextAlign::Left );
 }
@@ -20,7 +20,14 @@ fn new_uses_documented_defaults()
 fn size_builder_overrides_default()
 {
 	let t = Text::new( "" ).size( 32.0 );
-	assert_eq!( t.size, 32.0 );
+	assert_eq!( t.size, crate::Length::px( 32.0 ) );
+}
+
+#[ test ]
+fn size_builder_accepts_length()
+{
+	let t = Text::new( "" ).size( crate::Length::vmin( 5.0 ) );
+	assert_eq!( t.size.base, crate::LengthBase::Vmin( 5.0 ) );
 }
 
 #[ test ]