ltk_webkit/wpe/

browsing.rs

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

//! Browser-level controls of a [`WebView`]: navigation, page state, session
//! state, zoom, find-in-page, visibility and device scale.

use std::ffi::{ c_char, c_void, CStr, CString };
use std::ptr;

use glib_sys::{ g_bytes_get_data, g_bytes_new, g_bytes_unref };
use wpe_platform_sys::*;
use wpe_webkit_sys::*;

use ltk::types::Point;

use super::WebView;

const FIND_MAX_MATCHES: u32 = 1000;

pub( crate ) unsafe fn copy_user_agent( from: *mut WebKitWebView, to: *mut WebKitWebView )
{
	// SAFETY: both views are alive; WebKit copies the string it is given.
	unsafe
	{
		let source = webkit_web_view_get_settings( from );
		let target = webkit_web_view_get_settings( to );
		if source.is_null() || target.is_null() || source == target { return; }
		webkit_settings_set_user_agent( target, webkit_settings_get_user_agent( source ) );
	}
}

impl WebView
{
	pub( crate ) fn webview_ptr( &self ) -> Option<*mut WebKitWebView>
	{
		let ptr = self.inner.lock().ok()?.webview;
		if ptr.is_null() { None } else { Some( ptr ) }
	}

	fn view_ptr( &self ) -> Option<*mut WPEView>
	{
		let ptr = self.inner.lock().ok()?.view;
		if ptr.is_null() { None } else { Some( ptr ) }
	}

	/// Start loading `uri` in this view.
	pub fn load_uri( &self, uri: &str )
	{
		let Some( webview ) = self.webview_ptr() else { return };
		let Ok( uri_c )     = CString::new( uri ) else { return };
		self.mark_host_load();
		// SAFETY: `webview` stays alive for the lifetime of `self`.
		unsafe { webkit_web_view_load_uri( webview, uri_c.as_ptr() ); }
	}

	/// Replace the page with `html`. `base_uri` resolves relative links.
	pub fn load_html( &self, html: &str, base_uri: Option<&str> )
	{
		let Some( webview ) = self.webview_ptr() else { return };
		let Ok( html_c )    = CString::new( html ) else { return };
		let base_c          = base_uri.and_then( |b| CString::new( b ).ok() );
		let base_ptr        = base_c.as_ref().map( |b| b.as_ptr() ).unwrap_or( ptr::null() );
		self.mark_host_load();
		// SAFETY: both strings outlive the call, which copies them.
		unsafe { webkit_web_view_load_html( webview, html_c.as_ptr(), base_ptr ); }
	}

	pub fn go_back( &self )
	{
		let Some( webview ) = self.webview_ptr() else { return };
		self.mark_host_load();
		unsafe { webkit_web_view_go_back( webview ); }
	}

	pub fn go_forward( &self )
	{
		let Some( webview ) = self.webview_ptr() else { return };
		self.mark_host_load();
		unsafe { webkit_web_view_go_forward( webview ); }
	}

	pub fn reload( &self )
	{
		let Some( webview ) = self.webview_ptr() else { return };
		self.mark_host_load();
		unsafe { webkit_web_view_reload( webview ); }
	}

	pub fn stop( &self )
	{
		let Some( webview ) = self.webview_ptr() else { return };
		unsafe { webkit_web_view_stop_loading( webview ); }
	}

	pub fn can_go_back( &self ) -> bool
	{
		self.webview_ptr().is_some_and( |w| unsafe { webkit_web_view_can_go_back( w ) } != 0 )
	}

	pub fn can_go_forward( &self ) -> bool
	{
		self.webview_ptr().is_some_and( |w| unsafe { webkit_web_view_can_go_forward( w ) } != 0 )
	}

	/// URI of the current page; empty before the first load commits.
	pub fn uri( &self ) -> String
	{
		self.webview_ptr().map( |w| owned( unsafe { webkit_web_view_get_uri( w ) } ) ).unwrap_or_default()
	}

	/// Title of the current page; empty when the page declares none.
	pub fn title( &self ) -> String
	{
		self.webview_ptr().map( |w| owned( unsafe { webkit_web_view_get_title( w ) } ) ).unwrap_or_default()
	}

