Now viewport pos and size are stored in InputState::{viewport_inner_pos, viewport_outer_pos, viewport_inner_size, viewport_outer_size}

This fixes a lot of problems

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, ViewportBuilder, ViewportCommand, ViewportId};
+use egui::{mutex::RwLock, Pos2, ViewportBuilder, ViewportCommand, ViewportId};
 pub use winit;
 
 pub mod clipboard;
@@ -183,10 +183,39 @@ impl State {
         });
 
         self.egui_input.screen_rect = if getting_info {
-            Some(egui::Rect::from_min_size(
+            Some(egui::Rect::from_min_size(Pos2::ZERO, screen_size_in_points))
-                egui::Pos2::ZERO,
+        } else {
-                screen_size_in_points,
+            None
-            ))
+        };
+
+        self.egui_input.viewport_inner_pos = if getting_info {
+            window
+                .inner_position()
+                .map(|pos| Pos2::new(pos.x as f32, pos.y as f32))
+                .ok()
+        } else {
+            None
+        };
+
+        self.egui_input.viewport_outer_pos = if getting_info {
+            window
+                .outer_position()
+                .map(|pos| Pos2::new(pos.x as f32, pos.y as f32))
+                .ok()
+        } else {
+            None
+        };
+
+        self.egui_input.viewport_inner_size = if getting_info {
+            let size = window.inner_size();
+            Some(Pos2::new(size.width as f32, size.height as f32))
+        } else {
+            None
+        };
+
+        self.egui_input.viewport_outer_size = if getting_info {
+            let size = window.outer_size();
+            Some(Pos2::new(size.width as f32, size.height as f32))
         } else {
             None
         };

crates/egui/src/containers/window.rs

