jess
/
Graphite
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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
This commit is contained in:
Timon 2025-11-08 11:32:04 +00:00 committed by GitHub
parent 7254c470ef
commit f02f834097
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
25 changed files with 286 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
desktop/src/app.rs
View File

@ -8,6 +8,7 @@ use std::thread;
use std::time::Duration;
use std::time::Instant;
use winit::application::ApplicationHandler;
use winit::dpi::PhysicalSize;
use winit::event::WindowEvent;
use winit::event_loop::ActiveEventLoop;
use winit::event_loop::ControlFlow;
@ -25,8 +26,9 @@ use crate::wrapper::{DesktopWrapper, NodeGraphExecutionResult, WgpuContext, seri
pub(crate) struct App {
cef_context: Box<dyn cef::CefContext>,
window: Option<Window>,
window_scale: f64,
cef_schedule: Option<Instant>,
cef_window_size_sender: Sender<cef::WindowSize>,
cef_view_info_sender: Sender<cef::ViewInfoUpdate>,
graphics_state: Option<GraphicsState>,
wgpu_context: WgpuContext,
app_event_receiver: Receiver<AppEvent>,
@ -44,7 +46,7 @@ pub(crate) struct App {
impl App {
pub(crate) fn new(
cef_context: Box<dyn cef::CefContext>,
window_size_sender: Sender<cef::WindowSize>,
cef_view_info_sender: Sender<cef::ViewInfoUpdate>,
wgpu_context: WgpuContext,
app_event_receiver: Receiver<AppEvent>,
app_event_scheduler: AppEventScheduler,
@ -66,9 +68,10 @@ impl App {
Self {
cef_context,
window: None,
window_scale: 1.0,
cef_schedule: Some(Instant::now()),
graphics_state: None,
cef_window_size_sender: window_size_sender,
cef_view_info_sender,
wgpu_context,
app_event_receiver,
app_event_scheduler,
@ -147,19 +150,19 @@ impl App {
}
});
}
DesktopFrontendMessage::UpdateViewportBounds { x, y, width, height } => {
DesktopFrontendMessage::UpdateViewportPhysicalBounds { x, y, width, height } => {
if let Some(graphics_state) = &mut self.graphics_state
&& let Some(window) = &self.window
{
let window_size = window.surface_size();
let viewport_offset_x = x / window_size.width as f32;
let viewport_offset_y = y / window_size.height as f32;
graphics_state.set_viewport_offset([viewport_offset_x, viewport_offset_y]);
let viewport_offset_x = x / window_size.width as f64;
let viewport_offset_y = y / window_size.height as f64;
graphics_state.set_viewport_offset([viewport_offset_x as f32, viewport_offset_y as f32]);
let viewport_scale_x = if width != 0.0 { window_size.width as f32 / width } else { 1.0 };
let viewport_scale_y = if height != 0.0 { window_size.height as f32 / height } else { 1.0 };
graphics_state.set_viewport_scale([viewport_scale_x, viewport_scale_y]);
let viewport_scale_x = if width != 0.0 { window_size.width as f64 / width } else { 1.0 };
let viewport_scale_y = if height != 0.0 { window_size.height as f64 / height } else { 1.0 };
graphics_state.set_viewport_scale([viewport_scale_x as f32, viewport_scale_y as f32]);
}
}
DesktopFrontendMessage::UpdateOverlays(scene) => {
@ -179,7 +182,7 @@ impl App {
}
DesktopFrontendMessage::DragWindow => {
if let Some(window) = &self.window {
let _ = window.start_drag();
window.start_drag();
}
}
DesktopFrontendMessage::CloseWindow => {
@ -352,14 +355,17 @@ impl App {
impl ApplicationHandler for App {
fn can_create_surfaces(&mut self, event_loop: &dyn ActiveEventLoop) {
let window = Window::new(event_loop, self.app_event_scheduler.clone());
self.window_scale = window.scale_factor();
let _ = self.cef_view_info_sender.send(cef::ViewInfoUpdate::Scale(self.window_scale));
self.cef_context.notify_view_info_changed();
self.window = Some(window);
let graphics_state = GraphicsState::new(self.window.as_ref().unwrap(), self.wgpu_context.clone());
self.graphics_state = Some(graphics_state);
tracing::info!("Winit window created and ready");
self.desktop_wrapper.init(self.wgpu_context.clone());
#[cfg(target_os = "windows")]
@ -384,14 +390,22 @@ impl ApplicationHandler for App {
WindowEvent::CloseRequested => {
self.app_event_scheduler.schedule(AppEvent::CloseWindow);
}
WindowEvent::SurfaceResized(size) => {
let _ = self.cef_window_size_sender.send(size.into());
self.cef_context.notify_of_resize();
WindowEvent::SurfaceResized(PhysicalSize { width, height }) => {
let _ = self.cef_view_info_sender.send(cef::ViewInfoUpdate::Size {
width: width as usize,
height: height as usize,
});
self.cef_context.notify_view_info_changed();
if let Some(window) = &self.window {
let maximized = window.is_maximized();
self.app_event_scheduler.schedule(AppEvent::DesktopWrapperMessage(DesktopWrapperMessage::UpdateMaximized { maximized }));
}
}
WindowEvent::ScaleFactorChanged { scale_factor, .. } => {
self.window_scale = scale_factor;
let _ = self.cef_view_info_sender.send(cef::ViewInfoUpdate::Scale(self.window_scale));
self.cef_context.notify_view_info_changed();
}
WindowEvent::RedrawRequested => {
let Some(ref mut graphics_state) = self.graphics_state else { return };
// Only rerender once we have a new UI texture to display

101
desktop/src/cef.rs
View File

@ -38,8 +38,8 @@ use texture_import::SharedTextureHandle;
pub(crate) use context::{CefContext, CefContextBuilder, InitError};
pub(crate) trait CefEventHandler: Clone + Send + Sync + 'static {
fn window_size(&self) -> WindowSize;
pub(crate) trait CefEventHandler: Send + Sync + 'static {
fn view_info(&self) -> ViewInfo;
fn draw<'a>(&self, frame_buffer: FrameBufferRef<'a>);
#[cfg(feature = "accelerated_paint")]
fn draw_gpu(&self, shared_texture: SharedTextureHandle);
@ -50,24 +50,54 @@ 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 WindowSize {
pub(crate) width: usize,
pub(crate) height: usize,
pub(crate) struct ViewInfo {
width: usize,
height: usize,
scale: f64,
}
impl WindowSize {
pub(crate) fn new(width: usize, height: usize) -> Self {
Self { width, height }
impl ViewInfo {
pub(crate) fn new() -> Self {
Self { width: 1, height: 1, scale: 1. }
}
pub(crate) fn apply_update(&mut self, update: ViewInfoUpdate) {
match update {
ViewInfoUpdate::Size { width, height } if width > 0 && height > 0 => {
self.width = width;
self.height = height;
}
ViewInfoUpdate::Scale(scale) if scale > 0. => {
self.scale = scale;
}
_ => {}
}
}
pub(crate) fn zoom(&self) -> f64 {
self.scale.ln() / 1.2_f64.ln()
}
pub(crate) fn width(&self) -> usize {
self.width
}
pub(crate) fn height(&self) -> usize {
self.height
}
}
impl From<winit::dpi::PhysicalSize<u32>> for WindowSize {
fn from(size: winit::dpi::PhysicalSize<u32>) -> Self {
Self::new(size.width as usize, size.height as usize)
impl Default for ViewInfo {
fn default() -> Self {
Self::new()
}
}
pub(crate) enum ViewInfoUpdate {
Size { width: usize, height: usize },
Scale(f64),
}
#[derive(Clone)]
pub(crate) struct Resource {
pub(crate) reader: ResourceReader,
@ -89,34 +119,33 @@ impl Read for ResourceReader {
}
}
#[derive(Clone)]
pub(crate) struct CefHandler {
wgpu_context: WgpuContext,
app_event_scheduler: AppEventScheduler,
window_size_receiver: Arc<Mutex<WindowSizeReceiver>>,
view_info_receiver: Arc<Mutex<ViewInfoReceiver>>,
}
impl CefHandler {
pub(crate) fn new(wgpu_context: WgpuContext, app_event_scheduler: AppEventScheduler, window_size_receiver: Receiver<WindowSize>) -> Self {
pub(crate) fn new(wgpu_context: WgpuContext, app_event_scheduler: AppEventScheduler, view_info_receiver: Receiver<ViewInfoUpdate>) -> Self {
Self {
wgpu_context,
app_event_scheduler,
window_size_receiver: Arc::new(Mutex::new(WindowSizeReceiver::new(window_size_receiver))),
view_info_receiver: Arc::new(Mutex::new(ViewInfoReceiver::new(view_info_receiver))),
}
}
}
impl CefEventHandler for CefHandler {
fn window_size(&self) -> WindowSize {
let Ok(mut guard) = self.window_size_receiver.lock() else {
tracing::error!("Failed to lock window_size_receiver");
return WindowSize::new(1, 1);
fn view_info(&self) -> ViewInfo {
let Ok(mut guard) = self.view_info_receiver.lock() else {
tracing::error!("Failed to lock view_info_receiver");
return ViewInfo::new();
};
let WindowSizeReceiver { receiver, window_size } = &mut *guard;
for new_window_size in receiver.try_iter() {
*window_size = new_window_size;
let ViewInfoReceiver { receiver, view_info } = &mut *guard;
for update in receiver.try_iter() {
view_info.apply_update(update);
}
*window_size
*view_info
}
fn draw<'a>(&self, frame_buffer: FrameBufferRef<'a>) {
let width = frame_buffer.width() as u32;
@ -244,17 +273,25 @@ impl CefEventHandler for CefHandler {
};
self.app_event_scheduler.schedule(AppEvent::DesktopWrapperMessage(desktop_wrapper_message));
}
}
struct WindowSizeReceiver {
window_size: WindowSize,
receiver: Receiver<WindowSize>,
}
impl WindowSizeReceiver {
fn new(window_size_receiver: Receiver<WindowSize>) -> Self {
fn duplicate(&self) -> Self
where
Self: Sized,
{
Self {
window_size: WindowSize { width: 1, height: 1 },
receiver: window_size_receiver,
wgpu_context: self.wgpu_context.clone(),
app_event_scheduler: self.app_event_scheduler.clone(),
view_info_receiver: self.view_info_receiver.clone(),
}
}
}
struct ViewInfoReceiver {
view_info: ViewInfo,
receiver: Receiver<ViewInfoUpdate>,
}
impl ViewInfoReceiver {
fn new(receiver: Receiver<ViewInfoUpdate>) -> Self {
Self { view_info: ViewInfo::new(), receiver }
}
}

2
desktop/src/cef/context.rs
View File

@ -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>);
}

12
desktop/src/cef/context/builder.rs
View File

@ -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,

4
desktop/src/cef/context/multithreaded.rs
View File

@ -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();
}
});
});

12
desktop/src/cef/context/singlethreaded.rs
View File

@ -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>) {

4
desktop/src/cef/input.rs
View File

@ -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 };

2
desktop/src/cef/internal.rs
View File

@ -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;

12
desktop/src/cef/internal/browser_process_app.rs
View File

@ -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;
}

23
desktop/src/cef/internal/browser_process_client.rs
View File

@ -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(),
}
}

8
desktop/src/cef/internal/browser_process_handler.rs
View File

@ -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;
}

60
desktop/src/cef/internal/browser_process_load_handler.rs Normal file
View File

@ -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;
}
}

2
desktop/src/cef/internal/display_handler.rs
View File

@ -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(),
}
}
}

8
desktop/src/cef/internal/render_handler.rs
View File

@ -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(),
}
}
}

2
desktop/src/cef/internal/scheme_handler_factory.rs
View File

@ -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(),
}
}
}