	pub fn is_loading( &self ) -> bool
	{
		self.webview_ptr().is_some_and( |w| unsafe { webkit_web_view_is_loading( w ) } != 0 )
	}

	/// Load progress of the current page in `[0.0, 1.0]`.
	pub fn load_progress( &self ) -> f64
	{
		self.webview_ptr().map( |w| unsafe { webkit_web_view_get_estimated_load_progress( w ) } ).unwrap_or( 0.0 )
	}

	/// The view's session history — back / forward list, scroll positions,
	/// form data — as opaque bytes for [`Self::restore_session_state`]. A
	/// host persists them so back keeps working after a relaunch. The
	/// format belongs to WebKit and may change between its versions.
	pub fn session_state( &self ) -> Option<Vec<u8>>
	{
		let webview = self.webview_ptr()?;
		// SAFETY: `state` and `bytes` are owned references released below;
		// the data pointer is valid for `size` bytes while `bytes` lives.
		unsafe
		{
			let state = webkit_web_view_get_session_state( webview );
			if state.is_null() { return None; }
			let bytes = webkit_web_view_session_state_serialize( state );
			webkit_web_view_session_state_unref( state );
			if bytes.is_null() { return None; }
			let mut size = 0;
			let data     = g_bytes_get_data( bytes, &mut size ) as *const u8;
			let out      = if data.is_null() { None } else { Some( std::slice::from_raw_parts( data, size ).to_vec() ) };
			g_bytes_unref( bytes );
			out
		}
	}

	/// Replace the session history with one saved by [`Self::session_state`]
	/// and load its current entry. Returns `false` when WebKit does not
	/// recognise the bytes or the saved list is empty; the host then loads
	/// a URL instead. Meant for a view that has not loaded anything yet:
	/// see [`WebView::new`] with an empty URL.
	pub fn restore_session_state( &self, saved: &[ u8 ] ) -> bool
	{
		let Some( webview ) = self.webview_ptr() else { return false };
		// SAFETY: `g_bytes_new` copies `saved`; every reference taken here is
		// released before returning. The current item is owned by the list.
		unsafe
		{
			let bytes = g_bytes_new( saved.as_ptr() as *const c_void, saved.len() );
			let state = webkit_web_view_session_state_new( bytes );
			g_bytes_unref( bytes );
			if state.is_null() { return false; }
			webkit_web_view_restore_session_state( webview, state );
			webkit_web_view_session_state_unref( state );

			let list    = webkit_web_view_get_back_forward_list( webview );
			let current = if list.is_null() { ptr::null_mut() } else { webkit_back_forward_list_get_current_item( list ) };
			if current.is_null() { return false; }
			webkit_web_view_go_to_back_forward_list_item( webview, current );
			true
		}
	}

	pub fn zoom( &self ) -> f64
	{
		self.webview_ptr().map( |w| unsafe { webkit_web_view_get_zoom_level( w ) } ).unwrap_or( 1.0 )
	}

	pub fn set_zoom( &self, level: f64 )
	{
		let Some( webview ) = self.webview_ptr() else { return };
		unsafe { webkit_web_view_set_zoom_level( webview, level ); }
	}

	/// What the view sends as `User-Agent` from the next load on. Empty restores WebKit's default.
	pub fn set_user_agent( &self, user_agent: &str )
	{
		let Some( webview )  = self.webview_ptr() else { return };
		let Ok( user_agent ) = CString::new( user_agent ) else { return };
		// SAFETY: the settings object is owned by the view; WebKit copies the string.
		unsafe
		{
			let settings = webkit_web_view_get_settings( webview );
			if !settings.is_null() { webkit_settings_set_user_agent( settings, user_agent.as_ptr() ); }
		}
	}

	/// Highlight every case-insensitive match of `text`, wrapping around.
	/// An empty `text` clears the search.
	pub fn find( &self, text: &str )
	{
		if text.is_empty()
		{
			self.find_finish();
			return;
		}
		let Some( webview ) = self.webview_ptr() else { return };
		let Ok( text_c )    = CString::new( text ) else { return };
		let options         = WEBKIT_FIND_OPTIONS_CASE_INSENSITIVE | WEBKIT_FIND_OPTIONS_WRAP_AROUND;
		unsafe
		{
			let controller = webkit_web_view_get_find_controller( webview );
			webkit_find_controller_search( controller, text_c.as_ptr(), options, FIND_MAX_MATCHES );
		}
	}

