* InputState::{inner_pos, inner_size} compacted to InputState::inner_rect

* InputState::{outer_pos, outer_size} compacted to InputState::outer_rect
* RawInput::{inner_pos, inner_size} compected to RawInput::inner_rect
* RawInput::{outer_pos, outer_size} compected to RawInput::outer_rect
* Context::{viewport_inner_pos, viewport_inner_size} compacted to Context::inner_rect
* Context::{viewport_outer_pos, viewport_outer_size} compected to Context::outer_rect

crates/egui-winit/src/lib.rs

@@ -16,7 +16,7 @@ pub use accesskit_winit;
 pub use egui;
 #[cfg(feature = "accesskit")]
 use egui::accesskit;
-use egui::{mutex::RwLock, Pos2, ViewportBuilder, ViewportCommand, ViewportId};
+use egui::{mutex::RwLock, Pos2, Rect, Vec2, ViewportBuilder, ViewportCommand, ViewportId};
 pub use winit;
 
 pub mod clipboard;
@@ -188,7 +188,7 @@ impl State {
             None
         };
 
-        self.egui_input.inner_pos = if getting_info {
+        let inner_pos = if getting_info {
             window
                 .inner_position()
                 .map(|pos| Pos2::new(pos.x as f32, pos.y as f32))
@@ -197,7 +197,7 @@ impl State {
             None
         };
 
-        self.egui_input.outer_pos = if getting_info {
+        let outer_pos = if getting_info {
             window
                 .outer_position()
                 .map(|pos| Pos2::new(pos.x as f32, pos.y as f32))
@@ -206,16 +206,28 @@ impl State {
             None
         };
 
-        self.egui_input.inner_size = if getting_info {
+        let inner_size = if getting_info {
             let size = window.inner_size();
-            Some(Pos2::new(size.width as f32, size.height as f32))
+            Some(Vec2::new(size.width as f32, size.height as f32))
         } else {
             None
         };
 
-        self.egui_input.outer_size = if getting_info {
+        let outer_size = if getting_info {
             let size = window.outer_size();
-            Some(Pos2::new(size.width as f32, size.height as f32))
+            Some(Vec2::new(size.width as f32, size.height as f32))
+        } else {
+            None
+        };
+
+        self.egui_input.inner_rect = if let (Some(pos), Some(size)) = (inner_pos, inner_size) {
+            Some(Rect::from_min_size(pos, size))
+        } else {
+            None
+        };
+
+        self.egui_input.outer_rect = if let (Some(pos), Some(size)) = (outer_pos, outer_size) {
+            Some(Rect::from_min_size(pos, size))
         } else {
             None
         };

crates/egui/src/context.rs

@@ -1717,28 +1717,16 @@ impl Context {
         self.input(|i| i.screen_rect())
     }
 
-    /// This will return the inner position of the current viewport
+    /// Viewport inner position and size, only the drowable area
-    /// Viewport inner position, only the drowable area
+    /// unit = physical pixels
-    pub fn viewport_inner_pos(&self) -> Pos2 {
+    pub fn inner_rect(&self) -> Rect {
-        self.input(|i| i.inner_pos)
+        self.input(|i| i.inner_rect)
     }
 
-    /// This will return the outer position of the current viewport
+    /// Viewport outer position and size, drowable area + decorations
-    /// Viewport outer position, drowable area + decorations
+    /// unit = physical pixels
-    pub fn viewport_outer_pos(&self) -> Pos2 {
+    pub fn outer_rect(&self) -> Rect {
-        self.input(|i| i.outer_pos)
+        self.input(|i| i.outer_rect)
-    }
-
-    /// This will return the inner size of the current viewport
-    /// Viewport inner size, only drowable area
-    pub fn viewport_inner_size(&self) -> Pos2 {
-        self.input(|i| i.inner_size)
-    }
-
-    /// This will return the outer size of the current viewport
-    /// Viewport outer size, drowable area + decorations
-    pub fn viewport_outer_size(&self) -> Pos2 {
-        self.input(|i| i.outer_size)
     }
 
     /// How much space is still available after panels has been added.

crates/egui/src/data/input.rs

@@ -23,21 +23,13 @@ pub struct RawInput {
     /// `None` will be treated as "same as last frame", with the default being a very big area.
     pub screen_rect: Option<Rect>,
 
-    /// Viewport inner position, only the drowable area
+    /// Viewport inner position and size, only the drowable area
-    /// If is not working as expected is a winit bug!
+    /// unit = physical pixels
-    pub inner_pos: Option<Pos2>,
+    pub inner_rect: Option<Rect>,
 
-    /// Viewport outer position, drowable area + decorations
+    /// Viewport outer position and size, drowable area + decorations
-    /// If is not working as expected is a winit bug!
+    /// unit = physical pixels
-    pub outer_pos: Option<Pos2>,
+    pub outer_rect: Option<Rect>,
-
-    /// Viewport inner size, only drowable area
-    /// If is not working as expected is a winit bug!
-    pub inner_size: Option<Pos2>,
-
-    /// Viewport outer size, drowable area + decorations
-    /// If is not working as expected is a winit bug!
-    pub outer_size: Option<Pos2>,
 
     /// Also known as device pixel ratio, > 1 for high resolution screens.
     /// If text looks blurry you probably forgot to set this.
@@ -89,10 +81,8 @@ impl Default for RawInput {
     fn default() -> Self {
         Self {
             screen_rect: None,
-            inner_pos: None,
+            inner_rect: None,
-            outer_pos: None,
+            outer_rect: None,
-            inner_size: None,
-            outer_size: None,
             pixels_per_point: None,
             max_texture_side: None,
             time: None,
@@ -114,10 +104,8 @@ impl RawInput {
     pub fn take(&mut self) -> RawInput {
         RawInput {
             screen_rect: self.screen_rect.take(),
-            inner_pos: self.inner_pos.take(),
+            inner_rect: self.inner_rect.take(),
-            outer_pos: self.outer_pos.take(),
+            outer_rect: self.outer_rect.take(),
-            inner_size: self.inner_size.take(),
-            outer_size: self.outer_size.take(),
             pixels_per_point: self.pixels_per_point.take(),
             max_texture_side: self.max_texture_side.take(),
             time: self.time.take(),
@@ -134,10 +122,8 @@ impl RawInput {
     pub fn append(&mut self, newer: Self) {
         let Self {
             screen_rect,
-            inner_pos: viewport_inner_pos,
+            inner_rect,
-            outer_pos: viewport_outer_pos,
+            outer_rect,
-            inner_size: viewport_inner_size,
-            outer_size: viewport_outer_size,
             pixels_per_point,
             max_texture_side,
             time,
@@ -150,10 +136,8 @@ impl RawInput {
         } = newer;
 
         self.screen_rect = screen_rect.or(self.screen_rect);
-        self.inner_pos = viewport_inner_pos.or(self.inner_pos);
+        self.inner_rect = inner_rect.or(self.inner_rect);
-        self.outer_pos = viewport_outer_pos.or(self.outer_pos);
+        self.outer_rect = outer_rect.or(self.outer_rect);
-        self.inner_size = viewport_inner_size.or(self.inner_size);
-        self.outer_size = viewport_outer_size.or(self.outer_size);
         self.pixels_per_point = pixels_per_point.or(self.pixels_per_point);
         self.max_texture_side = max_texture_side.or(self.max_texture_side);
         self.time = time; // use latest time
@@ -969,10 +953,8 @@ impl RawInput {
     pub fn ui(&self, ui: &mut crate::Ui) {
         let Self {
             screen_rect,
-            inner_pos: viewport_inner_pos,
+            inner_rect,
-            outer_pos: viewport_outer_pos,
+            outer_rect,
-            inner_size: viewport_inner_size,
-            outer_size: viewport_outer_size,
             pixels_per_point,
             max_texture_side,
             time,
@@ -985,14 +967,8 @@ impl RawInput {
         } = self;
 
         ui.label(format!("screen_rect: {screen_rect:?} points"));
-        ui.label(format!("viewport_inner_pos: {viewport_inner_pos:?} pixels"));
+        ui.label(format!("inner_rect: {inner_rect:?} pixels"));
-        ui.label(format!("viewport_outer_pos: {viewport_outer_pos:?} pixels"));
+        ui.label(format!("outer_rect: {outer_rect:?} pixels"));
-        ui.label(format!(
-            "viewport_inner_size: {viewport_inner_size:?} pixels"
-        ));
-        ui.label(format!(
-            "viewport_outer_size: {viewport_outer_size:?} pixels"
-        ));
         ui.label(format!("pixels_per_point: {pixels_per_point:?}"))
             .on_hover_text(
                 "Also called HDPI factor.\nNumber of physical pixels per each logical pixel.",

crates/egui/src/input_state.rs

@@ -54,21 +54,13 @@ pub struct InputState {
     /// Position and size of the egui area.
     pub screen_rect: Rect,
 
-    /// Viewport inner position, only the drowable area
+    /// Viewport inner position and size, only the drowable area
-    /// If is not working as expected is a winit bug!
+    /// unit = physical pixels
-    pub inner_pos: Pos2,
+    pub inner_rect: Rect,
 
-    /// Viewport outer position, drowable area + decorations
+    /// Viewport outer position and size, drowable area + decorations
-    /// If is not working as expected is a winit bug!
+    /// unit = physical pixels
-    pub outer_pos: Pos2,
+    pub outer_rect: Rect,
-
-    /// Viewport inner size, only drowable area
-    /// If is not working as expected is a winit bug!
-    pub inner_size: Pos2,
-
-    /// Viewport outer size, drowable area + decorations
-    /// If is not working as expected is a winit bug!
-    pub outer_size: Pos2,
 
     /// Also known as device pixel ratio, > 1 for high resolution screens.
     pub pixels_per_point: f32,
@@ -154,10 +146,8 @@ impl Default for InputState {
             modifiers: Default::default(),
             keys_down: Default::default(),
             events: Default::default(),
-            inner_pos: Pos2::ZERO,
+            inner_rect: Rect::ZERO,
-            outer_pos: Pos2::ZERO,
+            outer_rect: Rect::ZERO,
-            inner_size: pos2(10_000.0, 10_000.0),
-            outer_size: pos2(10_000.0, 10_000.0),
         }
     }
 }
@@ -182,10 +172,8 @@ impl InputState {
         };
 
         let screen_rect = new.screen_rect.unwrap_or(self.screen_rect);
-        let viewport_inner_pos = new.inner_pos.unwrap_or(self.inner_pos);
+        let inner_rect = new.inner_rect.unwrap_or(self.inner_rect);
-        let viewport_outer_pos = new.outer_pos.unwrap_or(self.outer_pos);
+        let outer_rect = new.outer_rect.unwrap_or(self.outer_rect);
-        let viewport_inner_size = new.inner_size.unwrap_or(self.inner_size);
-        let viewport_outer_size = new.outer_size.unwrap_or(self.outer_size);
 
         self.create_touch_states_for_new_devices(&new.events);
         for touch_state in self.touch_states.values_mut() {
@@ -241,10 +229,8 @@ impl InputState {
             scroll_delta,
             zoom_factor_delta,
             screen_rect,
-            inner_pos: viewport_inner_pos,
+            inner_rect,
-            outer_pos: viewport_outer_pos,
+            outer_rect,
-            inner_size: viewport_inner_size,
-            outer_size: viewport_outer_size,
             pixels_per_point: new.pixels_per_point.unwrap_or(self.pixels_per_point),
             max_texture_side: new.max_texture_side.unwrap_or(self.max_texture_side),
             time,
@@ -1011,10 +997,8 @@ impl InputState {
             scroll_delta,
             zoom_factor_delta,
             screen_rect,
-            inner_pos: viewport_inner_pos,
+            inner_rect,
-            outer_pos: viewport_outer_pos,
+            outer_rect,
-            inner_size: viewport_inner_size,
-            outer_size: viewport_outer_size,
             pixels_per_point,
             max_texture_side,
             time,
@@ -1050,14 +1034,8 @@ impl InputState {
         ui.label(format!("scroll_delta: {scroll_delta:?} points"));
         ui.label(format!("zoom_factor_delta: {zoom_factor_delta:4.2}x"));
         ui.label(format!("screen_rect: {screen_rect:?} points"));
-        ui.label(format!("viewport_inner_pos: {viewport_inner_pos:?} pixels"));
+        ui.label(format!("inner_rect: {inner_rect:?} pixels"));
-        ui.label(format!("viewport_outer_pos: {viewport_outer_pos:?} pixels"));
+        ui.label(format!("outer_rect: {outer_rect:?} pixels"));
-        ui.label(format!(
-            "viewport_inner_size: {viewport_inner_size:?} pixels"
-        ));
-        ui.label(format!(
-            "viewport_outer_size: {viewport_outer_size:?} pixels"
-        ));
         ui.label(format!(
             "{pixels_per_point} physical pixels for each logical point"
         ));

examples/viewports/src/main.rs

@@ -263,8 +263,18 @@ fn ui_info(ui: &mut egui::Ui) {
     ui.label(format!("Frame: {}", ctx.frame_nr()));
     ui.label(format!("Current Viewport Id: {}", ctx.viewport_id()));
     ui.label(format!("Current Parent Viewport Id: {}", ctx.viewport_id()));
-    ui.label(format!("Pos: {:?}", ctx.viewport_outer_pos()));
+    let inner_rect = ctx.inner_rect();
-    ui.label(format!("Size: {:?}", ctx.viewport_inner_size()));
+    let outer_rect = ctx.outer_rect();
+    ui.label(format!(
+        "Inner Rect: Pos: {:?}, Size: {:?}",
+        inner_rect.min,
+        inner_rect.size()
+    ));
+    ui.label(format!(
+        "Outer Rect: Pos: {:?}, Size: {:?}",
+        outer_rect.min,
+        outer_rect.size()
+    ));
 }
 
 fn main() {