6
desktop/src/lib.rs
View File

@ -44,9 +44,9 @@ pub fn start() {
let (app_event_sender, app_event_receiver) = std::sync::mpsc::channel();
let app_event_scheduler = event_loop.create_app_event_scheduler(app_event_sender);
let (window_size_sender, window_size_receiver) = std::sync::mpsc::channel();
let (cef_view_info_sender, cef_view_info_receiver) = std::sync::mpsc::channel();
let cef_handler = cef::CefHandler::new(wgpu_context.clone(), app_event_scheduler.clone(), window_size_receiver);
let cef_handler = cef::CefHandler::new(wgpu_context.clone(), app_event_scheduler.clone(), cef_view_info_receiver);
let cef_context = match cef_context_builder.initialize(cef_handler, cli.disable_ui_acceleration) {
Ok(c) => {
tracing::info!("CEF initialized successfully");
@ -70,7 +70,7 @@ pub fn start() {
}
};
let mut app = App::new(Box::new(cef_context), window_size_sender, wgpu_context, app_event_receiver, app_event_scheduler, cli.files);
let mut app = App::new(Box::new(cef_context), cef_view_info_sender, wgpu_context, app_event_receiver, app_event_scheduler, cli.files);
event_loop.run_app(&mut app).unwrap();
}

4
desktop/src/window.rs
View File

@ -68,6 +68,10 @@ impl Window {
self.winit_window.surface_size()
}
pub(crate) fn scale_factor(&self) -> f64 {
self.winit_window.scale_factor()
}
pub(crate) fn minimize(&self) {
self.winit_window.set_minimized(true);
}

2
desktop/wrapper/src/handle_desktop_wrapper_message.rs
View File

@ -2,7 +2,7 @@ use graphene_std::Color;
use graphene_std::raster::Image;
use graphite_editor::messages::app_window::app_window_message_handler::AppWindowPlatform;
use graphite_editor::messages::layout::LayoutMessage;
use graphite_editor::messages::prelude::{AppWindowMessage, DocumentMessage, FrontendMessage, PortfolioMessage, PreferencesMessage};
use graphite_editor::messages::prelude::*;
use graphite_editor::messages::tool::tool_messages::tool_prelude::{LayoutTarget, WidgetId};
use crate::messages::Platform;

24
desktop/wrapper/src/intercept_editor_message.rs
View File

@ -1,23 +1,7 @@
use graphite_editor::messages::prelude::InputPreprocessorMessage;
use super::DesktopWrapperMessageDispatcher;
use super::messages::{DesktopFrontendMessage, EditorMessage};
use super::messages::EditorMessage;
pub(super) fn intercept_editor_message(dispatcher: &mut DesktopWrapperMessageDispatcher, message: EditorMessage) -> Option<EditorMessage> {
match message {
EditorMessage::InputPreprocessor(message) => {
if let InputPreprocessorMessage::BoundsOfViewports { bounds_of_viewports } = &message {
let top_left = bounds_of_viewports[0].top_left;
let bottom_right = bounds_of_viewports[0].bottom_right;
dispatcher.respond(DesktopFrontendMessage::UpdateViewportBounds {
x: top_left.x as f32,
y: top_left.y as f32,
width: (bottom_right.x - top_left.x) as f32,
height: (bottom_right.y - top_left.y) as f32,
});
}
Some(EditorMessage::InputPreprocessor(message))
}
m => Some(m),
}
pub(super) fn intercept_editor_message(_dispatcher: &mut DesktopWrapperMessageDispatcher, message: EditorMessage) -> Option<EditorMessage> {
// TODO: remove it turns out to be unnecessary
Some(message)
}

19
desktop/wrapper/src/intercept_frontend_message.rs
View File

@ -79,6 +79,9 @@ pub(super) fn intercept_frontend_message(dispatcher: &mut DesktopWrapperMessageD
FrontendMessage::TriggerMaximizeWindow => {
dispatcher.respond(DesktopFrontendMessage::MaximizeWindow);
}
FrontendMessage::UpdateViewportPhysicalBounds { x, y, width, height } => {
dispatcher.respond(DesktopFrontendMessage::UpdateViewportPhysicalBounds { x, y, width, height });
}
FrontendMessage::TriggerPersistenceWriteDocument { document_id, document, details } => {
dispatcher.respond(DesktopFrontendMessage::PersistenceWriteDocument {
id: document_id,
@ -133,8 +136,8 @@ pub(super) fn intercept_frontend_message(dispatcher: &mut DesktopWrapperMessageD
None
}
fn convert_menu_bar_entries_to_menu_items(layout: &Vec<MenuBarEntry>) -> Vec<MenuItem> {
layout.iter().filter_map(|entry| convert_menu_bar_entry_to_menu_item(entry)).collect()
fn convert_menu_bar_entries_to_menu_items(layout: &[MenuBarEntry]) -> Vec<MenuItem> {
layout.iter().filter_map(convert_menu_bar_entry_to_menu_item).collect()
}
fn convert_menu_bar_entry_to_menu_item(
@ -161,13 +164,7 @@ fn convert_menu_bar_entry_to_menu_item(
}
let shortcut = match shortcut {
Some(ActionKeys::Keys(LayoutKeysGroup(keys))) => {
if let Some(shortcut) = convert_layout_keys_to_shortcut(&keys) {
Some(shortcut)
} else {
None
}
}
Some(ActionKeys::Keys(LayoutKeysGroup(keys))) => convert_layout_keys_to_shortcut(keys),
_ => None,
};
@ -197,7 +194,7 @@ fn convert_menu_bar_entry_to_menu_item(
Some(MenuItem::Action { id, text, shortcut, enabled })
}
fn convert_menu_bar_entry_children_to_menu_items(children: &Vec<Vec<MenuBarEntry>>) -> Vec<MenuItem> {
fn convert_menu_bar_entry_children_to_menu_items(children: &[Vec<MenuBarEntry>]) -> Vec<MenuItem> {
let mut items = Vec::new();
for (i, section) in children.iter().enumerate() {
for entry in section.iter() {
@ -327,5 +324,5 @@ fn convert_layout_keys_to_shortcut(layout_keys: &Vec<LayoutKey>) -> Option<Short
_ => key = None,
}
}
if let Some(key) = key { Some(Shortcut { key, modifiers }) } else { None }
key.map(|key| Shortcut { key, modifiers })
}

10
desktop/wrapper/src/messages.rs
View File

@ -25,11 +25,11 @@ pub enum DesktopFrontendMessage {
content: Vec<u8>,
},
OpenUrl(String),
UpdateViewportBounds {
x: f32,
y: f32,
width: f32,
height: f32,
UpdateViewportPhysicalBounds {
x: f64,
y: f64,
width: f64,
height: f64,
},
UpdateOverlays(vello::Scene),
MinimizeWindow,

34
frontend/src/components/window/title-bar/TitleBar.svelte
View File

@ -59,26 +59,26 @@
</script>
<LayoutRow class="title-bar">
{#if platform !== "Mac"}
<!-- Menu bar -->
<LayoutRow>
<!-- Menu bar -->
<LayoutRow>
{#if platform !== "Mac"}
{#each entries as entry}
<TextButton label={entry.label} icon={entry.icon} menuListChildren={entry.children} action={entry.action} flush={true} />
{/each}
</LayoutRow>
<!-- Spacer -->
<LayoutRow class="spacer" on:mousedown={() => editor.handle.appWindowDrag()} on:dblclick={() => editor.handle.appWindowMaximize()} />
<!-- Window buttons -->
<LayoutRow>
{#if platform === "Web"}
<WindowButtonsWeb />
{:else if platform === "Windows"}
<WindowButtonsWindows {maximized} />
{:else if platform === "Linux"}
<WindowButtonsLinux {maximized} />
{/if}
</LayoutRow>
{/if}
{/if}
</LayoutRow>
<!-- Spacer -->
<LayoutRow class="spacer" on:mousedown={() => editor.handle.appWindowDrag()} on:dblclick={() => editor.handle.appWindowMaximize()} />
<!-- Window buttons -->
<LayoutRow>
{#if platform === "Web"}
<WindowButtonsWeb />
{:else if platform === "Windows"}
<WindowButtonsWindows {maximized} />
{:else if platform === "Linux"}
<WindowButtonsLinux {maximized} />
{/if}
</LayoutRow>
</LayoutRow>
<style lang="scss" global>

5
frontend/src/io-managers/input.ts
View File

@ -258,6 +258,11 @@ export function createInputManager(editor: Editor, dialog: DialogState, portfoli
const { target } = e;
const isTargetingCanvas = target instanceof Element && target.closest("[data-viewport], [data-viewport-container], [data-node-graph]");
// Prevent zooming the entire page when using Ctrl + scroll wheel outside of the viewport
if (e.ctrlKey && !isTargetingCanvas) {
e.preventDefault();
}
// Redirect vertical scroll wheel movement into a horizontal scroll on a horizontally scrollable element
// There seems to be no possible way to properly employ the browser's smooth scrolling interpolation
const horizontalScrollableElement = target instanceof Element && target.closest("[data-scrollable-x]");

41
node-graph/gstd/src/render_node.rs
View File

@ -103,6 +103,7 @@ async fn create_context<'a: 'n>(
for_export: render_config.for_export,
render_output_type,
footprint: Footprint::default(),
scale: render_config.scale,
..Default::default()
};
@ -136,12 +137,6 @@ async fn render<'a: 'n>(
let RenderIntermediate { ty, mut metadata, contains_artboard } = data;
metadata.apply_transform(footprint.transform);
let surface_handle = if cfg!(all(feature = "vello", target_family = "wasm")) {
_surface_handle.eval(None).await
} else {
None
};
let data = match (render_params.render_output_type, &ty) {
(RenderOutputTypeRequest::Svg, RenderIntermediateType::Svg(svg_data)) => {
let mut svg_renderer = SvgRender::new();
@ -173,19 +168,32 @@ async fn render<'a: 'n>(
unreachable!("Attempted to render with Vello when no GPU executor is available");
};
let (child, context) = Arc::as_ref(vello_data);
let footprint_transform = vello::kurbo::Affine::new(footprint.transform.to_cols_array());
let surface_handle = if cfg!(all(feature = "vello", target_family = "wasm")) {
_surface_handle.eval(None).await
} else {
None
};
// When rendering to a surface, we do not want to apply the scale
let scale = if surface_handle.is_none() { render_params.scale } else { 1. };
let scale_transform = glam::DAffine2::from_scale(glam::DVec2::splat(scale));
let footprint_transform = scale_transform * footprint.transform;
let footprint_transform_vello = vello::kurbo::Affine::new(footprint_transform.to_cols_array());
let mut scene = vello::Scene::new();
scene.append(child, Some(footprint_transform));
scene.append(child, Some(footprint_transform_vello));
let encoding = scene.encoding_mut();
let resolution = (footprint.resolution.as_dvec2() * scale).as_uvec2();
// We now replace all transforms which are supposed to be infinite with a transform which covers the entire viewport
// See <https://xi.zulipchat.com/#narrow/channel/197075-vello/topic/Full.20screen.20color.2Fgradients/near/538435044> for more detail
let scaled_infinite_transform = vello::kurbo::Affine::scale_non_uniform(resolution.x as f64, resolution.y as f64);
let encoding = scene.encoding_mut();
for transform in encoding.transforms.iter_mut() {
if transform.matrix[0] == f32::INFINITY {
*transform = vello_encoding::Transform::from_kurbo(&(vello::kurbo::Affine::scale_non_uniform(footprint.resolution.x as f64, footprint.resolution.y as f64)))
*transform = vello_encoding::Transform::from_kurbo(&scaled_infinite_transform);
}
}
@ -195,22 +203,21 @@ async fn render<'a: 'n>(
}
if let Some(surface_handle) = surface_handle {
exec.render_vello_scene(&scene, &surface_handle, footprint.resolution, context, background)
exec.render_vello_scene(&scene, &surface_handle, resolution, context, background)
.await
.expect("Failed to render Vello scene");
let frame = SurfaceFrame {
surface_id: surface_handle.window_id,
resolution: footprint.resolution,
// TODO: Find a cleaner way to get the unscaled resolution here.
// This is done because the surface frame (canvas) is in logical pixels, not physical pixels.
resolution,
transform: glam::DAffine2::IDENTITY,
};
RenderOutputType::CanvasFrame(frame)
} else {
let texture = exec
.render_vello_scene_to_texture(&scene, footprint.resolution, context, background)
.await
.expect("Failed to render Vello scene");
let texture = exec.render_vello_scene_to_texture(&scene, resolution, context, background).await.expect("Failed to render Vello scene");
RenderOutputType::Texture(ImageTexture { texture })
}

5
node-graph/gsvg-renderer/src/renderer.rs
View File

@ -168,11 +168,14 @@ pub enum RenderOutputType {
pub struct RenderParams {
pub render_mode: RenderMode,
pub footprint: Footprint,
/// Ratio of physical pixels to logical pixels. `scale := physical_pixels / logical_pixels`
/// Ignored when rendering to SVG.
pub scale: f64,
pub render_output_type: RenderOutputType,
pub thumbnail: bool,
/// Don't render the rectangle for an artboard to allow exporting with a transparent background.
pub hide_artboards: bool,
/// Are we exporting as a standalone SVG?
/// Are we exporting
pub for_export: bool,
/// Are we generating a mask in this render pass? Used to see if fill should be multiplied with alpha.
pub for_mask: bool,