	pub fn find_next( &self )
	{
		let Some( webview ) = self.webview_ptr() else { return };
		unsafe { webkit_find_controller_search_next( webkit_web_view_get_find_controller( webview ) ); }
	}

	pub fn find_previous( &self )
	{
		let Some( webview ) = self.webview_ptr() else { return };
		unsafe { webkit_find_controller_search_previous( webkit_web_view_get_find_controller( webview ) ); }
	}

	pub fn find_finish( &self )
	{
		let Some( webview ) = self.webview_ptr() else { return };
		unsafe { webkit_find_controller_search_finish( webkit_web_view_get_find_controller( webview ) ); }
	}

	/// Show or hide the page. A hidden page stops producing frames and has
	/// its timers throttled by WebKit, which is what a background tab wants.
	pub fn set_visible( &self, visible: bool )
	{
		let Some( view ) = self.view_ptr() else { return };
		// SAFETY: `view` stays alive for the lifetime of `self`.
		unsafe
		{
			if visible
			{
				wpe_view_set_visible( view, 1 );
				wpe_view_focus_in( view );
			} else {
				wpe_view_focus_out( view );
				wpe_view_set_visible( view, 0 );
			}
		}
		if visible
		{
			if let Ok( mut g ) = self.inner.lock() { g.needs_redraw = true; }
		}
	}

	/// What pages see in `prefers-color-scheme`. WPE takes it from the
	/// platform settings of the view's display, not from `WebKitSettings`.
	pub fn set_dark_mode( &self, dark: bool )
	{
		let display = match self.inner.lock() { Ok( g ) => g.display, Err( _ ) => return };
		if display.is_null() { return; }
		// SAFETY: `display` lives as long as `self`; the settings object is owned by it.
		unsafe
		{
			let settings = wpe_display_get_settings( display );
			if settings.is_null() { return; }
			let mut err: *mut glib_sys::GError = ptr::null_mut();
			wpe_settings_set_boolean(
				settings,
				WPE_SETTING_DARK_MODE.as_ptr() as *const c_char,
				dark as glib_sys::gboolean,
				WPE_SETTINGS_SOURCE_APPLICATION,
				&mut err,
			);
			if !err.is_null() { glib_sys::g_error_free( err ); }
		}
	}

	/// Set the device scale factor: physical pixels of the host surface per
	/// CSS pixel. Pass the value of `App::on_scale_changed` so a HiDPI panel
	/// lays pages out at their logical width instead of the physical one.
	pub fn set_scale( &self, scale: f64 )
	{
		if scale <= 0.0 { return; }
		let ( view, ( lw, lh ) ) = match self.inner.lock()
		{
			Ok( mut g ) =>
			{
				if ( g.scale - scale ).abs() < f64::EPSILON { return; }
				g.scale = scale;
				( g.view, g.logical_size() )
			}
			Err( _ ) => return,
		};
		if view.is_null() { return; }
		unsafe
		{
			let top = wpe_view_get_toplevel( view );
			if top.is_null() { return; }
			wpe_toplevel_scale_changed( top, scale );
			wpe_toplevel_resize( top, lw, lh );
		}
	}

	/// Whether `(x, y)`, in physical pixels of the host surface, falls inside
	/// the rect the view was last laid out at.
	pub fn contains( &self, x: f32, y: f32 ) -> bool
	{
		self.inner.lock().map( |g| g.last_rect.contains( Point { x, y } ) ).unwrap_or( false )
	}

	/// URIs the page asked to open in a new window since the previous call
	/// (`target="_blank"` links). The navigation itself is cancelled; the
	/// host decides where to load them — typically a new tab.
	pub fn take_new_window_requests( &self ) -> Vec<String>
	{
		self.inner.lock().map( |mut g| std::mem::take( &mut g.new_window_requests ) ).unwrap_or_default()
	}
}

pub( crate ) fn owned( s: *const c_char ) -> String
{
	if s.is_null() { return String::new(); }
	// SAFETY: WebKit returns NUL-terminated strings it owns; copied before returning.
	unsafe { CStr::from_ptr( s ).to_string_lossy().into_owned() }
}