(rustbasic) In Progress : Testing...

crates/eframe/src/epi.rs

@@ -186,13 +186,15 @@ pub trait App {
     /// egui recommends that rendering backends use a normal "gamma-space" (non-sRGB-aware) blending,
     ///  which means the values you return here should also be in `sRGB` gamma-space in the 0-1 range.
     /// You can use [`egui::Color32::to_normalized_gamma_f32`] for this.
-    fn clear_color(&self, _visuals: &egui::Visuals) -> [f32; 4] {
+    fn clear_color(&self, visuals: &egui::Visuals) -> [f32; 4] {
         // NOTE: a bright gray makes the shadows of the windows look weird.
         // We use a bit of transparency so that if the user switches on the
         // `transparent()` option they get immediate results.
-        egui::Color32::from_rgba_unmultiplied(12, 12, 12, 180).to_normalized_gamma_f32()
 
-        // _visuals.window_fill() would also be a natural choice
+        // egui::Color32::from_rgba_unmultiplied(12, 12, 12, 180).to_normalized_gamma_f32()
+        // or
+        // visuals.window_fill.to_normalized_gamma_f32()
+        visuals.window_fill.to_normalized_gamma_f32()
     }
 
     /// Controls whether or not the egui memory (window positions etc) will be

crates/eframe/src/native/epi_integration.rs

@@ -5,7 +5,7 @@ use winit::event_loop::EventLoopWindowTarget;
 
 use raw_window_handle::{HasDisplayHandle as _, HasWindowHandle as _};
 
-use egui::{DeferredViewportUiCallback, NumExt as _, ViewportBuilder, ViewportId};
+use egui::{DeferredViewportUiCallback, NumExt as _, ViewportBuilder};
 use egui_winit::{EventResponse, WindowSettings};
 
 use crate::{epi, Theme};
@@ -144,12 +144,10 @@ pub struct EpiIntegration {
     is_first_frame: bool,
     pub frame_start: Instant,
     pub egui_ctx: egui::Context,
-    pending_full_output: egui::FullOutput,
 
     /// When set, it is time to close the native window.
     close: bool,
 
-    can_drag_window: bool,
     follow_system_theme: bool,
     #[cfg(feature = "persistence")]
     persist_window: bool,
@@ -206,9 +204,7 @@ impl EpiIntegration {
             frame,
             last_auto_save: Instant::now(),
             egui_ctx,
-            pending_full_output: Default::default(),
             close: false,
-            can_drag_window: false,
             follow_system_theme: native_options.follow_system_theme,
             #[cfg(feature = "persistence")]
             persist_window: native_options.persist_window,
@@ -240,10 +236,14 @@ impl EpiIntegration {
         });
     }
 
+    /*
+
     /// If `true`, it is time to close the native window.
     pub fn should_close(&self) -> bool {
-        self.close
+        // self.close
+        self.egui_ctx.input(|i| i.viewport().should_close())
     }
+    */
 
     pub fn on_window_event(
         &mut self,
@@ -253,18 +253,13 @@ impl EpiIntegration {
     ) -> EventResponse {
         crate::profile_function!(egui_winit::short_window_event_description(event));
 
-        use winit::event::{ElementState, MouseButton, WindowEvent};
+        use winit::event::WindowEvent;
 
         match event {
             WindowEvent::Destroyed => {
                 log::debug!("Received WindowEvent::Destroyed");
                 self.close = true;
             }
-            WindowEvent::MouseInput {
-                button: MouseButton::Left,
-                state: ElementState::Pressed,
-                ..
-            } => self.can_drag_window = true,
             WindowEvent::ThemeChanged(winit_theme) if self.follow_system_theme => {
                 let theme = theme_from_winit_theme(*winit_theme);
                 self.frame.info.system_theme = Some(theme);
@@ -291,36 +286,32 @@ impl EpiIntegration {
     ) -> egui::FullOutput {
         raw_input.time = Some(self.beginning.elapsed().as_secs_f64());
 
-        let close_requested = raw_input.viewport().close_requested();
-
         app.raw_input_hook(&self.egui_ctx, &mut raw_input);
 
         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 is_root_viewport = viewport_ui_cb.is_none();
-        if is_root_viewport && close_requested {
-            let canceled = full_output.viewport_output[&ViewportId::ROOT]
-                .commands
-                .contains(&egui::ViewportCommand::CancelClose);
-            if canceled {
-                log::debug!("Closing of root viewport canceled with ViewportCommand::CancelClose");
-            } else {
-                log::debug!("Closing root viewport (ViewportCommand::CancelClose was not sent)");
-                self.close = true;
+            let continuous_mode = egui_ctx.options(|options| options.continuous_mode);
+            if continuous_mode {
+                let viewport_id = egui_ctx.viewport_id();
+                // TODO(rustbasic) : 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);
             }
-        }
+        });
 
-        self.pending_full_output.append(full_output);
-        std::mem::take(&mut self.pending_full_output)
+        // self.pending_full_output.append(full_output);
+        // std::mem::take(&mut self.pending_full_output)
+        full_output
     }
 
     pub fn report_frame_time(&mut self, seconds: f32) {