ltk/src/event_loop/osk.rs

// SPDX-License-Identifier: LGPL-2.1-only
// Copyright (C) 2026 Liberux Labs, S. L. <info@liberux.net>

//! The built-in keyboard under a focused text field, for a session whose compositor offers no input method.

use std::time::{ Duration, Instant };

use smithay_client_toolkit::seat::keyboard::KeyEvent;

use super::app_data::AppData;
use super::surface::SurfaceFocus;
use crate::app::App;
use crate::osk::{ Event, Modifiers, Panel };
use crate::Keysym;
use crate::tree::find_handlers;
use crate::types::{ Point, Rect };

/// Fit a surface's panel to the bottom of its `pw` by `ph` pixels; returns the height it takes.
pub( crate ) fn place_osk( osk: &mut Option<Panel>, pw: u32, ph: u32, sf: f32 ) -> f32
{
	let Some( panel ) = osk.as_mut() else { return 0.0 };
	let h = panel.height( pw as f32, sf ).min( ph as f32 );
	panel.set_rect( Rect { x: 0.0, y: ph as f32 - h, width: pw as f32, height: h }, sf );
	h
}

impl<A: App> AppData<A>
{
	fn builtin_keyboard( &self ) -> bool
	{
		self.builtin_osk || self.app.builtin_keyboard()
	}

	pub( crate ) fn show_osk( &mut self, focus: SurfaceFocus )
	{
		if !self.builtin_keyboard() { return; }
		let ss = self.surface_mut( focus );
		let purpose = ss.focused_idx
			.and_then( |i| find_handlers( &ss.frame.widget_rects, i ) )
			.map( |h| h.input_purpose() )
			.unwrap_or_default();
		if ss.osk.is_none()
		{
			let lang = std::env::var( "LANG" ).unwrap_or_default();
			ss.osk = Some( Panel::for_language( &lang ) );
		}
		if let Some( panel ) = ss.osk.as_mut() { panel.set_purpose( purpose ); }
		let sf = ss.scale_factor.max( 1 ) as f32;
		let ( pw, ph ) = ( ss.width * ss.scale_factor.max( 1 ) as u32, ss.height * ss.scale_factor.max( 1 ) as u32 );
		place_osk( &mut ss.osk, pw, ph, sf );
		ss.request_redraw();
	}

	pub( crate ) fn hide_osk( &mut self, focus: SurfaceFocus )
	{
		let ss = self.surface_mut( focus );
		if ss.osk.take().is_some() { ss.request_redraw(); }
	}

	/// A press on the text field that already had the focus brings a hidden keyboard back.
	pub( crate ) fn osk_after_press( &mut self, focus: SurfaceFocus, hit: Option<usize> )
	{
		let Some( idx ) = hit else { return };
		let ss = self.surface( focus );
		let is_text = find_handlers( &ss.frame.widget_rects, idx ).map( |h| h.is_text_input() ).unwrap_or( false );
		if is_text && ss.osk.is_none() && self.press_on_focused { self.show_osk( focus ); }
	}

	/// `true` when the press landed on the panel and was consumed.
	pub( crate ) fn osk_press( &mut self, focus: SurfaceFocus, pos: Point ) -> bool
	{
		let now = Instant::now();
		let Some( event ) = self.surface_mut( focus ).osk.as_mut().and_then( |p| p.press_down( pos, now ) ) else { return false };
		self.apply_osk_event( focus, event );
		true
	}

	/// `true` while a key is held, so the motion is the panel's and not a drag.
	pub( crate ) fn osk_move( &mut self, focus: SurfaceFocus, pos: Point ) -> bool
	{
		let ss = self.surface_mut( focus );
		let Some( panel ) = ss.osk.as_mut().filter( |p| p.pressed().is_some() ) else { return false };
		if panel.press_move( pos ) { ss.request_redraw(); }
		true
	}

	/// `true` when the release ended a key press.
	pub( crate ) fn osk_release( &mut self, focus: SurfaceFocus, pos: Point ) -> bool
	{
		let now = Instant::now();
		let Some( event ) = self.surface_mut( focus ).osk.as_mut().and_then( |p| p.press_up( pos, now ) ) else { return false };
		self.apply_osk_event( focus, event );
		true
	}

	pub( crate ) fn cancel_osk_presses( &mut self )
	{
		for ss in std::iter::once( &mut self.main ).chain( self.overlays.values_mut() )
		{
			if let Some( panel ) = ss.osk.as_mut() { panel.cancel_press(); }
		}
	}

	pub( crate ) fn next_osk_wakeup( &self ) -> Option<Duration>
	{
		let now = Instant::now();
		std::iter::once( &self.main ).chain( self.overlays.values() )
			.filter_map( |ss| ss.osk.as_ref().and_then( Panel::next_deadline ) )
			.map( |deadline| deadline.saturating_duration_since( now ) )
			.min()
	}

	pub( crate ) fn check_osk_deadlines( &mut self )
	{
		let now = Instant::now();
		let mut due: Vec<( SurfaceFocus, Event )> = Vec::new();
		if let Some( event ) = self.main.osk.as_mut().and_then( |p| p.tick( now ) ) { due.push( ( SurfaceFocus::Main, event ) ); }
		for ( id, ss ) in self.overlays.iter_mut()
		{
			if let Some( event ) = ss.osk.as_mut().and_then( |p| p.tick( now ) ) { due.push( ( SurfaceFocus::Overlay( *id ), event ) ); }
		}
		for ( focus, event ) in due { self.apply_osk_event( focus, event ); }
	}

	fn apply_osk_event( &mut self, focus: SurfaceFocus, event: Event )
	{
		match event
		{
			Event::Text( text )          => self.handle_text_insert( focus, &text ),
			Event::Backspace             => self.handle_backspace( focus ),
			Event::Enter                 => self.osk_enter( focus ),
			Event::Key( keysym, mods )   => self.osk_key( focus, keysym, mods ),
			Event::Hide                  => self.hide_osk( focus ),
			Event::Changed               => {}
		}
		self.surface_mut( focus ).request_redraw();
	}

	/// A key the panel cannot type as text goes through the same dispatch as a physical one.
	fn osk_key( &mut self, focus: SurfaceFocus, keysym: Keysym, mods: Modifiers )
	{
		let utf8  = ( !mods.any() ).then( || keysym.key_char() ).flatten().map( String::from );
		let event = KeyEvent { time: 0, raw_code: 0, keysym, utf8 };
		let ctrl  = std::mem::replace( &mut self.ctrl_pressed, mods.ctrl );
		self.dispatch_key( focus, event );
		self.ctrl_pressed = ctrl;
	}

	/// Enter as the physical key does it: a newline in a multiline field, otherwise the field's submit.
	fn osk_enter( &mut self, focus: SurfaceFocus )
	{
		let ss = self.surface( focus );
		let Some( idx ) = ss.focused_idx else { return };
		let Some( handlers ) = find_handlers( &ss.frame.widget_rects, idx ) else { return };
		if handlers.is_multiline_text_input()
		{
			self.handle_text_insert( focus, "\n" );
		} else if let Some( msg ) = handlers.submit_msg().or_else( || handlers.press_msg() ) {
			self.pending_msgs.push( msg );
		}
	}
}