@@ -436,7 +436,7 @@ impl<'open> Window<'open> {
                     let mut resize = resize.id(resize_id);
 
                     let mut area = area.begin(ctx);
-                    let win_size = ctx.input(|i| i.screen_rect.size());
+                    let win_size = ctx.screen_rect().size();
                     area.state_mut().set_left_top_pos(Pos2::ZERO);
                     area.state_mut().size = win_size;
                     let title_content_spacing = 2.0 * ctx.style().spacing.item_spacing.y;
@@ -588,26 +588,31 @@ impl<'open> Window<'open> {
                     let full_response = area.end(ctx, area_content_ui);
 
                     if !collapsing.is_open() {
-                        let size = ctx.round_vec_to_pixels(full_response.rect.size());
+                        let size = full_response.rect.size() * ctx.pixels_per_point();
                         ctx.viewport_command(
                             ctx.get_viewport_id(),
                             ViewportCommand::InnerSize(size.x as u32, size.y as u32),
                         );
                     }
 
-                    // let size = ctx.round_vec_to_pixels(full_response.rect.size());
                     if win_size.x < size.x {
                         println!("Set size!");
                         ctx.viewport_command(
                             ctx.get_viewport_id(),
-                            ViewportCommand::InnerSize(size.x as u32, win_size.y as u32),
+                            ViewportCommand::InnerSize(
+                                (size.x * ctx.pixels_per_point()) as u32,
+                                (win_size.y * ctx.pixels_per_point()) as u32,
+                            ),
                         );
                     }
                     if win_size.y < size.y {
                         println!("Set size!");
                         ctx.viewport_command(
                             ctx.get_viewport_id(),
-                            ViewportCommand::InnerSize(win_size.x as u32, size.y as u32),
+                            ViewportCommand::InnerSize(
+                                (win_size.x * ctx.pixels_per_point()) as u32,
+                                (size.y * ctx.pixels_per_point()) as u32,
+                            ),
                         );
                     }
                     if show_close_button && op != is_open {
@@ -825,8 +830,8 @@ impl<'open> Window<'open> {
         'create_viewport: {
             if !is_embedded && !ctx.force_embedding() {
                 if let Some(size) = ctx.data(|data| data.get_temp::<Vec2>(area.id.with("size"))) {
-                    let size = size.round()
+                    let size = (size.round() + ctx.style().spacing.window_margin.sum())
-                        + ctx.style().spacing.window_margin.sum() * ctx.pixels_per_point();
+                        * ctx.pixels_per_point();
                     window_builder = window_builder
                         .with_inner_size(Some((size.x as u32 + 1, size.y as u32 + 1)));
                 } else {
@@ -893,7 +898,7 @@ impl<'open> Window<'open> {
                     let mut resize = resize.id(resize_id);
 
                     let mut area = area.begin(ctx);
-                    let win_size = ctx.input(|i| i.screen_rect.size());
+                    let win_size = ctx.viewport_inner_size().to_vec2() * ctx.pixels_per_point();
                     area.state_mut().set_left_top_pos(Pos2::ZERO);
                     area.state_mut().size = win_size;
                     let title_content_spacing = 2.0 * ctx.style().spacing.item_spacing.y;
@@ -1045,7 +1050,7 @@ impl<'open> Window<'open> {
                     let full_response = area.end(ctx, area_content_ui);
 
                     if !collapsing.is_open() {
-                        let size = ctx.round_vec_to_pixels(full_response.rect.size());
+                        let size = full_response.rect.size() * ctx.pixels_per_point();
                         ctx.viewport_command(
                             ctx.get_viewport_id(),
                             ViewportCommand::InnerSize(size.x as u32, size.y as u32),
@@ -1057,14 +1062,20 @@ impl<'open> Window<'open> {
                         println!("Set size!");
                         ctx.viewport_command(
                             ctx.get_viewport_id(),
-                            ViewportCommand::InnerSize(size.x as u32, win_size.y as u32),
+                            ViewportCommand::InnerSize(
+                                (size.x * ctx.pixels_per_point()) as u32,
+                                (win_size.y * ctx.pixels_per_point()) as u32,
+                            ),
                         );
                     }
                     if win_size.y < size.y {
                         println!("Set size!");
                         ctx.viewport_command(
                             ctx.get_viewport_id(),
-                            ViewportCommand::InnerSize(win_size.x as u32, size.y as u32),
+                            ViewportCommand::InnerSize(
+                                (win_size.x * ctx.pixels_per_point()) as u32,
+                                (size.y * ctx.pixels_per_point()) as u32,
+                            ),
                         );
                     }
                     if show_close_button && op != is_open {

crates/egui/src/context.rs

@@ -267,7 +267,17 @@ impl ContextImpl {
         self.repaint.start_frame(self.get_viewport_id());
 
         if let Some(new_pixels_per_point) = self.memory.new_pixels_per_point {
+            if self
+                .memory
+                .new_pixels_per_viewport
+                .get(&viewport_id)
+                .map(|pixels| *pixels != new_pixels_per_point)
+                .unwrap_or(true)
+            {
                 new_raw_input.pixels_per_point = Some(new_pixels_per_point);
+                self.memory
+                    .new_pixels_per_viewport
+                    .insert(viewport_id, new_pixels_per_point);
 
                 let input = self.input.entry(viewport_id).or_default();
                 // This is a bit hacky, but is required to avoid jitter:
@@ -277,6 +287,7 @@ impl ContextImpl {
                 rect.max = (ratio * rect.max.to_vec2()).to_pos2();
                 new_raw_input.screen_rect = Some(rect);
             }
+        }
 
         self.layer_rects_prev_frame = self
             .layer_rects_prev_viewports
@@ -1493,6 +1504,9 @@ impl Context {
             ctx.output.retain(|id, _| viewports.contains(id));
             ctx.frame_state.retain(|id, _| viewports.contains(id));
             ctx.graphics.retain(|id, _| viewports.contains(id));
+            ctx.memory
+                .new_pixels_per_viewport
+                .retain(|id, _| viewports.contains(id));
         });
 
         let repaint_after =
@@ -1604,6 +1618,22 @@ impl Context {
         self.input(|i| i.screen_rect())
     }
 
+    pub fn viewport_inner_pos(&self) -> Pos2 {
+        self.input(|i| i.viewport_inner_pos)
+    }
+
+    pub fn viewport_outer_pos(&self) -> Pos2 {
+        self.input(|i| i.viewport_outer_pos)
+    }
+
+    pub fn viewport_inner_size(&self) -> Pos2 {
+        self.input(|i| i.viewport_inner_size)
+    }
+
+    pub fn viewport_outer_size(&self) -> Pos2 {
+        self.input(|i| i.viewport_outer_size)
+    }
+
     /// How much space is still available after panels has been added.
     ///
     /// This is the "background" area, what egui doesn't cover with panels (but may cover with windows).

crates/egui/src/data/input.rs

@@ -23,6 +23,11 @@ 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>,
 
+    pub viewport_inner_pos: Option<Pos2>,
+    pub viewport_outer_pos: Option<Pos2>,
+    pub viewport_inner_size: Option<Pos2>,
+    pub viewport_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.
     /// Set this the first frame, whenever it changes, or just on every frame.
@@ -73,6 +78,10 @@ impl Default for RawInput {
     fn default() -> Self {
         Self {
             screen_rect: None,
+            viewport_inner_pos: None,
+            viewport_outer_pos: None,
+            viewport_inner_size: None,
+            viewport_outer_size: None,
             pixels_per_point: None,
             max_texture_side: None,
             time: None,
@@ -94,6 +103,10 @@ impl RawInput {
     pub fn take(&mut self) -> RawInput {
         RawInput {
             screen_rect: self.screen_rect.take(),
+            viewport_inner_pos: self.viewport_inner_pos.take(),
+            viewport_outer_pos: self.viewport_outer_pos.take(),
+            viewport_inner_size: self.viewport_inner_size.take(),
+            viewport_outer_size: self.viewport_outer_size.take(),
             pixels_per_point: self.pixels_per_point.take(),
             max_texture_side: self.max_texture_side.take(),
             time: self.time.take(),
@@ -110,6 +123,10 @@ impl RawInput {
     pub fn append(&mut self, newer: Self) {
         let Self {
             screen_rect,
+            viewport_inner_pos,
+            viewport_outer_pos,
+            viewport_inner_size,
+            viewport_outer_size,
             pixels_per_point,
             max_texture_side,
             time,
@@ -122,6 +139,10 @@ impl RawInput {
         } = newer;
 
         self.screen_rect = screen_rect.or(self.screen_rect);
+        self.viewport_inner_pos = viewport_inner_pos.or(self.viewport_inner_pos);
+        self.viewport_outer_pos = viewport_outer_pos.or(self.viewport_outer_pos);
+        self.viewport_inner_size = viewport_inner_size.or(self.viewport_inner_size);
+        self.viewport_outer_size = viewport_outer_size.or(self.viewport_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
@@ -934,6 +955,10 @@ impl RawInput {
     pub fn ui(&self, ui: &mut crate::Ui) {
         let Self {
             screen_rect,
+            viewport_inner_pos,
+            viewport_outer_pos,
+            viewport_inner_size,
+            viewport_outer_size,
             pixels_per_point,
             max_texture_side,
             time,
@@ -946,6 +971,14 @@ impl RawInput {
         } = self;
 
         ui.label(format!("screen_rect: {screen_rect:?} points"));
+        ui.label(format!("viewport_inner_pos: {viewport_inner_pos:?} pixels"));
+        ui.label(format!("viewport_outer_pos: {viewport_outer_pos:?} 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,6 +54,11 @@ pub struct InputState {
     /// Position and size of the egui area.
     pub screen_rect: Rect,
 
+    pub viewport_inner_pos: Pos2,
+    pub viewport_outer_pos: Pos2,
+    pub viewport_inner_size: Pos2,
+    pub viewport_outer_size: Pos2,
+
     /// Also known as device pixel ratio, > 1 for high resolution screens.
     pub pixels_per_point: f32,
 
@@ -138,6 +143,10 @@ impl Default for InputState {
             modifiers: Default::default(),
             keys_down: Default::default(),
             events: Default::default(),
+            viewport_inner_pos: Pos2::ZERO,
+            viewport_outer_pos: Pos2::ZERO,
+            viewport_inner_size: pos2(10_000.0, 10_000.0),
+            viewport_outer_size: pos2(10_000.0, 10_000.0),
         }
     }
 }
@@ -161,6 +170,11 @@ impl InputState {
         };
 
         let screen_rect = new.screen_rect.unwrap_or(self.screen_rect);
+        let viewport_inner_pos = new.viewport_inner_pos.unwrap_or(self.viewport_inner_pos);
+        let viewport_outer_pos = new.viewport_outer_pos.unwrap_or(self.viewport_outer_pos);
+        let viewport_inner_size = new.viewport_inner_size.unwrap_or(self.viewport_inner_size);
+        let viewport_outer_size = new.viewport_outer_size.unwrap_or(self.viewport_outer_size);
+
         self.create_touch_states_for_new_devices(&new.events);
         for touch_state in self.touch_states.values_mut() {
             touch_state.begin_frame(time, &new, self.pointer.interact_pos);
@@ -215,6 +229,10 @@ impl InputState {
             scroll_delta,
             zoom_factor_delta,
             screen_rect,
+            viewport_inner_pos,
+            viewport_outer_pos,
+            viewport_inner_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,
@@ -972,6 +990,10 @@ impl InputState {
             scroll_delta,
             zoom_factor_delta,
             screen_rect,
+            viewport_inner_pos,
+            viewport_outer_pos,
+            viewport_inner_size,
+            viewport_outer_size,
             pixels_per_point,
             max_texture_side,
             time,
@@ -1007,6 +1029,14 @@ 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!("viewport_outer_pos: {viewport_outer_pos:?} 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"
         ));

crates/egui/src/memory.rs

@@ -67,6 +67,9 @@ pub struct Memory {
     #[cfg_attr(feature = "persistence", serde(skip))]
     pub(crate) new_pixels_per_point: Option<f32>,
 
+    #[cfg_attr(feature = "persistence", serde(skip))]
+    pub(crate) new_pixels_per_viewport: HashMap<ViewportId, f32>,
+
     /// new fonts that will be applied at the start of the next frame
     #[cfg_attr(feature = "persistence", serde(skip))]
     pub(crate) new_font_definitions: Option<epaint::text::FontDefinitions>,

examples/viewports/src/main.rs

@@ -51,6 +51,8 @@ impl eframe::App for App {
                 "Current Parent Viewport Id: {}",
                 ctx.get_viewport_id()
             ));
+            ui.label(format!("Pos: {:?}", ctx.viewport_outer_pos()));
+            ui.label(format!("Size: {:?}", ctx.viewport_inner_size()));
             ui.label("Look at the \"Frame: \" will tell you, what viewport is rendering!");
             {
                 let mut force_embedding = ctx.force_embedding();
@@ -91,8 +93,8 @@ impl eframe::App for App {
                                 "Current Parent Viewport Id: {}",
                                 ctx.get_viewport_id()
                             ));
-                            ui.label(format!("Pos: {:?}", ctx.screen_rect().min));
+                            ui.label(format!("Pos: {:?}", ctx.viewport_outer_pos()));
-                            ui.label(format!("Size: {:?}", ctx.screen_rect().max));
+                            ui.label(format!("Size: {:?}", ctx.viewport_inner_size()));
 
                             ui.checkbox(&mut show_async_viewport2, "Show Async Viewport 2");
                             ui.checkbox(&mut show_sync_viewport2, "Show Sync Viewport 2");
@@ -119,8 +121,14 @@ impl eframe::App for App {
                                                 "Current Parent Viewport Id: {}",
                                                 ctx.get_viewport_id()
                                             ));
-                                            ui.label(format!("Pos: {:?}", ctx.screen_rect().min));
+                                            ui.label(format!(
-                                            ui.label(format!("Size: {:?}", ctx.screen_rect().max));
+                                                "Pos: {:?}",
+                                                ctx.viewport_outer_pos()
+                                            ));
+                                            ui.label(format!(
+                                                "Size: {:?}",
+                                                ctx.viewport_inner_size()
+                                            ));
 
                                             ui.label(format!("Count: {state}"));
                                             if ui.button("Add").clicked() {
@@ -159,8 +167,14 @@ impl eframe::App for App {
                                                 "Current Parent Viewport Id: {}",
                                                 ctx.get_viewport_id()
                                             ));
-                                            ui.label(format!("Pos: {:?}", ctx.screen_rect().min));
+                                            ui.label(format!(
-                                            ui.label(format!("Size: {:?}", ctx.screen_rect().max));
+                                                "Pos: {:?}",
+                                                ctx.viewport_outer_pos()
+                                            ));
+                                            ui.label(format!(
+                                                "Size: {:?}",
+                                                ctx.viewport_inner_size()
+                                            ));
 
                                             ui.label(format!("Count: {state}"));
                                             if ui.button("Add").clicked() {
@@ -206,15 +220,16 @@ impl eframe::App for App {
                         let async_viewport_state2 = self.async_viewport_state2.clone();
                         let sync_viewport_state2 = self.sync_viewport_state2.clone();
 
-                        let content = |ui: &mut egui::Ui| {
+                        let content =
+                            |ui: &mut egui::Ui| {
                                 ui.label(format!("Frame: {}", ctx.frame_nr()));
                                 ui.label(format!("Current Viewport Id: {}", ctx.get_viewport_id()));
                                 ui.label(format!(
                                     "Current Parent Viewport Id: {}",
                                     ctx.get_viewport_id()
                                 ));
-                            ui.label(format!("Pos: {:?}", ctx.screen_rect().min));
+                                ui.label(format!("Pos: {:?}", ctx.viewport_outer_pos()));
-                            ui.label(format!("Size: {:?}", ctx.screen_rect().max));
+                                ui.label(format!("Size: {:?}", ctx.viewport_inner_size()));
 
                                 ui.checkbox(&mut show_async_viewport2, "Show Async Viewport");
                                 ui.checkbox(&mut show_sync_viewport2, "Show Sync Viewport");
@@ -241,8 +256,14 @@ impl eframe::App for App {
                                                     "Current Parent Viewport Id: {}",
                                                     ctx.get_viewport_id()
                                                 ));
-                                            ui.label(format!("Pos: {:?}", ctx.screen_rect().min));
+                                                ui.label(format!(
-                                            ui.label(format!("Size: {:?}", ctx.screen_rect().max));
+                                                    "Pos: {:?}",
+                                                    ctx.viewport_outer_pos()
+                                                ));
+                                                ui.label(format!(
+                                                    "Size: {:?}",
+                                                    ctx.viewport_inner_size()
+                                                ));
 
                                                 ui.label(format!("Count: {state}"));
                                                 if ui.button("Add").clicked() {
@@ -281,8 +302,14 @@ impl eframe::App for App {
                                                     "Current Parent Viewport Id: {}",
                                                     ctx.get_viewport_id()
                                                 ));
-                                            ui.label(format!("Pos: {:?}", ctx.screen_rect().min));
+                                                ui.label(format!(
-                                            ui.label(format!("Size: {:?}", ctx.screen_rect().max));
+                                                    "Pos: {:?}",
+                                                    ctx.viewport_outer_pos()
+                                                ));
+                                                ui.label(format!(
+                                                    "Size: {:?}",
+                                                    ctx.viewport_inner_size()
+                                                ));
 
                                                 ui.label(format!("Count: {state}"));
                                                 if ui.button("Add").clicked() {
@@ -292,13 +319,11 @@ impl eframe::App for App {
 
                                             // This will make the viewport content, a popup if is in the main window
                                             if ctx.get_viewport_id() == ViewportId::MAIN {
-                                            egui::Area::new("Sync Viewport in Sync Viewport").show(
+                                                egui::Area::new("Sync Viewport in Sync Viewport")
-                                                ctx,
+                                                    .show(ctx, |ui| {
-                                                |ui| {
                                                         egui::Frame::popup(ui.style())
                                                             .show(ui, content);
-                                                },
+                                                    });
-                                            );
                                             } else {
                                                 egui::CentralPanel::default().show(ctx, content);
                                             };
@@ -333,6 +358,8 @@ impl eframe::App for App {
                             "Current Parent Viewport Id: {}",
                             ctx.get_viewport_id()
                         ));
+                        ui.label(format!("Pos: {:?}", ctx.viewport_outer_pos()));
+                        ui.label(format!("Size: {:?}", ctx.viewport_inner_size()));
                         ui.label(format!("Count: {state}"));
                         if ui.button("Add").clicked() {
                             *state += 1;
@@ -345,9 +372,14 @@ impl eframe::App for App {
                 egui::Window::new("Sync Window")
                     .default_embedded(false)
                     .show(ctx, |ui| {
-                        ui.label(format!("Frame: {}", ui.ctx().frame_nr()));
                         ui.label(format!("Frame: {}", ctx.frame_nr()));
                         ui.label(format!("Current Viewport Id: {}", ctx.get_viewport_id()));
+                        ui.label(format!(
+                            "Current Parent Viewport Id: {}",
+                            ctx.get_viewport_id()
+                        ));
+                        ui.label(format!("Pos: {:?}", ctx.viewport_outer_pos()));
+                        ui.label(format!("Size: {:?}", ctx.viewport_inner_size()));
                         ui.label(format!("Count: {}", self.sync_window_state));
                         if ui.button("Add").clicked() {
                             self.sync_window_state += 1;