(rustbasic) In Progress : Testing...

crates/eframe/src/native/epi_integration.rs

@@ -278,13 +278,20 @@ impl EpiIntegration {
 
         let full_output = self.egui_ctx.run(raw_input, |egui_ctx| {
             if let Some(viewport_ui_cb) = viewport_ui_cb {
-                // Child viewport
+                // Child Deferred Viewport
                 crate::profile_scope!("viewport_callback");
                 viewport_ui_cb(egui_ctx);
             } else {
+                // ROOT Viewport ( with Immediate Viewport )
                 crate::profile_scope!("App::update");
                 app.update(egui_ctx, &mut self.frame);
             }
+
+            let viewport_id = egui_ctx.viewport_id();
+            // TODO : Do not recall until the next repaint.
+            // 1000 millis / 60 fps = 16.67 millis
+            self.egui_ctx
+                .request_repaint_after_for(std::time::Duration::from_millis(8), viewport_id);
         });
 
         let is_root_viewport = viewport_ui_cb.is_none();

crates/eframe/src/native/glow_integration.rs

@@ -353,8 +353,8 @@ impl WinitApp for GlowWinitApp {
     fn is_focused(&self, window_id: WindowId) -> bool {
         if let Some(running) = &self.running {
             let glutin = running.glutin.borrow();
-            if let Some(window_id) = glutin.viewport_from_window.get(&window_id) {
-                return glutin.focused_viewport == Some(*window_id);
+            if let Some(viewport_id) = glutin.viewport_from_window.get(&window_id) {
+                return glutin.focused_viewport == Some(*viewport_id);
             }
         }
 
@@ -463,7 +463,7 @@ impl WinitApp for GlowWinitApp {
                         }
 
                         if let Some(window) = viewport.window.as_ref() {
-                            EventResult::RepaintNext(window.id())
+                            EventResult::RepaintNow(window.id())
                         } else {
                             EventResult::Wait
                         }
@@ -509,7 +509,7 @@ impl GlowWinitRunning {
     ) -> EventResult {
         crate::profile_function!();
 
-        let Some(viewport_id) = self
+        let Some(mut viewport_id) = self
             .glutin
             .borrow()
             .viewport_from_window
@@ -525,32 +525,44 @@ impl GlowWinitRunning {
         let mut frame_timer = crate::stopwatch::Stopwatch::new();
         frame_timer.start();
 
-        {
-            let glutin = self.glutin.borrow();
-            let viewport = &glutin.viewports[&viewport_id];
-            let is_immediate = viewport.viewport_ui_cb.is_none();
+        let (raw_input, viewport_ui_cb) = {
+            crate::profile_scope!("Prepare");
+
+            let mut glutin = self.glutin.borrow_mut();
+            let original_viewport = &glutin.viewports[&viewport_id];
+            let is_immediate = original_viewport.viewport_ui_cb.is_none();
+
+            // This will only happens when a Immediate Viewport.
             if is_immediate && viewport_id != ViewportId::ROOT {
-                // This will only happen if this is an immediate viewport.
-                // That means that the viewport cannot be rendered by itself and needs his parent to be rendered.
-                if let Some(parent_viewport) = glutin.viewports.get(&viewport.ids.parent) {
-                    if let Some(window) = parent_viewport.window.as_ref() {
-                        return EventResult::RepaintNext(window.id());
+                if let Some(parent_viewport) = glutin.viewports.get(&original_viewport.ids.parent) {
+                    let is_deferred_parent = parent_viewport.viewport_ui_cb.is_some();
+                    if is_deferred_parent {
+                        // This will only happens when the parent is a Deferred Viewport.
+                        viewport_id = parent_viewport.ids.this;
+                    } else if let Some(root_viewport) = glutin.viewports.get(&ViewportId::ROOT) {
+                        // This will only happen when the parent is a Immediate Viewport.
+                        // That means that the viewport cannot be rendered by itself and needs his parent to be rendered.
+                        viewport_id = root_viewport.ids.this;
+                    } else {
+                        // Not actually used. Because there is always a `Some()` value.
+                        return EventResult::Wait;
                     }
                 }
-                return EventResult::Wait;
             }
-        }
 
-        let (raw_input, viewport_ui_cb) = {
-            let mut glutin = self.glutin.borrow_mut();
             let egui_ctx = glutin.egui_ctx.clone();
-            let viewport = glutin.viewports.get_mut(&viewport_id).unwrap();
+            let Some(viewport) = glutin.viewports.get_mut(&viewport_id) else {
+                return EventResult::Wait;
+            };
+
             let Some(window) = viewport.window.as_ref() else {
                 return EventResult::Wait;
             };
             egui_winit::update_viewport_info(&mut viewport.info, &egui_ctx, window);
 
-            let egui_winit = viewport.egui_winit.as_mut().unwrap();
+            let Some(egui_winit) = viewport.egui_winit.as_mut() else {
+                return EventResult::Wait;
+            };
             let mut raw_input = egui_winit.take_egui_input(window);
             let viewport_ui_cb = viewport.viewport_ui_cb.clone();
 
@@ -628,13 +640,18 @@ impl GlowWinitRunning {
             viewport_output,
         } = full_output;
 
+        glutin.active_viewports_retain(viewport_output.clone());
+
         let GlutinWindowContext {
             viewports,
             current_gl_context,
             ..
         } = &mut *glutin;
 
-        let viewport = viewports.get_mut(&viewport_id).unwrap();
+        let Some(viewport) = viewports.get_mut(&viewport_id) else {
+            return EventResult::Wait;
+        };
+
         viewport.info.events.clear(); // they should have been processed
         let window = viewport.window.clone().unwrap();
         let gl_surface = viewport.gl_surface.as_ref().unwrap();
@@ -707,15 +724,19 @@ impl GlowWinitRunning {
 
         integration.maybe_autosave(app.as_mut(), Some(&window));
 
-        if window.is_minimized() == Some(true) {
-            // On Mac, a minimized Window uses up all CPU:
-            // https://github.com/emilk/egui/issues/325
-            crate::profile_scope!("minimized_sleep");
-            std::thread::sleep(std::time::Duration::from_millis(10));
+        let is_windows = cfg!(target_os = "windows");
+        if !is_windows {
+            let is_minimized = window.is_minimized().unwrap_or(false);
+            if is_minimized {
+                // On Mac, a minimized Window uses up all CPU:
+                // https://github.com/emilk/egui/issues/325
+                crate::profile_scope!("minimized_sleep");
+                std::thread::sleep(std::time::Duration::from_millis(10));
+            }
         }
 
         if integration.should_close() {
-            EventResult::Exit
+            EventResult::Exit(window_id)
         } else {
             EventResult::Wait
         }
@@ -744,22 +765,16 @@ impl GlowWinitRunning {
         // to resizes anyway, as doing so avoids dropping frames.
         //
         // See: https://github.com/emilk/egui/issues/903
-        let mut repaint_asap = false;
 
         match event {
             winit::event::WindowEvent::Focused(new_focused) => {
                 glutin.focused_viewport = new_focused.then(|| viewport_id).flatten();
             }
 
             winit::event::WindowEvent::Resized(physical_size) => {
-                // Resize with 0 width and height is used by winit to signal a minimize event on Windows.
-                // See: https://github.com/rust-windowing/winit/issues/208
-                // This solves an issue where the app would panic when minimizing on Windows.
-                if 0 < physical_size.width && 0 < physical_size.height {
-                    if let Some(viewport_id) = viewport_id {
-                        repaint_asap = true;
-                        glutin.resize(viewport_id, *physical_size);
-                    }
+                if let Some(viewport_id) = viewport_id {
+                    glutin.resize(viewport_id, *physical_size);
+                    return EventResult::RepaintNext(window_id);
                 }
             }
 
@@ -768,7 +783,7 @@ impl GlowWinitRunning {
                     log::debug!(
                         "Received WindowEvent::CloseRequested for main viewport - shutting down."
                     );
-                    return EventResult::Exit;
+                    return EventResult::Exit(window_id);
                 }
 
                 log::debug!("Received WindowEvent::CloseRequested for viewport {viewport_id:?}");
@@ -782,9 +797,17 @@ impl GlowWinitRunning {
                         // and perhaps twice (once to notice the close-event, once again to enforce it).
                         // `request_repaint_of` does a double-repaint though:
                         self.integration.egui_ctx.request_repaint_of(viewport_id);
-                        self.integration
-                            .egui_ctx
-                            .request_repaint_of(viewport.ids.parent);
+                        if viewport_id != ViewportId::ROOT {
+                            self.integration
+                                .egui_ctx
+                                .request_repaint_of(viewport.ids.parent);
+                        }
+
+                        if viewport_id == ViewportId::ROOT {
+                            return EventResult::Wait;
+                        } else {
+                            return EventResult::ViewportExit(window_id);
+                        }
                     }
                 }
             }
@@ -793,7 +816,7 @@ impl GlowWinitRunning {
         }
 
         if self.integration.should_close() {
-            return EventResult::Exit;
+            return EventResult::Exit(window_id);
         }
 
         let mut event_response = egui_winit::EventResponse {
@@ -815,11 +838,7 @@ impl GlowWinitRunning {
         }
 
         if event_response.repaint {
-            if repaint_asap {
-                EventResult::RepaintNow(window_id)
-            } else {
-                EventResult::RepaintNext(window_id)
-            }
+            EventResult::RepaintNow(window_id)
         } else {
             EventResult::Wait
         }
@@ -976,8 +995,7 @@ impl GlutinWindowContext {
         if let Some(window) = &window {
             viewport_from_window.insert(window.id(), ViewportId::ROOT);
             window_from_viewport.insert(ViewportId::ROOT, window.id());
-            info.minimized = window.is_minimized();
-            info.maximized = Some(window.is_maximized());
+            info = egui_winit::get_update_viewport_info(&ViewportInfo::default(), window, None);
         }
 
         let mut viewports = ViewportIdMap::default();
@@ -1068,8 +1086,8 @@ impl GlutinWindowContext {
                 &window,
                 &viewport.builder,
             );
-            viewport.info.minimized = window.is_minimized();
-            viewport.info.maximized = Some(window.is_maximized());
+
+            viewport.info = egui_winit::get_update_viewport_info(&viewport.info, &window, None);
             viewport.window.insert(Arc::new(window))
         };
 
@@ -1168,6 +1186,22 @@ impl GlutinWindowContext {
             .expect("winit window doesn't exist")
     }
 
+    #[allow(clippy::needless_pass_by_value)]
+    pub(crate) fn active_viewports_retain(
+        &mut self,
+        viewport_output: ViewportIdMap<ViewportOutput>,
+    ) {
+        let active_viewports_ids: ViewportIdSet = viewport_output.keys().copied().collect();
+
+        // GC old viewports
+        self.viewports
+            .retain(|id, _| active_viewports_ids.contains(id));
+        self.viewport_from_window
+            .retain(|_, id| active_viewports_ids.contains(id));
+        self.window_from_viewport
+            .retain(|id, _| active_viewports_ids.contains(id));
+    }
+
     fn resize(&mut self, viewport_id: ViewportId, physical_size: winit::dpi::PhysicalSize<u32>) {
         let width_px = std::num::NonZeroU32::new(physical_size.width.at_least(1)).unwrap();
         let height_px = std::num::NonZeroU32::new(physical_size.height.at_least(1)).unwrap();
@@ -1206,8 +1240,6 @@ impl GlutinWindowContext {
     ) {
         crate::profile_function!();
 
-        let active_viewports_ids: ViewportIdSet = viewport_output.keys().copied().collect();
-
         for (
             viewport_id,
             ViewportOutput {
@@ -1218,7 +1250,7 @@ impl GlutinWindowContext {
                 commands,
                 repaint_delay: _, // ignored - we listened to the repaint callback instead
             },
-        ) in viewport_output
+        ) in viewport_output.clone()
         {
             let ids = ViewportIdPair::from_self_and_parent(viewport_id, parent);
 
@@ -1248,13 +1280,7 @@ impl GlutinWindowContext {
         // Create windows for any new viewports:
         self.initialize_all_windows(event_loop);
 
-        // GC old viewports
-        self.viewports
-            .retain(|id, _| active_viewports_ids.contains(id));
-        self.viewport_from_window
-            .retain(|_, id| active_viewports_ids.contains(id));
-        self.window_from_viewport
-            .retain(|id, _| active_viewports_ids.contains(id));
+        self.active_viewports_retain(viewport_output);
     }
 }