Simplify

crates/eframe/src/epi/mod.rs

@@ -9,7 +9,6 @@
 #[cfg(not(target_arch = "wasm32"))]
 mod icon_data;
 
-use egui::ViewportRender;
 #[cfg(not(target_arch = "wasm32"))]
 pub use icon_data::IconData;
 
@@ -113,7 +112,7 @@ pub trait App {
     /// The [`egui::Context`] can be cloned and saved if you like.
     ///
     /// To force a repaint, call [`egui::Context::request_repaint`] at any time (e.g. from another thread).
-    fn update(&mut self, ctx: &egui::Context, frame: &mut Frame, render: Option<&ViewportRender>);
+    fn update(&mut self, ctx: &egui::Context, frame: &mut Frame);
 
     /// Get a handle to the app.
     ///
@@ -805,7 +804,7 @@ impl Frame {
     /// struct MyApp;
     ///
     /// impl eframe::App for MyApp {
-    ///     fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame, _render: Option<&egui::ViewportRender>) {
+    ///     fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
     ///         // In real code the app would render something here
     ///         frame.request_screenshot();
     ///         // Things that are added to the frame after the call to

crates/eframe/src/lib.rs

@@ -32,7 +32,7 @@
 //! }
 //!
 //! impl eframe::App for MyEguiApp {
-//!    fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame, _render: Option<&egui::ViewportRender>) {
+//!    fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
 //!        egui::CentralPanel::default().show(ctx, |ui| {
 //!            ui.heading("Hello World!");
 //!        });
@@ -192,7 +192,7 @@ pub use native::file_storage::storage_dir;
 /// }
 ///
 /// impl eframe::App for MyEguiApp {
-///    fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame, _render: Option<&egui::ViewportRender>) {
+///    fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
 ///        egui::CentralPanel::default().show(ctx, |ui| {
 ///            ui.heading("Hello World!");
 ///        });
@@ -274,24 +274,13 @@ pub fn run_simple_native(
     native_options: NativeOptions,
     update_fun: impl FnMut(&egui::Context, &mut Frame) + 'static,
 ) -> Result<()> {
-    use egui::{ViewportId, ViewportRender};
-
     struct SimpleApp<U> {
         update_fun: U,
     }
 
     impl<U: FnMut(&egui::Context, &mut Frame)> App for SimpleApp<U> {
-        fn update(
+        fn update(&mut self, ctx: &egui::Context, frame: &mut Frame) {
-            &mut self,
-            ctx: &egui::Context,
-            frame: &mut Frame,
-            render: Option<&ViewportRender>,
-        ) {
-            if ctx.get_viewport_id() == ViewportId::MAIN {
             (self.update_fun)(ctx, frame);
-            } else if let Some(render_function) = render {
-                render_function(ctx);
-            }
         }
     }
 

crates/eframe/src/native/epi_integration.rs

@@ -502,7 +502,11 @@ impl EpiIntegration {
             .egui_ctx
             .run(raw_input, viewport_id, parent_id, |egui_ctx| {
                 crate::profile_scope!("App::update");
-                app.update(egui_ctx, &mut self.frame, render.as_ref().map(|r| &***r));
+                if let Some(render) = render {
+                    render(egui_ctx);
+                } else {
+                    app.update(egui_ctx, &mut self.frame);
+                }
             });
 
         self.pending_full_output.append(full_output);

crates/eframe/src/web/app_runner.rs

@@ -182,7 +182,7 @@ impl AppRunner {
         let full_output =
             self.egui_ctx
                 .run(raw_input, ViewportId::MAIN, ViewportId::MAIN, |egui_ctx| {
-                    self.app.update(egui_ctx, &mut self.frame, None);
+                    self.app.update(egui_ctx, &mut self.frame);
                 });
         let egui::FullOutput {
             platform_output,

crates/egui_demo_app/src/apps/custom3d_glow.rs

@@ -1,7 +1,7 @@
 use std::sync::Arc;
 
 use eframe::egui_glow;
-use egui::{mutex::Mutex, ViewportRender};
+use egui::mutex::Mutex;
 use egui_glow::glow;
 
 pub struct Custom3d {
@@ -21,16 +21,7 @@ impl Custom3d {
 }
 
 impl eframe::App for Custom3d {
-    fn update(
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
-        &mut self,
-        ctx: &egui::Context,
-        _frame: &mut eframe::Frame,
-        render: Option<&ViewportRender>,
-    ) {
-        if let Some(render) = render {
-            render(ctx);
-            return;
-        }
         egui::CentralPanel::default().show(ctx, |ui| {
             egui::ScrollArea::both()
                 .auto_shrink([false; 2])

crates/egui_demo_app/src/apps/custom3d_wgpu.rs

@@ -4,7 +4,6 @@ use eframe::{
     egui_wgpu::wgpu::util::DeviceExt,
     egui_wgpu::{self, wgpu},
 };
-use egui::ViewportRender;
 
 pub struct Custom3d {
     angle: f32,
@@ -97,16 +96,7 @@ impl Custom3d {
 }
 
 impl eframe::App for Custom3d {
-    fn update(
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
-        &mut self,
-        ctx: &egui::Context,
-        _frame: &mut eframe::Frame,
-        render: Option<&ViewportRender>,
-    ) {
-        if let Some(render) = render {
-            render(ctx);
-            return;
-        }
         egui::CentralPanel::default().show(ctx, |ui| {
             egui::ScrollArea::both()
                 .auto_shrink([false; 2])

crates/egui_demo_app/src/apps/http_app.rs

@@ -1,4 +1,3 @@
-use egui::ViewportRender;
 use egui_extras::RetainedImage;
 use poll_promise::Promise;
 
@@ -55,12 +54,7 @@ impl Default for HttpApp {
 }
 
 impl eframe::App for HttpApp {
-    fn update(
+    fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
-        &mut self,
-        ctx: &egui::Context,
-        frame: &mut eframe::Frame,
-        _: Option<&ViewportRender>,
-    ) {
         egui::TopBottomPanel::bottom("http_bottom").show(ctx, |ui| {
             let layout = egui::Layout::top_down(egui::Align::Center).with_main_justify(true);
             ui.allocate_ui_with_layout(ui.available_size(), layout, |ui| {

crates/egui_demo_app/src/wrap_app.rs

@@ -1,4 +1,3 @@
-use egui::ViewportRender;
 use egui_demo_lib::is_mobile;
 
 #[cfg(feature = "glow")]
@@ -14,16 +13,7 @@ struct EasyMarkApp {
 }
 
 impl eframe::App for EasyMarkApp {
-    fn update(
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
-        &mut self,
-        ctx: &egui::Context,
-        _frame: &mut eframe::Frame,
-        render: Option<&ViewportRender>,
-    ) {
-        if let Some(render) = render {
-            render(ctx);
-            return;
-        }
         self.editor.panels(ctx);
     }
 }
@@ -37,16 +27,7 @@ pub struct DemoApp {
 }
 
 impl eframe::App for DemoApp {
-    fn update(
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
-        &mut self,
-        ctx: &egui::Context,
-        _frame: &mut eframe::Frame,
-        render: Option<&ViewportRender>,
-    ) {
-        if let Some(render) = render {
-            render(ctx);
-            return;
-        }
         self.demo_windows.ui(ctx);
     }
 }
@@ -60,16 +41,7 @@ pub struct FractalClockApp {
 }
 
 impl eframe::App for FractalClockApp {
-    fn update(
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
-        &mut self,
-        ctx: &egui::Context,
-        _frame: &mut eframe::Frame,
-        render: Option<&ViewportRender>,
-    ) {
-        if let Some(render) = render {
-            render(ctx);
-            return;
-        }
         egui::CentralPanel::default()
             .frame(egui::Frame::dark_canvas(&ctx.style()))
             .show(ctx, |ui| {
@@ -88,16 +60,7 @@ pub struct ColorTestApp {
 }
 
 impl eframe::App for ColorTestApp {
-    fn update(
+    fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
-        &mut self,
-        ctx: &egui::Context,
-        frame: &mut eframe::Frame,
-        render: Option<&ViewportRender>,
-    ) {
-        if let Some(render) = render {
-            render(ctx);
-            return;
-        }
         egui::CentralPanel::default().show(ctx, |ui| {
             if frame.is_web() {
                 ui.label(
@@ -272,16 +235,7 @@ impl eframe::App for WrapApp {
         visuals.panel_fill.to_normalized_gamma_f32()
     }
 
-    fn update(
+    fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
-        &mut self,
-        ctx: &egui::Context,
-        frame: &mut eframe::Frame,
-        render: Option<&ViewportRender>,
-    ) {
-        if let Some(render) = render {
-            render(ctx);
-            return;
-        }
         #[cfg(target_arch = "wasm32")]
         if let Some(anchor) = frame.info().web_info.location.hash.strip_prefix('#') {
             let anchor = Anchor::all().into_iter().find(|x| x.to_string() == anchor);
@@ -310,7 +264,7 @@ impl eframe::App for WrapApp {
             cmd = self.backend_panel(ctx, frame);
         }
 
-        self.show_selected_app(ctx, frame, render);
+        self.show_selected_app(ctx, frame);
 
         self.state.backend_panel.end_of_frame(ctx);
 
@@ -397,16 +351,11 @@ impl WrapApp {
         });
     }
 
-    fn show_selected_app(
+    fn show_selected_app(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
-        &mut self,
-        ctx: &egui::Context,
-        frame: &mut eframe::Frame,
-        render: Option<&ViewportRender>,
-    ) {
         let selected_anchor = self.state.selected_anchor;
         for (_name, anchor, app) in self.apps_iter_mut() {
             if anchor == selected_anchor || ctx.memory(|mem| mem.everything_is_visible()) {
-                app.update(ctx, frame, render);
+                app.update(ctx, frame);
             }
         }
     }

docs/egui_demo_app.js

@@ -220,14 +220,10 @@ function makeMutClosure(arg0, arg1, dtor, f) {
 
     return real;
 }
-function __wbg_adapter_28(arg0, arg1) {
+function __wbg_adapter_30(arg0, arg1) {
-    wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h523cfda7f0d44218(arg0, arg1);
-}
-
-function __wbg_adapter_31(arg0, arg1) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h94e2299a5b82545f(retptr, arg0, arg1);
+        wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h10daae61e2d5fa23(retptr, arg0, arg1);
         var r0 = getInt32Memory0()[retptr / 4 + 0];
         var r1 = getInt32Memory0()[retptr / 4 + 1];
         if (r1) {
@@ -238,8 +234,12 @@ function __wbg_adapter_31(arg0, arg1) {
     }
 }
 
-function __wbg_adapter_34(arg0, arg1, arg2) {
+function __wbg_adapter_33(arg0, arg1, arg2) {
-    wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h64ea11302d5f5d14(arg0, arg1, addHeapObject(arg2));
+    wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hf11f8fd9c1459f8c(arg0, arg1, addHeapObject(arg2));
+}
+
+function __wbg_adapter_36(arg0, arg1) {
+    wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hccc8eda1a6d5d2ec(arg0, arg1);
 }
 
 function makeClosure(arg0, arg1, dtor, f) {
@@ -263,12 +263,12 @@ function makeClosure(arg0, arg1, dtor, f) {
 
     return real;
 }
-function __wbg_adapter_37(arg0, arg1, arg2) {
+function __wbg_adapter_39(arg0, arg1, arg2) {
-    wasm._dyn_core__ops__function__Fn__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hb124382083cfbddf(arg0, arg1, addHeapObject(arg2));
+    wasm._dyn_core__ops__function__Fn__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h4ddba6a8fff69111(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wbg_adapter_42(arg0, arg1, arg2) {
+function __wbg_adapter_44(arg0, arg1, arg2) {
-    wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hbe35f1bd5c558805(arg0, arg1, addHeapObject(arg2));
+    wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h345136054112d087(arg0, arg1, addHeapObject(arg2));
 }
 
 function handleError(f, args) {
@@ -278,8 +278,8 @@ function handleError(f, args) {
         wasm.__wbindgen_exn_store(addHeapObject(e));
     }
 }
-function __wbg_adapter_580(arg0, arg1, arg2, arg3) {
+function __wbg_adapter_586(arg0, arg1, arg2, arg3) {
-    wasm.wasm_bindgen__convert__closures__invoke2_mut__h352520d82dcfcae6(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+    wasm.wasm_bindgen__convert__closures__invoke2_mut__h515d036c962da99a(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 /**
@@ -442,12 +442,28 @@ function __wbg_get_imports() {
         getInt32Memory0()[arg0 / 4 + 1] = len1;
         getInt32Memory0()[arg0 / 4 + 0] = ptr1;
     };
+    imports.wbg.__wbindgen_number_new = function(arg0) {
+        const ret = arg0;
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbindgen_number_get = function(arg0, arg1) {
         const obj = getObject(arg1);
         const ret = typeof(obj) === 'number' ? obj : undefined;
         getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret;
         getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
     };
+    imports.wbg.__wbg_trace_822e2ec9f55bdc14 = function(arg0, arg1) {
+        console.trace(getStringFromWasm0(arg0, arg1));
+    };
+    imports.wbg.__wbg_debug_02a842456bfd3d07 = function(arg0, arg1) {
+        console.debug(getStringFromWasm0(arg0, arg1));
+    };
+    imports.wbg.__wbg_info_9914de2e2314812b = function(arg0, arg1) {
+        console.info(getStringFromWasm0(arg0, arg1));
+    };
+    imports.wbg.__wbg_warn_0d84cc9f60d72161 = function(arg0, arg1) {
+        console.warn(getStringFromWasm0(arg0, arg1));
+    };
     imports.wbg.__wbg_error_ef675d96d0bf24dc = function(arg0, arg1) {
         let deferred0_0;
         let deferred0_1;
@@ -474,18 +490,6 @@ function __wbg_get_imports() {
         const ret = getObject(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_trace_822e2ec9f55bdc14 = function(arg0, arg1) {
-        console.trace(getStringFromWasm0(arg0, arg1));
-    };
-    imports.wbg.__wbg_debug_02a842456bfd3d07 = function(arg0, arg1) {
-        console.debug(getStringFromWasm0(arg0, arg1));
-    };
-    imports.wbg.__wbg_info_9914de2e2314812b = function(arg0, arg1) {
-        console.info(getStringFromWasm0(arg0, arg1));
-    };
-    imports.wbg.__wbg_warn_0d84cc9f60d72161 = function(arg0, arg1) {
-        console.warn(getStringFromWasm0(arg0, arg1));
-    };
     imports.wbg.__wbindgen_boolean_get = function(arg0) {
         const v = getObject(arg0);
         const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
@@ -1396,6 +1400,13 @@ function __wbg_get_imports() {
         const ret = getObject(arg0).size;
         return ret;
     };
+    imports.wbg.__wbg_type_8b3fde044d705ef3 = function(arg0, arg1) {
+        const ret = getObject(arg1).type;
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len1;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr1;
+    };
     imports.wbg.__wbg_arrayBuffer_27cefaea55cbf063 = function(arg0) {
         const ret = getObject(arg0).arrayBuffer();
         return addHeapObject(ret);
@@ -1562,6 +1573,10 @@ function __wbg_get_imports() {
         const ret = getObject(arg0).getTimezoneOffset();
         return ret;
     };
+    imports.wbg.__wbg_new_cd59bfc8881f487b = function(arg0) {
+        const ret = new Date(getObject(arg0));
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_new0_c0be7df4b6bd481f = function() {
         const ret = new Date();
         return addHeapObject(ret);
@@ -1573,7 +1588,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wbg_adapter_580(a, state0.b, arg0, arg1);
+                    return __wbg_adapter_586(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -1657,28 +1672,28 @@ function __wbg_get_imports() {
         const ret = wasm.memory;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper10784 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbindgen_closure_wrapper14295 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 1464, __wbg_adapter_28);
+        const ret = makeMutClosure(arg0, arg1, 1619, __wbg_adapter_30);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper10786 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbindgen_closure_wrapper14297 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 1462, __wbg_adapter_31);
+        const ret = makeMutClosure(arg0, arg1, 1621, __wbg_adapter_33);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper10788 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbindgen_closure_wrapper14299 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 1466, __wbg_adapter_34);
+        const ret = makeMutClosure(arg0, arg1, 1617, __wbg_adapter_36);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper12539 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbindgen_closure_wrapper14985 = function(arg0, arg1, arg2) {
-        const ret = makeClosure(arg0, arg1, 1524, __wbg_adapter_37);
+        const ret = makeClosure(arg0, arg1, 1686, __wbg_adapter_39);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper12541 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbindgen_closure_wrapper14987 = function(arg0, arg1, arg2) {
-        const ret = makeClosure(arg0, arg1, 1524, __wbg_adapter_37);
+        const ret = makeClosure(arg0, arg1, 1686, __wbg_adapter_39);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper12581 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbindgen_closure_wrapper15027 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 1547, __wbg_adapter_42);
+        const ret = makeMutClosure(arg0, arg1, 1709, __wbg_adapter_44);
         return addHeapObject(ret);
     };
 

examples/confirm_exit/src/main.rs

@@ -1,6 +1,6 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
 
-use eframe::egui::{self, ViewportRender};
+use eframe::egui;
 
 fn main() -> Result<(), eframe::Error> {
     env_logger::init(); // Log to stderr (if you run with `RUST_LOG=debug`).
@@ -27,16 +27,7 @@ impl eframe::App for MyApp {
         self.allowed_to_close
     }
 
-    fn update(
+    fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
-        &mut self,
-        ctx: &egui::Context,
-        frame: &mut eframe::Frame,
-        render: Option<&ViewportRender>,
-    ) {
-        if let Some(render) = render {
-            render(ctx);
-            return;
-        }
         egui::CentralPanel::default().show(ctx, |ui| {
             ui.heading("Try to close the window");
         });

examples/custom_3d_glow/src/main.rs

@@ -1,7 +1,7 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
 #![allow(unsafe_code)]
 
-use eframe::egui::{self, ViewportRender};
+use eframe::egui;
 
 use egui::mutex::Mutex;
 use std::sync::Arc;
@@ -41,16 +41,7 @@ impl MyApp {
 }
 
 impl eframe::App for MyApp {
-    fn update(
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
-        &mut self,
-        ctx: &egui::Context,
-        _frame: &mut eframe::Frame,
-        render: Option<&ViewportRender>,
-    ) {
-        if let Some(render) = render {
-            render(ctx);
-            return;
-        }
         egui::CentralPanel::default().show(ctx, |ui| {
             ui.horizontal(|ui| {
                 ui.spacing_mut().item_spacing.x = 0.0;

examples/custom_font/src/main.rs

@@ -1,6 +1,6 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
 
-use eframe::egui::{self, ViewportRender};
+use eframe::egui;
 
 fn main() -> Result<(), eframe::Error> {
     env_logger::init(); // Log to stderr (if you run with `RUST_LOG=debug`).
@@ -60,16 +60,7 @@ impl MyApp {
 }
 
 impl eframe::App for MyApp {
-    fn update(
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
-        &mut self,
-        ctx: &egui::Context,
-        _frame: &mut eframe::Frame,
-        render: Option<&ViewportRender>,
-    ) {
-        if let Some(render) = render {
-            render(ctx);
-            return;
-        }
         egui::CentralPanel::default().show(ctx, |ui| {
             ui.heading("egui using custom fonts");
             ui.text_edit_multiline(&mut self.text);

examples/custom_font_style/src/main.rs

@@ -1,6 +1,6 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
 
-use eframe::egui::{self, ViewportRender};
+use eframe::egui;
 use egui::{FontFamily, FontId, RichText, TextStyle};
 
 fn main() -> Result<(), eframe::Error> {
@@ -64,16 +64,7 @@ impl MyApp {
 }
 
 impl eframe::App for MyApp {
-    fn update(
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
-        &mut self,
-        ctx: &egui::Context,
-        _frame: &mut eframe::Frame,
-        render: Option<&ViewportRender>,
-    ) {
-        if let Some(render) = render {
-            render(ctx);
-            return;
-        }
         egui::CentralPanel::default().show(ctx, content);
     }
 }

examples/custom_window_frame/src/main.rs

@@ -2,7 +2,7 @@
 
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
 
-use eframe::egui::{self, ViewportRender};
+use eframe::egui;
 
 fn main() -> Result<(), eframe::Error> {
     env_logger::init(); // Log to stderr (if you run with `RUST_LOG=debug`).
@@ -30,16 +30,7 @@ impl eframe::App for MyApp {
         egui::Rgba::TRANSPARENT.to_array() // Make sure we don't paint anything behind the rounded corners
     }
 
-    fn update(
+    fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
-        &mut self,
-        ctx: &egui::Context,
-        frame: &mut eframe::Frame,
-        render: Option<&ViewportRender>,
-    ) {
-        if let Some(render) = render {
-            render(ctx);
-            return;
-        }
         custom_window_frame(ctx, frame, "egui with custom frame", |ui| {
             ui.label("This is just the contents of the window.");
             ui.horizontal(|ui| {

examples/download_image/src/main.rs

@@ -1,6 +1,6 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
 
-use eframe::egui::{self, ViewportRender};
+use eframe::egui;
 use egui_extras::RetainedImage;
 use poll_promise::Promise;
 
@@ -21,16 +21,7 @@ struct MyApp {
 }
 
 impl eframe::App for MyApp {
-    fn update(
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
-        &mut self,
-        ctx: &egui::Context,
-        _frame: &mut eframe::Frame,
-        render: Option<&ViewportRender>,
-    ) {
-        if let Some(render) = render {
-            render(ctx);
-            return;
-        }
         let promise = self.promise.get_or_insert_with(|| {
             // Begin download.
             // We download the image using `ehttp`, a library that works both in WASM and on native.

examples/file_dialog/src/main.rs

@@ -1,6 +1,6 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
 
-use eframe::egui::{self, ViewportRender};
+use eframe::egui;
 
 fn main() -> Result<(), eframe::Error> {
     env_logger::init(); // Log to stderr (if you run with `RUST_LOG=debug`).
@@ -23,16 +23,7 @@ struct MyApp {
 }
 
 impl eframe::App for MyApp {
-    fn update(
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
-        &mut self,
-        ctx: &egui::Context,
-        _frame: &mut eframe::Frame,
-        render: Option<&ViewportRender>,
-    ) {
-        if let Some(render) = render {
-            render(ctx);
-            return;
-        }
         egui::CentralPanel::default().show(ctx, |ui| {
             ui.label("Drag-and-drop files onto the window!");
 

examples/hello_world/src/main.rs

@@ -1,6 +1,6 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
 
-use eframe::egui::{self, ViewportRender};
+use eframe::egui;
 
 fn main() -> Result<(), eframe::Error> {
     env_logger::init(); // Log to stderr (if you run with `RUST_LOG=debug`).
@@ -30,12 +30,7 @@ impl Default for MyApp {
 }
 
 impl eframe::App for MyApp {
-    fn update(
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
-        &mut self,
-        ctx: &egui::Context,
-        _frame: &mut eframe::Frame,
-        _: Option<&ViewportRender>,
-    ) {
         egui::CentralPanel::default().show(ctx, |ui| {
             ui.heading("My egui Application");
             ui.horizontal(|ui| {

examples/hello_world_par/src/main.rs

@@ -5,7 +5,7 @@
 use std::sync::mpsc;
 use std::thread::JoinHandle;
 
-use eframe::egui::{self, ViewportRender};
+use eframe::egui;
 
 fn main() -> Result<(), eframe::Error> {
     env_logger::init(); // Log to stderr (if you run with `RUST_LOG=debug`).
@@ -115,12 +115,7 @@ impl std::ops::Drop for MyApp {
 }
 
 impl eframe::App for MyApp {
-    fn update(
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
-        &mut self,
-        ctx: &egui::Context,
-        _frame: &mut eframe::Frame,
-        _: Option<&ViewportRender>,
-    ) {
         egui::Window::new("Main thread").show(ctx, |ui| {
             if ui.button("Spawn another thread").clicked() {
                 self.spawn_thread();

examples/keyboard_events/src/main.rs

@@ -19,16 +19,7 @@ struct Content {
 }
 
 impl eframe::App for Content {
-    fn update(
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
-        &mut self,
-        ctx: &egui::Context,
-        _frame: &mut eframe::Frame,
-        render: Option<&ViewportRender>,
-    ) {
-        if let Some(render) = render {
-            render(ctx);
-            return;
-        }
         egui::CentralPanel::default().show(ctx, |ui| {
             ui.heading("Press/Hold/Release example. Press A to test.");
             if ui.button("Clear").clicked() {

examples/puffin_profiler/src/main.rs

@@ -1,6 +1,6 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
 
-use eframe::egui::{self, ViewportRender};
+use eframe::egui::{self};
 
 fn main() -> Result<(), eframe::Error> {
     env_logger::init(); // Log to stderr (if you run with `RUST_LOG=debug`).
@@ -17,16 +17,7 @@ fn main() -> Result<(), eframe::Error> {
 struct MyApp {}
 
 impl eframe::App for MyApp {
-    fn update(
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
-        &mut self,
-        ctx: &egui::Context,
-        _frame: &mut eframe::Frame,
-        render: Option<&ViewportRender>,
-    ) {
-        if let Some(render) = render {
-            render(ctx);
-            return;
-        }
         egui::CentralPanel::default().show(ctx, |ui| {
             ui.heading("Example of how to use the puffin profiler with egui");
             ui.separator();

examples/retained_image/src/main.rs

@@ -1,6 +1,6 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
 
-use eframe::egui::{self, ViewportRender};
+use eframe::egui::{self};
 use egui_extras::RetainedImage;
 
 fn main() -> Result<(), eframe::Error> {
@@ -34,17 +34,7 @@ impl Default for MyApp {
 }
 
 impl eframe::App for MyApp {
-    fn update(
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
-        &mut self,
-        ctx: &egui::Context,
-        _frame: &mut eframe::Frame,
-        render: Option<&ViewportRender>,
-    ) {
-        if let Some(render) = render {
-            render(ctx);
-            return;
-        }
-
         let Self {
             image,
             rounding,

examples/save_plot/src/main.rs

@@ -1,7 +1,7 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
 
 use eframe::egui::ColorImage;
-use eframe::egui::{self, ViewportRender};
+use eframe::egui::{self};
 use egui_plot::{Legend, Line, Plot, PlotPoints};
 
 fn main() -> Result<(), eframe::Error> {
@@ -24,16 +24,7 @@ struct MyApp {
 }
 
 impl eframe::App for MyApp {
-    fn update(
+    fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
-        &mut self,
-        ctx: &egui::Context,
-        frame: &mut eframe::Frame,
-        render: Option<&ViewportRender>,
-    ) {
-        if let Some(render) = render {
-            render(ctx);
-            return;
-        }
         let mut plot_rect = None;
         egui::CentralPanel::default().show(ctx, |ui| {
             // these are just some dummy variables for the example,

examples/screenshot/src/main.rs

@@ -1,6 +1,6 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
 
-use eframe::egui::{self, ColorImage, ViewportRender};
+use eframe::egui::{self, ColorImage};
 
 fn main() -> Result<(), eframe::Error> {
     env_logger::init(); // Log to stderr (if you run with `RUST_LOG=debug`).
@@ -24,16 +24,7 @@ struct MyApp {
 }
 
 impl eframe::App for MyApp {
-    fn update(
+    fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
-        &mut self,
-        ctx: &egui::Context,
-        frame: &mut eframe::Frame,
-        render: Option<&ViewportRender>,
-    ) {
-        if let Some(render) = render {
-            render(ctx);
-            return;
-        }
         egui::CentralPanel::default().show(ctx, |ui| {
             if let Some(screenshot) = self.screenshot.take() {
                 self.texture = Some(ui.ctx().load_texture(

examples/serial_windows/src/main.rs

@@ -1,6 +1,6 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
 
-use eframe::egui::{self, ViewportRender};
+use eframe::egui::{self};
 
 fn main() -> Result<(), eframe::Error> {
     env_logger::init(); // Log to stderr (if you run with `RUST_LOG=debug`).
@@ -46,16 +46,7 @@ struct MyApp {
 }
 
 impl eframe::App for MyApp {
-    fn update(
+    fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
-        &mut self,
-        ctx: &egui::Context,
-        frame: &mut eframe::Frame,
-        render: Option<&ViewportRender>,
-    ) {
-        if let Some(render) = render {
-            render(ctx);
-            return;
-        }
         egui::CentralPanel::default().show(ctx, |ui| {
             let label_text = if self.has_next {
                 "When this window is closed the next will be opened after a short delay"

examples/svg/src/main.rs

@@ -4,7 +4,7 @@
 
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
 
-use eframe::egui::{self, ViewportRender};
+use eframe::egui;
 
 fn main() -> Result<(), eframe::Error> {
     env_logger::init(); // Log to stderr (if you run with `RUST_LOG=debug`).
@@ -37,16 +37,7 @@ impl Default for MyApp {
 }
 
 impl eframe::App for MyApp {
-    fn update(
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
-        &mut self,
-        ctx: &egui::Context,
-        _frame: &mut eframe::Frame,
-        render: Option<&ViewportRender>,
-    ) {
-        if let Some(render) = render {
-            render(ctx);
-            return;
-        }
         egui::CentralPanel::default().show(ctx, |ui| {
             ui.heading("SVG example");
             ui.label("The SVG is rasterized and displayed as a texture.");

examples/user_attention/src/main.rs

@@ -1,5 +1,5 @@
 use eframe::{
-    egui::{Button, CentralPanel, Context, UserAttentionType, ViewportRender},
+    egui::{Button, CentralPanel, Context, UserAttentionType},
     CreationContext, NativeOptions,
 };
 
@@ -54,16 +54,7 @@ impl Application {
 }
 
 impl eframe::App for Application {
-    fn update(
+    fn update(&mut self, ctx: &Context, frame: &mut eframe::Frame) {
-        &mut self,
-        ctx: &Context,
-        frame: &mut eframe::Frame,
-        render: Option<&ViewportRender>,
-    ) {
-        if let Some(render) = render {
-            render(ctx);
-            return;
-        }
         if let Some(request_at) = self.request_at {
             if request_at < SystemTime::now() {
                 self.request_at = None;

examples/viewports/src/main.rs

@@ -32,19 +32,7 @@ pub struct App {
 }
 
 impl eframe::App for App {
-    fn update(
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
-        &mut self,
-        ctx: &egui::Context,
-        _frame: &mut eframe::Frame,
-        render_function: Option<&egui::ViewportRender>,
-    ) {
-        // This needs to be like this to be able to show stuf on a async viewport
-        if let Some(render) = render_function {
-            // This is the render function for the current async viewport
-            render(ctx);
-            return;
-        }
-
         egui::CentralPanel::default().show(ctx, |ui| {
             ui_info(ui);
             ui.label("Look at the \"Frame: \" will tell you, what viewport is rendering!");