Desktop: Add support for UI scaling (#3310)

* desktop support ui scaling

* fix some warnings

* use browser zoom if needed

* fix infinite footprint size

* fix web canvas scale

* always set zoom

* use only zoom for scaling

* prevent user zoom

* remove mouse position scaling

desktop/src/cef/context.rs

@@ -10,7 +10,7 @@ pub(crate) trait CefContext {
 
 	fn handle_window_event(&mut self, event: &winit::event::WindowEvent);
 
-	fn notify_of_resize(&self);
+	fn notify_view_info_changed(&self);
 
 	fn send_web_message(&self, message: Vec<u8>);
 }

desktop/src/cef/context/builder.rs

@@ -3,7 +3,7 @@ use std::path::{Path, PathBuf};
 use cef::args::Args;
 use cef::sys::{CEF_API_VERSION_LAST, cef_resultcode_t};
 use cef::{
-	App, BrowserSettings, CefString, Client, DictionaryValue, ImplCommandLine, ImplRequestContext, RenderHandler, RequestContextSettings, SchemeHandlerFactory, Settings, WindowInfo, api_hash,
+	App, BrowserSettings, CefString, Client, DictionaryValue, ImplCommandLine, ImplRequestContext, RequestContextSettings, SchemeHandlerFactory, Settings, WindowInfo, api_hash,
 	browser_host_create_browser_sync, execute_process,
 };
 
@@ -13,7 +13,7 @@ use crate::cef::CefEventHandler;
 use crate::cef::consts::{RESOURCE_DOMAIN, RESOURCE_SCHEME};
 use crate::cef::dirs::create_instance_dir;
 use crate::cef::input::InputState;
-use crate::cef::internal::{BrowserProcessAppImpl, BrowserProcessClientImpl, RenderHandlerImpl, RenderProcessAppImpl, SchemeHandlerFactoryImpl};
+use crate::cef::internal::{BrowserProcessAppImpl, BrowserProcessClientImpl, RenderProcessAppImpl, SchemeHandlerFactoryImpl};
 
 pub(crate) struct CefContextBuilder<H: CefEventHandler> {
 	pub(crate) args: Args,
@@ -131,7 +131,7 @@ impl<H: CefEventHandler> CefContextBuilder<H> {
 
 	fn initialize_inner(self, event_handler: &H, settings: Settings) -> Result<(), InitError> {
 		// Attention! Wrapping this in an extra App is necessary, otherwise the program still compiles but segfaults
-		let mut cef_app = App::new(BrowserProcessAppImpl::new(event_handler.clone()));
+		let mut cef_app = App::new(BrowserProcessAppImpl::new(event_handler.duplicate()));
 
 		let result = cef::initialize(Some(self.args.as_main_args()), Some(&settings), Some(&mut cef_app), std::ptr::null_mut());
 		if result != 1 {
@@ -146,8 +146,7 @@ impl<H: CefEventHandler> CefContextBuilder<H> {
 }
 
 fn create_browser<H: CefEventHandler>(event_handler: H, instance_dir: PathBuf, disable_gpu_acceleration: bool) -> Result<SingleThreadedCefContext, InitError> {
-	let render_handler = RenderHandler::new(RenderHandlerImpl::new(event_handler.clone()));
-	let mut client = Client::new(BrowserProcessClientImpl::new(render_handler, event_handler.clone()));
+	let mut client = Client::new(BrowserProcessClientImpl::new(&event_handler));
 
 	#[cfg(feature = "accelerated_paint")]
 	let use_accelerated_paint = if disable_gpu_acceleration {
@@ -180,7 +179,7 @@ fn create_browser<H: CefEventHandler>(event_handler: H, instance_dir: PathBuf, d
 		return Err(InitError::RequestContextCreationFailed);
 	};
 
-	let mut scheme_handler_factory = SchemeHandlerFactory::new(SchemeHandlerFactoryImpl::new(event_handler.clone()));
+	let mut scheme_handler_factory = SchemeHandlerFactory::new(SchemeHandlerFactoryImpl::new(event_handler.duplicate()));
 	incognito_request_context.clear_scheme_handler_factories();
 	incognito_request_context.register_scheme_handler_factory(Some(&CefString::from(RESOURCE_SCHEME)), Some(&CefString::from(RESOURCE_DOMAIN)), Some(&mut scheme_handler_factory));
 
@@ -197,6 +196,7 @@ fn create_browser<H: CefEventHandler>(event_handler: H, instance_dir: PathBuf, d
 
 	if let Some(browser) = browser {
 		Ok(SingleThreadedCefContext {
+			event_handler: Box::new(event_handler),
 			browser,
 			input_state: InputState::default(),
 			instance_dir,

desktop/src/cef/context/multithreaded.rs

@@ -30,11 +30,11 @@ impl CefContext for MultiThreadedCefContextProxy {
 		});
 	}
 
-	fn notify_of_resize(&self) {
+	fn notify_view_info_changed(&self) {
 		run_on_ui_thread(move || {
 			CONTEXT.with(|b| {
 				if let Some(context) = b.borrow_mut().as_mut() {
-					context.notify_of_resize();
+					context.notify_view_info_changed();
 				}
 			});
 		});

desktop/src/cef/context/singlethreaded.rs

@@ -1,13 +1,14 @@
 use cef::{Browser, ImplBrowser, ImplBrowserHost};
 use winit::event::WindowEvent;
 
-use crate::cef::input;
 use crate::cef::input::InputState;
 use crate::cef::ipc::{MessageType, SendMessage};
+use crate::cef::{CefEventHandler, input};
 
 use super::CefContext;
 
 pub(super) struct SingleThreadedCefContext {
+	pub(super) event_handler: Box<dyn CefEventHandler>,
 	pub(super) browser: Browser,
 	pub(super) input_state: InputState,
 	pub(super) instance_dir: std::path::PathBuf,
@@ -19,11 +20,14 @@ impl CefContext for SingleThreadedCefContext {
 	}
 
 	fn handle_window_event(&mut self, event: &WindowEvent) {
-		input::handle_window_event(&self.browser, &mut self.input_state, event)
+		input::handle_window_event(&self.browser, &mut self.input_state, event);
 	}
 
-	fn notify_of_resize(&self) {
-		self.browser.host().unwrap().was_resized();
+	fn notify_view_info_changed(&self) {
+		let view_info = self.event_handler.view_info();
+		let host = self.browser.host().unwrap();
+		host.set_zoom_level(view_info.zoom());
+		host.was_resized();
 	}
 
 	fn send_web_message(&self, message: Vec<u8>) {

desktop/src/cef/input.rs

@@ -12,14 +12,14 @@ use super::consts::{MULTICLICK_ALLOWED_TRAVEL, MULTICLICK_TIMEOUT, PINCH_ZOOM_SP
 pub(crate) fn handle_window_event(browser: &Browser, input_state: &mut InputState, event: &WindowEvent) {
 	match event {
 		WindowEvent::PointerMoved { position, .. } | WindowEvent::PointerEntered { position, .. } => {
-			input_state.cursor_move(position);
+			input_state.cursor_move(&position);
 
 			let Some(host) = browser.host() else { return };
 			host.send_mouse_move_event(Some(&input_state.into()), 0);
 		}
 		WindowEvent::PointerLeft { position, .. } => {
 			if let Some(position) = position {
-				input_state.cursor_move(position);
+				input_state.cursor_move(&position);
 			}
 
 			let Some(host) = browser.host() else { return };

desktop/src/cef/internal.rs

@@ -2,6 +2,7 @@ mod browser_process_app;
 mod browser_process_client;
 mod browser_process_handler;
 mod browser_process_life_span_handler;
+mod browser_process_load_handler;
 
 mod render_process_app;
 mod render_process_handler;
@@ -19,6 +20,5 @@ pub(super) mod task;
 
 pub(super) use browser_process_app::BrowserProcessAppImpl;
 pub(super) use browser_process_client::BrowserProcessClientImpl;
-pub(super) use render_handler::RenderHandlerImpl;
 pub(super) use render_process_app::RenderProcessAppImpl;
 pub(super) use scheme_handler_factory::SchemeHandlerFactoryImpl;

desktop/src/cef/internal/browser_process_app.rs

@@ -13,7 +13,7 @@ pub(crate) struct BrowserProcessAppImpl<H: CefEventHandler> {
 	object: *mut RcImpl<_cef_app_t, Self>,
 	event_handler: H,
 }
-impl<H: CefEventHandler + Clone> BrowserProcessAppImpl<H> {
+impl<H: CefEventHandler> BrowserProcessAppImpl<H> {
 	pub(crate) fn new(event_handler: H) -> Self {
 		Self {
 			object: std::ptr::null_mut(),
@@ -22,9 +22,9 @@ impl<H: CefEventHandler + Clone> BrowserProcessAppImpl<H> {
 	}
 }
 
-impl<H: CefEventHandler + Clone> ImplApp for BrowserProcessAppImpl<H> {
+impl<H: CefEventHandler> ImplApp for BrowserProcessAppImpl<H> {
 	fn browser_process_handler(&self) -> Option<BrowserProcessHandler> {
-		Some(BrowserProcessHandler::new(BrowserProcessHandlerImpl::new(self.event_handler.clone())))
+		Some(BrowserProcessHandler::new(BrowserProcessHandlerImpl::new(self.event_handler.duplicate())))
 	}
 
 	fn on_register_custom_schemes(&self, registrar: Option<&mut SchemeRegistrar>) {
@@ -80,7 +80,7 @@ impl<H: CefEventHandler + Clone> ImplApp for BrowserProcessAppImpl<H> {
 	}
 }
 
-impl<H: CefEventHandler + Clone> Clone for BrowserProcessAppImpl<H> {
+impl<H: CefEventHandler> Clone for BrowserProcessAppImpl<H> {
 	fn clone(&self) -> Self {
 		unsafe {
 			let rc_impl = &mut *self.object;
@@ -88,7 +88,7 @@ impl<H: CefEventHandler + Clone> Clone for BrowserProcessAppImpl<H> {
 		}
 		Self {
 			object: self.object,
-			event_handler: self.event_handler.clone(),
+			event_handler: self.event_handler.duplicate(),
 		}
 	}
 }
@@ -100,7 +100,7 @@ impl<H: CefEventHandler> Rc for BrowserProcessAppImpl<H> {
 		}
 	}
 }
-impl<H: CefEventHandler + Clone> WrapApp for BrowserProcessAppImpl<H> {
+impl<H: CefEventHandler> WrapApp for BrowserProcessAppImpl<H> {
 	fn wrap_rc(&mut self, object: *mut RcImpl<_cef_app_t, Self>) {
 		self.object = object;
 	}

desktop/src/cef/internal/browser_process_client.rs

@@ -1,26 +1,30 @@
 use cef::rc::{Rc, RcImpl};
 use cef::sys::{_cef_client_t, cef_base_ref_counted_t};
-use cef::{DisplayHandler, ImplClient, LifeSpanHandler, RenderHandler, WrapClient};
+use cef::{DisplayHandler, ImplClient, LifeSpanHandler, LoadHandler, RenderHandler, WrapClient};
 
 use crate::cef::CefEventHandler;
 use crate::cef::ipc::{MessageType, UnpackMessage, UnpackedMessage};
 
 use super::browser_process_life_span_handler::BrowserProcessLifeSpanHandlerImpl;
+use super::browser_process_load_handler::LoadHandlerImpl;
 use super::display_handler::DisplayHandlerImpl;
+use super::render_handler::RenderHandlerImpl;
 
 pub(crate) struct BrowserProcessClientImpl<H: CefEventHandler> {
 	object: *mut RcImpl<_cef_client_t, Self>,
-	render_handler: RenderHandler,
 	event_handler: H,
+	load_handler: LoadHandler,
+	render_handler: RenderHandler,
 	display_handler: DisplayHandler,
 }
 impl<H: CefEventHandler> BrowserProcessClientImpl<H> {
-	pub(crate) fn new(render_handler: RenderHandler, event_handler: H) -> Self {
+	pub(crate) fn new(event_handler: &H) -> Self {
 		Self {
 			object: std::ptr::null_mut(),
-			render_handler,
-			event_handler: event_handler.clone(),
-			display_handler: DisplayHandler::new(DisplayHandlerImpl::new(event_handler)),
+			event_handler: event_handler.duplicate(),
+			load_handler: LoadHandler::new(LoadHandlerImpl::new(event_handler.duplicate())),
+			render_handler: RenderHandler::new(RenderHandlerImpl::new(event_handler.duplicate())),
+			display_handler: DisplayHandler::new(DisplayHandlerImpl::new(event_handler.duplicate())),
 		}
 	}
 }
@@ -52,6 +56,10 @@ impl<H: CefEventHandler> ImplClient for BrowserProcessClientImpl<H> {
 		1
 	}
 
+	fn load_handler(&self) -> Option<cef::LoadHandler> {
+		Some(self.load_handler.clone())
+	}
+
 	fn render_handler(&self) -> Option<RenderHandler> {
 		Some(self.render_handler.clone())
 	}
@@ -77,8 +85,9 @@ impl<H: CefEventHandler> Clone for BrowserProcessClientImpl<H> {
 		}
 		Self {
 			object: self.object,
+			event_handler: self.event_handler.duplicate(),
+			load_handler: self.load_handler.clone(),
 			render_handler: self.render_handler.clone(),
-			event_handler: self.event_handler.clone(),
 			display_handler: self.display_handler.clone(),
 		}
 	}

desktop/src/cef/internal/browser_process_handler.rs

@@ -19,7 +19,7 @@ impl<H: CefEventHandler> BrowserProcessHandlerImpl<H> {
 	}
 }
 
-impl<H: CefEventHandler + Clone> ImplBrowserProcessHandler for BrowserProcessHandlerImpl<H> {
+impl<H: CefEventHandler> ImplBrowserProcessHandler for BrowserProcessHandlerImpl<H> {
 	fn on_schedule_message_pump_work(&self, delay_ms: i64) {
 		self.event_handler.schedule_cef_message_loop_work(Instant::now() + Duration::from_millis(delay_ms as u64));
 	}
@@ -33,7 +33,7 @@ impl<H: CefEventHandler + Clone> ImplBrowserProcessHandler for BrowserProcessHan
 	}
 }
 
-impl<H: CefEventHandler + Clone> Clone for BrowserProcessHandlerImpl<H> {
+impl<H: CefEventHandler> Clone for BrowserProcessHandlerImpl<H> {
 	fn clone(&self) -> Self {
 		unsafe {
 			let rc_impl = &mut *self.object;
@@ -41,7 +41,7 @@ impl<H: CefEventHandler + Clone> Clone for BrowserProcessHandlerImpl<H> {
 		}
 		Self {
 			object: self.object,
-			event_handler: self.event_handler.clone(),
+			event_handler: self.event_handler.duplicate(),
 		}
 	}
 }
@@ -53,7 +53,7 @@ impl<H: CefEventHandler> Rc for BrowserProcessHandlerImpl<H> {
 		}
 	}
 }
-impl<H: CefEventHandler + Clone> WrapBrowserProcessHandler for BrowserProcessHandlerImpl<H> {
+impl<H: CefEventHandler> WrapBrowserProcessHandler for BrowserProcessHandlerImpl<H> {
 	fn wrap_rc(&mut self, object: *mut RcImpl<_cef_browser_process_handler_t, Self>) {
 		self.object = object;
 	}

desktop/src/cef/internal/browser_process_load_handler.rs

@@ -0,0 +1,60 @@
+use cef::rc::{Rc, RcImpl};
+use cef::sys::{_cef_load_handler_t, cef_base_ref_counted_t, cef_load_handler_t};
+use cef::{ImplBrowser, ImplBrowserHost, ImplLoadHandler, WrapLoadHandler};
+
+use crate::cef::CefEventHandler;
+
+pub(crate) struct LoadHandlerImpl<H: CefEventHandler> {
+	object: *mut RcImpl<cef_load_handler_t, Self>,
+	event_handler: H,
+}
+impl<H: CefEventHandler> LoadHandlerImpl<H> {
+	pub(crate) fn new(event_handler: H) -> Self {
+		Self {
+			object: std::ptr::null_mut(),
+			event_handler,
+		}
+	}
+}
+
+impl<H: CefEventHandler> ImplLoadHandler for LoadHandlerImpl<H> {
+	fn on_loading_state_change(&self, browser: Option<&mut cef::Browser>, is_loading: ::std::os::raw::c_int, _can_go_back: ::std::os::raw::c_int, _can_go_forward: ::std::os::raw::c_int) {
+		let view_info = self.event_handler.view_info();
+
+		if let Some(browser) = browser
+			&& is_loading == 0
+		{
+			browser.host().unwrap().set_zoom_level(view_info.zoom());
+		}
+	}
+
+	fn get_raw(&self) -> *mut _cef_load_handler_t {
+		self.object.cast()
+	}
+}
+
+impl<H: CefEventHandler> Clone for LoadHandlerImpl<H> {
+	fn clone(&self) -> Self {
+		unsafe {
+			let rc_impl = &mut *self.object;
+			rc_impl.interface.add_ref();
+		}
+		Self {
+			object: self.object,
+			event_handler: self.event_handler.duplicate(),
+		}
+	}
+}
+impl<H: CefEventHandler> Rc for LoadHandlerImpl<H> {
+	fn as_base(&self) -> &cef_base_ref_counted_t {
+		unsafe {
+			let base = &*self.object;
+			std::mem::transmute(&base.cef_object)
+		}
+	}
+}
+impl<H: CefEventHandler> WrapLoadHandler for LoadHandlerImpl<H> {
+	fn wrap_rc(&mut self, object: *mut RcImpl<_cef_load_handler_t, Self>) {
+		self.object = object;
+	}
+}

desktop/src/cef/internal/display_handler.rs

@@ -122,7 +122,7 @@ impl<H: CefEventHandler> Clone for DisplayHandlerImpl<H> {
 		}
 		Self {
 			object: self.object,
-			event_handler: self.event_handler.clone(),
+			event_handler: self.event_handler.duplicate(),
 		}
 	}
 }

desktop/src/cef/internal/render_handler.rs

@@ -21,12 +21,12 @@ impl<H: CefEventHandler> RenderHandlerImpl<H> {
 impl<H: CefEventHandler> ImplRenderHandler for RenderHandlerImpl<H> {
 	fn view_rect(&self, _browser: Option<&mut Browser>, rect: Option<&mut Rect>) {
 		if let Some(rect) = rect {
-			let view = self.event_handler.window_size();
+			let view_info = self.event_handler.view_info();
 			*rect = Rect {
 				x: 0,
 				y: 0,
-				width: view.width as i32,
-				height: view.height as i32,
+				width: view_info.width() as i32,
+				height: view_info.height() as i32,
 			};
 		}
 	}
@@ -78,7 +78,7 @@ impl<H: CefEventHandler> Clone for RenderHandlerImpl<H> {
 		}
 		Self {
 			object: self.object,
-			event_handler: self.event_handler.clone(),
+			event_handler: self.event_handler.duplicate(),
 		}
 	}
 }

desktop/src/cef/internal/scheme_handler_factory.rs

@@ -55,7 +55,7 @@ impl<H: CefEventHandler> Clone for SchemeHandlerFactoryImpl<H> {
 		}
 		Self {
 			object: self.object,
-			event_handler: self.event_handler.clone(),
+			event_handler: self.event_handler.duplicate(),
 		}
 	}
 }