Merge branch 'inner-outer-pos-size' into 'main'

Add support for inner and outer position and size

See merge request verso-browser/verso!323

Author: pewsheen

Cargo.lock

@@ -2,7 +2,7 @@
 members = ["verso", "versoview_messages", "versoview_build"]
 
 [workspace.package]
-version = "0.0.2"
+version = "0.0.3"
 edition = "2024"
 license = "Apache-2.0 OR MIT"
 homepage = "https://versotile.org/verso"

Cargo.toml

@@ -33,7 +33,7 @@ use script::{self, JSEngineSetup};
 use servo_config::{opts, pref};
 use servo_url::ServoUrl;
 use style;
-use versoview_messages::{ToControllerMessage, ToVersoMessage};
+use versoview_messages::{PositionType, SizeType, ToControllerMessage, ToVersoMessage};
 use webgpu;
 use webrender::{ShaderPrecacheFlags, WebRenderOptions, create_webrender_instance};
 use webrender_api::*;
@@ -697,21 +697,31 @@ impl Verso {
                     let _ = window.window.drag_window();
                 }
             }
-            ToVersoMessage::GetSize(id) => {
+            ToVersoMessage::GetSize(id, size_type) => {
                 if let Some(window) = self.first_window() {
                     if let Err(error) = self.to_controller_sender.as_ref().unwrap().send(
-                        ToControllerMessage::GetSizeResponse(id, window.window.inner_size()),
+                        ToControllerMessage::GetSizeResponse(
+                            id,
+                            match size_type {
+                                SizeType::Inner => window.window.inner_size(),
+                                SizeType::Outer => window.window.outer_size(),
+                            },
+                        ),
                     ) {
                         log::error!("Verso failed to send GetSizeReponse to controller: {error}")
                     }
                 }
             }
-            ToVersoMessage::GetPosition(id) => {
+            ToVersoMessage::GetPosition(id, position_type) => {
                 if let Some(window) = self.first_window() {
                     if let Err(error) = self.to_controller_sender.as_ref().unwrap().send(
                         ToControllerMessage::GetPositionResponse(
                             id,
-                            window.window.inner_position().ok(),
+                            match position_type {
+                                PositionType::Inner => window.window.inner_position(),
+                                PositionType::Outer => window.window.outer_position(),
+                            }
+                            .ok(),
                         ),
                     ) {
                         log::error!(

src/verso.rs

@@ -11,7 +11,8 @@ use std::{
 };
 pub use versoview_messages::{ConfigFromController as VersoviewSettings, ProfilerSettings};
 use versoview_messages::{
-    ToControllerMessage, ToVersoMessage, WebResourceRequest, WebResourceRequestResponse,
+    PositionType, SizeType, ToControllerMessage, ToVersoMessage, WebResourceRequest,
+    WebResourceRequestResponse,
 };
 
 use ipc_channel::{
@@ -298,15 +299,18 @@ impl VersoviewController {
     }
 
     /// Get the window's size
-    pub fn get_size(&self) -> Result<PhysicalSize<u32>, Box<ipc_channel::ErrorKind>> {
+    fn get_size(
+        &self,
+        size_type: SizeType,
+    ) -> Result<PhysicalSize<u32>, Box<ipc_channel::ErrorKind>> {
         let id = uuid::Uuid::new_v4();
         let (sender, receiver) = std::sync::mpsc::channel();
         self.event_listeners
             .size_response
             .lock()
             .unwrap()
             .insert(id, sender);
-        if let Err(error) = self.sender.send(ToVersoMessage::GetSize(id)) {
+        if let Err(error) = self.sender.send(ToVersoMessage::GetSize(id, size_type)) {
             self.event_listeners
                 .size_response
                 .lock()
@@ -317,10 +321,26 @@ impl VersoviewController {
         Ok(receiver.recv().unwrap())
     }
 
+    /// Returns the physical size of the window's client area.
+    ///
+    /// The client area is the content of the window, excluding the title bar and borders.
+    pub fn get_inner_size(&self) -> Result<PhysicalSize<u32>, Box<ipc_channel::ErrorKind>> {
+        self.get_size(SizeType::Inner)
+    }
+
+    /// Returns the physical size of the entire window.
+    ///
+    /// These dimensions include the title bar and borders.
+    /// If you don't want that (and you usually don't), use [`Self::get_inner_size`] instead.
+    pub fn get_outer_size(&self) -> Result<PhysicalSize<u32>, Box<ipc_channel::ErrorKind>> {
+        self.get_size(SizeType::Outer)
+    }
+
     /// Get the window's position,
     /// returns [`None`] on unsupported platforms (currently only Wayland)
-    pub fn get_position(
+    fn get_position(
         &self,
+        position_type: PositionType,
     ) -> Result<Option<PhysicalPosition<i32>>, Box<ipc_channel::ErrorKind>> {
         let id = uuid::Uuid::new_v4();
         let (sender, receiver) = std::sync::mpsc::channel();
@@ -329,7 +349,10 @@ impl VersoviewController {
             .lock()
             .unwrap()
             .insert(id, sender);
-        if let Err(error) = self.sender.send(ToVersoMessage::GetPosition(id)) {
+        if let Err(error) = self
+            .sender
+            .send(ToVersoMessage::GetPosition(id, position_type))
+        {
             self.event_listeners
                 .position_response
                 .lock()
@@ -340,6 +363,22 @@ impl VersoviewController {
         Ok(receiver.recv().unwrap())
     }
 
+    /// Get the window's inner position,
+    /// returns [`None`] on unsupported platforms (currently only Wayland)
+    pub fn get_inner_position(
+        &self,
+    ) -> Result<Option<PhysicalPosition<i32>>, Box<ipc_channel::ErrorKind>> {
+        self.get_position(PositionType::Inner)
+    }
+
+    /// Get the window's outer position,
+    /// returns [`None`] on unsupported platforms (currently only Wayland)
+    pub fn get_outer_position(
+        &self,
+    ) -> Result<Option<PhysicalPosition<i32>>, Box<ipc_channel::ErrorKind>> {
+        self.get_position(PositionType::Outer)
+    }
+
     /// Get if the window is currently maximized or not
     pub fn is_maximized(&self) -> Result<bool, Box<ipc_channel::ErrorKind>> {
         let id = uuid::Uuid::new_v4();

verso/src/lib.rs

@@ -51,9 +51,9 @@ pub enum ToVersoMessage {
     /// Moves the window with the left mouse button until the button is released
     StartDragging,
     /// Get the window's size, need a response with [`ToControllerMessage::GetSizeResponse`]
-    GetSize(uuid::Uuid),
+    GetSize(uuid::Uuid, SizeType),
     /// Get the window's position, need a response with [`ToControllerMessage::GetPositionResponse`]
-    GetPosition(uuid::Uuid),
+    GetPosition(uuid::Uuid, PositionType),
     /// Get if the window is currently maximized or not, need a response with [`ToControllerMessage::GetMaximizedResponse`]
     GetMaximized(uuid::Uuid),
     /// Get if the window is currently minimized or not, need a response with [`ToControllerMessage::GetMinimizedResponse`]
@@ -68,6 +68,18 @@ pub enum ToVersoMessage {
     GetCurrentUrl(uuid::Uuid),
 }
 
+#[derive(Debug, Serialize, Deserialize)]
+pub enum PositionType {
+    Inner,
+    Outer,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum SizeType {
+    Inner,
+    Outer,
+}
+
 /// Message sent from versoview to the controller
 #[derive(Debug, Serialize, Deserialize)]
 #[non_exhaustive]