Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-09-27 23:30:08 +01:00
Code Issues Projects Releases Packages Wiki Activity

libservo: Start moving WindowMethods to WebViewDelegate (#36223)

Browse source 
`WindowMethods` is used by the embedding layer to get information from
the embedder. This change moves the functionality for getting screen
size and `WebView` offsets to `WebViewDelegate`.

This is important because `WebView`s might be on different screens or
have different offsets on the screen itself, so it makes sense for this
to be per-`WebView` and not global to the embedder. HiDPI and animation
state functionality will move to the embedder in subsequent changes.

Signed-off-by: Martin Robinson <mrobinson@igalia.com>

<!-- Please describe your changes on the following line: -->


---
<!-- Thank you for contributing to Servo! Please replace each `[ ]` by
`[X]` when the step is complete, and replace `___` with appropriate
data: -->
- [x] `./mach build -d` does not report any errors
- [x] `./mach test-tidy` does not report any errors
- [x] These changes do not require tests because they just modify the
`WebView` API surface a bit.

<!-- Also, please make sure that "Allow edits from maintainers" checkbox
is checked, so that we can help you if you get stuck somewhere along the
way.-->

<!-- Pull requests that do not address these steps are welcome, but they
will require additional verification as part of the review process. -->

Signed-off-by: Martin Robinson <mrobinson@igalia.com>
This commit is contained in:
Martin Robinson 2025-04-02 13:17:24 +02:00 • committed by GitHub
parent 520a7f7bc5
commit b925c31424
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
17 changed files with 235 additions and 183 deletions
Download patch file Download diff file Expand all files Collapse all files

7
ports/servoshell/desktop/app.rs
View file

@ -11,13 +11,16 @@ use std::rc::Rc;
use std::time::Instant;
use std::{env, fs};
use euclid::Scale;
use log::{info, trace, warn};
use servo::compositing::windowing::{AnimationState, WindowMethods};
use servo::config::opts::Opts;
use servo::config::prefs::Preferences;
use servo::servo_config::pref;
use servo::servo_geometry::DeviceIndependentPixel;
use servo::servo_url::ServoUrl;
use servo::user_content_manager::{UserContentManager, UserScript};
use servo::webrender_api::units::DevicePixel;
use servo::webxr::glwindow::GlWindowDiscovery;
#[cfg(target_os = "windows")]
use servo::webxr::openxr::{AppInfo, OpenXrDiscovery};
@ -140,8 +143,8 @@ impl App {
// <https://github.com/rust-lang/rust/issues/65991>
struct UpcastedWindow(Rc<dyn WindowPortsMethods>);
impl WindowMethods for UpcastedWindow {
fn get_coordinates(&self) -> servo::compositing::windowing::EmbedderCoordinates {
self.0.get_coordinates()
fn hidpi_factor(&self) -> Scale<f32, DeviceIndependentPixel, DevicePixel> {
self.0.hidpi_factor()
}
fn set_animation_state(&self, state: AnimationState) {
self.0.set_animation_state(state);

4
ports/servoshell/desktop/app_state.rs
View file

@ -392,6 +392,10 @@ impl ServoDelegate for ServoShellServoDelegate {
}
impl WebViewDelegate for RunningAppState {
fn screen_geometry(&self, _webview: WebView) -> Option<servo::ScreenGeometry> {
Some(self.inner().window.screen_geometry())
}
fn notify_status_text_changed(&self, _webview: servo::WebView, _status: Option<String>) {
self.inner_mut().need_update = true;
}

55
ports/servoshell/desktop/headed_window.rs
View file

@ -14,18 +14,16 @@ use euclid::{Angle, Length, Point2D, Rotation3D, Scale, Size2D, UnknownUnit, Vec
use keyboard_types::{Modifiers, ShortcutMatcher};
use log::{debug, info};
use raw_window_handle::{HasDisplayHandle, HasWindowHandle, RawWindowHandle};
use servo::compositing::windowing::{
AnimationState, EmbedderCoordinates, WebRenderDebugOption, WindowMethods,
};
use servo::compositing::windowing::{AnimationState, WebRenderDebugOption, WindowMethods};
use servo::servo_config::pref;
use servo::servo_geometry::DeviceIndependentPixel;
use servo::webrender_api::ScrollLocation;
use servo::webrender_api::units::{DeviceIntPoint, DeviceIntRect, DeviceIntSize, DevicePixel};
use servo::webrender_api::units::{DeviceIntPoint, DeviceIntSize, DevicePixel};
use servo::{
Cursor, ImeEvent, InputEvent, Key, KeyState, KeyboardEvent, MouseButton as ServoMouseButton,
MouseButtonAction, MouseButtonEvent, MouseMoveEvent, OffscreenRenderingContext,
RenderingContext, Theme, TouchEvent, TouchEventType, TouchId, WebView, WheelDelta, WheelEvent,
WheelMode, WindowRenderingContext,
RenderingContext, ScreenGeometry, Theme, TouchEvent, TouchEventType, TouchId, WebView,
WheelDelta, WheelEvent, WheelMode, WindowRenderingContext,
};
use surfman::{Context, Device};
use url::Url;
@ -114,7 +112,7 @@ impl Window {
.expect("No monitor detected");
let (screen_size, screen_scale) = servoshell_preferences.screen_size_override.map_or_else(
|| (monitor.size(), monitor.scale_factor()),
|| (monitor.size(), winit_window.scale_factor()),
|size| (PhysicalSize::new(size.width, size.height), 1.0),
);
let screen_scale: Scale<f64, DeviceIndependentPixel, DevicePixel> =
@ -446,6 +444,26 @@ impl Window {
}
impl WindowPortsMethods for Window {
fn screen_geometry(&self) -> ScreenGeometry {
let hidpi_factor = self.hidpi_factor();
let toolbar_size = Size2D::new(0.0, (self.toolbar_height.get() * self.hidpi_factor()).0);
let screen_size = self.screen_size.to_f32() * hidpi_factor;
let available_screen_size = screen_size - toolbar_size;
// Offset the WebView origin by the toolbar so that it reflects the actual viewport and
// not the window origin.
let window_origin = self.winit_window.inner_position().unwrap_or_default();
let window_origin = winit_position_to_euclid_point(window_origin).to_f32();
let offset = window_origin + toolbar_size;
ScreenGeometry {
size: screen_size.to_i32(),
available_size: available_screen_size.to_i32(),
offset: offset.to_i32(),
}
}
fn device_hidpi_factor(&self) -> Scale<f32, DeviceIndependentPixel, DevicePixel> {
Scale::new(self.winit_window.scale_factor() as f32)
}
@ -646,9 +664,6 @@ impl WindowPortsMethods for Window {
winit::window::Theme::Dark => Theme::Dark,
});
},
WindowEvent::Moved(_new_position) => {
webview.notify_embedder_window_moved();
},
WindowEvent::Ime(ime) => match ime {
Ime::Enabled => {
webview.notify_input_event(InputEvent::Ime(ImeEvent::Composition(
@ -753,23 +768,9 @@ impl WindowPortsMethods for Window {
}
impl WindowMethods for Window {
fn get_coordinates(&self) -> EmbedderCoordinates {
let window_size = winit_size_to_euclid_size(self.winit_window.outer_size()).to_i32();
let window_origin = self.winit_window.outer_position().unwrap_or_default();
let window_origin = winit_position_to_euclid_point(window_origin).to_i32();
let window_rect = DeviceIntRect::from_origin_and_size(window_origin, window_size);
let window_scale: Scale<f64, DeviceIndependentPixel, DevicePixel> =
Scale::new(self.winit_window.scale_factor());
let window_rect = (window_rect.to_f64() / window_scale).to_i32();
let screen_size = self.screen_size.to_i32();
EmbedderCoordinates {
window_rect,
screen_size,
// FIXME: Winit doesn't have API for available size. Fallback to screen size
available_screen_size: screen_size,
hidpi_factor: self.hidpi_factor(),
}
fn hidpi_factor(&self) -> Scale<f32, DeviceIndependentPixel, DevicePixel> {
self.device_pixel_ratio_override()
.unwrap_or_else(|| self.device_hidpi_factor())
}
fn set_animation_state(&self, state: AnimationState) {

39
ports/servoshell/desktop/headless_window.rs
View file

@ -8,11 +8,11 @@ use std::cell::Cell;
use std::rc::Rc;
use euclid::num::Zero;
use euclid::{Box2D, Length, Point2D, Scale, Size2D};
use servo::compositing::windowing::{AnimationState, EmbedderCoordinates, WindowMethods};
use euclid::{Length, Scale, Size2D};
use servo::compositing::windowing::{AnimationState, WindowMethods};
use servo::servo_geometry::DeviceIndependentPixel;
use servo::webrender_api::units::{DeviceIntSize, DevicePixel};
use servo::{RenderingContext, SoftwareRenderingContext};
use servo::{RenderingContext, ScreenGeometry, SoftwareRenderingContext};
use winit::dpi::PhysicalSize;
use super::app_state::RunningAppState;
@ -24,8 +24,7 @@ pub struct Window {
fullscreen: Cell<bool>,
device_pixel_ratio_override: Option<Scale<f32, DeviceIndependentPixel, DevicePixel>>,
inner_size: Cell<DeviceIntSize>,
screen_size: Size2D<i32, DeviceIndependentPixel>,
window_rect: Box2D<i32, DeviceIndependentPixel>,
screen_size: Size2D<i32, DevicePixel>,
rendering_context: Rc<SoftwareRenderingContext>,
}
@ -44,12 +43,11 @@ impl Window {
let rendering_context =
SoftwareRenderingContext::new(physical_size).expect("Failed to create WR surfman");
let window_rect = Box2D::from_origin_and_size(Point2D::zero(), size.to_i32());
let screen_size = servoshell_preferences.screen_size_override.map_or_else(
|| window_rect.size(),
|screen_size_override| screen_size_override.to_i32(),
);
let screen_size = servoshell_preferences
.screen_size_override
.map_or(inner_size, |screen_size_override| {
(screen_size_override.to_f32() * hidpi_factor).to_i32()
});
let window = Window {
animation_state: Cell::new(AnimationState::Idle),
@ -57,7 +55,6 @@ impl Window {
device_pixel_ratio_override,
inner_size: Cell::new(inner_size),
screen_size,
window_rect,
rendering_context: Rc::new(rendering_context),
};
@ -70,6 +67,14 @@ impl WindowPortsMethods for Window {
winit::window::WindowId::dummy()
}
fn screen_geometry(&self) -> servo::ScreenGeometry {
ScreenGeometry {
size: self.screen_size,
available_size: self.screen_size,
offset: Default::default(),
}
}
fn request_resize(
&self,
webview: &::servo::WebView,
@ -148,13 +153,9 @@ impl WindowPortsMethods for Window {
}
impl WindowMethods for Window {
fn get_coordinates(&self) -> EmbedderCoordinates {
EmbedderCoordinates {
window_rect: self.window_rect,
screen_size: self.screen_size,
available_screen_size: self.screen_size,
hidpi_factor: self.hidpi_factor(),
}
fn hidpi_factor(&self) -> Scale<f32, DeviceIndependentPixel, DevicePixel> {
self.device_pixel_ratio_override()
.unwrap_or_else(|| self.device_hidpi_factor())
}
fn set_animation_state(&self, state: AnimationState) {

7
ports/servoshell/desktop/window_trait.rs
View file

@ -11,7 +11,7 @@ use euclid::{Length, Scale};
use servo::compositing::windowing::WindowMethods;
use servo::servo_geometry::DeviceIndependentPixel;
use servo::webrender_api::units::{DeviceIntPoint, DeviceIntSize, DevicePixel};
use servo::{Cursor, RenderingContext, WebView};
use servo::{Cursor, RenderingContext, ScreenGeometry, WebView};
use super::app_state::RunningAppState;
@ -20,10 +20,7 @@ pub const LINE_HEIGHT: f32 = 38.0;
pub trait WindowPortsMethods: WindowMethods {
fn id(&self) -> winit::window::WindowId;
fn hidpi_factor(&self) -> Scale<f32, DeviceIndependentPixel, DevicePixel> {
self.device_pixel_ratio_override()
.unwrap_or_else(|| self.device_hidpi_factor())
}
fn screen_geometry(&self) -> ScreenGeometry;
fn device_hidpi_factor(&self) -> Scale<f32, DeviceIndependentPixel, DevicePixel>;
fn device_pixel_ratio_override(
&self,

17
ports/servoshell/egl/app_state.rs
View file

@ -11,10 +11,8 @@ use keyboard_types::{CompositionEvent, CompositionState};
use log::{debug, error, info, warn};
use raw_window_handle::{RawWindowHandle, WindowHandle};
use servo::base::id::WebViewId;
use servo::compositing::windowing::{
AnimationState, EmbedderCoordinates, EmbedderMethods, WindowMethods,
};
use servo::euclid::{Box2D, Point2D, Rect, Scale, Size2D, Vector2D};
use servo::compositing::windowing::{AnimationState, EmbedderMethods, WindowMethods};
use servo::euclid::{Point2D, Rect, Scale, Size2D, Vector2D};
use servo::servo_geometry::DeviceIndependentPixel;
use servo::webrender_api::ScrollLocation;
use servo::webrender_api::units::{DeviceIntRect, DeviceIntSize, DevicePixel};
@ -683,15 +681,8 @@ impl EmbedderMethods for ServoEmbedderCallbacks {
}
impl WindowMethods for ServoWindowCallbacks {
fn get_coordinates(&self) -> EmbedderCoordinates {
let coords = self.coordinates.borrow();
let screen_size = (coords.viewport.size.to_f32() / self.hidpi_factor).to_i32();
EmbedderCoordinates {
window_rect: Box2D::from_origin_and_size(Point2D::zero(), screen_size),
screen_size,
available_screen_size: screen_size,
hidpi_factor: self.hidpi_factor,
}
fn hidpi_factor(&self) -> Scale<f32, DeviceIndependentPixel, DevicePixel> {
self.hidpi_factor
}
fn set_animation_state(&self, state: AnimationState) {