refactor: split every monolithic module into focused submodules

Each source file that had grown beyond a single concern is replaced by an identically-named directory containing focused submodules. `src/event_loop/mod.rs` (878 lines) becomes a directory with clipboard, context_menu, cursor_shape, drag, focus, handlers, invalidation, overlays_reconcile, repeat, run, surface, text_editing, and tooltip. Every widget, input handler, and theme component follows the same split. Public interfaces are unchanged — only the internal file layout moves.
image bumped from 0.25.2 to 0.25.9.

src/widget/text/mod.rs

@@ -0,0 +1,302 @@
+// SPDX-License-Identifier: LGPL-2.1-only
+// Copyright (C) 2026 Liberux Labs, S. L. <info@liberux.net>
+
+use std::sync::Arc;
+
+use fontdue::Font;
+
+use crate::theme::FontStyle;
+use crate::types::{ Color, Rect };
+use crate::render::Canvas;
+use super::Element;
+
+#[ cfg( test ) ]
+mod tests;
+
+#[ derive( Debug, Clone, Copy, PartialEq ) ]
+pub enum TextAlign
+{
+	Left,
+	Center,
+	Right,
+}
+
+pub struct Text
+{
+	pub content:  String,
+	pub size:     f32,
+	pub color:    Color,
+	pub align:    TextAlign,
+	pub wrap:     bool,
+	/// When `true` (default), overflowing single-line text is truncated
+	/// with an ellipsis. When `false`, the full string is painted even
+	/// if it extends past the layout rect — useful for very short
+	/// labels (calendar day numbers, day-of-week stubs) where a couple
+	/// of pixels of overflow is invisible but "..." is noisy.
+	pub truncate: bool,
+	/// Optional `(family, weight, style)` override resolved through
+	/// the active theme's font registry on every draw. `None` keeps
+	/// the canvas default font (Sora Regular in `ltk-theme-default`).
+	pub font:    Option<( String, u16, FontStyle )>,
+}
+
+impl Text
+{
+	pub fn new( content: impl Into<String> ) -> Self
+	{
+		Self
+		{
+			content:  content.into(),
+			size:     16.0,
+			color:    Color::WHITE,
+			align:    TextAlign::Left,
+			wrap:     false,
+			truncate: true,
+			font:     None,
+		}
+	}
+
+	pub fn no_truncate( mut self ) -> Self
+	{
+		self.truncate = false;
+		self
+	}
+
+	/// Set a `(family, weight, style)` override for this text node.
+	/// The triple is resolved through [`Canvas::font_for`] at draw
+	/// time, so missing weights fall through the registry's nearest-
+	/// match precedence.
+	pub fn font( mut self, family: impl Into<String>, weight: u16, style: FontStyle ) -> Self
+	{
+		self.font = Some( ( family.into(), weight, style ) );
+		self
+	}
+
+	/// Shorthand for [`Self::font`] when the desired override is just
+	/// a weight on the default Sora family (the family `ltk-theme-
+	/// default` declares).
+	pub fn weight( mut self, weight: u16 ) -> Self
+	{
+		self.font = Some( ( "sora".to_string(), weight, FontStyle::Normal ) );
+		self
+	}
+
+	pub fn size( mut self, s: f32 ) -> Self
+	{
+		self.size = s;
+		self
+	}
+
+	pub fn color( mut self, c: Color ) -> Self
+	{
+		self.color = c;
+		self
+	}
+
+	pub fn align( mut self, a: TextAlign ) -> Self
+	{
+		self.align = a;
+		self
+	}
+
+	pub fn align_center( mut self ) -> Self
+	{
+		self.align = TextAlign::Center;
+		self
+	}
+
+	/// Enable word-wrapping. With `wrap = true` the text breaks on
+	/// whitespace at `max_width` and the widget reports the natural
+	/// height of all the resulting lines. With `wrap = false` (the
+	/// default) the text stays on one line and is truncated with an
+	/// ellipsis when it overflows.
+	pub fn wrap( mut self, w: bool ) -> Self
+	{
+		self.wrap = w;
+		self
+	}
+
+	fn resolve_font( &self, canvas: &Canvas ) -> Option<Arc<Font>>
+	{
+		self.font.as_ref().map( |( family, weight, style )|
+		{
+			canvas.font_for( family, *weight, *style )
+		} )
+	}
+
+	fn measure( &self, text: &str, canvas: &Canvas, font: Option<&Arc<Font>> ) -> f32
+	{
+		match font
+		{
+			Some( f ) => canvas.measure_text_with_font( text, self.size, f ),
+			None      => canvas.measure_text( text, self.size ),
+		}
+	}
+
+	fn measure_char( &self, ch: char, canvas: &Canvas, font: Option<&Arc<Font>> ) -> f32
+	{
+		match font
+		{
+			Some( f ) => f.metrics( ch, self.size * canvas.dpi_scale() ).advance_width,
+			None      => canvas.font_metrics( ch, self.size ).advance_width,
+		}
+	}
+
+	fn paint( &self, canvas: &mut Canvas, text: &str, x: f32, y: f32, font: Option<&Arc<Font>> )
+	{
+		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 ),
+		}
+	}
+
+	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 font = self.resolve_font( canvas );
+
+		if self.wrap
+		{
+			let lines = wrap_lines( &self.content, self.size, max_width, canvas, font.as_ref() );
+			let h = line_h * lines.len().max( 1 ) as f32;
+			( max_width, h )
+		}
+		else
+		{
+			let w = ( self.measure( &self.content, canvas, font.as_ref() ) + 8.0 ).min( max_width );
+			( w, line_h )
+		}
+	}
+
+	pub fn draw( &self, canvas: &mut Canvas, rect: Rect, _focused: bool )
+	{
+		let ascent = canvas.font_line_metrics( self.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 );
+		let font = self.resolve_font( canvas );
+
+		if self.wrap
+		{
+			let lines = wrap_lines( &self.content, self.size, rect.width, canvas, font.as_ref() );
+			for ( i, line ) in lines.iter().enumerate()
+			{
+				let line_w = self.measure( line, canvas, font.as_ref() );
+				let slack  = ( rect.width - line_w ).max( 0.0 );
+				let pad    = 4.0_f32.min( slack );
+				let tx = match self.align
+				{
+					TextAlign::Left   => rect.x + pad,
+					TextAlign::Center => rect.x + slack / 2.0,
+					TextAlign::Right  => rect.x + rect.width - line_w - pad,
+				};
+				let ty = rect.y + ascent + line_h * i as f32;
+				self.paint( canvas, line, tx, ty, font.as_ref() );
+			}
+			return;
+		}
+
+		let text_w = self.measure( &self.content, canvas, font.as_ref() );
+
+		let display = if self.truncate && text_w > rect.width && rect.width > 0.0
+		{
+			let ellipsis = "...";
+			let ell_w = self.measure( ellipsis, canvas, font.as_ref() );
+			let budget = rect.width - ell_w;
+			if budget <= 0.0
+			{
+				ellipsis.to_string()
+			}
+			else
+			{
+				let mut accum = 0.0_f32;
+				let truncated: String = self.content.chars().take_while( |ch|
+				{
+					let cw = self.measure_char( *ch, canvas, font.as_ref() );
+					accum += cw;
+					accum <= budget
+				} ).collect();
+				format!( "{truncated}{ellipsis}" )
+			}
+		}
+		else
+		{
+			self.content.clone()
+		};
+
+		let disp_w = self.measure( &display, canvas, font.as_ref() );
+		let slack  = ( rect.width - disp_w ).max( 0.0 );
+		let pad    = 4.0_f32.min( slack );
+		let tx = match self.align
+		{
+			TextAlign::Left   => rect.x + pad,
+			TextAlign::Center => rect.x + slack / 2.0,
+			TextAlign::Right  => rect.x + rect.width - disp_w - pad,
+		};
+
+		let ty = rect.y + ascent;
+		self.paint( canvas, &display, tx, ty, font.as_ref() );
+	}
+}
+
+/// Greedy word-wrap: split `text` on whitespace and pack words into
+/// lines whose total width stays under `max_width`. A word longer
+/// than `max_width` overflows on its own line rather than being
+/// hyphenated. Routes through the font override when one is set so
+/// measurement and rendering agree on advance widths.
+fn wrap_lines( text: &str, size: f32, max_width: f32, canvas: &Canvas, font: Option<&Arc<Font>> ) -> Vec<String>
+{
+	if max_width <= 0.0 || text.is_empty()
+	{
+		return vec![ text.to_string() ];
+	}
+	let measure = |s: &str| -> f32
+	{
+		match font
+		{
+			Some( f ) => canvas.measure_text_with_font( s, size, f ),
+			None      => canvas.measure_text( s, size ),
+		}
+	};
+	let space_w = measure( " " );
+	let mut lines = Vec::new();
+	let mut current   = String::new();
+	let mut current_w = 0.0_f32;
+	for word in text.split_whitespace()
+	{
+		let word_w = measure( word );
+		if current.is_empty()
+		{
+			current.push_str( word );
+			current_w = word_w;
+		}
+		else if current_w + space_w + word_w <= max_width
+		{
+			current.push( ' ' );
+			current.push_str( word );
+			current_w += space_w + word_w;
+		}
+		else
+		{
+			lines.push( std::mem::take( &mut current ) );
+			current.push_str( word );
+			current_w = word_w;
+		}
+	}
+	if !current.is_empty() { lines.push( current ); }
+	if lines.is_empty() { lines.push( String::new() ); }
+	lines
+}
+
+impl<Msg: Clone + 'static> From<Text> for Element<Msg>
+{
+	fn from( t: Text ) -> Self
+	{
+		Element::Text( t )
+	}
+}