use browser zoom if needed

Author: timon-schelling

desktop/src/app.rs

@@ -182,7 +182,7 @@ impl App {
 			}
 			DesktopFrontendMessage::DragWindow => {
 				if let Some(window) = &self.window {
-					let _ = window.start_drag();
+					window.start_drag();
 				}
 			}
 			DesktopFrontendMessage::CloseWindow => {
@@ -384,7 +384,7 @@ impl ApplicationHandler for App {
 	}
 
 	fn window_event(&mut self, event_loop: &dyn ActiveEventLoop, _window_id: WindowId, event: WindowEvent) {
-		self.cef_context.handle_window_event(&event, self.window_scale);
+		self.cef_context.handle_window_event(&event);
 
 		match event {
 			WindowEvent::CloseRequested => {

desktop/src/cef.rs

@@ -38,7 +38,7 @@ use texture_import::SharedTextureHandle;
 
 pub(crate) use context::{CefContext, CefContextBuilder, InitError};
 
-pub(crate) trait CefEventHandler: Clone + Send + Sync + 'static {
+pub(crate) trait CefEventHandler: Send + Sync + 'static {
 	fn view_info(&self) -> ViewInfo;
 	fn draw<'a>(&self, frame_buffer: FrameBufferRef<'a>);
 	#[cfg(feature = "accelerated_paint")]
@@ -50,17 +50,26 @@ pub(crate) trait CefEventHandler: Clone + Send + Sync + 'static {
 	fn schedule_cef_message_loop_work(&self, scheduled_time: Instant);
 	fn initialized_web_communication(&self);
 	fn receive_web_message(&self, message: &[u8]);
+	fn duplicate(&self) -> Self
+	where
+		Self: Sized;
 }
 
 #[derive(Clone, Copy)]
 pub(crate) struct ViewInfo {
 	width: usize,
 	height: usize,
 	scale: f64,
+	use_fractional: bool,
 }
 impl ViewInfo {
 	pub(crate) fn new() -> Self {
-		Self { width: 1, height: 1, scale: 1.0 }
+		Self {
+			width: 1,
+			height: 1,
+			scale: 1.0,
+			use_fractional: false,
+		}
 	}
 	pub(crate) fn apply_update(&mut self, update: ViewInfoUpdate) {
 		match update {
@@ -73,15 +82,42 @@ impl ViewInfo {
 			}
 			_ => {}
 		}
+		self.use_fractional = self.use_fractional();
+	}
+	pub(crate) fn scale(&self) -> Option<f64> {
+		if self.use_fractional {
+			return None;
+		}
+		Some(self.scale)
 	}
-	pub(crate) fn scale(&self) -> f64 {
-		self.scale
+	pub(crate) fn zoom(&self) -> Option<f64> {
+		if !self.use_fractional {
+			return None;
+		}
+		Some(self.scale.ln() / 1.2f64.ln())
+	}
+	pub(crate) fn width(&self) -> usize {
+		if self.use_fractional { self.width } else { (self.width as f64 / self.scale).round() as usize }
 	}
-	pub(crate) fn scaled_width(&self) -> usize {
-		(self.width as f64 / self.scale).round() as usize
+	pub(crate) fn height(&self) -> usize {
+		if self.use_fractional { self.height } else { (self.height as f64 / self.scale).round() as usize }
 	}
-	pub(crate) fn scaled_height(&self) -> usize {
-		(self.height as f64 / self.scale).round() as usize
+
+	fn use_fractional(&self) -> bool {
+		#[cfg(not(target_os = "macos"))]
+		{
+			let frac_width = (self.width as f64 / self.scale) as usize;
+			let frac_height = (self.height as f64 / self.scale) as usize;
+			frac_width != self.width || frac_height != self.height
+		}
+		#[cfg(target_os = "macos")]
+		{
+			let int_width = (self.width as f64 / self.scale.round()) as usize;
+			let int_height = (self.height as f64 / self.scale.round()) as usize;
+			let frac_width = (self.width as f64 / self.scale) as usize;
+			let frac_height = (self.height as f64 / self.scale) as usize;
+			int_width != frac_width || int_height != frac_height
+		}
 	}
 }
 impl Default for ViewInfo {
@@ -116,7 +152,6 @@ impl Read for ResourceReader {
 	}
 }
 
-#[derive(Clone)]
 pub(crate) struct CefHandler {
 	wgpu_context: WgpuContext,
 	app_event_scheduler: AppEventScheduler,
@@ -271,6 +306,17 @@ impl CefEventHandler for CefHandler {
 		};
 		self.app_event_scheduler.schedule(AppEvent::DesktopWrapperMessage(desktop_wrapper_message));
 	}
+
+	fn duplicate(&self) -> Self
+	where
+		Self: Sized,
+	{
+		Self {
+			wgpu_context: self.wgpu_context.clone(),
+			app_event_scheduler: self.app_event_scheduler.clone(),
+			view_info_receiver: self.view_info_receiver.clone(),
+		}
+	}
 }
 
 struct ViewInfoReceiver {

desktop/src/cef/context.rs

@@ -8,7 +8,7 @@ pub(crate) use builder::{CefContextBuilder, InitError};
 pub(crate) trait CefContext {
 	fn work(&mut self);
 
-	fn handle_window_event(&mut self, event: &winit::event::WindowEvent, scale: f64);
+	fn handle_window_event(&mut self, event: &winit::event::WindowEvent);
 
 	fn notify_view_info_changed(&self);
 

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

@@ -19,12 +19,12 @@ impl CefContext for MultiThreadedCefContextProxy {
 		// CEF handles its own message loop in multi-threaded mode
 	}
 
-	fn handle_window_event(&mut self, event: &WindowEvent, scale: f64) {
+	fn handle_window_event(&mut self, event: &WindowEvent) {
 		let event_clone = event.clone();
 		run_on_ui_thread(move || {
 			CONTEXT.with(|b| {
 				if let Some(context) = b.borrow_mut().as_mut() {
-					context.handle_window_event(&event_clone, scale);
+					context.handle_window_event(&event_clone);
 				}
 			});
 		});

desktop/src/cef/context/singlethreaded.rs

@@ -1,14 +1,15 @@
 use cef::{Browser, ImplBrowser};
 use winit::event::WindowEvent;
 
-use crate::cef::input;
 use crate::cef::input::InputState;
 use crate::cef::internal::NotifyViewInfoChanged;
 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,12 +20,13 @@ impl CefContext for SingleThreadedCefContext {
 		cef::do_message_loop_work();
 	}
 
-	fn handle_window_event(&mut self, event: &WindowEvent, scale: f64) {
-		input::handle_window_event(&self.browser, &mut self.input_state, event, scale)
+	fn handle_window_event(&mut self, event: &WindowEvent) {
+		input::handle_window_event(&self.browser, &mut self.input_state, event, self.event_handler.as_ref());
 	}
 
 	fn notify_view_info_changed(&self) {
-		self.browser.host().unwrap().notify_view_info_changed();
+		let view_info = self.event_handler.view_info();
+		self.browser.host().unwrap().notify_view_info_changed(&view_info);
 	}
 
 	fn send_web_message(&self, message: Vec<u8>) {

desktop/src/cef/input.rs

@@ -7,18 +7,22 @@ use winit::event::{ButtonSource, ElementState, MouseButton, MouseScrollDelta, Wi
 mod keymap;
 use keymap::{ToNativeKeycode, ToVKBits};
 
+use crate::cef::CefEventHandler;
+
 use super::consts::{MULTICLICK_ALLOWED_TRAVEL, MULTICLICK_TIMEOUT, PINCH_ZOOM_SPEED, SCROLL_LINE_HEIGHT, SCROLL_LINE_WIDTH, SCROLL_SPEED_X, SCROLL_SPEED_Y};
 
-pub(crate) fn handle_window_event(browser: &Browser, input_state: &mut InputState, event: &WindowEvent, scale: f64) {
+pub(crate) fn handle_window_event(browser: &Browser, input_state: &mut InputState, event: &WindowEvent, event_handler: &dyn CefEventHandler) {
 	match event {
 		WindowEvent::PointerMoved { position, .. } | WindowEvent::PointerEntered { position, .. } => {
+			let scale = event_handler.view_info().scale().unwrap_or(1.0);
 			input_state.cursor_move(&position.to_logical(scale));
 
 			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 {
+				let scale = event_handler.view_info().scale().unwrap_or(1.0);
 				input_state.cursor_move(&position.to_logical(scale));
 			}
 

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,15 +20,19 @@ 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;
 
+use crate::cef::ViewInfo;
+
 pub(super) trait NotifyViewInfoChanged {
-	fn notify_view_info_changed(&self);
+	fn notify_view_info_changed(&self, view_info: &ViewInfo);
 }
 impl<T: cef::ImplBrowserHost> NotifyViewInfoChanged for T {
-	fn notify_view_info_changed(&self) {
+	fn notify_view_info_changed(&self, view_info: &ViewInfo) {
+		if let Some(zoom) = view_info.zoom() {
+			self.set_zoom_level(zoom);
+		}
 		self.notify_screen_info_changed();
 		self.was_resized();
 	}

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,15 +80,15 @@ 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;
 			rc_impl.interface.add_ref();
 		}
 		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;
 	}