Reduce indentation by making some function non-members

crates/eframe/src/native/run.rs

@@ -897,18 +897,22 @@ mod glow_integration {
             let mut active_viewports_ids = ViewportIdSet::default();
             active_viewports_ids.insert(ViewportId::ROOT);
 
+            // Process existing viewpors:
             viewports.retain_mut(
                 |ViewportOutput {
                      builder: new_builder,
-                     id_pair: ViewportIdPair { this: id, parent },
+                     id_pair,
                      viewport_ui_cb,
                  }| {
-                    let builder = self.builders.entry(*id).or_insert(new_builder.clone());
+                    let builder = self
+                        .builders
+                        .entry(id_pair.this)
+                        .or_insert(new_builder.clone());
                     let (commands, recreate) = builder.patch(new_builder);
-                    if let Some(viewport) = self.viewports.get(id) {
+                    if let Some(viewport) = self.viewports.get(&id_pair.this) {
                         let mut viewport = viewport.borrow_mut();
 
-                        viewport.id_pair.parent = *parent;
+                        viewport.id_pair.parent = id_pair.parent;
                         viewport.viewport_ui_cb = viewport_ui_cb.clone(); // always update the latest callback
 
                         if recreate {
@@ -922,7 +926,7 @@ mod glow_integration {
                                 is_viewport_focused,
                             );
                         }
-                        active_viewports_ids.insert(*id);
+                        active_viewports_ids.insert(id_pair.this);
                         false
                     } else {
                         true
@@ -930,6 +934,7 @@ mod glow_integration {
                 },
             );
 
+            // Process new viewports:
             for ViewportOutput {
                 mut builder,
                 id_pair,
@@ -959,6 +964,7 @@ mod glow_integration {
                 active_viewports_ids.insert(id_pair.this);
             }
 
+            // GC old viewports
             self.viewports
                 .retain(|id, _| active_viewports_ids.contains(id));
             self.builders
@@ -1190,7 +1196,7 @@ mod glow_integration {
                             #[allow(unsafe_code)]
                             let event_loop = unsafe { event_loop.as_ref().unwrap() };
 
-                            Self::render_immediate_viewport(
+                            render_immediate_viewport(
                                 event_loop,
                                 egui_ctx,
                                 viewport_builder,
@@ -1218,6 +1224,7 @@ mod glow_integration {
 
             Ok(())
         }
+    }
 
     /// This is called (via a callback) by user code to render immediate viewports,
     /// i.e. viewport that are directly nested inside a parent viewport.
@@ -1259,9 +1266,9 @@ mod glow_integration {
                 .entry(id_pair.this)
                 .or_insert(viewport_builder);
 
-                glutin.init_viewport(id_pair.this, event_loop).expect(
+            glutin
-                    "Failed to initialize window in egui::Context::show_viewport_immediate",
+                .init_viewport(id_pair.this, event_loop)
-                );
+                .expect("Failed to initialize window in egui::Context::show_viewport_immediate");
         }
 
         let viewport = glutin.borrow().viewports.get(&id_pair.this).cloned();
@@ -1344,13 +1351,7 @@ mod glow_integration {
             }
         }
 
-            winit_state.handle_platform_output(
+        winit_state.handle_platform_output(&window, id_pair.this, egui_ctx, output.platform_output);
-                &window,
-                id_pair.this,
-                egui_ctx,
-                output.platform_output,
-            );
-        }
     }
 
     impl WinitApp for GlowWinitApp {
@@ -1378,17 +1379,14 @@ mod glow_integration {
         }
 
         fn window(&self, window_id: WindowId) -> Option<Rc<RefCell<winit::window::Window>>> {
-            self.running.as_ref().and_then(|r| {
+            let running = self.running.as_ref()?;
-                let glutin_ctx = r.glutin_ctx.borrow();
+            let glutin_ctx = running.glutin_ctx.borrow();
-                if let Some(viewport_id) = glutin_ctx.viewport_maps.get(&window_id) {
+            let viewport_id = *glutin_ctx.viewport_maps.get(&window_id)?;
-                    if let Some(viewport) = glutin_ctx.viewports.get(viewport_id) {
+            if let Some(viewport) = glutin_ctx.viewports.get(&viewport_id) {
-                        if let Some(window) = viewport.borrow().window.as_ref() {
+                viewport.borrow().window.clone()
-                            return Some(window.clone());
+            } else {
-                        }
-                    }
-                }
                 None
-            })
+            }
         }
 
         fn window_id_from_viewport_id(&self, id: ViewportId) -> Option<WindowId> {
@@ -1404,7 +1402,6 @@ mod glow_integration {
         }
 
         fn save_and_destroy(&mut self) {
-            crate::profile_function!();
             if let Some(mut running) = self.running.take() {
                 crate::profile_function!();
 
@@ -1920,29 +1917,6 @@ mod wgpu_integration {
             }
         }
 
-        fn create_window(
-            event_loop: &EventLoopWindowTarget<UserEvent>,
-            storage: Option<&dyn epi::Storage>,
-            title: &str,
-            native_options: &mut NativeOptions,
-        ) -> Result<(winit::window::Window, ViewportBuilder), winit::error::OsError> {
-            crate::profile_function!();
-
-            let window_settings = epi_integration::load_window_settings(storage);
-            let window_builder =
-                epi_integration::window_builder(event_loop, title, native_options, window_settings);
-            let window = {
-                crate::profile_scope!("WindowBuilder::build");
-                create_winit_window_builder(&window_builder).build(event_loop)?
-            };
-            epi_integration::apply_native_options_to_window(
-                &window,
-                native_options,
-                window_settings,
-            );
-            Ok((window, window_builder))
-        }
-
         fn build_windows(&mut self, event_loop: &EventLoopWindowTarget<UserEvent>) {
             let Some(running) = &mut self.running else {
                 return;
@@ -1961,7 +1935,7 @@ mod wgpu_integration {
                     continue;
                 }
 
-                Self::init_window(
+                init_window(
                     *id,
                     builder,
                     viewport_maps,
@@ -1973,34 +1947,6 @@ mod wgpu_integration {
             }
         }
 
-        fn init_window(
-            id: ViewportId,
-            builder: &ViewportBuilder,
-            windows_id: &mut HashMap<winit::window::WindowId, ViewportId>,
-            painter: &mut egui_wgpu::winit::Painter,
-            window: &mut Option<Rc<RefCell<winit::window::Window>>>,
-            egui_winit: &mut Option<egui_winit::State>,
-            event_loop: &EventLoopWindowTarget<UserEvent>,
-        ) {
-            crate::profile_function!();
-
-            if let Ok(new_window) = create_winit_window_builder(builder).build(event_loop) {
-                windows_id.insert(new_window.id(), id);
-
-                if let Err(err) = pollster::block_on(painter.set_window(id, Some(&new_window))) {
-                    log::error!("on set_window: viewport_id {id:?} {err}");
-                }
-
-                *egui_winit = Some(egui_winit::State::new(
-                    event_loop,
-                    Some(new_window.scale_factor() as f32),
-                    painter.max_texture_side(),
-                ));
-
-                *window = Some(Rc::new(RefCell::new(new_window)));
-            }
-        }
-
         fn set_window(&mut self, id: ViewportId) -> Result<(), egui_wgpu::WgpuError> {
             if let Some(running) = &mut self.running {
                 crate::profile_function!();
@@ -2160,7 +2106,7 @@ mod wgpu_integration {
                             #[allow(unsafe_code)]
                             let event_loop = unsafe { event_loop.as_ref().unwrap() };
 
-                            Self::render_immediate_viewport(
+                            render_immediate_viewport(
                                 event_loop,
                                 egui_ctx,
                                 viewport_builder,
@@ -2184,6 +2130,54 @@ mod wgpu_integration {
 
             Ok(())
         }
+    }
+
+    fn create_window(
+        event_loop: &EventLoopWindowTarget<UserEvent>,
+        storage: Option<&dyn epi::Storage>,
+        title: &str,
+        native_options: &mut NativeOptions,
+    ) -> Result<(winit::window::Window, ViewportBuilder), winit::error::OsError> {
+        crate::profile_function!();
+
+        let window_settings = epi_integration::load_window_settings(storage);
+        let window_builder =
+            epi_integration::window_builder(event_loop, title, native_options, window_settings);
+        let window = {
+            crate::profile_scope!("WindowBuilder::build");
+            create_winit_window_builder(&window_builder).build(event_loop)?
+        };
+        epi_integration::apply_native_options_to_window(&window, native_options, window_settings);
+        Ok((window, window_builder))
+    }
+
+    fn init_window(
+        id: ViewportId,
+        builder: &ViewportBuilder,
+        windows_id: &mut HashMap<winit::window::WindowId, ViewportId>,
+        painter: &mut egui_wgpu::winit::Painter,
+        window: &mut Option<Rc<RefCell<winit::window::Window>>>,
+        egui_winit: &mut Option<egui_winit::State>,
+        event_loop: &EventLoopWindowTarget<UserEvent>,
+    ) {
+        crate::profile_function!();
+
+        if let Ok(new_window) = create_winit_window_builder(builder).build(event_loop) {
+            windows_id.insert(new_window.id(), id);
+
+            if let Err(err) = pollster::block_on(painter.set_window(id, Some(&new_window))) {
+                log::error!("on set_window: viewport_id {id:?} {err}");
+            }
+
+            *egui_winit = Some(egui_winit::State::new(
+                event_loop,
+                Some(new_window.scale_factor() as f32),
+                painter.max_texture_side(),
+            ));
+
+            *window = Some(Rc::new(RefCell::new(new_window)));
+        }
+    }
 
     #[inline(always)]
     #[allow(clippy::too_many_arguments)]
@@ -2210,8 +2204,7 @@ mod wgpu_integration {
             // Creating a new native window if is needed
             if !viewports.contains_key(&id_pair.this) {
                 {
-                        if viewport_builder.icon.is_none() && builders.get(&id_pair.this).is_none()
+                    if viewport_builder.icon.is_none() && builders.get(&id_pair.this).is_none() {
-                        {
                         viewport_builder.icon =
                             builders.get(&id_pair.parent).and_then(|b| b.icon.clone());
                     }
@@ -2231,7 +2224,7 @@ mod wgpu_integration {
                     .entry(id_pair.this)
                     .or_insert(viewport_builder.clone());
 
-                    Self::init_window(
+                init_window(
                     id_pair.this,
                     &viewport_builder,
                     viewport_maps,
@@ -2299,13 +2292,7 @@ mod wgpu_integration {
             false,
         );
 
-            winit_state.handle_platform_output(
+        winit_state.handle_platform_output(&window, id_pair.this, egui_ctx, output.platform_output);
-                &window,
-                id_pair.this,
-                egui_ctx,
-                output.platform_output,
-            );
-        }
     }
 
     impl WinitApp for WgpuWinitApp {
@@ -2355,9 +2342,9 @@ mod wgpu_integration {
         }
 
         fn save_and_destroy(&mut self) {
+            if let Some(mut running) = self.running.take() {
                 crate::profile_function!();
 
-            if let Some(mut running) = self.running.take() {
                 let mut shared = running.shared.borrow_mut();
                 if let Some(Viewport { window, .. }) = shared.viewports.get(&ViewportId::ROOT) {
                     running.integration.save(
@@ -2618,7 +2605,7 @@ mod wgpu_integration {
                             .viewports
                             .contains_key(&ViewportId::ROOT)
                         {
-                            let _ = Self::create_window(
+                            let _ = create_window(
                                 event_loop,
                                 running.integration.frame.storage(),
                                 &self.app_name,
@@ -2633,7 +2620,7 @@ mod wgpu_integration {
                                 .as_ref()
                                 .unwrap_or(&self.app_name),
                         );
-                        let (window, builder) = Self::create_window(
+                        let (window, builder) = create_window(
                             event_loop,
                             storage.as_deref(),
                             &self.app_name,