From f0b7737bdf5bf875876cb44550ad54fe48150a20 Mon Sep 17 00:00:00 2001
From: rustbasic <127506429+rustbasic@users.noreply.github.com>
Date: Sat, 23 Mar 2024 15:37:56 +0900
Subject: [PATCH 01/10] Update memory.rs

---
 crates/egui/src/memory.rs | 1233 ++++++++++---------------------------
 1 file changed, 321 insertions(+), 912 deletions(-)

diff --git a/crates/egui/src/memory.rs b/crates/egui/src/memory.rs
index 068347b5697..1fa349b2a05 100644
--- a/crates/egui/src/memory.rs
+++ b/crates/egui/src/memory.rs
@@ -1,1003 +1,412 @@
-#![warn(missing_docs)] // Let's keep this file well-documented.` to memory.rs
+//! Common tools used by [`super::glow_integration`] and [`super::wgpu_integration`].
 
-use ahash::HashMap;
-use epaint::emath::TSTransform;
+use web_time::Instant;
+use winit::event_loop::EventLoopWindowTarget;
 
-use crate::{
-    area, vec2, EventFilter, Id, IdMap, LayerId, Order, Pos2, Rangef, RawInput, Rect, Style, Vec2,
-    ViewportId, ViewportIdMap, ViewportIdSet,
-};
+use raw_window_handle::{HasDisplayHandle as _, HasWindowHandle as _};
 
-// ----------------------------------------------------------------------------
+use egui::{DeferredViewportUiCallback, NumExt as _, ViewportBuilder, ViewportId};
+use egui_winit::{EventResponse, WindowSettings};
 
-/// The data that egui persists between frames.
-///
-/// This includes window positions and sizes,
-/// how far the user has scrolled in a [`ScrollArea`](crate::ScrollArea) etc.
-///
-/// If you want this to persist when closing your app you should serialize [`Memory`] and store it.
-/// For this you need to enable the `persistence`.
-///
-/// If you want to store data for your widgets, you should look at [`Memory::data`]
-#[derive(Clone, Debug)]
-#[cfg_attr(feature = "persistence", derive(serde::Deserialize, serde::Serialize))]
-#[cfg_attr(feature = "persistence", serde(default))]
-pub struct Memory {
-    /// Global egui options.
-    pub options: Options,
-
-    /// This map stores some superficial state for all widgets with custom [`Id`]s.
-    ///
-    /// This includes storing if a [`crate::CollapsingHeader`] is open, how far scrolled a
-    /// [`crate::ScrollArea`] is, where the cursor in a [`crate::TextEdit`] is, etc.
-    ///
-    /// This is NOT meant to store any important data. Store that in your own structures!
-    ///
-    /// Each read clones the data, so keep your values cheap to clone.
-    /// If you want to store a lot of data you should wrap it in `Arc<Mutex<…>>` so it is cheap to clone.
-    ///
-    /// This will be saved between different program runs if you use the `persistence` feature.
-    ///
-    /// To store a state common for all your widgets (a singleton), use [`Id::NULL`] as the key.
-    pub data: crate::util::IdTypeMap,
+use crate::{epi, Theme};
 
-    // ------------------------------------------
-    /// Can be used to cache computations from one frame to another.
-    ///
-    /// This is for saving CPU when you have something that may take 1-100ms to compute.
-    /// Things that are very slow (>100ms) should instead be done async (i.e. in another thread)
-    /// so as not to lock the UI thread.
-    ///
-    /// ```
-    /// use egui::util::cache::{ComputerMut, FrameCache};
-    ///
-    /// #[derive(Default)]
-    /// struct CharCounter {}
-    /// impl ComputerMut<&str, usize> for CharCounter {
-    ///     fn compute(&mut self, s: &str) -> usize {
-    ///         s.chars().count() // you probably want to cache something more expensive than this
-    ///     }
-    /// }
-    /// type CharCountCache<'a> = FrameCache<usize, CharCounter>;
-    ///
-    /// # let mut ctx = egui::Context::default();
-    /// ctx.memory_mut(|mem| {
-    ///     let cache = mem.caches.cache::<CharCountCache<'_>>();
-    ///     assert_eq!(cache.get("hello"), 5);
-    /// });
-    /// ```
-    #[cfg_attr(feature = "persistence", serde(skip))]
-    pub caches: crate::util::cache::CacheStorage,
-
-    // ------------------------------------------
-    /// 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>,
-
-    // Current active viewport
-    #[cfg_attr(feature = "persistence", serde(skip))]
-    pub(crate) viewport_id: ViewportId,
-
-    /// Which popup-window is open (if any)?
-    /// Could be a combo box, color picker, menu etc.
-    #[cfg_attr(feature = "persistence", serde(skip))]
-    popup: Option<Id>,
-
-    #[cfg_attr(feature = "persistence", serde(skip))]
-    everything_is_visible: bool,
-
-    /// Transforms per layer
-    pub layer_transforms: HashMap<LayerId, TSTransform>,
-
-    // -------------------------------------------------
-    // Per-viewport:
-    areas: ViewportIdMap<Areas>,
-
-    #[cfg_attr(feature = "persistence", serde(skip))]
-    pub(crate) interactions: ViewportIdMap<InteractionState>,
-
-    #[cfg_attr(feature = "persistence", serde(skip))]
-    pub(crate) focus: ViewportIdMap<Focus>,
-}
+pub fn viewport_builder<E>(
+    egui_zoom_factor: f32,
+    event_loop: &EventLoopWindowTarget<E>,
+    native_options: &mut epi::NativeOptions,
+    window_settings: Option<WindowSettings>,
+) -> ViewportBuilder {
+    crate::profile_function!();
 
-impl Default for Memory {
-    fn default() -> Self {
-        let mut slf = Self {
-            options: Default::default(),
-            data: Default::default(),
-            caches: Default::default(),
-            new_font_definitions: Default::default(),
-            interactions: Default::default(),
-            focus: Default::default(),
-            viewport_id: Default::default(),
-            areas: Default::default(),
-            layer_transforms: Default::default(),
-            popup: Default::default(),
-            everything_is_visible: Default::default(),
-        };
-        slf.interactions.entry(slf.viewport_id).or_default();
-        slf.areas.entry(slf.viewport_id).or_default();
-        slf
-    }
-}
+    let mut viewport_builder = native_options.viewport.clone();
 
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
-enum FocusDirection {
-    /// Select the widget closest above the current focused widget.
-    Up,
+    // Always use the default window size / position on iOS. Trying to restore the previous position
+    // causes the window to be shown too small.
+    #[cfg(not(target_os = "ios"))]
+    let inner_size_points = if let Some(mut window_settings) = window_settings {
+        // Restore pos/size from previous session
 
-    /// Select the widget to the right of the current focused widget.
-    Right,
+        window_settings
+            .clamp_size_to_sane_values(largest_monitor_point_size(egui_zoom_factor, event_loop));
+        window_settings.clamp_position_to_monitors(egui_zoom_factor, event_loop);
 
-    /// Select the widget below the current focused widget.
-    Down,
-
-    /// Select the widget to the left of the the current focused widget.
-    Left,
+        viewport_builder = window_settings.initialize_viewport_builder(viewport_builder);
+        window_settings.inner_size_points()
+    } else {
+        if let Some(pos) = viewport_builder.position {
+            viewport_builder = viewport_builder.with_position(pos);
+        }
 
-    /// Select the previous widget that had focus.
-    Previous,
+        if let Some(initial_window_size) = viewport_builder.inner_size {
+            let initial_window_size = initial_window_size
+                .at_most(largest_monitor_point_size(egui_zoom_factor, event_loop));
+            viewport_builder = viewport_builder.with_inner_size(initial_window_size);
+        }
 
-    /// Select the next widget that wants focus.
-    Next,
+        viewport_builder.inner_size
+    };
+
+    #[cfg(not(target_os = "ios"))]
+    if native_options.centered {
+        crate::profile_scope!("center");
+        if let Some(monitor) = event_loop.available_monitors().next() {
+            let monitor_size = monitor
+                .size()
+                .to_logical::<f32>(egui_zoom_factor as f64 * monitor.scale_factor());
+            let inner_size = inner_size_points.unwrap_or(egui::Vec2 { x: 800.0, y: 600.0 });
+            if 0.0 < monitor_size.width && 0.0 < monitor_size.height {
+                let x = (monitor_size.width - inner_size.x) / 2.0;
+                let y = (monitor_size.height - inner_size.y) / 2.0;
+                viewport_builder = viewport_builder.with_position([x, y]);
+            }
+        }
+    }
 
-    /// Don't change focus.
-    #[default]
-    None,
+    match std::mem::take(&mut native_options.window_builder) {
+        Some(hook) => hook(viewport_builder),
+        None => viewport_builder,
+    }
 }
 
-impl FocusDirection {
-    fn is_cardinal(&self) -> bool {
-        match self {
-            Self::Up | Self::Right | Self::Down | Self::Left => true,
+pub fn apply_window_settings(
+    window: &winit::window::Window,
+    window_settings: Option<WindowSettings>,
+) {
+    crate::profile_function!();
 
-            Self::Previous | Self::Next | Self::None => false,
-        }
+    if let Some(window_settings) = window_settings {
+        window_settings.initialize_window(window);
     }
 }
 
-// ----------------------------------------------------------------------------
-
-/// Some global options that you can read and write.
-///
-/// See also [`crate::style::DebugOptions`].
-#[derive(Clone, Debug, PartialEq)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-#[cfg_attr(feature = "serde", serde(default))]
-pub struct Options {
-    /// The default style for new [`Ui`](crate::Ui):s.
-    #[cfg_attr(feature = "serde", serde(skip))]
-    pub(crate) style: std::sync::Arc<Style>,
-
-    /// Global zoom factor of the UI.
-    ///
-    /// This is used to calculate the `pixels_per_point`
-    /// for the UI as `pixels_per_point = zoom_fator * native_pixels_per_point`.
-    ///
-    /// The default is 1.0.
-    /// Make larger to make everything larger.
-    ///
-    /// Please call [`crate::Context::set_zoom_factor`]
-    /// instead of modifying this directly!
-    pub zoom_factor: f32,
-
-    /// If `true`, egui will change the scale of the ui ([`crate::Context::zoom_factor`]) when the user
-    /// presses Cmd+Plus, Cmd+Minus or Cmd+0, just like in a browser.
-    ///
-    /// This is `true` by default.
-    #[cfg_attr(feature = "serde", serde(skip))]
-    pub zoom_with_keyboard: bool,
+fn largest_monitor_point_size<E>(
+    egui_zoom_factor: f32,
+    event_loop: &EventLoopWindowTarget<E>,
+) -> egui::Vec2 {
+    crate::profile_function!();
 
-    /// Controls the tessellator.
-    pub tessellation_options: epaint::TessellationOptions,
+    let mut max_size = egui::Vec2::ZERO;
 
-    /// If any widget moves or changes id, repaint everything.
-    ///
-    /// It is recommended you keep this OFF, because
-    /// it is know to cause endless repaints, for unknown reasons
-    /// (<https://github.com/rerun-io/rerun/issues/5018>).
-    pub repaint_on_widget_change: bool,
+    let available_monitors = {
+        crate::profile_scope!("available_monitors");
+        event_loop.available_monitors()
+    };
 
-    /// This is a signal to any backend that we want the [`crate::PlatformOutput::events`] read out loud.
-    ///
-    /// The only change to egui is that labels can be focused by pressing tab.
-    ///
-    /// Screen readers is an experimental feature of egui, and not supported on all platforms.
-    ///
-    /// `eframe` supports it only on web,
-    /// but you should consider using [AccessKit](https://github.com/AccessKit/accesskit) instead,
-    /// which `eframe` supports.
-    pub screen_reader: bool,
-
-    /// If true, the most common glyphs (ASCII) are pre-rendered to the texture atlas.
-    ///
-    /// Only the fonts in [`Style::text_styles`] will be pre-cached.
-    ///
-    /// This can lead to fewer texture operations, but may use up the texture atlas quicker
-    /// if you are changing [`Style::text_styles`], of have a lot of text styles.
-    pub preload_font_glyphs: bool,
-
-    /// Check reusing of [`Id`]s, and show a visual warning on screen when one is found.
-    ///
-    /// By default this is `true` in debug builds.
-    pub warn_on_id_clash: bool,
-}
+    for monitor in available_monitors {
+        let size = monitor
+            .size()
+            .to_logical::<f32>(egui_zoom_factor as f64 * monitor.scale_factor());
+        let size = egui::vec2(size.width, size.height);
+        max_size = max_size.max(size);
+    }
 
-impl Default for Options {
-    fn default() -> Self {
-        Self {
-            style: Default::default(),
-            zoom_factor: 1.0,
-            zoom_with_keyboard: true,
-            tessellation_options: Default::default(),
-            repaint_on_widget_change: false,
-            screen_reader: false,
-            preload_font_glyphs: true,
-            warn_on_id_clash: cfg!(debug_assertions),
-        }
+    if max_size == egui::Vec2::ZERO {
+        egui::Vec2::splat(16000.0)
+    } else {
+        max_size
     }
 }
 
-impl Options {
-    /// Show the options in the ui.
-    pub fn ui(&mut self, ui: &mut crate::Ui) {
-        let Self {
-            style,          // covered above
-            zoom_factor: _, // TODO
-            zoom_with_keyboard,
-            tessellation_options,
-            repaint_on_widget_change,
-            screen_reader: _, // needs to come from the integration
-            preload_font_glyphs: _,
-            warn_on_id_clash,
-        } = self;
-
-        use crate::Widget as _;
-
-        CollapsingHeader::new("⚙ Options")
-            .default_open(false)
-            .show(ui, |ui| {
-                ui.checkbox(
-                    repaint_on_widget_change,
-                    "Repaint if any widget moves or changes id",
-                );
-
-                ui.checkbox(
-                    zoom_with_keyboard,
-                    "Zoom with keyboard (Cmd +, Cmd -, Cmd 0)",
-                );
-
-                ui.checkbox(warn_on_id_clash, "Warn if two widgets have the same Id");
-            });
-
-        use crate::containers::*;
-        CollapsingHeader::new("🎑 Style")
-            .default_open(true)
-            .show(ui, |ui| {
-                std::sync::Arc::make_mut(style).ui(ui);
-            });
-
-        CollapsingHeader::new("✒ Painting")
-            .default_open(true)
-            .show(ui, |ui| {
-                tessellation_options.ui(ui);
-                ui.vertical_centered(|ui| crate::reset_button(ui, tessellation_options));
-            });
-
-        ui.vertical_centered(|ui| crate::reset_button(ui, self));
+// ----------------------------------------------------------------------------
+
+/// For loading/saving app state and/or egui memory to disk.
+pub fn create_storage(_app_name: &str) -> Option<Box<dyn epi::Storage>> {
+    #[cfg(feature = "persistence")]
+    if let Some(storage) = super::file_storage::FileStorage::from_app_id(_app_name) {
+        return Some(Box::new(storage));
     }
+    None
 }
 
 // ----------------------------------------------------------------------------
 
-/// The state of the interaction in egui,
-/// i.e. what is being dragged.
+/// Everything needed to make a winit-based integration for [`epi`].
 ///
-/// Say there is a button in a scroll area.
-/// If the user clicks the button, the button should click.
-/// If the user drags the button we should scroll the scroll area.
-/// So what we do is that when the mouse is pressed we register both the button
-/// and the scroll area (as `click_id`/`drag_id`).
-/// If the user releases the button without moving the mouse we register it as a click on `click_id`.
-/// If the cursor moves too much we clear the `click_id` and start passing move events to `drag_id`.
-#[derive(Clone, Debug, Default)]
-pub(crate) struct InteractionState {
-    /// A widget interested in clicks that has a mouse press on it.
-    pub potential_click_id: Option<Id>,
-
-    /// A widget interested in drags that has a mouse press on it.
-    ///
-    /// Note that this is set as soon as the mouse is pressed,
-    /// so the widget may not yet be marked as "dragged",
-    /// as that can only happen after the mouse has moved a bit
-    /// (at least if the widget is interesated in both clicks and drags).
-    pub potential_drag_id: Option<Id>,
+/// Only one instance per app (not one per viewport).
+pub struct EpiIntegration {
+    pub frame: epi::Frame,
+    last_auto_save: Instant,
+    pub beginning: Instant,
+    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,
+    app_icon_setter: super::app_icon::AppTitleIconSetter,
 }
 
-/// Keeps tracks of what widget has keyboard focus
-#[derive(Clone, Debug, Default)]
-pub(crate) struct Focus {
-    /// The widget with keyboard focus (i.e. a text input field).
-    focused_widget: Option<FocusWidget>,
-
-    /// What had keyboard focus previous frame?
-    id_previous_frame: Option<Id>,
-
-    /// Give focus to this widget next frame
-    id_next_frame: Option<Id>,
-
-    #[cfg(feature = "accesskit")]
-    id_requested_by_accesskit: Option<accesskit::NodeId>,
-
-    /// If set, the next widget that is interested in focus will automatically get it.
-    /// Probably because the user pressed Tab.
-    give_to_next: bool,
-
-    /// The last widget interested in focus.
-    last_interested: Option<Id>,
-
-    /// Set when looking for widget with navigational keys like arrows, tab, shift+tab
-    focus_direction: FocusDirection,
-
-    /// A cache of widget ids that are interested in focus with their corresponding rectangles.
-    focus_widgets_cache: IdMap<Rect>,
-}
+impl EpiIntegration {
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(
+        egui_ctx: egui::Context,
+        window: &winit::window::Window,
+        system_theme: Option<Theme>,
+        app_name: &str,
+        native_options: &crate::NativeOptions,
+        storage: Option<Box<dyn epi::Storage>>,
+        #[cfg(feature = "glow")] gl: Option<std::sync::Arc<glow::Context>>,
+        #[cfg(feature = "wgpu")] wgpu_render_state: Option<egui_wgpu::RenderState>,
+    ) -> Self {
+        let frame = epi::Frame {
+            info: epi::IntegrationInfo {
+                system_theme,
+                cpu_usage: None,
+            },
+            storage,
+            #[cfg(feature = "glow")]
+            gl,
+            #[cfg(feature = "wgpu")]
+            wgpu_render_state,
+            raw_display_handle: window.display_handle().map(|h| h.as_raw()),
+            raw_window_handle: window.window_handle().map(|h| h.as_raw()),
+        };
 
-/// The widget with focus.
-#[derive(Clone, Copy, Debug)]
-struct FocusWidget {
-    pub id: Id,
-    pub filter: EventFilter,
-}
+        let icon = native_options
+            .viewport
+            .icon
+            .clone()
+            .unwrap_or_else(|| std::sync::Arc::new(load_default_egui_icon()));
+
+        let app_icon_setter = super::app_icon::AppTitleIconSetter::new(
+            native_options
+                .viewport
+                .title
+                .clone()
+                .unwrap_or_else(|| app_name.to_owned()),
+            Some(icon),
+        );
 
-impl FocusWidget {
-    pub fn new(id: Id) -> Self {
         Self {
-            id,
-            filter: Default::default(),
+            frame,
+            last_auto_save: Instant::now(),
+            beginning: Instant::now(),
+            is_first_frame: true,
+            frame_start: 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,
+            app_icon_setter,
         }
     }
-}
 
-impl InteractionState {
-    /// Are we currently clicking or dragging an egui widget?
-    pub fn is_using_pointer(&self) -> bool {
-        self.potential_click_id.is_some() || self.potential_drag_id.is_some()
-    }
-}
+    #[cfg(feature = "accesskit")]
+    pub fn init_accesskit<E: From<egui_winit::accesskit_winit::ActionRequestEvent> + Send>(
+        &self,
+        egui_winit: &mut egui_winit::State,
+        window: &winit::window::Window,
+        event_loop_proxy: winit::event_loop::EventLoopProxy<E>,
+    ) {
+        crate::profile_function!();
 
-impl Focus {
-    /// Which widget currently has keyboard focus?
-    pub fn focused(&self) -> Option<Id> {
-        self.focused_widget.as_ref().map(|w| w.id)
+        let egui_ctx = self.egui_ctx.clone();
+        egui_winit.init_accesskit(window, event_loop_proxy, move || {
+            // This function is called when an accessibility client
+            // (e.g. screen reader) makes its first request. If we got here,
+            // we know that an accessibility tree is actually wanted.
+            egui_ctx.enable_accesskit();
+            // Enqueue a repaint so we'll receive a full tree update soon.
+            egui_ctx.request_repaint();
+            egui_ctx.accesskit_placeholder_tree_update()
+        });
     }
 
-    fn begin_frame(&mut self, new_input: &crate::data::input::RawInput) {
-        self.id_previous_frame = self.focused();
-        if let Some(id) = self.id_next_frame.take() {
-            self.focused_widget = Some(FocusWidget::new(id));
-        }
-        let event_filter = self.focused_widget.map(|w| w.filter).unwrap_or_default();
-
-        #[cfg(feature = "accesskit")]
-        {
-            self.id_requested_by_accesskit = None;
-        }
-
-        self.focus_direction = FocusDirection::None;
-
-        for event in &new_input.events {
-            if !event_filter.matches(event) {
-                if let crate::Event::Key {
-                    key,
-                    pressed: true,
-                    modifiers,
-                    ..
-                } = event
-                {
-                    if let Some(cardinality) = match key {
-                        crate::Key::ArrowUp => Some(FocusDirection::Up),
-                        crate::Key::ArrowRight => Some(FocusDirection::Right),
-                        crate::Key::ArrowDown => Some(FocusDirection::Down),
-                        crate::Key::ArrowLeft => Some(FocusDirection::Left),
-
-                        crate::Key::Tab => {
-                            if modifiers.shift {
-                                Some(FocusDirection::Previous)
-                            } else {
-                                Some(FocusDirection::Next)
-                            }
-                        }
-                        crate::Key::Escape => {
-                            self.focused_widget = None;
-                            Some(FocusDirection::None)
-                        }
-                        _ => None,
-                    } {
-                        self.focus_direction = cardinality;
-                    }
-                }
-            }
-
-            #[cfg(feature = "accesskit")]
-            {
-                if let crate::Event::AccessKitActionRequest(accesskit::ActionRequest {
-                    action: accesskit::Action::Focus,
-                    target,
-                    data: None,
-                }) = event
-                {
-                    self.id_requested_by_accesskit = Some(*target);
-                }
-            }
-        }
+    /// If `true`, it is time to close the native window.
+    pub fn should_close(&self) -> bool {
+        self.close
     }
 
-    pub(crate) fn end_frame(&mut self, used_ids: &IdMap<Rect>) {
-        if self.focus_direction.is_cardinal() {
-            if let Some(found_widget) = self.find_widget_in_direction(used_ids) {
-                self.focused_widget = Some(FocusWidget::new(found_widget));
-            }
-        }
+    pub fn on_window_event(
+        &mut self,
+        window: &winit::window::Window,
+        egui_winit: &mut egui_winit::State,
+        event: &winit::event::WindowEvent,
+    ) -> EventResponse {
+        crate::profile_function!(egui_winit::short_window_event_description(event));
 
-        if let Some(focused_widget) = self.focused_widget {
-            // Allow calling `request_focus` one frame and not using it until next frame
-            let recently_gained_focus = self.id_previous_frame != Some(focused_widget.id);
+        use winit::event::{ElementState, MouseButton, WindowEvent};
 
-            if !recently_gained_focus && !used_ids.contains_key(&focused_widget.id) {
-                // Dead-mans-switch: the widget with focus has disappeared!
-                self.focused_widget = None;
+        match event {
+            WindowEvent::Destroyed => {
+                log::debug!("Received WindowEvent::Destroyed");
+                self.close = true;
             }
-        }
-    }
-
-    pub(crate) fn had_focus_last_frame(&self, id: Id) -> bool {
-        self.id_previous_frame == Some(id)
-    }
-
-    fn interested_in_focus(&mut self, id: Id) {
-        #[cfg(feature = "accesskit")]
-        {
-            if self.id_requested_by_accesskit == Some(id.accesskit_id()) {
-                self.focused_widget = Some(FocusWidget::new(id));
-                self.id_requested_by_accesskit = None;
-                self.give_to_next = false;
-                self.reset_focus();
+            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);
+                self.egui_ctx.set_visuals(theme.egui_visuals());
             }
+            _ => {}
         }
 
-        // The rect is updated at the end of the frame.
-        self.focus_widgets_cache
-            .entry(id)
-            .or_insert(Rect::EVERYTHING);
-
-        if self.give_to_next && !self.had_focus_last_frame(id) {
-            self.focused_widget = Some(FocusWidget::new(id));
-            self.give_to_next = false;
-        } else if self.focused() == Some(id) {
-            if self.focus_direction == FocusDirection::Next {
-                self.focused_widget = None;
-                self.give_to_next = true;
-                self.reset_focus();
-            } else if self.focus_direction == FocusDirection::Previous {
-                self.id_next_frame = self.last_interested; // frame-delay so gained_focus works
-                self.reset_focus();
-            }
-        } else if self.focus_direction == FocusDirection::Next
-            && self.focused_widget.is_none()
-            && !self.give_to_next
-        {
-            // nothing has focus and the user pressed tab - give focus to the first widgets that wants it:
-            self.focused_widget = Some(FocusWidget::new(id));
-            self.reset_focus();
-        } else if self.focus_direction == FocusDirection::Previous
-            && self.focused_widget.is_none()
-            && !self.give_to_next
-        {
-            // nothing has focus and the user pressed Shift+Tab - give focus to the last widgets that wants it:
-            self.focused_widget = self.last_interested.map(FocusWidget::new);
-            self.reset_focus();
-        }
-
-        self.last_interested = Some(id);
+        egui_winit.on_window_event(window, event)
     }
 
-    fn reset_focus(&mut self) {
-        self.focus_direction = FocusDirection::None;
+    pub fn pre_update(&mut self) {
+        self.app_icon_setter.update();
     }
 
-    fn find_widget_in_direction(&mut self, new_rects: &IdMap<Rect>) -> Option<Id> {
-        // NOTE: `new_rects` here include some widgets _not_ interested in focus.
-
-        /// * negative if `a` is left of `b`
-        /// * positive if `a` is right of `b`
-        /// * zero if the ranges overlap significantly
-        fn range_diff(a: Rangef, b: Rangef) -> f32 {
-            let has_significant_overlap = a.intersection(b).span() >= 0.5 * b.span().min(a.span());
-            if has_significant_overlap {
-                0.0
-            } else {
-                a.center() - b.center()
-            }
-        }
+    /// Run user code - this can create immediate viewports, so hold no locks over this!
+    ///
+    /// If `viewport_ui_cb` is None, we are in the root viewport and will call [`crate::App::update`].
+    pub fn update(
+        &mut self,
+        app: &mut dyn epi::App,
+        viewport_ui_cb: Option<&DeferredViewportUiCallback>,
+        mut raw_input: egui::RawInput,
+    ) -> egui::FullOutput {
+        raw_input.time = Some(self.beginning.elapsed().as_secs_f64());
 
-        let current_focused = self.focused_widget?;
+        let close_requested = raw_input.viewport().close_requested();
 
-        // In what direction we are looking for the next widget.
-        let search_direction = match self.focus_direction {
-            FocusDirection::Up => Vec2::UP,
-            FocusDirection::Right => Vec2::RIGHT,
-            FocusDirection::Down => Vec2::DOWN,
-            FocusDirection::Left => Vec2::LEFT,
-            _ => {
-                return None;
-            }
-        };
+        app.raw_input_hook(&self.egui_ctx, &mut raw_input);
 
-        // Update cache with new rects
-        self.focus_widgets_cache.retain(|id, old_rect| {
-            if let Some(new_rect) = new_rects.get(id) {
-                *old_rect = *new_rect;
-                true // Keep the item
+        let full_output = self.egui_ctx.run(raw_input, |egui_ctx| {
+            if let Some(viewport_ui_cb) = viewport_ui_cb {
+                // Child Deferred Viewport
+                crate::profile_scope!("viewport_callback");
+                viewport_ui_cb(egui_ctx);
             } else {
-                false // Remove the item
+                // ROOT Viewport ( with Immediate Viewport )
+                crate::profile_scope!("App::update");
+                app.update(egui_ctx, &mut self.frame);
             }
-        });
-
-        let current_rect = self.focus_widgets_cache.get(&current_focused.id)?;
-
-        let mut best_score = std::f32::INFINITY;
-        let mut best_id = None;
 
-        for (candidate_id, candidate_rect) in &self.focus_widgets_cache {
-            if *candidate_id == current_focused.id {
-                continue;
+            let continuous_mode = egui_ctx.options(|options| options.continuous_mode);
+            if continuous_mode {
+                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);
             }
+        });
 
-            // There is a lot of room for improvement here.
-            let to_candidate = vec2(
-                range_diff(candidate_rect.x_range(), current_rect.x_range()),
-                range_diff(candidate_rect.y_range(), current_rect.y_range()),
-            );
-
-            let acos_angle = to_candidate.normalized().dot(search_direction);
-
-            // Only interested in widgets that fall in a 90° cone (±45°)
-            // of the search direction.
-            let is_in_search_cone = 0.5_f32.sqrt() <= acos_angle;
-            if is_in_search_cone {
-                let distance = to_candidate.length();
-
-                // There is a lot of room for improvement here.
-                let score = distance / (acos_angle * acos_angle);
-
-                if score < best_score {
-                    best_score = score;
-                    best_id = Some(*candidate_id);
-                }
+        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;
             }
         }
 
-        best_id
-    }
-}
-
-impl Memory {
-    pub(crate) fn begin_frame(&mut self, new_raw_input: &RawInput, viewports: &ViewportIdSet) {
-        crate::profile_function!();
-
-        self.viewport_id = new_raw_input.viewport_id;
-
-        // Cleanup
-        self.interactions.retain(|id, _| viewports.contains(id));
-        self.areas.retain(|id, _| viewports.contains(id));
-
-        self.areas.entry(self.viewport_id).or_default();
-
-        // self.interactions  is handled elsewhere
-
-        self.focus
-            .entry(self.viewport_id)
-            .or_default()
-            .begin_frame(new_raw_input);
+        self.pending_full_output.append(full_output);
+        std::mem::take(&mut self.pending_full_output)
     }
 
-    pub(crate) fn end_frame(&mut self, used_ids: &IdMap<Rect>) {
-        self.caches.update();
-        self.areas_mut().end_frame();
-        self.focus_mut().end_frame(used_ids);
+    pub fn report_frame_time(&mut self, seconds: f32) {
+        self.frame.info.cpu_usage = Some(seconds);
     }
 
-    pub(crate) fn set_viewport_id(&mut self, viewport_id: ViewportId) {
-        self.viewport_id = viewport_id;
-    }
-
-    /// Access memory of the [`Area`](crate::containers::area::Area)s, such as `Window`s.
-    pub fn areas(&self) -> &Areas {
-        self.areas
-            .get(&self.viewport_id)
-            .expect("Memory broken: no area for the current viewport")
-    }
-
-    /// Access memory of the [`Area`](crate::containers::area::Area)s, such as `Window`s.
-    pub fn areas_mut(&mut self) -> &mut Areas {
-        self.areas.entry(self.viewport_id).or_default()
-    }
-
-    /// Top-most layer at the given position.
-    pub fn layer_id_at(&self, pos: Pos2) -> Option<LayerId> {
-        self.areas().layer_id_at(pos, &self.layer_transforms)
-    }
-
-    /// An iterator over all layers. Back-to-front. Top is last.
-    pub fn layer_ids(&self) -> impl ExactSizeIterator<Item = LayerId> + '_ {
-        self.areas().order().iter().copied()
-    }
-
-    pub(crate) fn had_focus_last_frame(&self, id: Id) -> bool {
-        self.focus().and_then(|f| f.id_previous_frame) == Some(id)
-    }
-
-    /// True if the given widget had keyboard focus last frame, but not this one.
-    pub(crate) fn lost_focus(&self, id: Id) -> bool {
-        self.had_focus_last_frame(id) && !self.has_focus(id)
-    }
-
-    /// True if the given widget has keyboard focus this frame, but didn't last frame.
-    pub(crate) fn gained_focus(&self, id: Id) -> bool {
-        !self.had_focus_last_frame(id) && self.has_focus(id)
-    }
-
-    /// Does this widget have keyboard focus?
-    ///
-    /// This function does not consider whether the UI as a whole (e.g. window)
-    /// has the keyboard focus. That makes this function suitable for deciding
-    /// widget state that should not be disrupted if the user moves away
-    /// from the window and back.
-    #[inline(always)]
-    pub fn has_focus(&self, id: Id) -> bool {
-        self.focused() == Some(id)
-    }
-
-    /// Which widget has keyboard focus?
-    pub fn focused(&self) -> Option<Id> {
-        self.focus().and_then(|f| f.focused())
-    }
-
-    /// Set an event filter for a widget.
-    ///
-    /// This allows you to control whether the widget will loose focus
-    /// when the user presses tab, arrow keys, or escape.
-    ///
-    /// You must first give focus to the widget before calling this.
-    pub fn set_focus_lock_filter(&mut self, id: Id, event_filter: EventFilter) {
-        if self.had_focus_last_frame(id) && self.has_focus(id) {
-            if let Some(focused) = &mut self.focus_mut().focused_widget {
-                if focused.id == id {
-                    focused.filter = event_filter;
-                }
-            }
-        }
-    }
-
-    /// Give keyboard focus to a specific widget.
-    /// See also [`crate::Response::request_focus`].
-    #[inline(always)]
-    pub fn request_focus(&mut self, id: Id) {
-        self.focus_mut().focused_widget = Some(FocusWidget::new(id));
-    }
-
-    /// Surrender keyboard focus for a specific widget.
-    /// See also [`crate::Response::surrender_focus`].
-    #[inline(always)]
-    pub fn surrender_focus(&mut self, id: Id) {
-        let focus = self.focus_mut();
-        if focus.focused() == Some(id) {
-            focus.focused_widget = None;
+    pub fn post_rendering(&mut self, window: &winit::window::Window) {
+        crate::profile_function!();
+        if std::mem::take(&mut self.is_first_frame) {
+            // We keep hidden until we've painted something. See https://github.com/emilk/egui/pull/2279
+            window.set_visible(true);
         }
     }
 
-    /// Register this widget as being interested in getting keyboard focus.
-    /// This will allow the user to select it with tab and shift-tab.
-    /// This is normally done automatically when handling interactions,
-    /// but it is sometimes useful to pre-register interest in focus,
-    /// e.g. before deciding which type of underlying widget to use,
-    /// as in the [`crate::DragValue`] widget, so a widget can be focused
-    /// and rendered correctly in a single frame.
-    #[inline(always)]
-    pub fn interested_in_focus(&mut self, id: Id) {
-        self.focus_mut().interested_in_focus(id);
-    }
-
-    /// Stop editing of active [`TextEdit`](crate::TextEdit) (if any).
-    #[inline(always)]
-    pub fn stop_text_input(&mut self) {
-        self.focus_mut().focused_widget = None;
-    }
-
-    /// Is any widget being dragged?
-    #[deprecated = "Use `Context::dragged_id` instead"]
-    #[inline(always)]
-    pub fn is_anything_being_dragged(&self) -> bool {
-        self.interaction().potential_drag_id.is_some()
-    }
-
-    /// Is this specific widget being dragged?
-    ///
-    /// Usually it is better to use [`crate::Response::dragged`].
-    ///
-    /// A widget that sense both clicks and drags is only marked as "dragged"
-    /// when the mouse has moved a bit, but `is_being_dragged` will return true immediately.
-    #[deprecated = "Use `Context::is_being_dragged` instead"]
-    #[inline(always)]
-    pub fn is_being_dragged(&self, id: Id) -> bool {
-        self.interaction().potential_drag_id == Some(id)
-    }
-
-    /// Get the id of the widget being dragged, if any.
-    ///
-    /// Note that this is set as soon as the mouse is pressed,
-    /// so the widget may not yet be marked as "dragged",
-    /// as that can only happen after the mouse has moved a bit
-    /// (at least if the widget is interesated in both clicks and drags).
-    #[deprecated = "Use `Context::dragged_id` instead"]
-    #[inline(always)]
-    pub fn dragged_id(&self) -> Option<Id> {
-        self.interaction().potential_drag_id
-    }
-
-    /// Set which widget is being dragged.
-    #[inline(always)]
-    #[deprecated = "Use `Context::set_dragged_id` instead"]
-    pub fn set_dragged_id(&mut self, id: Id) {
-        self.interaction_mut().potential_drag_id = Some(id);
-    }
-
-    /// Stop dragging any widget.
-    #[inline(always)]
-    #[deprecated = "Use `Context::stop_dragging` instead"]
-    pub fn stop_dragging(&mut self) {
-        self.interaction_mut().potential_drag_id = None;
-    }
+    // ------------------------------------------------------------------------
+    // Persistence stuff:
 
-    /// Is something else being dragged?
-    ///
-    /// Returns true if we are dragging something, but not the given widget.
-    #[inline(always)]
-    #[deprecated = "Use `Context::dragging_something_else` instead"]
-    pub fn dragging_something_else(&self, not_this: Id) -> bool {
-        let drag_id = self.interaction().potential_drag_id;
-        drag_id.is_some() && drag_id != Some(not_this)
-    }
-
-    /// Forget window positions, sizes etc.
-    /// Can be used to auto-layout windows.
-    pub fn reset_areas(&mut self) {
-        for area in self.areas.values_mut() {
-            *area = Default::default();
+    pub fn maybe_autosave(
+        &mut self,
+        app: &mut dyn epi::App,
+        window: Option<&winit::window::Window>,
+    ) {
+        let now = Instant::now();
+        if now - self.last_auto_save > app.auto_save_interval() {
+            self.save(app, window);
+            self.last_auto_save = now;
         }
     }
 
-    /// Obtain the previous rectangle of an area.
-    pub fn area_rect(&self, id: impl Into<Id>) -> Option<Rect> {
-        self.areas().get(id.into()).map(|state| state.rect())
-    }
-
-    pub(crate) fn interaction(&self) -> &InteractionState {
-        self.interactions
-            .get(&self.viewport_id)
-            .expect("Failed to get interaction")
-    }
-
-    pub(crate) fn interaction_mut(&mut self) -> &mut InteractionState {
-        self.interactions.entry(self.viewport_id).or_default()
-    }
-
-    pub(crate) fn focus(&self) -> Option<&Focus> {
-        self.focus.get(&self.viewport_id)
-    }
-
-    pub(crate) fn focus_mut(&mut self) -> &mut Focus {
-        self.focus.entry(self.viewport_id).or_default()
-    }
-}
-
-/// ## Popups
-/// Popups are things like combo-boxes, color pickers, menus etc.
-/// Only one can be be open at a time.
-impl Memory {
-    /// Is the given popup open?
-    pub fn is_popup_open(&self, popup_id: Id) -> bool {
-        self.popup == Some(popup_id) || self.everything_is_visible()
-    }
-
-    /// Is any popup open?
-    pub fn any_popup_open(&self) -> bool {
-        self.popup.is_some() || self.everything_is_visible()
-    }
-
-    /// Open the given popup, and close all other.
-    pub fn open_popup(&mut self, popup_id: Id) {
-        self.popup = Some(popup_id);
-    }
-
-    /// Close the open popup, if any.
-    pub fn close_popup(&mut self) {
-        self.popup = None;
-    }
+    #[allow(clippy::unused_self)]
+    pub fn save(&mut self, _app: &mut dyn epi::App, _window: Option<&winit::window::Window>) {
+        #[cfg(feature = "persistence")]
+        if let Some(storage) = self.frame.storage_mut() {
+            crate::profile_function!();
+
+            if let Some(window) = _window {
+                if self.persist_window {
+                    crate::profile_scope!("native_window");
+                    epi::set_value(
+                        storage,
+                        STORAGE_WINDOW_KEY,
+                        &WindowSettings::from_window(self.egui_ctx.zoom_factor(), window),
+                    );
+                }
+            }
+            if _app.persist_egui_memory() {
+                crate::profile_scope!("egui_memory");
+                self.egui_ctx
+                    .memory(|mem| epi::set_value(storage, STORAGE_EGUI_MEMORY_KEY, mem));
+            }
+            {
+                crate::profile_scope!("App::save");
+                _app.save(storage);
+            }
 
-    /// Toggle the given popup between closed and open.
-    ///
-    /// Note: at most one popup can be open at one time.
-    pub fn toggle_popup(&mut self, popup_id: Id) {
-        if self.is_popup_open(popup_id) {
-            self.close_popup();
-        } else {
-            self.open_popup(popup_id);
+            crate::profile_scope!("Storage::flush");
+            storage.flush();
         }
     }
-
-    /// If true, all windows, menus, tooltips etc are to be visible at once.
-    ///
-    /// This is useful for testing, benchmarking, pre-caching, etc.
-    ///
-    /// Experimental feature!
-    #[inline(always)]
-    pub fn everything_is_visible(&self) -> bool {
-        self.everything_is_visible
-    }
-
-    /// If true, all windows, menus, tooltips etc are to be visible at once.
-    ///
-    /// This is useful for testing, benchmarking, pre-caching, etc.
-    ///
-    /// Experimental feature!
-    pub fn set_everything_is_visible(&mut self, value: bool) {
-        self.everything_is_visible = value;
-    }
 }
 
-// ----------------------------------------------------------------------------
-
-/// Keeps track of [`Area`](crate::containers::area::Area)s, which are free-floating [`Ui`](crate::Ui)s.
-/// These [`Area`](crate::containers::area::Area)s can be in any [`Order`](crate::Order).
-#[derive(Clone, Debug, Default)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-#[cfg_attr(feature = "serde", serde(default))]
-pub struct Areas {
-    areas: IdMap<area::State>,
-
-    /// Back-to-front. Top is last.
-    order: Vec<LayerId>,
-
-    visible_last_frame: ahash::HashSet<LayerId>,
-    visible_current_frame: ahash::HashSet<LayerId>,
-
-    /// When an area want to be on top, it is put in here.
-    /// At the end of the frame, this is used to reorder the layers.
-    /// This means if several layers want to be on top, they will keep their relative order.
-    /// So if you close three windows and then reopen them all in one frame,
-    /// they will all be sent to the top, but keep their previous internal order.
-    wants_to_be_on_top: ahash::HashSet<LayerId>,
+fn load_default_egui_icon() -> egui::IconData {
+    crate::profile_function!();
+    crate::icon_data::from_png_bytes(&include_bytes!("../../data/icon.png")[..]).unwrap()
 }
 
-impl Areas {
-    pub(crate) fn count(&self) -> usize {
-        self.areas.len()
-    }
+#[cfg(feature = "persistence")]
+const STORAGE_EGUI_MEMORY_KEY: &str = "egui";
 
-    pub(crate) fn get(&self, id: Id) -> Option<&area::State> {
-        self.areas.get(&id)
-    }
+#[cfg(feature = "persistence")]
+const STORAGE_WINDOW_KEY: &str = "window";
 
-    /// Back-to-front. Top is last.
-    pub(crate) fn order(&self) -> &[LayerId] {
-        &self.order
-    }
-
-    /// For each layer, which order is it in [`Self::order`]?
-    pub(crate) fn order_map(&self) -> HashMap<LayerId, usize> {
-        self.order
-            .iter()
-            .enumerate()
-            .map(|(i, id)| (*id, i))
-            .collect()
-    }
-
-    pub(crate) fn set_state(&mut self, layer_id: LayerId, state: area::State) {
-        self.visible_current_frame.insert(layer_id);
-        self.areas.insert(layer_id.id, state);
-        if !self.order.iter().any(|x| *x == layer_id) {
-            self.order.push(layer_id);
-        }
-    }
-
-    /// Top-most layer at the given position.
-    pub fn layer_id_at(
-        &self,
-        pos: Pos2,
-        layer_transforms: &HashMap<LayerId, TSTransform>,
-    ) -> Option<LayerId> {
-        for layer in self.order.iter().rev() {
-            if self.is_visible(layer) {
-                if let Some(state) = self.areas.get(&layer.id) {
-                    let mut rect = state.rect();
-                    if state.interactable {
-                        if let Some(transform) = layer_transforms.get(layer) {
-                            rect = *transform * rect;
-                        }
-
-                        if rect.contains(pos) {
-                            return Some(*layer);
-                        }
-                    }
-                }
-            }
-        }
-        None
-    }
-
-    pub fn visible_last_frame(&self, layer_id: &LayerId) -> bool {
-        self.visible_last_frame.contains(layer_id)
-    }
-
-    pub fn is_visible(&self, layer_id: &LayerId) -> bool {
-        self.visible_last_frame.contains(layer_id) || self.visible_current_frame.contains(layer_id)
-    }
-
-    pub fn visible_layer_ids(&self) -> ahash::HashSet<LayerId> {
-        self.visible_last_frame
-            .iter()
-            .copied()
-            .chain(self.visible_current_frame.iter().copied())
-            .collect()
-    }
-
-    pub(crate) fn visible_windows(&self) -> Vec<&area::State> {
-        self.visible_layer_ids()
-            .iter()
-            .filter(|layer| layer.order == crate::Order::Middle)
-            .filter_map(|layer| self.get(layer.id))
-            .collect()
-    }
-
-    pub fn move_to_top(&mut self, layer_id: LayerId) {
-        self.visible_current_frame.insert(layer_id);
-        self.wants_to_be_on_top.insert(layer_id);
-
-        if !self.order.iter().any(|x| *x == layer_id) {
-            self.order.push(layer_id);
-        }
-    }
-
-    pub fn top_layer_id(&self, order: Order) -> Option<LayerId> {
-        self.order
-            .iter()
-            .filter(|layer| layer.order == order)
-            .last()
-            .copied()
+pub fn load_window_settings(_storage: Option<&dyn epi::Storage>) -> Option<WindowSettings> {
+    crate::profile_function!();
+    #[cfg(feature = "persistence")]
+    {
+        epi::get_value(_storage?, STORAGE_WINDOW_KEY)
     }
+    #[cfg(not(feature = "persistence"))]
+    None
+}
 
-    pub(crate) fn end_frame(&mut self) {
-        let Self {
-            visible_last_frame,
-            visible_current_frame,
-            order,
-            wants_to_be_on_top,
-            ..
-        } = self;
-
-        std::mem::swap(visible_last_frame, visible_current_frame);
-        visible_current_frame.clear();
-        order.sort_by_key(|layer| (layer.order, wants_to_be_on_top.contains(layer)));
-        wants_to_be_on_top.clear();
+pub fn load_egui_memory(_storage: Option<&dyn epi::Storage>) -> Option<egui::Memory> {
+    crate::profile_function!();
+    #[cfg(feature = "persistence")]
+    {
+        epi::get_value(_storage?, STORAGE_EGUI_MEMORY_KEY)
     }
+    #[cfg(not(feature = "persistence"))]
+    None
 }
 
-// ----------------------------------------------------------------------------
-
-#[test]
-fn memory_impl_send_sync() {
-    fn assert_send_sync<T: Send + Sync>() {}
-    assert_send_sync::<Memory>();
+pub(crate) fn theme_from_winit_theme(theme: winit::window::Theme) -> Theme {
+    match theme {
+        winit::window::Theme::Dark => Theme::Dark,
+        winit::window::Theme::Light => Theme::Light,
+    }
 }

From 3b98d7f9864014f81aae4f032aeede0845366027 Mon Sep 17 00:00:00 2001
From: rustbasic <127506429+rustbasic@users.noreply.github.com>
Date: Sat, 23 Mar 2024 15:39:26 +0900
Subject: [PATCH 02/10] Update epi_integration.rs

---
 crates/eframe/src/native/epi_integration.rs | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/crates/eframe/src/native/epi_integration.rs b/crates/eframe/src/native/epi_integration.rs
index f27d011202e..30dea793f21 100644
--- a/crates/eframe/src/native/epi_integration.rs
+++ b/crates/eframe/src/native/epi_integration.rs
@@ -278,13 +278,23 @@ 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 continuous_mode = egui_ctx.options(|options| options.continuous_mode);
+            if continuous_mode {
+                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();

From af5a7bb99195d2436422a412a81522e09b5f06fa Mon Sep 17 00:00:00 2001
From: rustbasic <127506429+rustbasic@users.noreply.github.com>
Date: Sat, 23 Mar 2024 15:43:51 +0900
Subject: [PATCH 03/10] Update memory.rs

---
 crates/egui/src/memory.rs | 1251 +++++++++++++++++++++++++++----------
 1 file changed, 930 insertions(+), 321 deletions(-)

diff --git a/crates/egui/src/memory.rs b/crates/egui/src/memory.rs
index 1fa349b2a05..bd8c2bfc3c3 100644
--- a/crates/egui/src/memory.rs
+++ b/crates/egui/src/memory.rs
@@ -1,412 +1,1021 @@
-//! Common tools used by [`super::glow_integration`] and [`super::wgpu_integration`].
+#![warn(missing_docs)] // Let's keep this file well-documented.` to memory.rs
 
-use web_time::Instant;
-use winit::event_loop::EventLoopWindowTarget;
+use ahash::HashMap;
+use epaint::emath::TSTransform;
 
-use raw_window_handle::{HasDisplayHandle as _, HasWindowHandle as _};
+use crate::{
+    area, vec2, EventFilter, Id, IdMap, LayerId, Order, Pos2, Rangef, RawInput, Rect, Style, Vec2,
+    ViewportId, ViewportIdMap, ViewportIdSet,
+};
 
-use egui::{DeferredViewportUiCallback, NumExt as _, ViewportBuilder, ViewportId};
-use egui_winit::{EventResponse, WindowSettings};
+// ----------------------------------------------------------------------------
 
-use crate::{epi, Theme};
+/// The data that egui persists between frames.
+///
+/// This includes window positions and sizes,
+/// how far the user has scrolled in a [`ScrollArea`](crate::ScrollArea) etc.
+///
+/// If you want this to persist when closing your app you should serialize [`Memory`] and store it.
+/// For this you need to enable the `persistence`.
+///
+/// If you want to store data for your widgets, you should look at [`Memory::data`]
+#[derive(Clone, Debug)]
+#[cfg_attr(feature = "persistence", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "persistence", serde(default))]
+pub struct Memory {
+    /// Global egui options.
+    pub options: Options,
+
+    /// This map stores some superficial state for all widgets with custom [`Id`]s.
+    ///
+    /// This includes storing if a [`crate::CollapsingHeader`] is open, how far scrolled a
+    /// [`crate::ScrollArea`] is, where the cursor in a [`crate::TextEdit`] is, etc.
+    ///
+    /// This is NOT meant to store any important data. Store that in your own structures!
+    ///
+    /// Each read clones the data, so keep your values cheap to clone.
+    /// If you want to store a lot of data you should wrap it in `Arc<Mutex<…>>` so it is cheap to clone.
+    ///
+    /// This will be saved between different program runs if you use the `persistence` feature.
+    ///
+    /// To store a state common for all your widgets (a singleton), use [`Id::NULL`] as the key.
+    pub data: crate::util::IdTypeMap,
+
+    // ------------------------------------------
+    /// Can be used to cache computations from one frame to another.
+    ///
+    /// This is for saving CPU when you have something that may take 1-100ms to compute.
+    /// Things that are very slow (>100ms) should instead be done async (i.e. in another thread)
+    /// so as not to lock the UI thread.
+    ///
+    /// ```
+    /// use egui::util::cache::{ComputerMut, FrameCache};
+    ///
+    /// #[derive(Default)]
+    /// struct CharCounter {}
+    /// impl ComputerMut<&str, usize> for CharCounter {
+    ///     fn compute(&mut self, s: &str) -> usize {
+    ///         s.chars().count() // you probably want to cache something more expensive than this
+    ///     }
+    /// }
+    /// type CharCountCache<'a> = FrameCache<usize, CharCounter>;
+    ///
+    /// # let mut ctx = egui::Context::default();
+    /// ctx.memory_mut(|mem| {
+    ///     let cache = mem.caches.cache::<CharCountCache<'_>>();
+    ///     assert_eq!(cache.get("hello"), 5);
+    /// });
+    /// ```
+    #[cfg_attr(feature = "persistence", serde(skip))]
+    pub caches: crate::util::cache::CacheStorage,
+
+    // ------------------------------------------
+    /// 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>,
+
+    // Current active viewport
+    #[cfg_attr(feature = "persistence", serde(skip))]
+    pub(crate) viewport_id: ViewportId,
+
+    /// Which popup-window is open (if any)?
+    /// Could be a combo box, color picker, menu etc.
+    #[cfg_attr(feature = "persistence", serde(skip))]
+    popup: Option<Id>,
+
+    #[cfg_attr(feature = "persistence", serde(skip))]
+    everything_is_visible: bool,
+
+    /// Transforms per layer
+    pub layer_transforms: HashMap<LayerId, TSTransform>,
+
+    // -------------------------------------------------
+    // Per-viewport:
+    areas: ViewportIdMap<Areas>,
+
+    #[cfg_attr(feature = "persistence", serde(skip))]
+    pub(crate) interactions: ViewportIdMap<InteractionState>,
+
+    #[cfg_attr(feature = "persistence", serde(skip))]
+    pub(crate) focus: ViewportIdMap<Focus>,
+}
 
-pub fn viewport_builder<E>(
-    egui_zoom_factor: f32,
-    event_loop: &EventLoopWindowTarget<E>,
-    native_options: &mut epi::NativeOptions,
-    window_settings: Option<WindowSettings>,
-) -> ViewportBuilder {
-    crate::profile_function!();
+impl Default for Memory {
+    fn default() -> Self {
+        let mut slf = Self {
+            options: Default::default(),
+            data: Default::default(),
+            caches: Default::default(),
+            new_font_definitions: Default::default(),
+            interactions: Default::default(),
+            focus: Default::default(),
+            viewport_id: Default::default(),
+            areas: Default::default(),
+            layer_transforms: Default::default(),
+            popup: Default::default(),
+            everything_is_visible: Default::default(),
+        };
+        slf.interactions.entry(slf.viewport_id).or_default();
+        slf.areas.entry(slf.viewport_id).or_default();
+        slf
+    }
+}
 
-    let mut viewport_builder = native_options.viewport.clone();
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+enum FocusDirection {
+    /// Select the widget closest above the current focused widget.
+    Up,
 
-    // Always use the default window size / position on iOS. Trying to restore the previous position
-    // causes the window to be shown too small.
-    #[cfg(not(target_os = "ios"))]
-    let inner_size_points = if let Some(mut window_settings) = window_settings {
-        // Restore pos/size from previous session
+    /// Select the widget to the right of the current focused widget.
+    Right,
 
-        window_settings
-            .clamp_size_to_sane_values(largest_monitor_point_size(egui_zoom_factor, event_loop));
-        window_settings.clamp_position_to_monitors(egui_zoom_factor, event_loop);
+    /// Select the widget below the current focused widget.
+    Down,
 
-        viewport_builder = window_settings.initialize_viewport_builder(viewport_builder);
-        window_settings.inner_size_points()
-    } else {
-        if let Some(pos) = viewport_builder.position {
-            viewport_builder = viewport_builder.with_position(pos);
-        }
+    /// Select the widget to the left of the the current focused widget.
+    Left,
 
-        if let Some(initial_window_size) = viewport_builder.inner_size {
-            let initial_window_size = initial_window_size
-                .at_most(largest_monitor_point_size(egui_zoom_factor, event_loop));
-            viewport_builder = viewport_builder.with_inner_size(initial_window_size);
-        }
+    /// Select the previous widget that had focus.
+    Previous,
 
-        viewport_builder.inner_size
-    };
-
-    #[cfg(not(target_os = "ios"))]
-    if native_options.centered {
-        crate::profile_scope!("center");
-        if let Some(monitor) = event_loop.available_monitors().next() {
-            let monitor_size = monitor
-                .size()
-                .to_logical::<f32>(egui_zoom_factor as f64 * monitor.scale_factor());
-            let inner_size = inner_size_points.unwrap_or(egui::Vec2 { x: 800.0, y: 600.0 });
-            if 0.0 < monitor_size.width && 0.0 < monitor_size.height {
-                let x = (monitor_size.width - inner_size.x) / 2.0;
-                let y = (monitor_size.height - inner_size.y) / 2.0;
-                viewport_builder = viewport_builder.with_position([x, y]);
-            }
-        }
-    }
+    /// Select the next widget that wants focus.
+    Next,
 
-    match std::mem::take(&mut native_options.window_builder) {
-        Some(hook) => hook(viewport_builder),
-        None => viewport_builder,
-    }
+    /// Don't change focus.
+    #[default]
+    None,
 }
 
-pub fn apply_window_settings(
-    window: &winit::window::Window,
-    window_settings: Option<WindowSettings>,
-) {
-    crate::profile_function!();
+impl FocusDirection {
+    fn is_cardinal(&self) -> bool {
+        match self {
+            Self::Up | Self::Right | Self::Down | Self::Left => true,
 
-    if let Some(window_settings) = window_settings {
-        window_settings.initialize_window(window);
+            Self::Previous | Self::Next | Self::None => false,
+        }
     }
 }
 
-fn largest_monitor_point_size<E>(
-    egui_zoom_factor: f32,
-    event_loop: &EventLoopWindowTarget<E>,
-) -> egui::Vec2 {
-    crate::profile_function!();
+// ----------------------------------------------------------------------------
 
-    let mut max_size = egui::Vec2::ZERO;
+/// Some global options that you can read and write.
+///
+/// See also [`crate::style::DebugOptions`].
+#[derive(Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct Options {
+    /// The default style for new [`Ui`](crate::Ui):s.
+    #[cfg_attr(feature = "serde", serde(skip))]
+    pub(crate) style: std::sync::Arc<Style>,
+
+    /// Global zoom factor of the UI.
+    ///
+    /// This is used to calculate the `pixels_per_point`
+    /// for the UI as `pixels_per_point = zoom_fator * native_pixels_per_point`.
+    ///
+    /// The default is 1.0.
+    /// Make larger to make everything larger.
+    ///
+    /// Please call [`crate::Context::set_zoom_factor`]
+    /// instead of modifying this directly!
+    pub zoom_factor: f32,
 
-    let available_monitors = {
-        crate::profile_scope!("available_monitors");
-        event_loop.available_monitors()
-    };
+    /// If `true`, egui will change the scale of the ui ([`crate::Context::zoom_factor`]) when the user
+    /// presses Cmd+Plus, Cmd+Minus or Cmd+0, just like in a browser.
+    ///
+    /// This is `true` by default.
+    #[cfg_attr(feature = "serde", serde(skip))]
+    pub zoom_with_keyboard: bool,
 
-    for monitor in available_monitors {
-        let size = monitor
-            .size()
-            .to_logical::<f32>(egui_zoom_factor as f64 * monitor.scale_factor());
-        let size = egui::vec2(size.width, size.height);
-        max_size = max_size.max(size);
-    }
+    /// Controls the tessellator.
+    pub tessellation_options: epaint::TessellationOptions,
 
-    if max_size == egui::Vec2::ZERO {
-        egui::Vec2::splat(16000.0)
-    } else {
-        max_size
-    }
+    /// If `true`, This will call `egui::Context::request_repaint()` at the end of each frame
+    /// If `false` (default), egui is only updated if are input events (like mouse movements) or there are some animations in the GUI.
+    ///
+    /// ```
+    ///     ui.ctx().options_mut(|options| { options.continuous_mode = true});
+    /// ```
+    pub continuous_mode: bool,
+
+    /// If any widget moves or changes id, repaint everything.
+    ///
+    /// It is recommended you keep this OFF, because
+    /// it is know to cause endless repaints, for unknown reasons
+    /// (<https://github.com/rerun-io/rerun/issues/5018>).
+    pub repaint_on_widget_change: bool,
+
+    /// This is a signal to any backend that we want the [`crate::PlatformOutput::events`] read out loud.
+    ///
+    /// The only change to egui is that labels can be focused by pressing tab.
+    ///
+    /// Screen readers is an experimental feature of egui, and not supported on all platforms.
+    ///
+    /// `eframe` supports it only on web,
+    /// but you should consider using [AccessKit](https://github.com/AccessKit/accesskit) instead,
+    /// which `eframe` supports.
+    pub screen_reader: bool,
+
+    /// If true, the most common glyphs (ASCII) are pre-rendered to the texture atlas.
+    ///
+    /// Only the fonts in [`Style::text_styles`] will be pre-cached.
+    ///
+    /// This can lead to fewer texture operations, but may use up the texture atlas quicker
+    /// if you are changing [`Style::text_styles`], of have a lot of text styles.
+    pub preload_font_glyphs: bool,
+
+    /// Check reusing of [`Id`]s, and show a visual warning on screen when one is found.
+    ///
+    /// By default this is `true` in debug builds.
+    pub warn_on_id_clash: bool,
 }
 
-// ----------------------------------------------------------------------------
+impl Default for Options {
+    fn default() -> Self {
+        Self {
+            style: Default::default(),
+            zoom_factor: 1.0,
+            zoom_with_keyboard: true,
+            tessellation_options: Default::default(),
+            continuous_mode: false,
+            repaint_on_widget_change: false,
+            screen_reader: false,
+            preload_font_glyphs: true,
+            warn_on_id_clash: cfg!(debug_assertions),
+        }
+    }
+}
 
-/// For loading/saving app state and/or egui memory to disk.
-pub fn create_storage(_app_name: &str) -> Option<Box<dyn epi::Storage>> {
-    #[cfg(feature = "persistence")]
-    if let Some(storage) = super::file_storage::FileStorage::from_app_id(_app_name) {
-        return Some(Box::new(storage));
+impl Options {
+    /// Show the options in the ui.
+    pub fn ui(&mut self, ui: &mut crate::Ui) {
+        let Self {
+            style,          // covered above
+            zoom_factor: _, // TODO
+            zoom_with_keyboard,
+            tessellation_options,
+            continuous_mode,
+            repaint_on_widget_change,
+            screen_reader: _, // needs to come from the integration
+            preload_font_glyphs: _,
+            warn_on_id_clash,
+        } = self;
+
+        use crate::Widget as _;
+
+        CollapsingHeader::new("⚙ Options")
+            .default_open(false)
+            .show(ui, |ui| {
+                ui.checkbox(continuous_mode, "Repaint at the end of each frame");
+
+                ui.checkbox(
+                    repaint_on_widget_change,
+                    "Repaint if any widget moves or changes id",
+                );
+
+                ui.checkbox(
+                    zoom_with_keyboard,
+                    "Zoom with keyboard (Cmd +, Cmd -, Cmd 0)",
+                );
+
+                ui.checkbox(warn_on_id_clash, "Warn if two widgets have the same Id");
+            });
+
+        use crate::containers::*;
+        CollapsingHeader::new("🎑 Style")
+            .default_open(true)
+            .show(ui, |ui| {
+                std::sync::Arc::make_mut(style).ui(ui);
+            });
+
+        CollapsingHeader::new("✒ Painting")
+            .default_open(true)
+            .show(ui, |ui| {
+                tessellation_options.ui(ui);
+                ui.vertical_centered(|ui| crate::reset_button(ui, tessellation_options));
+            });
+
+        ui.vertical_centered(|ui| crate::reset_button(ui, self));
     }
-    None
 }
 
 // ----------------------------------------------------------------------------
 
-/// Everything needed to make a winit-based integration for [`epi`].
+/// The state of the interaction in egui,
+/// i.e. what is being dragged.
 ///
-/// Only one instance per app (not one per viewport).
-pub struct EpiIntegration {
-    pub frame: epi::Frame,
-    last_auto_save: Instant,
-    pub beginning: Instant,
-    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,
-    app_icon_setter: super::app_icon::AppTitleIconSetter,
+/// Say there is a button in a scroll area.
+/// If the user clicks the button, the button should click.
+/// If the user drags the button we should scroll the scroll area.
+/// So what we do is that when the mouse is pressed we register both the button
+/// and the scroll area (as `click_id`/`drag_id`).
+/// If the user releases the button without moving the mouse we register it as a click on `click_id`.
+/// If the cursor moves too much we clear the `click_id` and start passing move events to `drag_id`.
+#[derive(Clone, Debug, Default)]
+pub(crate) struct InteractionState {
+    /// A widget interested in clicks that has a mouse press on it.
+    pub potential_click_id: Option<Id>,
+
+    /// A widget interested in drags that has a mouse press on it.
+    ///
+    /// Note that this is set as soon as the mouse is pressed,
+    /// so the widget may not yet be marked as "dragged",
+    /// as that can only happen after the mouse has moved a bit
+    /// (at least if the widget is interesated in both clicks and drags).
+    pub potential_drag_id: Option<Id>,
 }
 
-impl EpiIntegration {
-    #[allow(clippy::too_many_arguments)]
-    pub fn new(
-        egui_ctx: egui::Context,
-        window: &winit::window::Window,
-        system_theme: Option<Theme>,
-        app_name: &str,
-        native_options: &crate::NativeOptions,
-        storage: Option<Box<dyn epi::Storage>>,
-        #[cfg(feature = "glow")] gl: Option<std::sync::Arc<glow::Context>>,
-        #[cfg(feature = "wgpu")] wgpu_render_state: Option<egui_wgpu::RenderState>,
-    ) -> Self {
-        let frame = epi::Frame {
-            info: epi::IntegrationInfo {
-                system_theme,
-                cpu_usage: None,
-            },
-            storage,
-            #[cfg(feature = "glow")]
-            gl,
-            #[cfg(feature = "wgpu")]
-            wgpu_render_state,
-            raw_display_handle: window.display_handle().map(|h| h.as_raw()),
-            raw_window_handle: window.window_handle().map(|h| h.as_raw()),
-        };
+/// Keeps tracks of what widget has keyboard focus
+#[derive(Clone, Debug, Default)]
+pub(crate) struct Focus {
+    /// The widget with keyboard focus (i.e. a text input field).
+    focused_widget: Option<FocusWidget>,
 
-        let icon = native_options
-            .viewport
-            .icon
-            .clone()
-            .unwrap_or_else(|| std::sync::Arc::new(load_default_egui_icon()));
-
-        let app_icon_setter = super::app_icon::AppTitleIconSetter::new(
-            native_options
-                .viewport
-                .title
-                .clone()
-                .unwrap_or_else(|| app_name.to_owned()),
-            Some(icon),
-        );
+    /// What had keyboard focus previous frame?
+    id_previous_frame: Option<Id>,
 
+    /// Give focus to this widget next frame
+    id_next_frame: Option<Id>,
+
+    #[cfg(feature = "accesskit")]
+    id_requested_by_accesskit: Option<accesskit::NodeId>,
+
+    /// If set, the next widget that is interested in focus will automatically get it.
+    /// Probably because the user pressed Tab.
+    give_to_next: bool,
+
+    /// The last widget interested in focus.
+    last_interested: Option<Id>,
+
+    /// Set when looking for widget with navigational keys like arrows, tab, shift+tab
+    focus_direction: FocusDirection,
+
+    /// A cache of widget ids that are interested in focus with their corresponding rectangles.
+    focus_widgets_cache: IdMap<Rect>,
+}
+
+/// The widget with focus.
+#[derive(Clone, Copy, Debug)]
+struct FocusWidget {
+    pub id: Id,
+    pub filter: EventFilter,
+}
+
+impl FocusWidget {
+    pub fn new(id: Id) -> Self {
         Self {
-            frame,
-            last_auto_save: Instant::now(),
-            beginning: Instant::now(),
-            is_first_frame: true,
-            frame_start: 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,
-            app_icon_setter,
+            id,
+            filter: Default::default(),
         }
     }
+}
 
-    #[cfg(feature = "accesskit")]
-    pub fn init_accesskit<E: From<egui_winit::accesskit_winit::ActionRequestEvent> + Send>(
-        &self,
-        egui_winit: &mut egui_winit::State,
-        window: &winit::window::Window,
-        event_loop_proxy: winit::event_loop::EventLoopProxy<E>,
-    ) {
-        crate::profile_function!();
-
-        let egui_ctx = self.egui_ctx.clone();
-        egui_winit.init_accesskit(window, event_loop_proxy, move || {
-            // This function is called when an accessibility client
-            // (e.g. screen reader) makes its first request. If we got here,
-            // we know that an accessibility tree is actually wanted.
-            egui_ctx.enable_accesskit();
-            // Enqueue a repaint so we'll receive a full tree update soon.
-            egui_ctx.request_repaint();
-            egui_ctx.accesskit_placeholder_tree_update()
-        });
+impl InteractionState {
+    /// Are we currently clicking or dragging an egui widget?
+    pub fn is_using_pointer(&self) -> bool {
+        self.potential_click_id.is_some() || self.potential_drag_id.is_some()
     }
+}
 
-    /// If `true`, it is time to close the native window.
-    pub fn should_close(&self) -> bool {
-        self.close
+impl Focus {
+    /// Which widget currently has keyboard focus?
+    pub fn focused(&self) -> Option<Id> {
+        self.focused_widget.as_ref().map(|w| w.id)
     }
 
-    pub fn on_window_event(
-        &mut self,
-        window: &winit::window::Window,
-        egui_winit: &mut egui_winit::State,
-        event: &winit::event::WindowEvent,
-    ) -> EventResponse {
-        crate::profile_function!(egui_winit::short_window_event_description(event));
+    fn begin_frame(&mut self, new_input: &crate::data::input::RawInput) {
+        self.id_previous_frame = self.focused();
+        if let Some(id) = self.id_next_frame.take() {
+            self.focused_widget = Some(FocusWidget::new(id));
+        }
+        let event_filter = self.focused_widget.map(|w| w.filter).unwrap_or_default();
 
-        use winit::event::{ElementState, MouseButton, WindowEvent};
+        #[cfg(feature = "accesskit")]
+        {
+            self.id_requested_by_accesskit = None;
+        }
 
-        match event {
-            WindowEvent::Destroyed => {
-                log::debug!("Received WindowEvent::Destroyed");
-                self.close = true;
+        self.focus_direction = FocusDirection::None;
+
+        for event in &new_input.events {
+            if !event_filter.matches(event) {
+                if let crate::Event::Key {
+                    key,
+                    pressed: true,
+                    modifiers,
+                    ..
+                } = event
+                {
+                    if let Some(cardinality) = match key {
+                        crate::Key::ArrowUp => Some(FocusDirection::Up),
+                        crate::Key::ArrowRight => Some(FocusDirection::Right),
+                        crate::Key::ArrowDown => Some(FocusDirection::Down),
+                        crate::Key::ArrowLeft => Some(FocusDirection::Left),
+
+                        crate::Key::Tab => {
+                            if modifiers.shift {
+                                Some(FocusDirection::Previous)
+                            } else {
+                                Some(FocusDirection::Next)
+                            }
+                        }
+                        crate::Key::Escape => {
+                            self.focused_widget = None;
+                            Some(FocusDirection::None)
+                        }
+                        _ => None,
+                    } {
+                        self.focus_direction = cardinality;
+                    }
+                }
             }
-            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);
-                self.egui_ctx.set_visuals(theme.egui_visuals());
+
+            #[cfg(feature = "accesskit")]
+            {
+                if let crate::Event::AccessKitActionRequest(accesskit::ActionRequest {
+                    action: accesskit::Action::Focus,
+                    target,
+                    data: None,
+                }) = event
+                {
+                    self.id_requested_by_accesskit = Some(*target);
+                }
             }
-            _ => {}
         }
+    }
 
-        egui_winit.on_window_event(window, event)
+    pub(crate) fn end_frame(&mut self, used_ids: &IdMap<Rect>) {
+        if self.focus_direction.is_cardinal() {
+            if let Some(found_widget) = self.find_widget_in_direction(used_ids) {
+                self.focused_widget = Some(FocusWidget::new(found_widget));
+            }
+        }
+
+        if let Some(focused_widget) = self.focused_widget {
+            // Allow calling `request_focus` one frame and not using it until next frame
+            let recently_gained_focus = self.id_previous_frame != Some(focused_widget.id);
+
+            if !recently_gained_focus && !used_ids.contains_key(&focused_widget.id) {
+                // Dead-mans-switch: the widget with focus has disappeared!
+                self.focused_widget = None;
+            }
+        }
     }
 
-    pub fn pre_update(&mut self) {
-        self.app_icon_setter.update();
+    pub(crate) fn had_focus_last_frame(&self, id: Id) -> bool {
+        self.id_previous_frame == Some(id)
     }
 
-    /// Run user code - this can create immediate viewports, so hold no locks over this!
-    ///
-    /// If `viewport_ui_cb` is None, we are in the root viewport and will call [`crate::App::update`].
-    pub fn update(
-        &mut self,
-        app: &mut dyn epi::App,
-        viewport_ui_cb: Option<&DeferredViewportUiCallback>,
-        mut raw_input: egui::RawInput,
-    ) -> egui::FullOutput {
-        raw_input.time = Some(self.beginning.elapsed().as_secs_f64());
+    fn interested_in_focus(&mut self, id: Id) {
+        #[cfg(feature = "accesskit")]
+        {
+            if self.id_requested_by_accesskit == Some(id.accesskit_id()) {
+                self.focused_widget = Some(FocusWidget::new(id));
+                self.id_requested_by_accesskit = None;
+                self.give_to_next = false;
+                self.reset_focus();
+            }
+        }
+
+        // The rect is updated at the end of the frame.
+        self.focus_widgets_cache
+            .entry(id)
+            .or_insert(Rect::EVERYTHING);
+
+        if self.give_to_next && !self.had_focus_last_frame(id) {
+            self.focused_widget = Some(FocusWidget::new(id));
+            self.give_to_next = false;
+        } else if self.focused() == Some(id) {
+            if self.focus_direction == FocusDirection::Next {
+                self.focused_widget = None;
+                self.give_to_next = true;
+                self.reset_focus();
+            } else if self.focus_direction == FocusDirection::Previous {
+                self.id_next_frame = self.last_interested; // frame-delay so gained_focus works
+                self.reset_focus();
+            }
+        } else if self.focus_direction == FocusDirection::Next
+            && self.focused_widget.is_none()
+            && !self.give_to_next
+        {
+            // nothing has focus and the user pressed tab - give focus to the first widgets that wants it:
+            self.focused_widget = Some(FocusWidget::new(id));
+            self.reset_focus();
+        } else if self.focus_direction == FocusDirection::Previous
+            && self.focused_widget.is_none()
+            && !self.give_to_next
+        {
+            // nothing has focus and the user pressed Shift+Tab - give focus to the last widgets that wants it:
+            self.focused_widget = self.last_interested.map(FocusWidget::new);
+            self.reset_focus();
+        }
 
-        let close_requested = raw_input.viewport().close_requested();
+        self.last_interested = Some(id);
+    }
+
+    fn reset_focus(&mut self) {
+        self.focus_direction = FocusDirection::None;
+    }
 
-        app.raw_input_hook(&self.egui_ctx, &mut raw_input);
+    fn find_widget_in_direction(&mut self, new_rects: &IdMap<Rect>) -> Option<Id> {
+        // NOTE: `new_rects` here include some widgets _not_ interested in focus.
 
-        let full_output = self.egui_ctx.run(raw_input, |egui_ctx| {
-            if let Some(viewport_ui_cb) = viewport_ui_cb {
-                // Child Deferred Viewport
-                crate::profile_scope!("viewport_callback");
-                viewport_ui_cb(egui_ctx);
+        /// * negative if `a` is left of `b`
+        /// * positive if `a` is right of `b`
+        /// * zero if the ranges overlap significantly
+        fn range_diff(a: Rangef, b: Rangef) -> f32 {
+            let has_significant_overlap = a.intersection(b).span() >= 0.5 * b.span().min(a.span());
+            if has_significant_overlap {
+                0.0
             } else {
-                // ROOT Viewport ( with Immediate Viewport )
-                crate::profile_scope!("App::update");
-                app.update(egui_ctx, &mut self.frame);
+                a.center() - b.center()
             }
+        }
 
-            let continuous_mode = egui_ctx.options(|options| options.continuous_mode);
-            if continuous_mode {
-                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 Some(current_focused) = self.focused_widget else {
+            return None;
+        };
+
+        // In what direction we are looking for the next widget.
+        let search_direction = match self.focus_direction {
+            FocusDirection::Up => Vec2::UP,
+            FocusDirection::Right => Vec2::RIGHT,
+            FocusDirection::Down => Vec2::DOWN,
+            FocusDirection::Left => Vec2::LEFT,
+            _ => {
+                return None;
             }
-        });
+        };
 
-        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");
+        // Update cache with new rects
+        self.focus_widgets_cache.retain(|id, old_rect| {
+            if let Some(new_rect) = new_rects.get(id) {
+                *old_rect = *new_rect;
+                true // Keep the item
             } else {
-                log::debug!("Closing root viewport (ViewportCommand::CancelClose was not sent)");
-                self.close = true;
+                false // Remove the item
+            }
+        });
+
+        let Some(current_rect) = self.focus_widgets_cache.get(&current_focused.id) else {
+            return None;
+        };
+
+        let mut best_score = std::f32::INFINITY;
+        let mut best_id = None;
+
+        for (candidate_id, candidate_rect) in &self.focus_widgets_cache {
+            if *candidate_id == current_focused.id {
+                continue;
+            }
+
+            // There is a lot of room for improvement here.
+            let to_candidate = vec2(
+                range_diff(candidate_rect.x_range(), current_rect.x_range()),
+                range_diff(candidate_rect.y_range(), current_rect.y_range()),
+            );
+
+            let acos_angle = to_candidate.normalized().dot(search_direction);
+
+            // Only interested in widgets that fall in a 90° cone (±45°)
+            // of the search direction.
+            let is_in_search_cone = 0.5_f32.sqrt() <= acos_angle;
+            if is_in_search_cone {
+                let distance = to_candidate.length();
+
+                // There is a lot of room for improvement here.
+                let score = distance / (acos_angle * acos_angle);
+
+                if score < best_score {
+                    best_score = score;
+                    best_id = Some(*candidate_id);
+                }
             }
         }
 
-        self.pending_full_output.append(full_output);
-        std::mem::take(&mut self.pending_full_output)
+        best_id
     }
+}
 
-    pub fn report_frame_time(&mut self, seconds: f32) {
-        self.frame.info.cpu_usage = Some(seconds);
+impl Memory {
+    pub(crate) fn begin_frame(&mut self, new_raw_input: &RawInput, viewports: &ViewportIdSet) {
+        crate::profile_function!();
+
+        self.viewport_id = new_raw_input.viewport_id;
+
+        // Cleanup
+        self.interactions.retain(|id, _| viewports.contains(id));
+        self.areas.retain(|id, _| viewports.contains(id));
+
+        self.areas.entry(self.viewport_id).or_default();
+
+        // self.interactions  is handled elsewhere
+
+        self.focus
+            .entry(self.viewport_id)
+            .or_default()
+            .begin_frame(new_raw_input);
     }
 
-    pub fn post_rendering(&mut self, window: &winit::window::Window) {
-        crate::profile_function!();
-        if std::mem::take(&mut self.is_first_frame) {
-            // We keep hidden until we've painted something. See https://github.com/emilk/egui/pull/2279
-            window.set_visible(true);
-        }
+    pub(crate) fn end_frame(&mut self, used_ids: &IdMap<Rect>) {
+        self.caches.update();
+        self.areas_mut().end_frame();
+        self.focus_mut().end_frame(used_ids);
     }
 
-    // ------------------------------------------------------------------------
-    // Persistence stuff:
+    pub(crate) fn set_viewport_id(&mut self, viewport_id: ViewportId) {
+        self.viewport_id = viewport_id;
+    }
 
-    pub fn maybe_autosave(
-        &mut self,
-        app: &mut dyn epi::App,
-        window: Option<&winit::window::Window>,
-    ) {
-        let now = Instant::now();
-        if now - self.last_auto_save > app.auto_save_interval() {
-            self.save(app, window);
-            self.last_auto_save = now;
-        }
+    /// Access memory of the [`Area`](crate::containers::area::Area)s, such as `Window`s.
+    pub fn areas(&self) -> &Areas {
+        self.areas
+            .get(&self.viewport_id)
+            .expect("Memory broken: no area for the current viewport")
+    }
+
+    /// Access memory of the [`Area`](crate::containers::area::Area)s, such as `Window`s.
+    pub fn areas_mut(&mut self) -> &mut Areas {
+        self.areas.entry(self.viewport_id).or_default()
+    }
+
+    /// Top-most layer at the given position.
+    pub fn layer_id_at(&self, pos: Pos2) -> Option<LayerId> {
+        self.areas().layer_id_at(pos, &self.layer_transforms)
+    }
+
+    /// An iterator over all layers. Back-to-front. Top is last.
+    pub fn layer_ids(&self) -> impl ExactSizeIterator<Item = LayerId> + '_ {
+        self.areas().order().iter().copied()
+    }
+
+    pub(crate) fn had_focus_last_frame(&self, id: Id) -> bool {
+        self.focus().id_previous_frame == Some(id)
+    }
+
+    /// True if the given widget had keyboard focus last frame, but not this one.
+    pub(crate) fn lost_focus(&self, id: Id) -> bool {
+        self.had_focus_last_frame(id) && !self.has_focus(id)
+    }
+
+    /// True if the given widget has keyboard focus this frame, but didn't last frame.
+    pub(crate) fn gained_focus(&self, id: Id) -> bool {
+        !self.had_focus_last_frame(id) && self.has_focus(id)
     }
 
-    #[allow(clippy::unused_self)]
-    pub fn save(&mut self, _app: &mut dyn epi::App, _window: Option<&winit::window::Window>) {
-        #[cfg(feature = "persistence")]
-        if let Some(storage) = self.frame.storage_mut() {
-            crate::profile_function!();
-
-            if let Some(window) = _window {
-                if self.persist_window {
-                    crate::profile_scope!("native_window");
-                    epi::set_value(
-                        storage,
-                        STORAGE_WINDOW_KEY,
-                        &WindowSettings::from_window(self.egui_ctx.zoom_factor(), window),
-                    );
+    /// Does this widget have keyboard focus?
+    ///
+    /// This function does not consider whether the UI as a whole (e.g. window)
+    /// has the keyboard focus. That makes this function suitable for deciding
+    /// widget state that should not be disrupted if the user moves away
+    /// from the window and back.
+    #[inline(always)]
+    pub fn has_focus(&self, id: Id) -> bool {
+        self.focused() == Some(id)
+    }
+
+    /// Which widget has keyboard focus?
+    pub fn focused(&self) -> Option<Id> {
+        self.focus().focused()
+    }
+
+    /// Set an event filter for a widget.
+    ///
+    /// This allows you to control whether the widget will loose focus
+    /// when the user presses tab, arrow keys, or escape.
+    ///
+    /// You must first give focus to the widget before calling this.
+    pub fn set_focus_lock_filter(&mut self, id: Id, event_filter: EventFilter) {
+        if self.had_focus_last_frame(id) && self.has_focus(id) {
+            if let Some(focused) = &mut self.focus_mut().focused_widget {
+                if focused.id == id {
+                    focused.filter = event_filter;
                 }
             }
-            if _app.persist_egui_memory() {
-                crate::profile_scope!("egui_memory");
-                self.egui_ctx
-                    .memory(|mem| epi::set_value(storage, STORAGE_EGUI_MEMORY_KEY, mem));
-            }
-            {
-                crate::profile_scope!("App::save");
-                _app.save(storage);
-            }
+        }
+    }
+
+    /// Give keyboard focus to a specific widget.
+    /// See also [`crate::Response::request_focus`].
+    #[inline(always)]
+    pub fn request_focus(&mut self, id: Id) {
+        self.focus_mut().focused_widget = Some(FocusWidget::new(id));
+    }
 
-            crate::profile_scope!("Storage::flush");
-            storage.flush();
+    /// Surrender keyboard focus for a specific widget.
+    /// See also [`crate::Response::surrender_focus`].
+    #[inline(always)]
+    pub fn surrender_focus(&mut self, id: Id) {
+        let focus = self.focus_mut();
+        if focus.focused() == Some(id) {
+            focus.focused_widget = None;
         }
     }
-}
 
-fn load_default_egui_icon() -> egui::IconData {
-    crate::profile_function!();
-    crate::icon_data::from_png_bytes(&include_bytes!("../../data/icon.png")[..]).unwrap()
-}
+    /// Register this widget as being interested in getting keyboard focus.
+    /// This will allow the user to select it with tab and shift-tab.
+    /// This is normally done automatically when handling interactions,
+    /// but it is sometimes useful to pre-register interest in focus,
+    /// e.g. before deciding which type of underlying widget to use,
+    /// as in the [`crate::DragValue`] widget, so a widget can be focused
+    /// and rendered correctly in a single frame.
+    #[inline(always)]
+    pub fn interested_in_focus(&mut self, id: Id) {
+        self.focus_mut().interested_in_focus(id);
+    }
+
+    /// Stop editing of active [`TextEdit`](crate::TextEdit) (if any).
+    #[inline(always)]
+    pub fn stop_text_input(&mut self) {
+        self.focus_mut().focused_widget = None;
+    }
+
+    /// Is any widget being dragged?
+    #[deprecated = "Use `Context::dragged_id` instead"]
+    #[inline(always)]
+    pub fn is_anything_being_dragged(&self) -> bool {
+        self.interaction().potential_drag_id.is_some()
+    }
 
-#[cfg(feature = "persistence")]
-const STORAGE_EGUI_MEMORY_KEY: &str = "egui";
+    /// Is this specific widget being dragged?
+    ///
+    /// Usually it is better to use [`crate::Response::dragged`].
+    ///
+    /// A widget that sense both clicks and drags is only marked as "dragged"
+    /// when the mouse has moved a bit, but `is_being_dragged` will return true immediately.
+    #[deprecated = "Use `Context::is_being_dragged` instead"]
+    #[inline(always)]
+    pub fn is_being_dragged(&self, id: Id) -> bool {
+        self.interaction().potential_drag_id == Some(id)
+    }
+
+    /// Get the id of the widget being dragged, if any.
+    ///
+    /// Note that this is set as soon as the mouse is pressed,
+    /// so the widget may not yet be marked as "dragged",
+    /// as that can only happen after the mouse has moved a bit
+    /// (at least if the widget is interesated in both clicks and drags).
+    #[deprecated = "Use `Context::dragged_id` instead"]
+    #[inline(always)]
+    pub fn dragged_id(&self) -> Option<Id> {
+        self.interaction().potential_drag_id
+    }
+
+    /// Set which widget is being dragged.
+    #[inline(always)]
+    #[deprecated = "Use `Context::set_dragged_id` instead"]
+    pub fn set_dragged_id(&mut self, id: Id) {
+        self.interaction_mut().potential_drag_id = Some(id);
+    }
+
+    /// Stop dragging any widget.
+    #[inline(always)]
+    #[deprecated = "Use `Context::stop_dragging` instead"]
+    pub fn stop_dragging(&mut self) {
+        self.interaction_mut().potential_drag_id = None;
+    }
+
+    /// Is something else being dragged?
+    ///
+    /// Returns true if we are dragging something, but not the given widget.
+    #[inline(always)]
+    #[deprecated = "Use `Context::dragging_something_else` instead"]
+    pub fn dragging_something_else(&self, not_this: Id) -> bool {
+        let drag_id = self.interaction().potential_drag_id;
+        drag_id.is_some() && drag_id != Some(not_this)
+    }
+
+    /// Forget window positions, sizes etc.
+    /// Can be used to auto-layout windows.
+    pub fn reset_areas(&mut self) {
+        for area in self.areas.values_mut() {
+            *area = Default::default();
+        }
+    }
+
+    /// Obtain the previous rectangle of an area.
+    pub fn area_rect(&self, id: impl Into<Id>) -> Option<Rect> {
+        self.areas().get(id.into()).map(|state| state.rect())
+    }
+
+    pub(crate) fn interaction(&self) -> &InteractionState {
+        self.interactions
+            .get(&self.viewport_id)
+            .expect("Failed to get interaction")
+    }
+
+    pub(crate) fn interaction_mut(&mut self) -> &mut InteractionState {
+        self.interactions.entry(self.viewport_id).or_default()
+    }
 
-#[cfg(feature = "persistence")]
-const STORAGE_WINDOW_KEY: &str = "window";
+    pub(crate) fn focus(&self) -> &Focus {
+        self.focus
+            .get(&self.viewport_id)
+            .expect("Failed to get focus")
+    }
 
-pub fn load_window_settings(_storage: Option<&dyn epi::Storage>) -> Option<WindowSettings> {
-    crate::profile_function!();
-    #[cfg(feature = "persistence")]
-    {
-        epi::get_value(_storage?, STORAGE_WINDOW_KEY)
+    pub(crate) fn focus_mut(&mut self) -> &mut Focus {
+        self.focus.entry(self.viewport_id).or_default()
     }
-    #[cfg(not(feature = "persistence"))]
-    None
 }
 
-pub fn load_egui_memory(_storage: Option<&dyn epi::Storage>) -> Option<egui::Memory> {
-    crate::profile_function!();
-    #[cfg(feature = "persistence")]
-    {
-        epi::get_value(_storage?, STORAGE_EGUI_MEMORY_KEY)
+/// ## Popups
+/// Popups are things like combo-boxes, color pickers, menus etc.
+/// Only one can be be open at a time.
+impl Memory {
+    /// Is the given popup open?
+    pub fn is_popup_open(&self, popup_id: Id) -> bool {
+        self.popup == Some(popup_id) || self.everything_is_visible()
+    }
+
+    /// Is any popup open?
+    pub fn any_popup_open(&self) -> bool {
+        self.popup.is_some() || self.everything_is_visible()
+    }
+
+    /// Open the given popup, and close all other.
+    pub fn open_popup(&mut self, popup_id: Id) {
+        self.popup = Some(popup_id);
+    }
+
+    /// Close the open popup, if any.
+    pub fn close_popup(&mut self) {
+        self.popup = None;
+    }
+
+    /// Toggle the given popup between closed and open.
+    ///
+    /// Note: at most one popup can be open at one time.
+    pub fn toggle_popup(&mut self, popup_id: Id) {
+        if self.is_popup_open(popup_id) {
+            self.close_popup();
+        } else {
+            self.open_popup(popup_id);
+        }
+    }
+
+    /// If true, all windows, menus, tooltips etc are to be visible at once.
+    ///
+    /// This is useful for testing, benchmarking, pre-caching, etc.
+    ///
+    /// Experimental feature!
+    #[inline(always)]
+    pub fn everything_is_visible(&self) -> bool {
+        self.everything_is_visible
     }
-    #[cfg(not(feature = "persistence"))]
-    None
+
+    /// If true, all windows, menus, tooltips etc are to be visible at once.
+    ///
+    /// This is useful for testing, benchmarking, pre-caching, etc.
+    ///
+    /// Experimental feature!
+    pub fn set_everything_is_visible(&mut self, value: bool) {
+        self.everything_is_visible = value;
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Keeps track of [`Area`](crate::containers::area::Area)s, which are free-floating [`Ui`](crate::Ui)s.
+/// These [`Area`](crate::containers::area::Area)s can be in any [`Order`](crate::Order).
+#[derive(Clone, Debug, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+#[cfg_attr(feature = "serde", serde(default))]
+pub struct Areas {
+    areas: IdMap<area::State>,
+
+    /// Back-to-front. Top is last.
+    order: Vec<LayerId>,
+
+    visible_last_frame: ahash::HashSet<LayerId>,
+    visible_current_frame: ahash::HashSet<LayerId>,
+
+    /// When an area want to be on top, it is put in here.
+    /// At the end of the frame, this is used to reorder the layers.
+    /// This means if several layers want to be on top, they will keep their relative order.
+    /// So if you close three windows and then reopen them all in one frame,
+    /// they will all be sent to the top, but keep their previous internal order.
+    wants_to_be_on_top: ahash::HashSet<LayerId>,
 }
 
-pub(crate) fn theme_from_winit_theme(theme: winit::window::Theme) -> Theme {
-    match theme {
-        winit::window::Theme::Dark => Theme::Dark,
-        winit::window::Theme::Light => Theme::Light,
+impl Areas {
+    pub(crate) fn count(&self) -> usize {
+        self.areas.len()
+    }
+
+    pub(crate) fn get(&self, id: Id) -> Option<&area::State> {
+        self.areas.get(&id)
+    }
+
+    /// Back-to-front. Top is last.
+    pub(crate) fn order(&self) -> &[LayerId] {
+        &self.order
+    }
+
+    /// For each layer, which order is it in [`Self::order`]?
+    pub(crate) fn order_map(&self) -> HashMap<LayerId, usize> {
+        self.order
+            .iter()
+            .enumerate()
+            .map(|(i, id)| (*id, i))
+            .collect()
     }
+
+    pub(crate) fn set_state(&mut self, layer_id: LayerId, state: area::State) {
+        self.visible_current_frame.insert(layer_id);
+        self.areas.insert(layer_id.id, state);
+        if !self.order.iter().any(|x| *x == layer_id) {
+            self.order.push(layer_id);
+        }
+    }
+
+    /// Top-most layer at the given position.
+    pub fn layer_id_at(
+        &self,
+        pos: Pos2,
+        layer_transforms: &HashMap<LayerId, TSTransform>,
+    ) -> Option<LayerId> {
+        for layer in self.order.iter().rev() {
+            if self.is_visible(layer) {
+                if let Some(state) = self.areas.get(&layer.id) {
+                    let mut rect = state.rect();
+                    if state.interactable {
+                        if let Some(transform) = layer_transforms.get(layer) {
+                            rect = *transform * rect;
+                        }
+
+                        if rect.contains(pos) {
+                            return Some(*layer);
+                        }
+                    }
+                }
+            }
+        }
+        None
+    }
+
+    pub fn visible_last_frame(&self, layer_id: &LayerId) -> bool {
+        self.visible_last_frame.contains(layer_id)
+    }
+
+    pub fn is_visible(&self, layer_id: &LayerId) -> bool {
+        self.visible_last_frame.contains(layer_id) || self.visible_current_frame.contains(layer_id)
+    }
+
+    pub fn visible_layer_ids(&self) -> ahash::HashSet<LayerId> {
+        self.visible_last_frame
+            .iter()
+            .copied()
+            .chain(self.visible_current_frame.iter().copied())
+            .collect()
+    }
+
+    pub(crate) fn visible_windows(&self) -> Vec<&area::State> {
+        self.visible_layer_ids()
+            .iter()
+            .filter(|layer| layer.order == crate::Order::Middle)
+            .filter_map(|layer| self.get(layer.id))
+            .collect()
+    }
+
+    pub fn move_to_top(&mut self, layer_id: LayerId) {
+        self.visible_current_frame.insert(layer_id);
+        self.wants_to_be_on_top.insert(layer_id);
+
+        if !self.order.iter().any(|x| *x == layer_id) {
+            self.order.push(layer_id);
+        }
+    }
+
+    pub fn top_layer_id(&self, order: Order) -> Option<LayerId> {
+        self.order
+            .iter()
+            .filter(|layer| layer.order == order)
+            .last()
+            .copied()
+    }
+
+    pub(crate) fn end_frame(&mut self) {
+        let Self {
+            visible_last_frame,
+            visible_current_frame,
+            order,
+            wants_to_be_on_top,
+            ..
+        } = self;
+
+        std::mem::swap(visible_last_frame, visible_current_frame);
+        visible_current_frame.clear();
+        order.sort_by_key(|layer| (layer.order, wants_to_be_on_top.contains(layer)));
+        wants_to_be_on_top.clear();
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+#[test]
+fn memory_impl_send_sync() {
+    fn assert_send_sync<T: Send + Sync>() {}
+    assert_send_sync::<Memory>();
 }

From 7f66b56ed8aaaa8e6441b4a88cc7610e92a0e995 Mon Sep 17 00:00:00 2001
From: rustbasic <127506429+rustbasic@users.noreply.github.com>
Date: Sat, 23 Mar 2024 15:45:51 +0900
Subject: [PATCH 04/10] Update memory.rs

---
 crates/egui/src/memory.rs | 30 ++++++------------------------
 1 file changed, 6 insertions(+), 24 deletions(-)

diff --git a/crates/egui/src/memory.rs b/crates/egui/src/memory.rs
index bd8c2bfc3c3..068347b5697 100644
--- a/crates/egui/src/memory.rs
+++ b/crates/egui/src/memory.rs
@@ -191,14 +191,6 @@ pub struct Options {
     /// Controls the tessellator.
     pub tessellation_options: epaint::TessellationOptions,
 
-    /// If `true`, This will call `egui::Context::request_repaint()` at the end of each frame
-    /// If `false` (default), egui is only updated if are input events (like mouse movements) or there are some animations in the GUI.
-    ///
-    /// ```
-    ///     ui.ctx().options_mut(|options| { options.continuous_mode = true});
-    /// ```
-    pub continuous_mode: bool,
-
     /// If any widget moves or changes id, repaint everything.
     ///
     /// It is recommended you keep this OFF, because
@@ -238,7 +230,6 @@ impl Default for Options {
             zoom_factor: 1.0,
             zoom_with_keyboard: true,
             tessellation_options: Default::default(),
-            continuous_mode: false,
             repaint_on_widget_change: false,
             screen_reader: false,
             preload_font_glyphs: true,
@@ -255,7 +246,6 @@ impl Options {
             zoom_factor: _, // TODO
             zoom_with_keyboard,
             tessellation_options,
-            continuous_mode,
             repaint_on_widget_change,
             screen_reader: _, // needs to come from the integration
             preload_font_glyphs: _,
@@ -267,8 +257,6 @@ impl Options {
         CollapsingHeader::new("⚙ Options")
             .default_open(false)
             .show(ui, |ui| {
-                ui.checkbox(continuous_mode, "Repaint at the end of each frame");
-
                 ui.checkbox(
                     repaint_on_widget_change,
                     "Repaint if any widget moves or changes id",
@@ -533,9 +521,7 @@ impl Focus {
             }
         }
 
-        let Some(current_focused) = self.focused_widget else {
-            return None;
-        };
+        let current_focused = self.focused_widget?;
 
         // In what direction we are looking for the next widget.
         let search_direction = match self.focus_direction {
@@ -558,9 +544,7 @@ impl Focus {
             }
         });
 
-        let Some(current_rect) = self.focus_widgets_cache.get(&current_focused.id) else {
-            return None;
-        };
+        let current_rect = self.focus_widgets_cache.get(&current_focused.id)?;
 
         let mut best_score = std::f32::INFINITY;
         let mut best_id = None;
@@ -651,7 +635,7 @@ impl Memory {
     }
 
     pub(crate) fn had_focus_last_frame(&self, id: Id) -> bool {
-        self.focus().id_previous_frame == Some(id)
+        self.focus().and_then(|f| f.id_previous_frame) == Some(id)
     }
 
     /// True if the given widget had keyboard focus last frame, but not this one.
@@ -677,7 +661,7 @@ impl Memory {
 
     /// Which widget has keyboard focus?
     pub fn focused(&self) -> Option<Id> {
-        self.focus().focused()
+        self.focus().and_then(|f| f.focused())
     }
 
     /// Set an event filter for a widget.
@@ -809,10 +793,8 @@ impl Memory {
         self.interactions.entry(self.viewport_id).or_default()
     }
 
-    pub(crate) fn focus(&self) -> &Focus {
-        self.focus
-            .get(&self.viewport_id)
-            .expect("Failed to get focus")
+    pub(crate) fn focus(&self) -> Option<&Focus> {
+        self.focus.get(&self.viewport_id)
     }
 
     pub(crate) fn focus_mut(&mut self) -> &mut Focus {

From 6396c4aa8e2b60fbde8c4c5aedf8ca935bd6cf5f Mon Sep 17 00:00:00 2001
From: rustbasic <127506429+rustbasic@users.noreply.github.com>
Date: Sat, 23 Mar 2024 15:48:33 +0900
Subject: [PATCH 05/10] Update epi_integration.rs

---
 crates/eframe/src/native/epi_integration.rs | 12 +-----------
 1 file changed, 1 insertion(+), 11 deletions(-)

diff --git a/crates/eframe/src/native/epi_integration.rs b/crates/eframe/src/native/epi_integration.rs
index 30dea793f21..f27d011202e 100644
--- a/crates/eframe/src/native/epi_integration.rs
+++ b/crates/eframe/src/native/epi_integration.rs
@@ -278,23 +278,13 @@ impl EpiIntegration {
 
         let full_output = self.egui_ctx.run(raw_input, |egui_ctx| {
             if let Some(viewport_ui_cb) = viewport_ui_cb {
-                // Child Deferred Viewport
+                // Child 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 continuous_mode = egui_ctx.options(|options| options.continuous_mode);
-            if continuous_mode {
-                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();

From 821dff0300d2d3d464648fa3abb4b0f77c15b03d Mon Sep 17 00:00:00 2001
From: rustbasic <127506429+rustbasic@users.noreply.github.com>
Date: Sat, 30 Mar 2024 17:20:06 +0900
Subject: [PATCH 06/10] Update epi_integration.rs

---
 crates/eframe/src/native/epi_integration.rs | 2055 ++++++++++++++++---
 1 file changed, 1746 insertions(+), 309 deletions(-)

diff --git a/crates/eframe/src/native/epi_integration.rs b/crates/eframe/src/native/epi_integration.rs
index fbf7b6dc078..e6cb9e1fba8 100644
--- a/crates/eframe/src/native/epi_integration.rs
+++ b/crates/eframe/src/native/epi_integration.rs
@@ -1,407 +1,1844 @@
-//! Common tools used by [`super::glow_integration`] and [`super::wgpu_integration`].
+//! [`egui`] bindings for [`winit`](https://github.com/rust-windowing/winit).
+//!
+//! The library translates winit events to egui, handled copy/paste,
+//! updates the cursor, open links clicked in egui, etc.
+//!
+//! ## Feature flags
+#![cfg_attr(feature = "document-features", doc = document_features::document_features!())]
+//!
 
-use web_time::Instant;
-use winit::event_loop::EventLoopWindowTarget;
+#![allow(clippy::manual_range_contains)]
 
-use raw_window_handle::{HasDisplayHandle as _, HasWindowHandle as _};
+#[cfg(feature = "accesskit")]
+pub use accesskit_winit;
+pub use egui;
+#[cfg(feature = "accesskit")]
+use egui::accesskit;
+use egui::{Pos2, Rect, Vec2, ViewportBuilder, ViewportCommand, ViewportId, ViewportInfo};
+pub use winit;
 
-use egui::{DeferredViewportUiCallback, NumExt as _, ViewportBuilder, ViewportId};
-use egui_winit::{EventResponse, WindowSettings};
+pub mod clipboard;
+mod window_settings;
 
-use crate::{epi, Theme};
+pub use window_settings::WindowSettings;
 
-pub fn viewport_builder<E>(
-    egui_zoom_factor: f32,
-    event_loop: &EventLoopWindowTarget<E>,
-    native_options: &mut epi::NativeOptions,
-    window_settings: Option<WindowSettings>,
-) -> ViewportBuilder {
-    crate::profile_function!();
-
-    let mut viewport_builder = native_options.viewport.clone();
+use raw_window_handle::HasDisplayHandle;
 
-    // Always use the default window size / position on iOS. Trying to restore the previous position
-    // causes the window to be shown too small.
-    #[cfg(not(target_os = "ios"))]
-    let inner_size_points = if let Some(mut window_settings) = window_settings {
-        // Restore pos/size from previous session
+#[allow(unused_imports)]
+pub(crate) use profiling_scopes::*;
 
-        window_settings
-            .clamp_size_to_sane_values(largest_monitor_point_size(egui_zoom_factor, event_loop));
-        window_settings.clamp_position_to_monitors(egui_zoom_factor, event_loop);
-
-        viewport_builder = window_settings.initialize_viewport_builder(viewport_builder);
-        window_settings.inner_size_points()
-    } else {
-        if let Some(pos) = viewport_builder.position {
-            viewport_builder = viewport_builder.with_position(pos);
-        }
-
-        if let Some(initial_window_size) = viewport_builder.inner_size {
-            let initial_window_size = initial_window_size
-                .at_most(largest_monitor_point_size(egui_zoom_factor, event_loop));
-            viewport_builder = viewport_builder.with_inner_size(initial_window_size);
-        }
+use winit::{
+    dpi::{PhysicalPosition, PhysicalSize},
+    event_loop::EventLoopWindowTarget,
+    window::{CursorGrabMode, Window, WindowButtons, WindowLevel},
+};
 
-        viewport_builder.inner_size
-    };
-
-    #[cfg(not(target_os = "ios"))]
-    if native_options.centered {
-        crate::profile_scope!("center");
-        if let Some(monitor) = event_loop.available_monitors().next() {
-            let monitor_size = monitor
-                .size()
-                .to_logical::<f32>(egui_zoom_factor as f64 * monitor.scale_factor());
-            let inner_size = inner_size_points.unwrap_or(egui::Vec2 { x: 800.0, y: 600.0 });
-            if 0.0 < monitor_size.width && 0.0 < monitor_size.height {
-                let x = (monitor_size.width - inner_size.x) / 2.0;
-                let y = (monitor_size.height - inner_size.y) / 2.0;
-                viewport_builder = viewport_builder.with_position([x, y]);
-            }
-        }
-    }
+pub fn screen_size_in_pixels(window: &Window) -> egui::Vec2 {
+    let size = window.inner_size();
+    egui::vec2(size.width as f32, size.height as f32)
+}
 
-    match std::mem::take(&mut native_options.window_builder) {
-        Some(hook) => hook(viewport_builder),
-        None => viewport_builder,
-    }
+/// Calculate the `pixels_per_point` for a given window, given the current egui zoom factor
+pub fn pixels_per_point(egui_ctx: &egui::Context, window: &Window) -> f32 {
+    let native_pixels_per_point = window.scale_factor() as f32;
+    let egui_zoom_factor = egui_ctx.zoom_factor();
+    egui_zoom_factor * native_pixels_per_point
 }
 
-pub fn apply_window_settings(
-    window: &winit::window::Window,
-    window_settings: Option<WindowSettings>,
-) {
-    crate::profile_function!();
+// ----------------------------------------------------------------------------
 
-    if let Some(window_settings) = window_settings {
-        window_settings.initialize_window(window);
-    }
+#[must_use]
+#[derive(Clone, Copy, Debug, Default)]
+pub struct EventResponse {
+    /// If true, egui consumed this event, i.e. wants exclusive use of this event
+    /// (e.g. a mouse click on an egui window, or entering text into a text field).
+    ///
+    /// For instance, if you use egui for a game, you should only
+    /// pass on the events to your game when [`Self::consumed`] is `false.
+    ///
+    /// Note that egui uses `tab` to move focus between elements, so this will always be `true` for tabs.
+    pub consumed: bool,
+
+    /// Do we need an egui refresh because of this event?
+    pub repaint: bool,
 }
 
-fn largest_monitor_point_size<E>(
-    egui_zoom_factor: f32,
-    event_loop: &EventLoopWindowTarget<E>,
-) -> egui::Vec2 {
-    crate::profile_function!();
+// ----------------------------------------------------------------------------
 
-    let mut max_size = egui::Vec2::ZERO;
+/// Handles the integration between egui and a winit Window.
+///
+/// Instantiate one of these per viewport/window.
+pub struct State {
+    /// Shared clone.
+    egui_ctx: egui::Context,
 
-    let available_monitors = {
-        crate::profile_scope!("available_monitors");
-        event_loop.available_monitors()
-    };
+    viewport_id: ViewportId,
+    start_time: web_time::Instant,
+    egui_input: egui::RawInput,
+    pointer_pos_in_points: Option<egui::Pos2>,
+    any_pointer_button_down: bool,
+    current_cursor_icon: Option<egui::CursorIcon>,
 
-    for monitor in available_monitors {
-        let size = monitor
-            .size()
-            .to_logical::<f32>(egui_zoom_factor as f64 * monitor.scale_factor());
-        let size = egui::vec2(size.width, size.height);
-        max_size = max_size.max(size);
-    }
+    clipboard: clipboard::Clipboard,
 
-    if max_size == egui::Vec2::ZERO {
-        egui::Vec2::splat(16000.0)
-    } else {
-        max_size
-    }
-}
+    /// If `true`, mouse inputs will be treated as touches.
+    /// Useful for debugging touch support in egui.
+    ///
+    /// Creates duplicate touches, if real touch inputs are coming.
+    simulate_touch_screen: bool,
 
-// ----------------------------------------------------------------------------
+    /// Is Some(…) when a touch is being translated to a pointer.
+    ///
+    /// Only one touch will be interpreted as pointer at any time.
+    pointer_touch_id: Option<u64>,
 
-/// For loading/saving app state and/or egui memory to disk.
-pub fn create_storage(_app_name: &str) -> Option<Box<dyn epi::Storage>> {
-    #[cfg(feature = "persistence")]
-    if let Some(storage) = super::file_storage::FileStorage::from_app_id(_app_name) {
-        return Some(Box::new(storage));
-    }
-    None
-}
+    /// track ime state
+    input_method_editor_started: bool,
 
-// ----------------------------------------------------------------------------
+    #[cfg(feature = "accesskit")]
+    accesskit: Option<accesskit_winit::Adapter>,
 
-/// Everything needed to make a winit-based integration for [`epi`].
-///
-/// Only one instance per app (not one per viewport).
-pub struct EpiIntegration {
-    pub frame: epi::Frame,
-    last_auto_save: Instant,
-    pub beginning: Instant,
-    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,
-    app_icon_setter: super::app_icon::AppTitleIconSetter,
+    allow_ime: bool,
 }
 
-impl EpiIntegration {
-    #[allow(clippy::too_many_arguments)]
+impl State {
+    /// Construct a new instance
     pub fn new(
         egui_ctx: egui::Context,
-        window: &winit::window::Window,
-        system_theme: Option<Theme>,
-        app_name: &str,
-        native_options: &crate::NativeOptions,
-        storage: Option<Box<dyn epi::Storage>>,
-        #[cfg(feature = "glow")] gl: Option<std::sync::Arc<glow::Context>>,
-        #[cfg(feature = "glow")] glow_register_native_texture: Option<
-            Box<dyn FnMut(glow::Texture) -> egui::TextureId>,
-        >,
-        #[cfg(feature = "wgpu")] wgpu_render_state: Option<egui_wgpu::RenderState>,
+        viewport_id: ViewportId,
+        display_target: &dyn HasDisplayHandle,
+        native_pixels_per_point: Option<f32>,
+        max_texture_side: Option<usize>,
     ) -> Self {
-        let frame = epi::Frame {
-            info: epi::IntegrationInfo {
-                system_theme,
-                cpu_usage: None,
-            },
-            storage,
-            #[cfg(feature = "glow")]
-            gl,
-            #[cfg(feature = "glow")]
-            glow_register_native_texture,
-            #[cfg(feature = "wgpu")]
-            wgpu_render_state,
-            raw_display_handle: window.display_handle().map(|h| h.as_raw()),
-            raw_window_handle: window.window_handle().map(|h| h.as_raw()),
-        };
+        crate::profile_function!();
 
-        let icon = native_options
-            .viewport
-            .icon
-            .clone()
-            .unwrap_or_else(|| std::sync::Arc::new(load_default_egui_icon()));
-
-        let app_icon_setter = super::app_icon::AppTitleIconSetter::new(
-            native_options
-                .viewport
-                .title
-                .clone()
-                .unwrap_or_else(|| app_name.to_owned()),
-            Some(icon),
-        );
+        let egui_input = egui::RawInput {
+            focused: false, // winit will tell us when we have focus
+            ..Default::default()
+        };
 
-        Self {
-            frame,
-            last_auto_save: Instant::now(),
+        let mut slf = Self {
             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,
-            app_icon_setter,
-            beginning: Instant::now(),
-            is_first_frame: true,
-            frame_start: Instant::now(),
+            viewport_id,
+            start_time: web_time::Instant::now(),
+            egui_input,
+            pointer_pos_in_points: None,
+            any_pointer_button_down: false,
+            current_cursor_icon: None,
+
+            clipboard: clipboard::Clipboard::new(
+                display_target.display_handle().ok().map(|h| h.as_raw()),
+            ),
+
+            simulate_touch_screen: false,
+            pointer_touch_id: None,
+
+            input_method_editor_started: false,
+
+            #[cfg(feature = "accesskit")]
+            accesskit: None,
+
+            allow_ime: false,
+        };
+
+        slf.egui_input
+            .viewports
+            .entry(ViewportId::ROOT)
+            .or_default()
+            .native_pixels_per_point = native_pixels_per_point;
+
+        if let Some(max_texture_side) = max_texture_side {
+            slf.set_max_texture_side(max_texture_side);
         }
+        slf
     }
 
     #[cfg(feature = "accesskit")]
-    pub fn init_accesskit<E: From<egui_winit::accesskit_winit::ActionRequestEvent> + Send>(
-        &self,
-        egui_winit: &mut egui_winit::State,
-        window: &winit::window::Window,
-        event_loop_proxy: winit::event_loop::EventLoopProxy<E>,
+    pub fn init_accesskit<T: From<accesskit_winit::ActionRequestEvent> + Send>(
+        &mut self,
+        window: &Window,
+        event_loop_proxy: winit::event_loop::EventLoopProxy<T>,
+        initial_tree_update_factory: impl 'static + FnOnce() -> accesskit::TreeUpdate + Send,
     ) {
         crate::profile_function!();
+        self.accesskit = Some(accesskit_winit::Adapter::new(
+            window,
+            initial_tree_update_factory,
+            event_loop_proxy,
+        ));
+    }
 
-        let egui_ctx = self.egui_ctx.clone();
-        egui_winit.init_accesskit(window, event_loop_proxy, move || {
-            // This function is called when an accessibility client
-            // (e.g. screen reader) makes its first request. If we got here,
-            // we know that an accessibility tree is actually wanted.
-            egui_ctx.enable_accesskit();
-            // Enqueue a repaint so we'll receive a full tree update soon.
-            egui_ctx.request_repaint();
-            egui_ctx.accesskit_placeholder_tree_update()
-        });
+    /// Call this once a graphics context has been created to update the maximum texture dimensions
+    /// that egui will use.
+    pub fn set_max_texture_side(&mut self, max_texture_side: usize) {
+        self.egui_input.max_texture_side = Some(max_texture_side);
+    }
+
+    /// Fetches text from the clipboard and returns it.
+    pub fn clipboard_text(&mut self) -> Option<String> {
+        self.clipboard.get()
+    }
+
+    /// Places the text onto the clipboard.
+    pub fn set_clipboard_text(&mut self, text: String) {
+        self.clipboard.set(text);
+    }
+
+    /// Returns [`false`] or the last value that [`Window::set_ime_allowed()`] was called with, used for debouncing.
+    pub fn allow_ime(&self) -> bool {
+        self.allow_ime
+    }
+
+    /// Set the last value that [`Window::set_ime_allowed()`] was called with.
+    pub fn set_allow_ime(&mut self, allow: bool) {
+        self.allow_ime = allow;
+    }
+
+    #[inline]
+    pub fn egui_ctx(&self) -> &egui::Context {
+        &self.egui_ctx
+    }
+
+    /// The current input state.
+    /// This is changed by [`Self::on_window_event`] and cleared by [`Self::take_egui_input`].
+    #[inline]
+    pub fn egui_input(&self) -> &egui::RawInput {
+        &self.egui_input
     }
 
-    /// If `true`, it is time to close the native window.
-    pub fn should_close(&self) -> bool {
-        self.close
+    /// The current input state.
+    /// This is changed by [`Self::on_window_event`] and cleared by [`Self::take_egui_input`].
+    #[inline]
+    pub fn egui_input_mut(&mut self) -> &mut egui::RawInput {
+        &mut self.egui_input
     }
 
+    /// Prepare for a new frame by extracting the accumulated input,
+    ///
+    /// as well as setting [the time](egui::RawInput::time) and [screen rectangle](egui::RawInput::screen_rect).
+    ///
+    /// You need to set [`egui::RawInput::viewports`] yourself though.
+    /// Use [`update_viewport_info`] to update the info for each
+    /// viewport.
+    pub fn take_egui_input(&mut self, window: &Window) -> egui::RawInput {
+        crate::profile_function!();
+
+        self.egui_input.time = Some(self.start_time.elapsed().as_secs_f64());
+
+        // On Windows, a minimized window will have 0 width and height.
+        // See: https://github.com/rust-windowing/winit/issues/208
+        // This solves an issue where egui window positions would be changed when minimizing on Windows.
+        let screen_size_in_pixels = screen_size_in_pixels(window);
+        let screen_size_in_points =
+            screen_size_in_pixels / pixels_per_point(&self.egui_ctx, window);
+
+        self.egui_input.screen_rect = (screen_size_in_points.x > 0.0
+            && screen_size_in_points.y > 0.0)
+            .then(|| Rect::from_min_size(Pos2::ZERO, screen_size_in_points));
+
+        // Tell egui which viewport is now active:
+        self.egui_input.viewport_id = self.viewport_id;
+
+        self.egui_input
+            .viewports
+            .entry(self.viewport_id)
+            .or_default()
+            .native_pixels_per_point = Some(window.scale_factor() as f32);
+
+        self.egui_input.take()
+    }
+
+    /// Call this when there is a new event.
+    ///
+    /// The result can be found in [`Self::egui_input`] and be extracted with [`Self::take_egui_input`].
     pub fn on_window_event(
         &mut self,
-        window: &winit::window::Window,
-        egui_winit: &mut egui_winit::State,
+        window: &Window,
         event: &winit::event::WindowEvent,
     ) -> EventResponse {
-        crate::profile_function!(egui_winit::short_window_event_description(event));
+        crate::profile_function!(short_window_event_description(event));
 
-        use winit::event::{ElementState, MouseButton, WindowEvent};
+        #[cfg(feature = "accesskit")]
+        if let Some(accesskit) = &self.accesskit {
+            accesskit.process_event(window, event);
+        }
 
+        use winit::event::WindowEvent;
         match event {
-            WindowEvent::Destroyed => {
-                log::debug!("Received WindowEvent::Destroyed");
-                self.close = true;
+            WindowEvent::ScaleFactorChanged { scale_factor, .. } => {
+                let native_pixels_per_point = *scale_factor as f32;
+
+                self.egui_input
+                    .viewports
+                    .entry(self.viewport_id)
+                    .or_default()
+                    .native_pixels_per_point = Some(native_pixels_per_point);
+
+                EventResponse {
+                    repaint: true,
+                    consumed: false,
+                }
             }
-            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);
-                self.egui_ctx.set_visuals(theme.egui_visuals());
+            WindowEvent::MouseInput { state, button, .. } => {
+                self.on_mouse_button_input(*state, *button);
+                EventResponse {
+                    repaint: true,
+                    consumed: self.egui_ctx.wants_pointer_input(),
+                }
             }
-            _ => {}
-        }
+            WindowEvent::MouseWheel { delta, .. } => {
+                self.on_mouse_wheel(window, *delta);
+                EventResponse {
+                    repaint: true,
+                    consumed: self.egui_ctx.wants_pointer_input(),
+                }
+            }
+            WindowEvent::CursorMoved { position, .. } => {
+                self.on_cursor_moved(window, *position);
+                EventResponse {
+                    repaint: true,
+                    consumed: self.egui_ctx.is_using_pointer(),
+                }
+            }
+            WindowEvent::CursorLeft { .. } => {
+                self.pointer_pos_in_points = None;
+                self.egui_input.events.push(egui::Event::PointerGone);
+                EventResponse {
+                    repaint: true,
+                    consumed: false,
+                }
+            }
+            // WindowEvent::TouchpadPressure {device_id, pressure, stage, ..  } => {} // TODO(emilk)
+            WindowEvent::Touch(touch) => {
+                self.on_touch(window, touch);
+                let consumed = match touch.phase {
+                    winit::event::TouchPhase::Started
+                    | winit::event::TouchPhase::Ended
+                    | winit::event::TouchPhase::Cancelled => self.egui_ctx.wants_pointer_input(),
+                    winit::event::TouchPhase::Moved => self.egui_ctx.is_using_pointer(),
+                };
+                EventResponse {
+                    repaint: true,
+                    consumed,
+                }
+            }
+
+            WindowEvent::Ime(ime) => {
+                // on Mac even Cmd-C is pressed during ime, a `c` is pushed to Preedit.
+                // So no need to check is_mac_cmd.
+                //
+                // How winit produce `Ime::Enabled` and `Ime::Disabled` differs in MacOS
+                // and Windows.
+                //
+                // - On Windows, before and after each Commit will produce an Enable/Disabled
+                // event.
+                // - On MacOS, only when user explicit enable/disable ime. No Disabled
+                // after Commit.
+                //
+                // We use input_method_editor_started to manually insert CompositionStart
+                // between Commits.
+                match ime {
+                    winit::event::Ime::Enabled | winit::event::Ime::Disabled => (),
+                    winit::event::Ime::Commit(text) => {
+                        self.input_method_editor_started = false;
+                        self.egui_input
+                            .events
+                            .push(egui::Event::CompositionEnd(text.clone()));
+                    }
+                    winit::event::Ime::Preedit(text, Some(_)) => {
+                        if !self.input_method_editor_started {
+                            self.input_method_editor_started = true;
+                            self.egui_input.events.push(egui::Event::CompositionStart);
+                        }
+                        self.egui_input
+                            .events
+                            .push(egui::Event::CompositionUpdate(text.clone()));
+                    }
+                    winit::event::Ime::Preedit(_, None) => {}
+                };
+
+                EventResponse {
+                    repaint: true,
+                    consumed: self.egui_ctx.wants_keyboard_input(),
+                }
+            }
+            WindowEvent::KeyboardInput { event, .. } => {
+                self.on_keyboard_input(event);
 
-        egui_winit.on_window_event(window, event)
+                // When pressing the Tab key, egui focuses the first focusable element, hence Tab always consumes.
+                let consumed = self.egui_ctx.wants_keyboard_input()
+                    || event.logical_key
+                        == winit::keyboard::Key::Named(winit::keyboard::NamedKey::Tab);
+                EventResponse {
+                    repaint: true,
+                    consumed,
+                }
+            }
+            WindowEvent::Focused(focused) => {
+                self.egui_input.focused = *focused;
+                self.egui_input
+                    .events
+                    .push(egui::Event::WindowFocused(*focused));
+                EventResponse {
+                    repaint: true,
+                    consumed: false,
+                }
+            }
+            WindowEvent::HoveredFile(path) => {
+                self.egui_input.hovered_files.push(egui::HoveredFile {
+                    path: Some(path.clone()),
+                    ..Default::default()
+                });
+                EventResponse {
+                    repaint: true,
+                    consumed: false,
+                }
+            }
+            WindowEvent::HoveredFileCancelled => {
+                self.egui_input.hovered_files.clear();
+                EventResponse {
+                    repaint: true,
+                    consumed: false,
+                }
+            }
+            WindowEvent::DroppedFile(path) => {
+                self.egui_input.hovered_files.clear();
+                self.egui_input.dropped_files.push(egui::DroppedFile {
+                    path: Some(path.clone()),
+                    ..Default::default()
+                });
+                EventResponse {
+                    repaint: true,
+                    consumed: false,
+                }
+            }
+            WindowEvent::ModifiersChanged(state) => {
+                let state = state.state();
+
+                let alt = state.alt_key();
+                let ctrl = state.control_key();
+                let shift = state.shift_key();
+                let super_ = state.super_key();
+
+                self.egui_input.modifiers.alt = alt;
+                self.egui_input.modifiers.ctrl = ctrl;
+                self.egui_input.modifiers.shift = shift;
+                self.egui_input.modifiers.mac_cmd = cfg!(target_os = "macos") && super_;
+                self.egui_input.modifiers.command = if cfg!(target_os = "macos") {
+                    super_
+                } else {
+                    ctrl
+                };
+
+                EventResponse {
+                    repaint: true,
+                    consumed: false,
+                }
+            }
+
+            // Things that may require repaint:
+            WindowEvent::RedrawRequested
+            | WindowEvent::CursorEntered { .. }
+            | WindowEvent::Destroyed
+            | WindowEvent::Occluded(_)
+            | WindowEvent::Resized(_)
+            | WindowEvent::Moved(_)
+            | WindowEvent::ThemeChanged(_)
+            | WindowEvent::TouchpadPressure { .. }
+            | WindowEvent::CloseRequested => EventResponse {
+                repaint: true,
+                consumed: false,
+            },
+
+            // Things we completely ignore:
+            WindowEvent::ActivationTokenDone { .. }
+            | WindowEvent::AxisMotion { .. }
+            | WindowEvent::SmartMagnify { .. }
+            | WindowEvent::TouchpadRotate { .. } => EventResponse {
+                repaint: false,
+                consumed: false,
+            },
+
+            WindowEvent::TouchpadMagnify { delta, .. } => {
+                // Positive delta values indicate magnification (zooming in).
+                // Negative delta values indicate shrinking (zooming out).
+                let zoom_factor = (*delta as f32).exp();
+                self.egui_input.events.push(egui::Event::Zoom(zoom_factor));
+                EventResponse {
+                    repaint: true,
+                    consumed: self.egui_ctx.wants_pointer_input(),
+                }
+            }
+        }
     }
 
-    pub fn pre_update(&mut self) {
-        self.app_icon_setter.update();
+    pub fn on_mouse_motion(&mut self, delta: (f64, f64)) {
+        self.egui_input.events.push(egui::Event::MouseMoved(Vec2 {
+            x: delta.0 as f32,
+            y: delta.1 as f32,
+        }));
     }
 
-    /// Run user code - this can create immediate viewports, so hold no locks over this!
+    /// Call this when there is a new [`accesskit::ActionRequest`].
     ///
-    /// If `viewport_ui_cb` is None, we are in the root viewport and will call [`crate::App::update`].
-    pub fn update(
+    /// The result can be found in [`Self::egui_input`] and be extracted with [`Self::take_egui_input`].
+    #[cfg(feature = "accesskit")]
+    pub fn on_accesskit_action_request(&mut self, request: accesskit::ActionRequest) {
+        self.egui_input
+            .events
+            .push(egui::Event::AccessKitActionRequest(request));
+    }
+
+    fn on_mouse_button_input(
         &mut self,
-        app: &mut dyn epi::App,
-        viewport_ui_cb: Option<&DeferredViewportUiCallback>,
-        mut raw_input: egui::RawInput,
-    ) -> egui::FullOutput {
-        raw_input.time = Some(self.beginning.elapsed().as_secs_f64());
+        state: winit::event::ElementState,
+        button: winit::event::MouseButton,
+    ) {
+        if let Some(pos) = self.pointer_pos_in_points {
+            if let Some(button) = translate_mouse_button(button) {
+                let pressed = state == winit::event::ElementState::Pressed;
 
-        let close_requested = raw_input.viewport().close_requested();
+                self.egui_input.events.push(egui::Event::PointerButton {
+                    pos,
+                    button,
+                    pressed,
+                    modifiers: self.egui_input.modifiers,
+                });
 
-        app.raw_input_hook(&self.egui_ctx, &mut raw_input);
+                if self.simulate_touch_screen {
+                    if pressed {
+                        self.any_pointer_button_down = true;
 
-        let full_output = self.egui_ctx.run(raw_input, |egui_ctx| {
-            if let Some(viewport_ui_cb) = viewport_ui_cb {
-                // Child viewport
-                crate::profile_scope!("viewport_callback");
-                viewport_ui_cb(egui_ctx);
-            } else {
-                crate::profile_scope!("App::update");
-                app.update(egui_ctx, &mut self.frame);
-            }
-        });
+                        self.egui_input.events.push(egui::Event::Touch {
+                            device_id: egui::TouchDeviceId(0),
+                            id: egui::TouchId(0),
+                            phase: egui::TouchPhase::Start,
+                            pos,
+                            force: None,
+                        });
+                    } else {
+                        self.any_pointer_button_down = false;
 
-        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;
+                        self.egui_input.events.push(egui::Event::PointerGone);
+
+                        self.egui_input.events.push(egui::Event::Touch {
+                            device_id: egui::TouchDeviceId(0),
+                            id: egui::TouchId(0),
+                            phase: egui::TouchPhase::End,
+                            pos,
+                            force: None,
+                        });
+                    };
+                }
             }
         }
+    }
+
+    fn on_cursor_moved(
+        &mut self,
+        window: &Window,
+        pos_in_pixels: winit::dpi::PhysicalPosition<f64>,
+    ) {
+        let pixels_per_point = pixels_per_point(&self.egui_ctx, window);
+
+        let pos_in_points = egui::pos2(
+            pos_in_pixels.x as f32 / pixels_per_point,
+            pos_in_pixels.y as f32 / pixels_per_point,
+        );
+        self.pointer_pos_in_points = Some(pos_in_points);
+
+        if self.simulate_touch_screen {
+            if self.any_pointer_button_down {
+                self.egui_input
+                    .events
+                    .push(egui::Event::PointerMoved(pos_in_points));
 
-        self.pending_full_output.append(full_output);
-        std::mem::take(&mut self.pending_full_output)
+                self.egui_input.events.push(egui::Event::Touch {
+                    device_id: egui::TouchDeviceId(0),
+                    id: egui::TouchId(0),
+                    phase: egui::TouchPhase::Move,
+                    pos: pos_in_points,
+                    force: None,
+                });
+            }
+        } else {
+            self.egui_input
+                .events
+                .push(egui::Event::PointerMoved(pos_in_points));
+        }
     }
 
-    pub fn report_frame_time(&mut self, seconds: f32) {
-        self.frame.info.cpu_usage = Some(seconds);
+    fn on_touch(&mut self, window: &Window, touch: &winit::event::Touch) {
+        let pixels_per_point = pixels_per_point(&self.egui_ctx, window);
+
+        // Emit touch event
+        self.egui_input.events.push(egui::Event::Touch {
+            device_id: egui::TouchDeviceId(egui::epaint::util::hash(touch.device_id)),
+            id: egui::TouchId::from(touch.id),
+            phase: match touch.phase {
+                winit::event::TouchPhase::Started => egui::TouchPhase::Start,
+                winit::event::TouchPhase::Moved => egui::TouchPhase::Move,
+                winit::event::TouchPhase::Ended => egui::TouchPhase::End,
+                winit::event::TouchPhase::Cancelled => egui::TouchPhase::Cancel,
+            },
+            pos: egui::pos2(
+                touch.location.x as f32 / pixels_per_point,
+                touch.location.y as f32 / pixels_per_point,
+            ),
+            force: match touch.force {
+                Some(winit::event::Force::Normalized(force)) => Some(force as f32),
+                Some(winit::event::Force::Calibrated {
+                    force,
+                    max_possible_force,
+                    ..
+                }) => Some((force / max_possible_force) as f32),
+                None => None,
+            },
+        });
+        // If we're not yet translating a touch or we're translating this very
+        // touch …
+        if self.pointer_touch_id.is_none() || self.pointer_touch_id.unwrap() == touch.id {
+            // … emit PointerButton resp. PointerMoved events to emulate mouse
+            match touch.phase {
+                winit::event::TouchPhase::Started => {
+                    self.pointer_touch_id = Some(touch.id);
+                    // First move the pointer to the right location
+                    self.on_cursor_moved(window, touch.location);
+                    self.on_mouse_button_input(
+                        winit::event::ElementState::Pressed,
+                        winit::event::MouseButton::Left,
+                    );
+                }
+                winit::event::TouchPhase::Moved => {
+                    self.on_cursor_moved(window, touch.location);
+                }
+                winit::event::TouchPhase::Ended => {
+                    self.pointer_touch_id = None;
+                    self.on_mouse_button_input(
+                        winit::event::ElementState::Released,
+                        winit::event::MouseButton::Left,
+                    );
+                    // The pointer should vanish completely to not get any
+                    // hover effects
+                    self.pointer_pos_in_points = None;
+                    self.egui_input.events.push(egui::Event::PointerGone);
+                }
+                winit::event::TouchPhase::Cancelled => {
+                    self.pointer_touch_id = None;
+                    self.pointer_pos_in_points = None;
+                    self.egui_input.events.push(egui::Event::PointerGone);
+                }
+            }
+        }
     }
 
-    pub fn post_rendering(&mut self, window: &winit::window::Window) {
-        crate::profile_function!();
-        if std::mem::take(&mut self.is_first_frame) {
-            // We keep hidden until we've painted something. See https://github.com/emilk/egui/pull/2279
-            window.set_visible(true);
+    fn on_mouse_wheel(&mut self, window: &Window, delta: winit::event::MouseScrollDelta) {
+        let pixels_per_point = pixels_per_point(&self.egui_ctx, window);
+
+        {
+            let (unit, delta) = match delta {
+                winit::event::MouseScrollDelta::LineDelta(x, y) => {
+                    (egui::MouseWheelUnit::Line, egui::vec2(x, y))
+                }
+                winit::event::MouseScrollDelta::PixelDelta(winit::dpi::PhysicalPosition {
+                    x,
+                    y,
+                }) => (
+                    egui::MouseWheelUnit::Point,
+                    egui::vec2(x as f32, y as f32) / pixels_per_point,
+                ),
+            };
+            let modifiers = self.egui_input.modifiers;
+            self.egui_input.events.push(egui::Event::MouseWheel {
+                unit,
+                delta,
+                modifiers,
+            });
+        }
+        let delta = match delta {
+            winit::event::MouseScrollDelta::LineDelta(x, y) => {
+                let points_per_scroll_line = 50.0; // Scroll speed decided by consensus: https://github.com/emilk/egui/issues/461
+                egui::vec2(x, y) * points_per_scroll_line
+            }
+            winit::event::MouseScrollDelta::PixelDelta(delta) => {
+                egui::vec2(delta.x as f32, delta.y as f32) / pixels_per_point
+            }
+        };
+
+        if self.egui_input.modifiers.ctrl || self.egui_input.modifiers.command {
+            // Treat as zoom instead:
+            let factor = (delta.y / 200.0).exp();
+            self.egui_input.events.push(egui::Event::Zoom(factor));
+        } else if self.egui_input.modifiers.shift {
+            // Treat as horizontal scrolling.
+            // Note: one Mac we already get horizontal scroll events when shift is down.
+            self.egui_input
+                .events
+                .push(egui::Event::Scroll(egui::vec2(delta.x + delta.y, 0.0)));
+        } else {
+            self.egui_input.events.push(egui::Event::Scroll(delta));
         }
     }
 
-    // ------------------------------------------------------------------------
-    // Persistence stuff:
+    fn on_keyboard_input(&mut self, event: &winit::event::KeyEvent) {
+        let winit::event::KeyEvent {
+            // Represents the position of a key independent of the currently active layout.
+            //
+            // It also uniquely identifies the physical key (i.e. it's mostly synonymous with a scancode).
+            // The most prevalent use case for this is games. For example the default keys for the player
+            // to move around might be the W, A, S, and D keys on a US layout. The position of these keys
+            // is more important than their label, so they should map to Z, Q, S, and D on an "AZERTY"
+            // layout. (This value is `KeyCode::KeyW` for the Z key on an AZERTY layout.)
+            physical_key,
+
+            // Represents the results of a keymap, i.e. what character a certain key press represents.
+            // When telling users "Press Ctrl-F to find", this is where we should
+            // look for the "F" key, because they may have a dvorak layout on
+            // a qwerty keyboard, and so the logical "F" character may not be located on the physical `KeyCode::KeyF` position.
+            logical_key,
+
+            text,
+
+            state,
 
-    pub fn maybe_autosave(
+            location: _, // e.g. is it on the numpad?
+            repeat: _,   // egui will figure this out for us
+            ..
+        } = event;
+
+        let pressed = *state == winit::event::ElementState::Pressed;
+
+        let physical_key = if let winit::keyboard::PhysicalKey::Code(keycode) = *physical_key {
+            key_from_key_code(keycode)
+        } else {
+            None
+        };
+
+        let logical_key = key_from_winit_key(logical_key);
+
+        // Helpful logging to enable when adding new key support
+        log::trace!(
+            "logical {:?} -> {:?},  physical {:?} -> {:?}",
+            event.logical_key,
+            logical_key,
+            event.physical_key,
+            physical_key
+        );
+
+        if let Some(logical_key) = logical_key {
+            if pressed {
+                if is_cut_command(self.egui_input.modifiers, logical_key) {
+                    self.egui_input.events.push(egui::Event::Cut);
+                    return;
+                } else if is_copy_command(self.egui_input.modifiers, logical_key) {
+                    self.egui_input.events.push(egui::Event::Copy);
+                    return;
+                } else if is_paste_command(self.egui_input.modifiers, logical_key) {
+                    if let Some(contents) = self.clipboard.get() {
+                        let contents = contents.replace("\r\n", "\n");
+                        if !contents.is_empty() {
+                            self.egui_input.events.push(egui::Event::Paste(contents));
+                        }
+                    }
+                    return;
+                }
+            }
+
+            self.egui_input.events.push(egui::Event::Key {
+                key: logical_key,
+                physical_key,
+                pressed,
+                repeat: false, // egui will fill this in for us!
+                modifiers: self.egui_input.modifiers,
+            });
+        }
+
+        if let Some(text) = &text {
+            // Make sure there is text, and that it is not control characters
+            // (e.g. delete is sent as "\u{f728}" on macOS).
+            if !text.is_empty() && text.chars().all(is_printable_char) {
+                // On some platforms we get here when the user presses Cmd-C (copy), ctrl-W, etc.
+                // We need to ignore these characters that are side-effects of commands.
+                // Also make sure the key is pressed (not released). On Linux, text might
+                // contain some data even when the key is released.
+                let is_cmd = self.egui_input.modifiers.ctrl
+                    || self.egui_input.modifiers.command
+                    || self.egui_input.modifiers.mac_cmd;
+                if pressed && !is_cmd {
+                    self.egui_input
+                        .events
+                        .push(egui::Event::Text(text.to_string()));
+                }
+            }
+        }
+    }
+
+    /// Call with the output given by `egui`.
+    ///
+    /// This will, if needed:
+    /// * update the cursor
+    /// * copy text to the clipboard
+    /// * open any clicked urls
+    /// * update the IME
+    /// *
+    pub fn handle_platform_output(
         &mut self,
-        app: &mut dyn epi::App,
-        window: Option<&winit::window::Window>,
+        window: &Window,
+        platform_output: egui::PlatformOutput,
     ) {
-        let now = Instant::now();
-        if now - self.last_auto_save > app.auto_save_interval() {
-            self.save(app, window);
-            self.last_auto_save = now;
-        }
-    }
-
-    #[allow(clippy::unused_self)]
-    pub fn save(&mut self, _app: &mut dyn epi::App, _window: Option<&winit::window::Window>) {
-        #[cfg(feature = "persistence")]
-        if let Some(storage) = self.frame.storage_mut() {
-            crate::profile_function!();
-
-            if let Some(window) = _window {
-                if self.persist_window {
-                    crate::profile_scope!("native_window");
-                    epi::set_value(
-                        storage,
-                        STORAGE_WINDOW_KEY,
-                        &WindowSettings::from_window(self.egui_ctx.zoom_factor(), window),
-                    );
-                }
+        crate::profile_function!();
+
+        let egui::PlatformOutput {
+            cursor_icon,
+            open_url,
+            copied_text,
+            events: _,                    // handled elsewhere
+            mutable_text_under_cursor: _, // only used in eframe web
+            ime,
+            #[cfg(feature = "accesskit")]
+            accesskit_update,
+        } = platform_output;
+
+        self.set_cursor_icon(window, cursor_icon);
+
+        if let Some(open_url) = open_url {
+            open_url_in_browser(&open_url.url);
+        }
+
+        if !copied_text.is_empty() {
+            self.clipboard.set(copied_text);
+        }
+
+        let allow_ime = ime.is_some();
+        if self.allow_ime != allow_ime {
+            self.allow_ime = allow_ime;
+            crate::profile_scope!("set_ime_allowed");
+            window.set_ime_allowed(allow_ime);
+        }
+
+        if let Some(ime) = ime {
+            let rect = ime.rect;
+            let pixels_per_point = pixels_per_point(&self.egui_ctx, window);
+            crate::profile_scope!("set_ime_cursor_area");
+            window.set_ime_cursor_area(
+                winit::dpi::PhysicalPosition {
+                    x: pixels_per_point * rect.min.x,
+                    y: pixels_per_point * rect.min.y,
+                },
+                winit::dpi::PhysicalSize {
+                    width: pixels_per_point * rect.width(),
+                    height: pixels_per_point * rect.height(),
+                },
+            );
+        }
+
+        #[cfg(feature = "accesskit")]
+        if let Some(accesskit) = self.accesskit.as_ref() {
+            if let Some(update) = accesskit_update {
+                crate::profile_scope!("accesskit");
+                accesskit.update_if_active(|| update);
             }
-            if _app.persist_egui_memory() {
-                crate::profile_scope!("egui_memory");
-                self.egui_ctx
-                    .memory(|mem| epi::set_value(storage, STORAGE_EGUI_MEMORY_KEY, mem));
+        }
+    }
+
+    fn set_cursor_icon(&mut self, window: &Window, cursor_icon: egui::CursorIcon) {
+        if self.current_cursor_icon == Some(cursor_icon) {
+            // Prevent flickering near frame boundary when Windows OS tries to control cursor icon for window resizing.
+            // On other platforms: just early-out to save CPU.
+            return;
+        }
+
+        let is_pointer_in_window = self.pointer_pos_in_points.is_some();
+        if is_pointer_in_window {
+            self.current_cursor_icon = Some(cursor_icon);
+
+            if let Some(winit_cursor_icon) = translate_cursor(cursor_icon) {
+                window.set_cursor_visible(true);
+                window.set_cursor_icon(winit_cursor_icon);
+            } else {
+                window.set_cursor_visible(false);
             }
+        } else {
+            // Remember to set the cursor again once the cursor returns to the screen:
+            self.current_cursor_icon = None;
+        }
+    }
+}
+
+pub fn inner_rect_in_points(window: &Window, pixels_per_point: f32) -> Option<Rect> {
+    let pos = window.inner_position().ok()?;
+    let inner_pos_px = egui::emath::Pos2::new(pos.x as f32, pos.y as f32);
+
+    let inner_size_px = {
+        let size = window.inner_size();
+        egui::Vec2::new(size.width as f32, size.height as f32)
+    };
+    let inner_rect_px = egui::Rect::from_min_size(inner_pos_px, inner_size_px);
+
+    Some(inner_rect_px / pixels_per_point)
+}
+
+pub fn outer_rect_in_points(window: &Window, pixels_per_point: f32) -> Option<Rect> {
+    let pos = window.outer_position().ok()?;
+    let outer_pos_px = egui::emath::Pos2::new(pos.x as f32, pos.y as f32);
+
+    let outer_size_px = {
+        let size = window.outer_size();
+        egui::Vec2::new(size.width as f32, size.height as f32)
+    };
+    let outer_rect_px = egui::Rect::from_min_size(outer_pos_px, outer_size_px);
+
+    Some(outer_rect_px / pixels_per_point)
+}
+
+/// Update the given viewport info with the current state of the window.
+///
+/// Call before [`State::take_egui_input`].
+pub fn update_viewport_info(
+    viewport_info: &mut ViewportInfo,
+    egui_ctx: &egui::Context,
+    window: &Window,
+) {
+    crate::profile_function!();
+
+    let pixels_per_point = pixels_per_point(egui_ctx, window);
+
+    let has_a_position = match window.is_minimized() {
+        Some(true) => false,
+        Some(false) | None => true,
+    };
+
+    let inner_rect = if has_a_position {
+        inner_rect_in_points(window, pixels_per_point)
+    } else {
+        None
+    };
+
+    let outer_rect = if has_a_position {
+        outer_rect_in_points(window, pixels_per_point)
+    } else {
+        None
+    };
+
+    let monitor_size = {
+        crate::profile_scope!("monitor_size");
+        if let Some(monitor) = window.current_monitor() {
+            let size = monitor.size().to_logical::<f32>(pixels_per_point.into());
+            Some(egui::vec2(size.width, size.height))
+        } else {
+            None
+        }
+    };
+
+    viewport_info.title = Some(window.title());
+    viewport_info.native_pixels_per_point = Some(window.scale_factor() as f32);
+
+    viewport_info.monitor_size = monitor_size;
+    viewport_info.inner_rect = inner_rect;
+    viewport_info.outer_rect = outer_rect;
+
+    if !cfg!(target_os = "macos") {
+        // It's tempting to do this, but it leads to a deadlock on Mac when running
+        // `cargo run -p custom_window_frame`.
+        // See https://github.com/emilk/egui/issues/3494
+        viewport_info.maximized = Some(window.is_maximized());
+        viewport_info.minimized = Some(window.is_minimized().unwrap_or(false));
+    }
+
+    viewport_info.fullscreen = Some(window.fullscreen().is_some());
+    viewport_info.decorations = Some(window.is_decorated());
+    viewport_info.focused = Some(window.has_focus());
+}
+
+fn open_url_in_browser(_url: &str) {
+    #[cfg(feature = "webbrowser")]
+    if let Err(err) = webbrowser::open(_url) {
+        log::warn!("Failed to open url: {}", err);
+    }
+
+    #[cfg(not(feature = "webbrowser"))]
+    {
+        log::warn!("Cannot open url - feature \"links\" not enabled.");
+    }
+}
+
+/// Winit sends special keys (backspace, delete, F1, …) as characters.
+/// Ignore those.
+/// We also ignore '\r', '\n', '\t'.
+/// Newlines are handled by the `Key::Enter` event.
+fn is_printable_char(chr: char) -> bool {
+    let is_in_private_use_area = '\u{e000}' <= chr && chr <= '\u{f8ff}'
+        || '\u{f0000}' <= chr && chr <= '\u{ffffd}'
+        || '\u{100000}' <= chr && chr <= '\u{10fffd}';
+
+    !is_in_private_use_area && !chr.is_ascii_control()
+}
+
+fn is_cut_command(modifiers: egui::Modifiers, keycode: egui::Key) -> bool {
+    keycode == egui::Key::Cut
+        || (modifiers.command && keycode == egui::Key::X)
+        || (cfg!(target_os = "windows") && modifiers.shift && keycode == egui::Key::Delete)
+}
+
+fn is_copy_command(modifiers: egui::Modifiers, keycode: egui::Key) -> bool {
+    keycode == egui::Key::Copy
+        || (modifiers.command && keycode == egui::Key::C)
+        || (cfg!(target_os = "windows") && modifiers.ctrl && keycode == egui::Key::Insert)
+}
+
+fn is_paste_command(modifiers: egui::Modifiers, keycode: egui::Key) -> bool {
+    keycode == egui::Key::Paste
+        || (modifiers.command && keycode == egui::Key::V)
+        || (cfg!(target_os = "windows") && modifiers.shift && keycode == egui::Key::Insert)
+}
+
+fn translate_mouse_button(button: winit::event::MouseButton) -> Option<egui::PointerButton> {
+    match button {
+        winit::event::MouseButton::Left => Some(egui::PointerButton::Primary),
+        winit::event::MouseButton::Right => Some(egui::PointerButton::Secondary),
+        winit::event::MouseButton::Middle => Some(egui::PointerButton::Middle),
+        winit::event::MouseButton::Back => Some(egui::PointerButton::Extra1),
+        winit::event::MouseButton::Forward => Some(egui::PointerButton::Extra2),
+        winit::event::MouseButton::Other(_) => None,
+    }
+}
+
+fn key_from_winit_key(key: &winit::keyboard::Key) -> Option<egui::Key> {
+    match key {
+        winit::keyboard::Key::Named(named_key) => key_from_named_key(*named_key),
+        winit::keyboard::Key::Character(str) => egui::Key::from_name(str.as_str()),
+        winit::keyboard::Key::Unidentified(_) | winit::keyboard::Key::Dead(_) => None,
+    }
+}
+
+fn key_from_named_key(named_key: winit::keyboard::NamedKey) -> Option<egui::Key> {
+    use egui::Key;
+    use winit::keyboard::NamedKey;
+
+    Some(match named_key {
+        NamedKey::Enter => Key::Enter,
+        NamedKey::Tab => Key::Tab,
+        NamedKey::ArrowDown => Key::ArrowDown,
+        NamedKey::ArrowLeft => Key::ArrowLeft,
+        NamedKey::ArrowRight => Key::ArrowRight,
+        NamedKey::ArrowUp => Key::ArrowUp,
+        NamedKey::End => Key::End,
+        NamedKey::Home => Key::Home,
+        NamedKey::PageDown => Key::PageDown,
+        NamedKey::PageUp => Key::PageUp,
+        NamedKey::Backspace => Key::Backspace,
+        NamedKey::Delete => Key::Delete,
+        NamedKey::Insert => Key::Insert,
+        NamedKey::Escape => Key::Escape,
+        NamedKey::Cut => Key::Cut,
+        NamedKey::Copy => Key::Copy,
+        NamedKey::Paste => Key::Paste,
+
+        NamedKey::Space => Key::Space,
+
+        NamedKey::F1 => Key::F1,
+        NamedKey::F2 => Key::F2,
+        NamedKey::F3 => Key::F3,
+        NamedKey::F4 => Key::F4,
+        NamedKey::F5 => Key::F5,
+        NamedKey::F6 => Key::F6,
+        NamedKey::F7 => Key::F7,
+        NamedKey::F8 => Key::F8,
+        NamedKey::F9 => Key::F9,
+        NamedKey::F10 => Key::F10,
+        NamedKey::F11 => Key::F11,
+        NamedKey::F12 => Key::F12,
+        NamedKey::F13 => Key::F13,
+        NamedKey::F14 => Key::F14,
+        NamedKey::F15 => Key::F15,
+        NamedKey::F16 => Key::F16,
+        NamedKey::F17 => Key::F17,
+        NamedKey::F18 => Key::F18,
+        NamedKey::F19 => Key::F19,
+        NamedKey::F20 => Key::F20,
+        NamedKey::F21 => Key::F21,
+        NamedKey::F22 => Key::F22,
+        NamedKey::F23 => Key::F23,
+        NamedKey::F24 => Key::F24,
+        NamedKey::F25 => Key::F25,
+        NamedKey::F26 => Key::F26,
+        NamedKey::F27 => Key::F27,
+        NamedKey::F28 => Key::F28,
+        NamedKey::F29 => Key::F29,
+        NamedKey::F30 => Key::F30,
+        NamedKey::F31 => Key::F31,
+        NamedKey::F32 => Key::F32,
+        NamedKey::F33 => Key::F33,
+        NamedKey::F34 => Key::F34,
+        NamedKey::F35 => Key::F35,
+        _ => {
+            log::trace!("Unknown key: {named_key:?}");
+            return None;
+        }
+    })
+}
+
+fn key_from_key_code(key: winit::keyboard::KeyCode) -> Option<egui::Key> {
+    use egui::Key;
+    use winit::keyboard::KeyCode;
+
+    Some(match key {
+        KeyCode::ArrowDown => Key::ArrowDown,
+        KeyCode::ArrowLeft => Key::ArrowLeft,
+        KeyCode::ArrowRight => Key::ArrowRight,
+        KeyCode::ArrowUp => Key::ArrowUp,
+
+        KeyCode::Escape => Key::Escape,
+        KeyCode::Tab => Key::Tab,
+        KeyCode::Backspace => Key::Backspace,
+        KeyCode::Enter | KeyCode::NumpadEnter => Key::Enter,
+
+        KeyCode::Insert => Key::Insert,
+        KeyCode::Delete => Key::Delete,
+        KeyCode::Home => Key::Home,
+        KeyCode::End => Key::End,
+        KeyCode::PageUp => Key::PageUp,
+        KeyCode::PageDown => Key::PageDown,
+
+        // Punctuation
+        KeyCode::Space => Key::Space,
+        KeyCode::Comma => Key::Comma,
+        KeyCode::Period => Key::Period,
+        // KeyCode::Colon => Key::Colon, // NOTE: there is no physical colon key on an american keyboard
+        KeyCode::Semicolon => Key::Semicolon,
+        KeyCode::Backslash => Key::Backslash,
+        KeyCode::Slash | KeyCode::NumpadDivide => Key::Slash,
+        KeyCode::BracketLeft => Key::OpenBracket,
+        KeyCode::BracketRight => Key::CloseBracket,
+        KeyCode::Backquote => Key::Backtick,
+
+        KeyCode::Cut => Key::Cut,
+        KeyCode::Copy => Key::Copy,
+        KeyCode::Paste => Key::Paste,
+        KeyCode::Minus | KeyCode::NumpadSubtract => Key::Minus,
+        KeyCode::NumpadAdd => Key::Plus,
+        KeyCode::Equal => Key::Equals,
+
+        KeyCode::Digit0 | KeyCode::Numpad0 => Key::Num0,
+        KeyCode::Digit1 | KeyCode::Numpad1 => Key::Num1,
+        KeyCode::Digit2 | KeyCode::Numpad2 => Key::Num2,
+        KeyCode::Digit3 | KeyCode::Numpad3 => Key::Num3,
+        KeyCode::Digit4 | KeyCode::Numpad4 => Key::Num4,
+        KeyCode::Digit5 | KeyCode::Numpad5 => Key::Num5,
+        KeyCode::Digit6 | KeyCode::Numpad6 => Key::Num6,
+        KeyCode::Digit7 | KeyCode::Numpad7 => Key::Num7,
+        KeyCode::Digit8 | KeyCode::Numpad8 => Key::Num8,
+        KeyCode::Digit9 | KeyCode::Numpad9 => Key::Num9,
+
+        KeyCode::KeyA => Key::A,
+        KeyCode::KeyB => Key::B,
+        KeyCode::KeyC => Key::C,
+        KeyCode::KeyD => Key::D,
+        KeyCode::KeyE => Key::E,
+        KeyCode::KeyF => Key::F,
+        KeyCode::KeyG => Key::G,
+        KeyCode::KeyH => Key::H,
+        KeyCode::KeyI => Key::I,
+        KeyCode::KeyJ => Key::J,
+        KeyCode::KeyK => Key::K,
+        KeyCode::KeyL => Key::L,
+        KeyCode::KeyM => Key::M,
+        KeyCode::KeyN => Key::N,
+        KeyCode::KeyO => Key::O,
+        KeyCode::KeyP => Key::P,
+        KeyCode::KeyQ => Key::Q,
+        KeyCode::KeyR => Key::R,
+        KeyCode::KeyS => Key::S,
+        KeyCode::KeyT => Key::T,
+        KeyCode::KeyU => Key::U,
+        KeyCode::KeyV => Key::V,
+        KeyCode::KeyW => Key::W,
+        KeyCode::KeyX => Key::X,
+        KeyCode::KeyY => Key::Y,
+        KeyCode::KeyZ => Key::Z,
+
+        KeyCode::F1 => Key::F1,
+        KeyCode::F2 => Key::F2,
+        KeyCode::F3 => Key::F3,
+        KeyCode::F4 => Key::F4,
+        KeyCode::F5 => Key::F5,
+        KeyCode::F6 => Key::F6,
+        KeyCode::F7 => Key::F7,
+        KeyCode::F8 => Key::F8,
+        KeyCode::F9 => Key::F9,
+        KeyCode::F10 => Key::F10,
+        KeyCode::F11 => Key::F11,
+        KeyCode::F12 => Key::F12,
+        KeyCode::F13 => Key::F13,
+        KeyCode::F14 => Key::F14,
+        KeyCode::F15 => Key::F15,
+        KeyCode::F16 => Key::F16,
+        KeyCode::F17 => Key::F17,
+        KeyCode::F18 => Key::F18,
+        KeyCode::F19 => Key::F19,
+        KeyCode::F20 => Key::F20,
+        KeyCode::F21 => Key::F21,
+        KeyCode::F22 => Key::F22,
+        KeyCode::F23 => Key::F23,
+        KeyCode::F24 => Key::F24,
+        KeyCode::F25 => Key::F25,
+        KeyCode::F26 => Key::F26,
+        KeyCode::F27 => Key::F27,
+        KeyCode::F28 => Key::F28,
+        KeyCode::F29 => Key::F29,
+        KeyCode::F30 => Key::F30,
+        KeyCode::F31 => Key::F31,
+        KeyCode::F32 => Key::F32,
+        KeyCode::F33 => Key::F33,
+        KeyCode::F34 => Key::F34,
+        KeyCode::F35 => Key::F35,
+
+        _ => {
+            return None;
+        }
+    })
+}
+
+fn translate_cursor(cursor_icon: egui::CursorIcon) -> Option<winit::window::CursorIcon> {
+    match cursor_icon {
+        egui::CursorIcon::None => None,
+
+        egui::CursorIcon::Alias => Some(winit::window::CursorIcon::Alias),
+        egui::CursorIcon::AllScroll => Some(winit::window::CursorIcon::AllScroll),
+        egui::CursorIcon::Cell => Some(winit::window::CursorIcon::Cell),
+        egui::CursorIcon::ContextMenu => Some(winit::window::CursorIcon::ContextMenu),
+        egui::CursorIcon::Copy => Some(winit::window::CursorIcon::Copy),
+        egui::CursorIcon::Crosshair => Some(winit::window::CursorIcon::Crosshair),
+        egui::CursorIcon::Default => Some(winit::window::CursorIcon::Default),
+        egui::CursorIcon::Grab => Some(winit::window::CursorIcon::Grab),
+        egui::CursorIcon::Grabbing => Some(winit::window::CursorIcon::Grabbing),
+        egui::CursorIcon::Help => Some(winit::window::CursorIcon::Help),
+        egui::CursorIcon::Move => Some(winit::window::CursorIcon::Move),
+        egui::CursorIcon::NoDrop => Some(winit::window::CursorIcon::NoDrop),
+        egui::CursorIcon::NotAllowed => Some(winit::window::CursorIcon::NotAllowed),
+        egui::CursorIcon::PointingHand => Some(winit::window::CursorIcon::Pointer),
+        egui::CursorIcon::Progress => Some(winit::window::CursorIcon::Progress),
+
+        egui::CursorIcon::ResizeHorizontal => Some(winit::window::CursorIcon::EwResize),
+        egui::CursorIcon::ResizeNeSw => Some(winit::window::CursorIcon::NeswResize),
+        egui::CursorIcon::ResizeNwSe => Some(winit::window::CursorIcon::NwseResize),
+        egui::CursorIcon::ResizeVertical => Some(winit::window::CursorIcon::NsResize),
+
+        egui::CursorIcon::ResizeEast => Some(winit::window::CursorIcon::EResize),
+        egui::CursorIcon::ResizeSouthEast => Some(winit::window::CursorIcon::SeResize),
+        egui::CursorIcon::ResizeSouth => Some(winit::window::CursorIcon::SResize),
+        egui::CursorIcon::ResizeSouthWest => Some(winit::window::CursorIcon::SwResize),
+        egui::CursorIcon::ResizeWest => Some(winit::window::CursorIcon::WResize),
+        egui::CursorIcon::ResizeNorthWest => Some(winit::window::CursorIcon::NwResize),
+        egui::CursorIcon::ResizeNorth => Some(winit::window::CursorIcon::NResize),
+        egui::CursorIcon::ResizeNorthEast => Some(winit::window::CursorIcon::NeResize),
+        egui::CursorIcon::ResizeColumn => Some(winit::window::CursorIcon::ColResize),
+        egui::CursorIcon::ResizeRow => Some(winit::window::CursorIcon::RowResize),
+
+        egui::CursorIcon::Text => Some(winit::window::CursorIcon::Text),
+        egui::CursorIcon::VerticalText => Some(winit::window::CursorIcon::VerticalText),
+        egui::CursorIcon::Wait => Some(winit::window::CursorIcon::Wait),
+        egui::CursorIcon::ZoomIn => Some(winit::window::CursorIcon::ZoomIn),
+        egui::CursorIcon::ZoomOut => Some(winit::window::CursorIcon::ZoomOut),
+    }
+}
+
+// Helpers for egui Viewports
+// ---------------------------------------------------------------------------
+
+pub fn process_viewport_commands(
+    egui_ctx: &egui::Context,
+    info: &mut ViewportInfo,
+    commands: impl IntoIterator<Item = ViewportCommand>,
+    window: &Window,
+    is_viewport_focused: bool,
+    screenshot_requested: &mut bool,
+) {
+    for command in commands {
+        process_viewport_command(
+            egui_ctx,
+            window,
+            command,
+            info,
+            is_viewport_focused,
+            screenshot_requested,
+        );
+    }
+}
+
+fn process_viewport_command(
+    egui_ctx: &egui::Context,
+    window: &Window,
+    command: ViewportCommand,
+    info: &mut ViewportInfo,
+    is_viewport_focused: bool,
+    screenshot_requested: &mut bool,
+) {
+    crate::profile_function!();
+
+    use winit::window::ResizeDirection;
+
+    log::trace!("Processing ViewportCommand::{command:?}");
+
+    let pixels_per_point = pixels_per_point(egui_ctx, window);
+
+    match command {
+        ViewportCommand::Close => {
+            info.close_requested_on();
+            info.close_cancelable_off();
+            // info.close_cancelable = false;
+            info.events.push(egui::ViewportEvent::Close);
+        }
+        ViewportCommand::CancelClose => {
+            // Need to be handled elsewhere
+            info.close_requested_off();
+            // info.close_cancelable_on();
+            // dbg!(&info.events);
+            // info.events.clear();
+            if let Some(position) = info
+                .events
+                .iter()
+                .position(|x| *x == egui::ViewportEvent::Close)
             {
-                crate::profile_scope!("App::save");
-                _app.save(storage);
+                info.events.remove(position);
             }
+        }
+        ViewportCommand::StartDrag => {
+            // If `is_viewport_focused` is not checked on x11 the input will be permanently taken until the app is killed!
 
-            crate::profile_scope!("Storage::flush");
-            storage.flush();
+            // TODO(emilk): check that the left mouse-button was pressed down recently,
+            // or we will have bugs on Windows.
+            // See https://github.com/emilk/egui/pull/1108
+            if is_viewport_focused {
+                if let Err(err) = window.drag_window() {
+                    log::warn!("{command:?}: {err}");
+                }
+            }
+        }
+        ViewportCommand::InnerSize(size) => {
+            let width_px = pixels_per_point * size.x.max(1.0);
+            let height_px = pixels_per_point * size.y.max(1.0);
+            if let Some(_inner_size) =
+                window.request_inner_size(PhysicalSize::new(width_px, height_px))
+            {
+                // ViewportCommand::InnerSize, not will be delivered later with the [WindowEvent::Resized]
+                // ex) linux
+                info.inner_rect = inner_rect_in_points(window, pixels_per_point);
+                info.outer_rect = outer_rect_in_points(window, pixels_per_point);
+            } else {
+                // ViewportCommand::InnerSize, will be delivered later with the [WindowEvent::Resized]
+                // ex) Windows, MacOS
+            }
+        }
+        ViewportCommand::BeginResize(direction) => {
+            if let Err(err) = window.drag_resize_window(match direction {
+                egui::viewport::ResizeDirection::North => ResizeDirection::North,
+                egui::viewport::ResizeDirection::South => ResizeDirection::South,
+                egui::viewport::ResizeDirection::East => ResizeDirection::East,
+                egui::viewport::ResizeDirection::West => ResizeDirection::West,
+                egui::viewport::ResizeDirection::NorthEast => ResizeDirection::NorthEast,
+                egui::viewport::ResizeDirection::SouthEast => ResizeDirection::SouthEast,
+                egui::viewport::ResizeDirection::NorthWest => ResizeDirection::NorthWest,
+                egui::viewport::ResizeDirection::SouthWest => ResizeDirection::SouthWest,
+            }) {
+                log::warn!("{command:?}: {err}");
+            }
+        }
+        ViewportCommand::Title(title) => {
+            window.set_title(&title);
+        }
+        ViewportCommand::Transparent(v) => {
+            window.set_transparent(v);
+            info.transparent = Some(v);
+        }
+        ViewportCommand::Visible(v) => window.set_visible(v),
+        ViewportCommand::OuterPosition(pos) => {
+            window.set_outer_position(PhysicalPosition::new(
+                pixels_per_point * pos.x,
+                pixels_per_point * pos.y,
+            ));
+        }
+        ViewportCommand::MinInnerSize(s) => {
+            window.set_min_inner_size((s.is_finite() && s != Vec2::ZERO).then_some(
+                PhysicalSize::new(pixels_per_point * s.x, pixels_per_point * s.y),
+            ));
+        }
+        ViewportCommand::MaxInnerSize(s) => {
+            window.set_max_inner_size((s.is_finite() && s != Vec2::INFINITY).then_some(
+                PhysicalSize::new(pixels_per_point * s.x, pixels_per_point * s.y),
+            ));
+        }
+        ViewportCommand::ResizeIncrements(s) => {
+            window.set_resize_increments(
+                s.map(|s| PhysicalSize::new(pixels_per_point * s.x, pixels_per_point * s.y)),
+            );
+        }
+        ViewportCommand::Resizable(v) => window.set_resizable(v),
+        ViewportCommand::EnableButtons {
+            close,
+            minimized,
+            maximize,
+        } => window.set_enabled_buttons(
+            if close {
+                WindowButtons::CLOSE
+            } else {
+                WindowButtons::empty()
+            } | if minimized {
+                WindowButtons::MINIMIZE
+            } else {
+                WindowButtons::empty()
+            } | if maximize {
+                WindowButtons::MAXIMIZE
+            } else {
+                WindowButtons::empty()
+            },
+        ),
+        ViewportCommand::Minimized(v) => {
+            window.set_minimized(v);
+            info.minimized = Some(v);
+        }
+        ViewportCommand::Maximized(v) => {
+            window.set_maximized(v);
+            info.maximized = Some(v);
+        }
+        ViewportCommand::Fullscreen(v) => {
+            window.set_fullscreen(v.then_some(winit::window::Fullscreen::Borderless(None)));
+        }
+        ViewportCommand::Decorations(v) => {
+            window.set_decorations(v);
+            info.decorations = Some(v);
+        }
+        ViewportCommand::WindowLevel(l) => window.set_window_level(match l {
+            egui::viewport::WindowLevel::AlwaysOnBottom => WindowLevel::AlwaysOnBottom,
+            egui::viewport::WindowLevel::AlwaysOnTop => WindowLevel::AlwaysOnTop,
+            egui::viewport::WindowLevel::Normal => WindowLevel::Normal,
+        }),
+        ViewportCommand::Icon(icon) => {
+            let winit_icon = icon.and_then(|icon| to_winit_icon(&icon));
+            window.set_window_icon(winit_icon);
+        }
+        ViewportCommand::IMERect(rect) => {
+            window.set_ime_cursor_area(
+                PhysicalPosition::new(pixels_per_point * rect.min.x, pixels_per_point * rect.min.y),
+                PhysicalSize::new(
+                    pixels_per_point * rect.size().x,
+                    pixels_per_point * rect.size().y,
+                ),
+            );
+        }
+        ViewportCommand::IMEAllowed(v) => window.set_ime_allowed(v),
+        ViewportCommand::IMEPurpose(p) => window.set_ime_purpose(match p {
+            egui::viewport::IMEPurpose::Password => winit::window::ImePurpose::Password,
+            egui::viewport::IMEPurpose::Terminal => winit::window::ImePurpose::Terminal,
+            egui::viewport::IMEPurpose::Normal => winit::window::ImePurpose::Normal,
+        }),
+        ViewportCommand::Focus => {
+            if !window.has_focus() {
+                window.focus_window();
+            }
+        }
+        ViewportCommand::RequestUserAttention(a) => {
+            window.request_user_attention(match a {
+                egui::UserAttentionType::Reset => None,
+                egui::UserAttentionType::Critical => {
+                    Some(winit::window::UserAttentionType::Critical)
+                }
+                egui::UserAttentionType::Informational => {
+                    Some(winit::window::UserAttentionType::Informational)
+                }
+            });
+        }
+        ViewportCommand::SetTheme(t) => window.set_theme(match t {
+            egui::SystemTheme::Light => Some(winit::window::Theme::Light),
+            egui::SystemTheme::Dark => Some(winit::window::Theme::Dark),
+            egui::SystemTheme::SystemDefault => None,
+        }),
+        ViewportCommand::ContentProtected(v) => window.set_content_protected(v),
+        ViewportCommand::CursorPosition(pos) => {
+            if let Err(err) = window.set_cursor_position(PhysicalPosition::new(
+                pixels_per_point * pos.x,
+                pixels_per_point * pos.y,
+            )) {
+                log::warn!("{command:?}: {err}");
+            }
+        }
+        ViewportCommand::CursorGrab(o) => {
+            if let Err(err) = window.set_cursor_grab(match o {
+                egui::viewport::CursorGrab::None => CursorGrabMode::None,
+                egui::viewport::CursorGrab::Confined => CursorGrabMode::Confined,
+                egui::viewport::CursorGrab::Locked => CursorGrabMode::Locked,
+            }) {
+                log::warn!("{command:?}: {err}");
+            }
+        }
+        ViewportCommand::CursorVisible(v) => window.set_cursor_visible(v),
+        ViewportCommand::MousePassthrough(passthrough) => {
+            if let Err(err) = window.set_cursor_hittest(!passthrough) {
+                log::warn!("{command:?}: {err}");
+            }
+        }
+        ViewportCommand::Screenshot => {
+            *screenshot_requested = true;
         }
     }
 }
 
-fn load_default_egui_icon() -> egui::IconData {
+/// Build and intitlaize a window.
+///
+/// Wrapper around `create_winit_window_builder` and `apply_viewport_builder_to_window`.
+pub fn create_window<T>(
+    egui_ctx: &egui::Context,
+    event_loop: &EventLoopWindowTarget<T>,
+    viewport_builder: &ViewportBuilder,
+) -> Result<Window, winit::error::OsError> {
     crate::profile_function!();
-    crate::icon_data::from_png_bytes(&include_bytes!("../../data/icon.png")[..]).unwrap()
+
+    let window_builder =
+        create_winit_window_builder(egui_ctx, event_loop, viewport_builder.clone());
+    let window = {
+        crate::profile_scope!("WindowBuilder::build");
+        window_builder.build(event_loop)?
+    };
+    apply_viewport_builder_to_window(egui_ctx, &window, viewport_builder);
+    Ok(window)
 }
 
-#[cfg(feature = "persistence")]
-const STORAGE_EGUI_MEMORY_KEY: &str = "egui";
+pub fn create_winit_window_builder<T>(
+    egui_ctx: &egui::Context,
+    event_loop: &EventLoopWindowTarget<T>,
+    viewport_builder: ViewportBuilder,
+) -> winit::window::WindowBuilder {
+    crate::profile_function!();
 
-#[cfg(feature = "persistence")]
-const STORAGE_WINDOW_KEY: &str = "window";
+    // We set sizes and positions in egui:s own ui points, which depends on the egui
+    // zoom_factor and the native pixels per point, so we need to know that here.
+    // We don't know what monitor the window will appear on though, but
+    // we'll try to fix that after the window is created in the vall to `apply_viewport_builder_to_window`.
+    let native_pixels_per_point = event_loop
+        .primary_monitor()
+        .or_else(|| event_loop.available_monitors().next())
+        .map_or_else(
+            || {
+                log::debug!("Failed to find a monitor - assuming native_pixels_per_point of 1.0");
+                1.0
+            },
+            |m| m.scale_factor() as f32,
+        );
+    let zoom_factor = egui_ctx.zoom_factor();
+    let pixels_per_point = zoom_factor * native_pixels_per_point;
 
-pub fn load_window_settings(_storage: Option<&dyn epi::Storage>) -> Option<WindowSettings> {
-    crate::profile_function!();
-    #[cfg(feature = "persistence")]
+    let ViewportBuilder {
+        title,
+        position,
+        inner_size,
+        min_inner_size,
+        max_inner_size,
+        fullscreen,
+        maximized,
+        resizable,
+        transparent,
+        decorations,
+        icon,
+        active,
+        visible,
+        close_button,
+        minimize_button,
+        maximize_button,
+        window_level,
+
+        // macOS:
+        fullsize_content_view: _fullsize_content_view,
+        title_shown: _title_shown,
+        titlebar_buttons_shown: _titlebar_buttons_shown,
+        titlebar_shown: _titlebar_shown,
+
+        // Windows:
+        drag_and_drop: _drag_and_drop,
+        taskbar: _taskbar,
+
+        // wayland:
+        app_id: _app_id,
+
+        // x11
+        window_type: _window_type,
+
+        mouse_passthrough: _, // handled in `apply_viewport_builder_to_window`
+    } = viewport_builder;
+
+    let mut window_builder = winit::window::WindowBuilder::new()
+        .with_title(title.unwrap_or_else(|| "egui window".to_owned()))
+        .with_transparent(transparent.unwrap_or(false))
+        .with_decorations(decorations.unwrap_or(true))
+        .with_resizable(resizable.unwrap_or(true))
+        .with_visible(visible.unwrap_or(true))
+        .with_maximized(maximized.unwrap_or(false))
+        .with_window_level(match window_level.unwrap_or_default() {
+            egui::viewport::WindowLevel::AlwaysOnBottom => WindowLevel::AlwaysOnBottom,
+            egui::viewport::WindowLevel::AlwaysOnTop => WindowLevel::AlwaysOnTop,
+            egui::viewport::WindowLevel::Normal => WindowLevel::Normal,
+        })
+        .with_fullscreen(
+            fullscreen.and_then(|e| e.then_some(winit::window::Fullscreen::Borderless(None))),
+        )
+        .with_enabled_buttons({
+            let mut buttons = WindowButtons::empty();
+            if minimize_button.unwrap_or(true) {
+                buttons |= WindowButtons::MINIMIZE;
+            }
+            if maximize_button.unwrap_or(true) {
+                buttons |= WindowButtons::MAXIMIZE;
+            }
+            if close_button.unwrap_or(true) {
+                buttons |= WindowButtons::CLOSE;
+            }
+            buttons
+        })
+        .with_active(active.unwrap_or(true));
+
+    if let Some(size) = inner_size {
+        window_builder = window_builder.with_inner_size(PhysicalSize::new(
+            pixels_per_point * size.x,
+            pixels_per_point * size.y,
+        ));
+    }
+
+    if let Some(size) = min_inner_size {
+        window_builder = window_builder.with_min_inner_size(PhysicalSize::new(
+            pixels_per_point * size.x,
+            pixels_per_point * size.y,
+        ));
+    }
+
+    if let Some(size) = max_inner_size {
+        window_builder = window_builder.with_max_inner_size(PhysicalSize::new(
+            pixels_per_point * size.x,
+            pixels_per_point * size.y,
+        ));
+    }
+
+    if let Some(pos) = position {
+        window_builder = window_builder.with_position(PhysicalPosition::new(
+            pixels_per_point * pos.x,
+            pixels_per_point * pos.y,
+        ));
+    }
+
+    if let Some(icon) = icon {
+        let winit_icon = to_winit_icon(&icon);
+        window_builder = window_builder.with_window_icon(winit_icon);
+    }
+
+    #[cfg(all(feature = "wayland", target_os = "linux"))]
+    if let Some(app_id) = _app_id {
+        use winit::platform::wayland::WindowBuilderExtWayland as _;
+        window_builder = window_builder.with_name(app_id, "");
+    }
+
+    #[cfg(all(feature = "x11", target_os = "linux"))]
     {
-        epi::get_value(_storage?, STORAGE_WINDOW_KEY)
+        if let Some(window_type) = _window_type {
+            use winit::platform::x11::WindowBuilderExtX11 as _;
+            use winit::platform::x11::XWindowType;
+            window_builder = window_builder.with_x11_window_type(vec![match window_type {
+                egui::X11WindowType::Normal => XWindowType::Normal,
+                egui::X11WindowType::Utility => XWindowType::Utility,
+                egui::X11WindowType::Dock => XWindowType::Dock,
+                egui::X11WindowType::Desktop => XWindowType::Desktop,
+                egui::X11WindowType::Toolbar => XWindowType::Toolbar,
+                egui::X11WindowType::Menu => XWindowType::Menu,
+                egui::X11WindowType::Splash => XWindowType::Splash,
+                egui::X11WindowType::Dialog => XWindowType::Dialog,
+                egui::X11WindowType::DropdownMenu => XWindowType::DropdownMenu,
+                egui::X11WindowType::PopupMenu => XWindowType::PopupMenu,
+                egui::X11WindowType::Tooltip => XWindowType::Tooltip,
+                egui::X11WindowType::Notification => XWindowType::Notification,
+                egui::X11WindowType::Combo => XWindowType::Combo,
+                egui::X11WindowType::Dnd => XWindowType::Dnd,
+            }]);
+        }
     }
-    #[cfg(not(feature = "persistence"))]
-    None
+
+    #[cfg(target_os = "windows")]
+    {
+        use winit::platform::windows::WindowBuilderExtWindows as _;
+        if let Some(enable) = _drag_and_drop {
+            window_builder = window_builder.with_drag_and_drop(enable);
+        }
+        if let Some(show) = _taskbar {
+            window_builder = window_builder.with_skip_taskbar(!show);
+        }
+    }
+
+    #[cfg(target_os = "macos")]
+    {
+        use winit::platform::macos::WindowBuilderExtMacOS as _;
+        window_builder = window_builder
+            .with_title_hidden(!_title_shown.unwrap_or(true))
+            .with_titlebar_buttons_hidden(!_titlebar_buttons_shown.unwrap_or(true))
+            .with_titlebar_transparent(!_titlebar_shown.unwrap_or(true))
+            .with_fullsize_content_view(_fullsize_content_view.unwrap_or(false));
+    }
+
+    window_builder
 }
 
-pub fn load_egui_memory(_storage: Option<&dyn epi::Storage>) -> Option<egui::Memory> {
-    crate::profile_function!();
-    #[cfg(feature = "persistence")]
+fn to_winit_icon(icon: &egui::IconData) -> Option<winit::window::Icon> {
+    if icon.is_empty() {
+        None
+    } else {
+        crate::profile_function!();
+        match winit::window::Icon::from_rgba(icon.rgba.clone(), icon.width, icon.height) {
+            Ok(winit_icon) => Some(winit_icon),
+            Err(err) => {
+                log::warn!("Invalid IconData: {err}");
+                None
+            }
+        }
+    }
+}
+
+/// Applies what `create_winit_window_builder` couldn't
+pub fn apply_viewport_builder_to_window(
+    egui_ctx: &egui::Context,
+    window: &Window,
+    builder: &ViewportBuilder,
+) {
+    if let Some(mouse_passthrough) = builder.mouse_passthrough {
+        if let Err(err) = window.set_cursor_hittest(!mouse_passthrough) {
+            log::warn!("set_cursor_hittest failed: {err}");
+        }
+    }
+
     {
-        epi::get_value(_storage?, STORAGE_EGUI_MEMORY_KEY)
+        // In `create_winit_window_builder` we didn't know
+        // on what monitor the window would appear, so we didn't know
+        // how to translate egui ui point to native physical pixels.
+        // Now we do know:
+
+        let pixels_per_point = pixels_per_point(egui_ctx, window);
+
+        if let Some(size) = builder.inner_size {
+            if window
+                .request_inner_size(PhysicalSize::new(
+                    pixels_per_point * size.x,
+                    pixels_per_point * size.y,
+                ))
+                .is_some()
+            {
+                log::debug!("Failed to set window size");
+            }
+        }
+        if let Some(size) = builder.min_inner_size {
+            window.set_min_inner_size(Some(PhysicalSize::new(
+                pixels_per_point * size.x,
+                pixels_per_point * size.y,
+            )));
+        }
+        if let Some(size) = builder.max_inner_size {
+            window.set_max_inner_size(Some(PhysicalSize::new(
+                pixels_per_point * size.x,
+                pixels_per_point * size.y,
+            )));
+        }
+        if let Some(pos) = builder.position {
+            let pos = PhysicalPosition::new(pixels_per_point * pos.x, pixels_per_point * pos.y);
+            window.set_outer_position(pos);
+        }
     }
-    #[cfg(not(feature = "persistence"))]
-    None
 }
 
-pub(crate) fn theme_from_winit_theme(theme: winit::window::Theme) -> Theme {
-    match theme {
-        winit::window::Theme::Dark => Theme::Dark,
-        winit::window::Theme::Light => Theme::Light,
+// ---------------------------------------------------------------------------
+
+/// Short and fast description of an event.
+/// Useful for logging and profiling.
+pub fn short_generic_event_description<T>(event: &winit::event::Event<T>) -> &'static str {
+    use winit::event::{DeviceEvent, Event, StartCause};
+
+    match event {
+        Event::AboutToWait => "Event::AboutToWait",
+        Event::LoopExiting => "Event::LoopExiting",
+        Event::Suspended => "Event::Suspended",
+        Event::Resumed => "Event::Resumed",
+        Event::MemoryWarning => "Event::MemoryWarning",
+        Event::UserEvent(_) => "UserEvent",
+        Event::DeviceEvent { event, .. } => match event {
+            DeviceEvent::Added { .. } => "DeviceEvent::Added",
+            DeviceEvent::Removed { .. } => "DeviceEvent::Removed",
+            DeviceEvent::MouseMotion { .. } => "DeviceEvent::MouseMotion",
+            DeviceEvent::MouseWheel { .. } => "DeviceEvent::MouseWheel",
+            DeviceEvent::Motion { .. } => "DeviceEvent::Motion",
+            DeviceEvent::Button { .. } => "DeviceEvent::Button",
+            DeviceEvent::Key { .. } => "DeviceEvent::Key",
+        },
+        Event::NewEvents(start_cause) => match start_cause {
+            StartCause::ResumeTimeReached { .. } => "NewEvents::ResumeTimeReached",
+            StartCause::WaitCancelled { .. } => "NewEvents::WaitCancelled",
+            StartCause::Poll => "NewEvents::Poll",
+            StartCause::Init => "NewEvents::Init",
+        },
+        Event::WindowEvent { event, .. } => short_window_event_description(event),
+    }
+}
+
+/// Short and fast description of an event.
+/// Useful for logging and profiling.
+pub fn short_window_event_description(event: &winit::event::WindowEvent) -> &'static str {
+    use winit::event::WindowEvent;
+
+    match event {
+        WindowEvent::ActivationTokenDone { .. } => "WindowEvent::ActivationTokenDone",
+        WindowEvent::Resized { .. } => "WindowEvent::Resized",
+        WindowEvent::Moved { .. } => "WindowEvent::Moved",
+        WindowEvent::CloseRequested { .. } => "WindowEvent::CloseRequested",
+        WindowEvent::Destroyed { .. } => "WindowEvent::Destroyed",
+        WindowEvent::DroppedFile { .. } => "WindowEvent::DroppedFile",
+        WindowEvent::HoveredFile { .. } => "WindowEvent::HoveredFile",
+        WindowEvent::HoveredFileCancelled { .. } => "WindowEvent::HoveredFileCancelled",
+        WindowEvent::Focused { .. } => "WindowEvent::Focused",
+        WindowEvent::KeyboardInput { .. } => "WindowEvent::KeyboardInput",
+        WindowEvent::ModifiersChanged { .. } => "WindowEvent::ModifiersChanged",
+        WindowEvent::Ime { .. } => "WindowEvent::Ime",
+        WindowEvent::CursorMoved { .. } => "WindowEvent::CursorMoved",
+        WindowEvent::CursorEntered { .. } => "WindowEvent::CursorEntered",
+        WindowEvent::CursorLeft { .. } => "WindowEvent::CursorLeft",
+        WindowEvent::MouseWheel { .. } => "WindowEvent::MouseWheel",
+        WindowEvent::MouseInput { .. } => "WindowEvent::MouseInput",
+        WindowEvent::TouchpadMagnify { .. } => "WindowEvent::TouchpadMagnify",
+        WindowEvent::RedrawRequested { .. } => "WindowEvent::RedrawRequested",
+        WindowEvent::SmartMagnify { .. } => "WindowEvent::SmartMagnify",
+        WindowEvent::TouchpadRotate { .. } => "WindowEvent::TouchpadRotate",
+        WindowEvent::TouchpadPressure { .. } => "WindowEvent::TouchpadPressure",
+        WindowEvent::AxisMotion { .. } => "WindowEvent::AxisMotion",
+        WindowEvent::Touch { .. } => "WindowEvent::Touch",
+        WindowEvent::ScaleFactorChanged { .. } => "WindowEvent::ScaleFactorChanged",
+        WindowEvent::ThemeChanged { .. } => "WindowEvent::ThemeChanged",
+        WindowEvent::Occluded { .. } => "WindowEvent::Occluded",
+    }
+}
+
+// ---------------------------------------------------------------------------
+
+mod profiling_scopes {
+    #![allow(unused_macros)]
+    #![allow(unused_imports)]
+
+    /// Profiling macro for feature "puffin"
+    macro_rules! profile_function {
+        ($($arg: tt)*) => {
+            #[cfg(feature = "puffin")]
+            #[cfg(not(target_arch = "wasm32"))] // Disabled on web because of the coarse 1ms clock resolution there.
+            puffin::profile_function!($($arg)*);
+        };
+    }
+    pub(crate) use profile_function;
+
+    /// Profiling macro for feature "puffin"
+    macro_rules! profile_scope {
+        ($($arg: tt)*) => {
+            #[cfg(feature = "puffin")]
+            #[cfg(not(target_arch = "wasm32"))] // Disabled on web because of the coarse 1ms clock resolution there.
+            puffin::profile_scope!($($arg)*);
+        };
     }
+    pub(crate) use profile_scope;
 }

From 331363312a9724761ed6aaa8c4baa73a5a7cf348 Mon Sep 17 00:00:00 2001
From: rustbasic <127506429+rustbasic@users.noreply.github.com>
Date: Mon, 1 Apr 2024 00:59:50 +0900
Subject: [PATCH 07/10] Update epi_integration.rs

---
 crates/eframe/src/native/epi_integration.rs | 2055 +++----------------
 1 file changed, 309 insertions(+), 1746 deletions(-)

diff --git a/crates/eframe/src/native/epi_integration.rs b/crates/eframe/src/native/epi_integration.rs
index e6cb9e1fba8..fbf7b6dc078 100644
--- a/crates/eframe/src/native/epi_integration.rs
+++ b/crates/eframe/src/native/epi_integration.rs
@@ -1,1844 +1,407 @@
-//! [`egui`] bindings for [`winit`](https://github.com/rust-windowing/winit).
-//!
-//! The library translates winit events to egui, handled copy/paste,
-//! updates the cursor, open links clicked in egui, etc.
-//!
-//! ## Feature flags
-#![cfg_attr(feature = "document-features", doc = document_features::document_features!())]
-//!
+//! Common tools used by [`super::glow_integration`] and [`super::wgpu_integration`].
 
-#![allow(clippy::manual_range_contains)]
+use web_time::Instant;
+use winit::event_loop::EventLoopWindowTarget;
 
-#[cfg(feature = "accesskit")]
-pub use accesskit_winit;
-pub use egui;
-#[cfg(feature = "accesskit")]
-use egui::accesskit;
-use egui::{Pos2, Rect, Vec2, ViewportBuilder, ViewportCommand, ViewportId, ViewportInfo};
-pub use winit;
+use raw_window_handle::{HasDisplayHandle as _, HasWindowHandle as _};
 
-pub mod clipboard;
-mod window_settings;
+use egui::{DeferredViewportUiCallback, NumExt as _, ViewportBuilder, ViewportId};
+use egui_winit::{EventResponse, WindowSettings};
 
-pub use window_settings::WindowSettings;
+use crate::{epi, Theme};
 
-use raw_window_handle::HasDisplayHandle;
+pub fn viewport_builder<E>(
+    egui_zoom_factor: f32,
+    event_loop: &EventLoopWindowTarget<E>,
+    native_options: &mut epi::NativeOptions,
+    window_settings: Option<WindowSettings>,
+) -> ViewportBuilder {
+    crate::profile_function!();
 
-#[allow(unused_imports)]
-pub(crate) use profiling_scopes::*;
+    let mut viewport_builder = native_options.viewport.clone();
 
-use winit::{
-    dpi::{PhysicalPosition, PhysicalSize},
-    event_loop::EventLoopWindowTarget,
-    window::{CursorGrabMode, Window, WindowButtons, WindowLevel},
-};
+    // Always use the default window size / position on iOS. Trying to restore the previous position
+    // causes the window to be shown too small.
+    #[cfg(not(target_os = "ios"))]
+    let inner_size_points = if let Some(mut window_settings) = window_settings {
+        // Restore pos/size from previous session
 
-pub fn screen_size_in_pixels(window: &Window) -> egui::Vec2 {
-    let size = window.inner_size();
-    egui::vec2(size.width as f32, size.height as f32)
-}
+        window_settings
+            .clamp_size_to_sane_values(largest_monitor_point_size(egui_zoom_factor, event_loop));
+        window_settings.clamp_position_to_monitors(egui_zoom_factor, event_loop);
 
-/// Calculate the `pixels_per_point` for a given window, given the current egui zoom factor
-pub fn pixels_per_point(egui_ctx: &egui::Context, window: &Window) -> f32 {
-    let native_pixels_per_point = window.scale_factor() as f32;
-    let egui_zoom_factor = egui_ctx.zoom_factor();
-    egui_zoom_factor * native_pixels_per_point
-}
+        viewport_builder = window_settings.initialize_viewport_builder(viewport_builder);
+        window_settings.inner_size_points()
+    } else {
+        if let Some(pos) = viewport_builder.position {
+            viewport_builder = viewport_builder.with_position(pos);
+        }
 
-// ----------------------------------------------------------------------------
+        if let Some(initial_window_size) = viewport_builder.inner_size {
+            let initial_window_size = initial_window_size
+                .at_most(largest_monitor_point_size(egui_zoom_factor, event_loop));
+            viewport_builder = viewport_builder.with_inner_size(initial_window_size);
+        }
 
-#[must_use]
-#[derive(Clone, Copy, Debug, Default)]
-pub struct EventResponse {
-    /// If true, egui consumed this event, i.e. wants exclusive use of this event
-    /// (e.g. a mouse click on an egui window, or entering text into a text field).
-    ///
-    /// For instance, if you use egui for a game, you should only
-    /// pass on the events to your game when [`Self::consumed`] is `false.
-    ///
-    /// Note that egui uses `tab` to move focus between elements, so this will always be `true` for tabs.
-    pub consumed: bool,
+        viewport_builder.inner_size
+    };
+
+    #[cfg(not(target_os = "ios"))]
+    if native_options.centered {
+        crate::profile_scope!("center");
+        if let Some(monitor) = event_loop.available_monitors().next() {
+            let monitor_size = monitor
+                .size()
+                .to_logical::<f32>(egui_zoom_factor as f64 * monitor.scale_factor());
+            let inner_size = inner_size_points.unwrap_or(egui::Vec2 { x: 800.0, y: 600.0 });
+            if 0.0 < monitor_size.width && 0.0 < monitor_size.height {
+                let x = (monitor_size.width - inner_size.x) / 2.0;
+                let y = (monitor_size.height - inner_size.y) / 2.0;
+                viewport_builder = viewport_builder.with_position([x, y]);
+            }
+        }
+    }
 
-    /// Do we need an egui refresh because of this event?
-    pub repaint: bool,
+    match std::mem::take(&mut native_options.window_builder) {
+        Some(hook) => hook(viewport_builder),
+        None => viewport_builder,
+    }
 }
 
-// ----------------------------------------------------------------------------
+pub fn apply_window_settings(
+    window: &winit::window::Window,
+    window_settings: Option<WindowSettings>,
+) {
+    crate::profile_function!();
 
-/// Handles the integration between egui and a winit Window.
-///
-/// Instantiate one of these per viewport/window.
-pub struct State {
-    /// Shared clone.
-    egui_ctx: egui::Context,
+    if let Some(window_settings) = window_settings {
+        window_settings.initialize_window(window);
+    }
+}
 
-    viewport_id: ViewportId,
-    start_time: web_time::Instant,
-    egui_input: egui::RawInput,
-    pointer_pos_in_points: Option<egui::Pos2>,
-    any_pointer_button_down: bool,
-    current_cursor_icon: Option<egui::CursorIcon>,
+fn largest_monitor_point_size<E>(
+    egui_zoom_factor: f32,
+    event_loop: &EventLoopWindowTarget<E>,
+) -> egui::Vec2 {
+    crate::profile_function!();
 
-    clipboard: clipboard::Clipboard,
+    let mut max_size = egui::Vec2::ZERO;
 
-    /// If `true`, mouse inputs will be treated as touches.
-    /// Useful for debugging touch support in egui.
-    ///
-    /// Creates duplicate touches, if real touch inputs are coming.
-    simulate_touch_screen: bool,
+    let available_monitors = {
+        crate::profile_scope!("available_monitors");
+        event_loop.available_monitors()
+    };
 
-    /// Is Some(…) when a touch is being translated to a pointer.
-    ///
-    /// Only one touch will be interpreted as pointer at any time.
-    pointer_touch_id: Option<u64>,
+    for monitor in available_monitors {
+        let size = monitor
+            .size()
+            .to_logical::<f32>(egui_zoom_factor as f64 * monitor.scale_factor());
+        let size = egui::vec2(size.width, size.height);
+        max_size = max_size.max(size);
+    }
 
-    /// track ime state
-    input_method_editor_started: bool,
+    if max_size == egui::Vec2::ZERO {
+        egui::Vec2::splat(16000.0)
+    } else {
+        max_size
+    }
+}
 
-    #[cfg(feature = "accesskit")]
-    accesskit: Option<accesskit_winit::Adapter>,
+// ----------------------------------------------------------------------------
 
-    allow_ime: bool,
+/// For loading/saving app state and/or egui memory to disk.
+pub fn create_storage(_app_name: &str) -> Option<Box<dyn epi::Storage>> {
+    #[cfg(feature = "persistence")]
+    if let Some(storage) = super::file_storage::FileStorage::from_app_id(_app_name) {
+        return Some(Box::new(storage));
+    }
+    None
 }
 
-impl State {
-    /// Construct a new instance
+// ----------------------------------------------------------------------------
+
+/// Everything needed to make a winit-based integration for [`epi`].
+///
+/// Only one instance per app (not one per viewport).
+pub struct EpiIntegration {
+    pub frame: epi::Frame,
+    last_auto_save: Instant,
+    pub beginning: Instant,
+    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,
+    app_icon_setter: super::app_icon::AppTitleIconSetter,
+}
+
+impl EpiIntegration {
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
         egui_ctx: egui::Context,
-        viewport_id: ViewportId,
-        display_target: &dyn HasDisplayHandle,
-        native_pixels_per_point: Option<f32>,
-        max_texture_side: Option<usize>,
+        window: &winit::window::Window,
+        system_theme: Option<Theme>,
+        app_name: &str,
+        native_options: &crate::NativeOptions,
+        storage: Option<Box<dyn epi::Storage>>,
+        #[cfg(feature = "glow")] gl: Option<std::sync::Arc<glow::Context>>,
+        #[cfg(feature = "glow")] glow_register_native_texture: Option<
+            Box<dyn FnMut(glow::Texture) -> egui::TextureId>,
+        >,
+        #[cfg(feature = "wgpu")] wgpu_render_state: Option<egui_wgpu::RenderState>,
     ) -> Self {
-        crate::profile_function!();
-
-        let egui_input = egui::RawInput {
-            focused: false, // winit will tell us when we have focus
-            ..Default::default()
-        };
-
-        let mut slf = Self {
-            egui_ctx,
-            viewport_id,
-            start_time: web_time::Instant::now(),
-            egui_input,
-            pointer_pos_in_points: None,
-            any_pointer_button_down: false,
-            current_cursor_icon: None,
-
-            clipboard: clipboard::Clipboard::new(
-                display_target.display_handle().ok().map(|h| h.as_raw()),
-            ),
-
-            simulate_touch_screen: false,
-            pointer_touch_id: None,
-
-            input_method_editor_started: false,
-
-            #[cfg(feature = "accesskit")]
-            accesskit: None,
-
-            allow_ime: false,
+        let frame = epi::Frame {
+            info: epi::IntegrationInfo {
+                system_theme,
+                cpu_usage: None,
+            },
+            storage,
+            #[cfg(feature = "glow")]
+            gl,
+            #[cfg(feature = "glow")]
+            glow_register_native_texture,
+            #[cfg(feature = "wgpu")]
+            wgpu_render_state,
+            raw_display_handle: window.display_handle().map(|h| h.as_raw()),
+            raw_window_handle: window.window_handle().map(|h| h.as_raw()),
         };
 
-        slf.egui_input
-            .viewports
-            .entry(ViewportId::ROOT)
-            .or_default()
-            .native_pixels_per_point = native_pixels_per_point;
+        let icon = native_options
+            .viewport
+            .icon
+            .clone()
+            .unwrap_or_else(|| std::sync::Arc::new(load_default_egui_icon()));
+
+        let app_icon_setter = super::app_icon::AppTitleIconSetter::new(
+            native_options
+                .viewport
+                .title
+                .clone()
+                .unwrap_or_else(|| app_name.to_owned()),
+            Some(icon),
+        );
 
-        if let Some(max_texture_side) = max_texture_side {
-            slf.set_max_texture_side(max_texture_side);
+        Self {
+            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,
+            app_icon_setter,
+            beginning: Instant::now(),
+            is_first_frame: true,
+            frame_start: Instant::now(),
         }
-        slf
     }
 
     #[cfg(feature = "accesskit")]
-    pub fn init_accesskit<T: From<accesskit_winit::ActionRequestEvent> + Send>(
-        &mut self,
-        window: &Window,
-        event_loop_proxy: winit::event_loop::EventLoopProxy<T>,
-        initial_tree_update_factory: impl 'static + FnOnce() -> accesskit::TreeUpdate + Send,
+    pub fn init_accesskit<E: From<egui_winit::accesskit_winit::ActionRequestEvent> + Send>(
+        &self,
+        egui_winit: &mut egui_winit::State,
+        window: &winit::window::Window,
+        event_loop_proxy: winit::event_loop::EventLoopProxy<E>,
     ) {
         crate::profile_function!();
-        self.accesskit = Some(accesskit_winit::Adapter::new(
-            window,
-            initial_tree_update_factory,
-            event_loop_proxy,
-        ));
-    }
-
-    /// Call this once a graphics context has been created to update the maximum texture dimensions
-    /// that egui will use.
-    pub fn set_max_texture_side(&mut self, max_texture_side: usize) {
-        self.egui_input.max_texture_side = Some(max_texture_side);
-    }
-
-    /// Fetches text from the clipboard and returns it.
-    pub fn clipboard_text(&mut self) -> Option<String> {
-        self.clipboard.get()
-    }
-
-    /// Places the text onto the clipboard.
-    pub fn set_clipboard_text(&mut self, text: String) {
-        self.clipboard.set(text);
-    }
-
-    /// Returns [`false`] or the last value that [`Window::set_ime_allowed()`] was called with, used for debouncing.
-    pub fn allow_ime(&self) -> bool {
-        self.allow_ime
-    }
-
-    /// Set the last value that [`Window::set_ime_allowed()`] was called with.
-    pub fn set_allow_ime(&mut self, allow: bool) {
-        self.allow_ime = allow;
-    }
-
-    #[inline]
-    pub fn egui_ctx(&self) -> &egui::Context {
-        &self.egui_ctx
-    }
 
-    /// The current input state.
-    /// This is changed by [`Self::on_window_event`] and cleared by [`Self::take_egui_input`].
-    #[inline]
-    pub fn egui_input(&self) -> &egui::RawInput {
-        &self.egui_input
+        let egui_ctx = self.egui_ctx.clone();
+        egui_winit.init_accesskit(window, event_loop_proxy, move || {
+            // This function is called when an accessibility client
+            // (e.g. screen reader) makes its first request. If we got here,
+            // we know that an accessibility tree is actually wanted.
+            egui_ctx.enable_accesskit();
+            // Enqueue a repaint so we'll receive a full tree update soon.
+            egui_ctx.request_repaint();
+            egui_ctx.accesskit_placeholder_tree_update()
+        });
     }
 
-    /// The current input state.
-    /// This is changed by [`Self::on_window_event`] and cleared by [`Self::take_egui_input`].
-    #[inline]
-    pub fn egui_input_mut(&mut self) -> &mut egui::RawInput {
-        &mut self.egui_input
+    /// If `true`, it is time to close the native window.
+    pub fn should_close(&self) -> bool {
+        self.close
     }
 
-    /// Prepare for a new frame by extracting the accumulated input,
-    ///
-    /// as well as setting [the time](egui::RawInput::time) and [screen rectangle](egui::RawInput::screen_rect).
-    ///
-    /// You need to set [`egui::RawInput::viewports`] yourself though.
-    /// Use [`update_viewport_info`] to update the info for each
-    /// viewport.
-    pub fn take_egui_input(&mut self, window: &Window) -> egui::RawInput {
-        crate::profile_function!();
-
-        self.egui_input.time = Some(self.start_time.elapsed().as_secs_f64());
-
-        // On Windows, a minimized window will have 0 width and height.
-        // See: https://github.com/rust-windowing/winit/issues/208
-        // This solves an issue where egui window positions would be changed when minimizing on Windows.
-        let screen_size_in_pixels = screen_size_in_pixels(window);
-        let screen_size_in_points =
-            screen_size_in_pixels / pixels_per_point(&self.egui_ctx, window);
-
-        self.egui_input.screen_rect = (screen_size_in_points.x > 0.0
-            && screen_size_in_points.y > 0.0)
-            .then(|| Rect::from_min_size(Pos2::ZERO, screen_size_in_points));
-
-        // Tell egui which viewport is now active:
-        self.egui_input.viewport_id = self.viewport_id;
-
-        self.egui_input
-            .viewports
-            .entry(self.viewport_id)
-            .or_default()
-            .native_pixels_per_point = Some(window.scale_factor() as f32);
-
-        self.egui_input.take()
-    }
-
-    /// Call this when there is a new event.
-    ///
-    /// The result can be found in [`Self::egui_input`] and be extracted with [`Self::take_egui_input`].
     pub fn on_window_event(
         &mut self,
-        window: &Window,
+        window: &winit::window::Window,
+        egui_winit: &mut egui_winit::State,
         event: &winit::event::WindowEvent,
     ) -> EventResponse {
-        crate::profile_function!(short_window_event_description(event));
+        crate::profile_function!(egui_winit::short_window_event_description(event));
 
-        #[cfg(feature = "accesskit")]
-        if let Some(accesskit) = &self.accesskit {
-            accesskit.process_event(window, event);
-        }
+        use winit::event::{ElementState, MouseButton, WindowEvent};
 
-        use winit::event::WindowEvent;
         match event {
-            WindowEvent::ScaleFactorChanged { scale_factor, .. } => {
-                let native_pixels_per_point = *scale_factor as f32;
-
-                self.egui_input
-                    .viewports
-                    .entry(self.viewport_id)
-                    .or_default()
-                    .native_pixels_per_point = Some(native_pixels_per_point);
-
-                EventResponse {
-                    repaint: true,
-                    consumed: false,
-                }
+            WindowEvent::Destroyed => {
+                log::debug!("Received WindowEvent::Destroyed");
+                self.close = true;
             }
-            WindowEvent::MouseInput { state, button, .. } => {
-                self.on_mouse_button_input(*state, *button);
-                EventResponse {
-                    repaint: true,
-                    consumed: self.egui_ctx.wants_pointer_input(),
-                }
-            }
-            WindowEvent::MouseWheel { delta, .. } => {
-                self.on_mouse_wheel(window, *delta);
-                EventResponse {
-                    repaint: true,
-                    consumed: self.egui_ctx.wants_pointer_input(),
-                }
-            }
-            WindowEvent::CursorMoved { position, .. } => {
-                self.on_cursor_moved(window, *position);
-                EventResponse {
-                    repaint: true,
-                    consumed: self.egui_ctx.is_using_pointer(),
-                }
-            }
-            WindowEvent::CursorLeft { .. } => {
-                self.pointer_pos_in_points = None;
-                self.egui_input.events.push(egui::Event::PointerGone);
-                EventResponse {
-                    repaint: true,
-                    consumed: false,
-                }
-            }
-            // WindowEvent::TouchpadPressure {device_id, pressure, stage, ..  } => {} // TODO(emilk)
-            WindowEvent::Touch(touch) => {
-                self.on_touch(window, touch);
-                let consumed = match touch.phase {
-                    winit::event::TouchPhase::Started
-                    | winit::event::TouchPhase::Ended
-                    | winit::event::TouchPhase::Cancelled => self.egui_ctx.wants_pointer_input(),
-                    winit::event::TouchPhase::Moved => self.egui_ctx.is_using_pointer(),
-                };
-                EventResponse {
-                    repaint: true,
-                    consumed,
-                }
-            }
-
-            WindowEvent::Ime(ime) => {
-                // on Mac even Cmd-C is pressed during ime, a `c` is pushed to Preedit.
-                // So no need to check is_mac_cmd.
-                //
-                // How winit produce `Ime::Enabled` and `Ime::Disabled` differs in MacOS
-                // and Windows.
-                //
-                // - On Windows, before and after each Commit will produce an Enable/Disabled
-                // event.
-                // - On MacOS, only when user explicit enable/disable ime. No Disabled
-                // after Commit.
-                //
-                // We use input_method_editor_started to manually insert CompositionStart
-                // between Commits.
-                match ime {
-                    winit::event::Ime::Enabled | winit::event::Ime::Disabled => (),
-                    winit::event::Ime::Commit(text) => {
-                        self.input_method_editor_started = false;
-                        self.egui_input
-                            .events
-                            .push(egui::Event::CompositionEnd(text.clone()));
-                    }
-                    winit::event::Ime::Preedit(text, Some(_)) => {
-                        if !self.input_method_editor_started {
-                            self.input_method_editor_started = true;
-                            self.egui_input.events.push(egui::Event::CompositionStart);
-                        }
-                        self.egui_input
-                            .events
-                            .push(egui::Event::CompositionUpdate(text.clone()));
-                    }
-                    winit::event::Ime::Preedit(_, None) => {}
-                };
-
-                EventResponse {
-                    repaint: true,
-                    consumed: self.egui_ctx.wants_keyboard_input(),
-                }
-            }
-            WindowEvent::KeyboardInput { event, .. } => {
-                self.on_keyboard_input(event);
-
-                // When pressing the Tab key, egui focuses the first focusable element, hence Tab always consumes.
-                let consumed = self.egui_ctx.wants_keyboard_input()
-                    || event.logical_key
-                        == winit::keyboard::Key::Named(winit::keyboard::NamedKey::Tab);
-                EventResponse {
-                    repaint: true,
-                    consumed,
-                }
-            }
-            WindowEvent::Focused(focused) => {
-                self.egui_input.focused = *focused;
-                self.egui_input
-                    .events
-                    .push(egui::Event::WindowFocused(*focused));
-                EventResponse {
-                    repaint: true,
-                    consumed: false,
-                }
-            }
-            WindowEvent::HoveredFile(path) => {
-                self.egui_input.hovered_files.push(egui::HoveredFile {
-                    path: Some(path.clone()),
-                    ..Default::default()
-                });
-                EventResponse {
-                    repaint: true,
-                    consumed: false,
-                }
-            }
-            WindowEvent::HoveredFileCancelled => {
-                self.egui_input.hovered_files.clear();
-                EventResponse {
-                    repaint: true,
-                    consumed: false,
-                }
-            }
-            WindowEvent::DroppedFile(path) => {
-                self.egui_input.hovered_files.clear();
-                self.egui_input.dropped_files.push(egui::DroppedFile {
-                    path: Some(path.clone()),
-                    ..Default::default()
-                });
-                EventResponse {
-                    repaint: true,
-                    consumed: false,
-                }
-            }
-            WindowEvent::ModifiersChanged(state) => {
-                let state = state.state();
-
-                let alt = state.alt_key();
-                let ctrl = state.control_key();
-                let shift = state.shift_key();
-                let super_ = state.super_key();
-
-                self.egui_input.modifiers.alt = alt;
-                self.egui_input.modifiers.ctrl = ctrl;
-                self.egui_input.modifiers.shift = shift;
-                self.egui_input.modifiers.mac_cmd = cfg!(target_os = "macos") && super_;
-                self.egui_input.modifiers.command = if cfg!(target_os = "macos") {
-                    super_
-                } else {
-                    ctrl
-                };
-
-                EventResponse {
-                    repaint: true,
-                    consumed: false,
-                }
-            }
-
-            // Things that may require repaint:
-            WindowEvent::RedrawRequested
-            | WindowEvent::CursorEntered { .. }
-            | WindowEvent::Destroyed
-            | WindowEvent::Occluded(_)
-            | WindowEvent::Resized(_)
-            | WindowEvent::Moved(_)
-            | WindowEvent::ThemeChanged(_)
-            | WindowEvent::TouchpadPressure { .. }
-            | WindowEvent::CloseRequested => EventResponse {
-                repaint: true,
-                consumed: false,
-            },
-
-            // Things we completely ignore:
-            WindowEvent::ActivationTokenDone { .. }
-            | WindowEvent::AxisMotion { .. }
-            | WindowEvent::SmartMagnify { .. }
-            | WindowEvent::TouchpadRotate { .. } => EventResponse {
-                repaint: false,
-                consumed: false,
-            },
-
-            WindowEvent::TouchpadMagnify { delta, .. } => {
-                // Positive delta values indicate magnification (zooming in).
-                // Negative delta values indicate shrinking (zooming out).
-                let zoom_factor = (*delta as f32).exp();
-                self.egui_input.events.push(egui::Event::Zoom(zoom_factor));
-                EventResponse {
-                    repaint: true,
-                    consumed: self.egui_ctx.wants_pointer_input(),
-                }
+            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);
+                self.egui_ctx.set_visuals(theme.egui_visuals());
             }
+            _ => {}
         }
-    }
 
-    pub fn on_mouse_motion(&mut self, delta: (f64, f64)) {
-        self.egui_input.events.push(egui::Event::MouseMoved(Vec2 {
-            x: delta.0 as f32,
-            y: delta.1 as f32,
-        }));
+        egui_winit.on_window_event(window, event)
     }
 
-    /// Call this when there is a new [`accesskit::ActionRequest`].
-    ///
-    /// The result can be found in [`Self::egui_input`] and be extracted with [`Self::take_egui_input`].
-    #[cfg(feature = "accesskit")]
-    pub fn on_accesskit_action_request(&mut self, request: accesskit::ActionRequest) {
-        self.egui_input
-            .events
-            .push(egui::Event::AccessKitActionRequest(request));
+    pub fn pre_update(&mut self) {
+        self.app_icon_setter.update();
     }
 
-    fn on_mouse_button_input(
-        &mut self,
-        state: winit::event::ElementState,
-        button: winit::event::MouseButton,
-    ) {
-        if let Some(pos) = self.pointer_pos_in_points {
-            if let Some(button) = translate_mouse_button(button) {
-                let pressed = state == winit::event::ElementState::Pressed;
-
-                self.egui_input.events.push(egui::Event::PointerButton {
-                    pos,
-                    button,
-                    pressed,
-                    modifiers: self.egui_input.modifiers,
-                });
-
-                if self.simulate_touch_screen {
-                    if pressed {
-                        self.any_pointer_button_down = true;
-
-                        self.egui_input.events.push(egui::Event::Touch {
-                            device_id: egui::TouchDeviceId(0),
-                            id: egui::TouchId(0),
-                            phase: egui::TouchPhase::Start,
-                            pos,
-                            force: None,
-                        });
-                    } else {
-                        self.any_pointer_button_down = false;
-
-                        self.egui_input.events.push(egui::Event::PointerGone);
-
-                        self.egui_input.events.push(egui::Event::Touch {
-                            device_id: egui::TouchDeviceId(0),
-                            id: egui::TouchId(0),
-                            phase: egui::TouchPhase::End,
-                            pos,
-                            force: None,
-                        });
-                    };
-                }
-            }
-        }
-    }
-
-    fn on_cursor_moved(
-        &mut self,
-        window: &Window,
-        pos_in_pixels: winit::dpi::PhysicalPosition<f64>,
-    ) {
-        let pixels_per_point = pixels_per_point(&self.egui_ctx, window);
-
-        let pos_in_points = egui::pos2(
-            pos_in_pixels.x as f32 / pixels_per_point,
-            pos_in_pixels.y as f32 / pixels_per_point,
-        );
-        self.pointer_pos_in_points = Some(pos_in_points);
-
-        if self.simulate_touch_screen {
-            if self.any_pointer_button_down {
-                self.egui_input
-                    .events
-                    .push(egui::Event::PointerMoved(pos_in_points));
-
-                self.egui_input.events.push(egui::Event::Touch {
-                    device_id: egui::TouchDeviceId(0),
-                    id: egui::TouchId(0),
-                    phase: egui::TouchPhase::Move,
-                    pos: pos_in_points,
-                    force: None,
-                });
-            }
-        } else {
-            self.egui_input
-                .events
-                .push(egui::Event::PointerMoved(pos_in_points));
-        }
-    }
-
-    fn on_touch(&mut self, window: &Window, touch: &winit::event::Touch) {
-        let pixels_per_point = pixels_per_point(&self.egui_ctx, window);
-
-        // Emit touch event
-        self.egui_input.events.push(egui::Event::Touch {
-            device_id: egui::TouchDeviceId(egui::epaint::util::hash(touch.device_id)),
-            id: egui::TouchId::from(touch.id),
-            phase: match touch.phase {
-                winit::event::TouchPhase::Started => egui::TouchPhase::Start,
-                winit::event::TouchPhase::Moved => egui::TouchPhase::Move,
-                winit::event::TouchPhase::Ended => egui::TouchPhase::End,
-                winit::event::TouchPhase::Cancelled => egui::TouchPhase::Cancel,
-            },
-            pos: egui::pos2(
-                touch.location.x as f32 / pixels_per_point,
-                touch.location.y as f32 / pixels_per_point,
-            ),
-            force: match touch.force {
-                Some(winit::event::Force::Normalized(force)) => Some(force as f32),
-                Some(winit::event::Force::Calibrated {
-                    force,
-                    max_possible_force,
-                    ..
-                }) => Some((force / max_possible_force) as f32),
-                None => None,
-            },
-        });
-        // If we're not yet translating a touch or we're translating this very
-        // touch …
-        if self.pointer_touch_id.is_none() || self.pointer_touch_id.unwrap() == touch.id {
-            // … emit PointerButton resp. PointerMoved events to emulate mouse
-            match touch.phase {
-                winit::event::TouchPhase::Started => {
-                    self.pointer_touch_id = Some(touch.id);
-                    // First move the pointer to the right location
-                    self.on_cursor_moved(window, touch.location);
-                    self.on_mouse_button_input(
-                        winit::event::ElementState::Pressed,
-                        winit::event::MouseButton::Left,
-                    );
-                }
-                winit::event::TouchPhase::Moved => {
-                    self.on_cursor_moved(window, touch.location);
-                }
-                winit::event::TouchPhase::Ended => {
-                    self.pointer_touch_id = None;
-                    self.on_mouse_button_input(
-                        winit::event::ElementState::Released,
-                        winit::event::MouseButton::Left,
-                    );
-                    // The pointer should vanish completely to not get any
-                    // hover effects
-                    self.pointer_pos_in_points = None;
-                    self.egui_input.events.push(egui::Event::PointerGone);
-                }
-                winit::event::TouchPhase::Cancelled => {
-                    self.pointer_touch_id = None;
-                    self.pointer_pos_in_points = None;
-                    self.egui_input.events.push(egui::Event::PointerGone);
-                }
-            }
-        }
-    }
-
-    fn on_mouse_wheel(&mut self, window: &Window, delta: winit::event::MouseScrollDelta) {
-        let pixels_per_point = pixels_per_point(&self.egui_ctx, window);
-
-        {
-            let (unit, delta) = match delta {
-                winit::event::MouseScrollDelta::LineDelta(x, y) => {
-                    (egui::MouseWheelUnit::Line, egui::vec2(x, y))
-                }
-                winit::event::MouseScrollDelta::PixelDelta(winit::dpi::PhysicalPosition {
-                    x,
-                    y,
-                }) => (
-                    egui::MouseWheelUnit::Point,
-                    egui::vec2(x as f32, y as f32) / pixels_per_point,
-                ),
-            };
-            let modifiers = self.egui_input.modifiers;
-            self.egui_input.events.push(egui::Event::MouseWheel {
-                unit,
-                delta,
-                modifiers,
-            });
-        }
-        let delta = match delta {
-            winit::event::MouseScrollDelta::LineDelta(x, y) => {
-                let points_per_scroll_line = 50.0; // Scroll speed decided by consensus: https://github.com/emilk/egui/issues/461
-                egui::vec2(x, y) * points_per_scroll_line
-            }
-            winit::event::MouseScrollDelta::PixelDelta(delta) => {
-                egui::vec2(delta.x as f32, delta.y as f32) / pixels_per_point
-            }
-        };
-
-        if self.egui_input.modifiers.ctrl || self.egui_input.modifiers.command {
-            // Treat as zoom instead:
-            let factor = (delta.y / 200.0).exp();
-            self.egui_input.events.push(egui::Event::Zoom(factor));
-        } else if self.egui_input.modifiers.shift {
-            // Treat as horizontal scrolling.
-            // Note: one Mac we already get horizontal scroll events when shift is down.
-            self.egui_input
-                .events
-                .push(egui::Event::Scroll(egui::vec2(delta.x + delta.y, 0.0)));
-        } else {
-            self.egui_input.events.push(egui::Event::Scroll(delta));
-        }
-    }
-
-    fn on_keyboard_input(&mut self, event: &winit::event::KeyEvent) {
-        let winit::event::KeyEvent {
-            // Represents the position of a key independent of the currently active layout.
-            //
-            // It also uniquely identifies the physical key (i.e. it's mostly synonymous with a scancode).
-            // The most prevalent use case for this is games. For example the default keys for the player
-            // to move around might be the W, A, S, and D keys on a US layout. The position of these keys
-            // is more important than their label, so they should map to Z, Q, S, and D on an "AZERTY"
-            // layout. (This value is `KeyCode::KeyW` for the Z key on an AZERTY layout.)
-            physical_key,
-
-            // Represents the results of a keymap, i.e. what character a certain key press represents.
-            // When telling users "Press Ctrl-F to find", this is where we should
-            // look for the "F" key, because they may have a dvorak layout on
-            // a qwerty keyboard, and so the logical "F" character may not be located on the physical `KeyCode::KeyF` position.
-            logical_key,
-
-            text,
-
-            state,
-
-            location: _, // e.g. is it on the numpad?
-            repeat: _,   // egui will figure this out for us
-            ..
-        } = event;
-
-        let pressed = *state == winit::event::ElementState::Pressed;
-
-        let physical_key = if let winit::keyboard::PhysicalKey::Code(keycode) = *physical_key {
-            key_from_key_code(keycode)
-        } else {
-            None
-        };
-
-        let logical_key = key_from_winit_key(logical_key);
-
-        // Helpful logging to enable when adding new key support
-        log::trace!(
-            "logical {:?} -> {:?},  physical {:?} -> {:?}",
-            event.logical_key,
-            logical_key,
-            event.physical_key,
-            physical_key
-        );
-
-        if let Some(logical_key) = logical_key {
-            if pressed {
-                if is_cut_command(self.egui_input.modifiers, logical_key) {
-                    self.egui_input.events.push(egui::Event::Cut);
-                    return;
-                } else if is_copy_command(self.egui_input.modifiers, logical_key) {
-                    self.egui_input.events.push(egui::Event::Copy);
-                    return;
-                } else if is_paste_command(self.egui_input.modifiers, logical_key) {
-                    if let Some(contents) = self.clipboard.get() {
-                        let contents = contents.replace("\r\n", "\n");
-                        if !contents.is_empty() {
-                            self.egui_input.events.push(egui::Event::Paste(contents));
-                        }
-                    }
-                    return;
-                }
-            }
-
-            self.egui_input.events.push(egui::Event::Key {
-                key: logical_key,
-                physical_key,
-                pressed,
-                repeat: false, // egui will fill this in for us!
-                modifiers: self.egui_input.modifiers,
-            });
-        }
-
-        if let Some(text) = &text {
-            // Make sure there is text, and that it is not control characters
-            // (e.g. delete is sent as "\u{f728}" on macOS).
-            if !text.is_empty() && text.chars().all(is_printable_char) {
-                // On some platforms we get here when the user presses Cmd-C (copy), ctrl-W, etc.
-                // We need to ignore these characters that are side-effects of commands.
-                // Also make sure the key is pressed (not released). On Linux, text might
-                // contain some data even when the key is released.
-                let is_cmd = self.egui_input.modifiers.ctrl
-                    || self.egui_input.modifiers.command
-                    || self.egui_input.modifiers.mac_cmd;
-                if pressed && !is_cmd {
-                    self.egui_input
-                        .events
-                        .push(egui::Event::Text(text.to_string()));
-                }
-            }
-        }
-    }
-
-    /// Call with the output given by `egui`.
+    /// Run user code - this can create immediate viewports, so hold no locks over this!
     ///
-    /// This will, if needed:
-    /// * update the cursor
-    /// * copy text to the clipboard
-    /// * open any clicked urls
-    /// * update the IME
-    /// *
-    pub fn handle_platform_output(
+    /// If `viewport_ui_cb` is None, we are in the root viewport and will call [`crate::App::update`].
+    pub fn update(
         &mut self,
-        window: &Window,
-        platform_output: egui::PlatformOutput,
-    ) {
-        crate::profile_function!();
-
-        let egui::PlatformOutput {
-            cursor_icon,
-            open_url,
-            copied_text,
-            events: _,                    // handled elsewhere
-            mutable_text_under_cursor: _, // only used in eframe web
-            ime,
-            #[cfg(feature = "accesskit")]
-            accesskit_update,
-        } = platform_output;
+        app: &mut dyn epi::App,
+        viewport_ui_cb: Option<&DeferredViewportUiCallback>,
+        mut raw_input: egui::RawInput,
+    ) -> egui::FullOutput {
+        raw_input.time = Some(self.beginning.elapsed().as_secs_f64());
 
-        self.set_cursor_icon(window, cursor_icon);
+        let close_requested = raw_input.viewport().close_requested();
 
-        if let Some(open_url) = open_url {
-            open_url_in_browser(&open_url.url);
-        }
+        app.raw_input_hook(&self.egui_ctx, &mut raw_input);
 
-        if !copied_text.is_empty() {
-            self.clipboard.set(copied_text);
-        }
-
-        let allow_ime = ime.is_some();
-        if self.allow_ime != allow_ime {
-            self.allow_ime = allow_ime;
-            crate::profile_scope!("set_ime_allowed");
-            window.set_ime_allowed(allow_ime);
-        }
-
-        if let Some(ime) = ime {
-            let rect = ime.rect;
-            let pixels_per_point = pixels_per_point(&self.egui_ctx, window);
-            crate::profile_scope!("set_ime_cursor_area");
-            window.set_ime_cursor_area(
-                winit::dpi::PhysicalPosition {
-                    x: pixels_per_point * rect.min.x,
-                    y: pixels_per_point * rect.min.y,
-                },
-                winit::dpi::PhysicalSize {
-                    width: pixels_per_point * rect.width(),
-                    height: pixels_per_point * rect.height(),
-                },
-            );
-        }
-
-        #[cfg(feature = "accesskit")]
-        if let Some(accesskit) = self.accesskit.as_ref() {
-            if let Some(update) = accesskit_update {
-                crate::profile_scope!("accesskit");
-                accesskit.update_if_active(|| update);
+        let full_output = self.egui_ctx.run(raw_input, |egui_ctx| {
+            if let Some(viewport_ui_cb) = viewport_ui_cb {
+                // Child viewport
+                crate::profile_scope!("viewport_callback");
+                viewport_ui_cb(egui_ctx);
+            } else {
+                crate::profile_scope!("App::update");
+                app.update(egui_ctx, &mut self.frame);
             }
-        }
-    }
-
-    fn set_cursor_icon(&mut self, window: &Window, cursor_icon: egui::CursorIcon) {
-        if self.current_cursor_icon == Some(cursor_icon) {
-            // Prevent flickering near frame boundary when Windows OS tries to control cursor icon for window resizing.
-            // On other platforms: just early-out to save CPU.
-            return;
-        }
-
-        let is_pointer_in_window = self.pointer_pos_in_points.is_some();
-        if is_pointer_in_window {
-            self.current_cursor_icon = Some(cursor_icon);
+        });
 
-            if let Some(winit_cursor_icon) = translate_cursor(cursor_icon) {
-                window.set_cursor_visible(true);
-                window.set_cursor_icon(winit_cursor_icon);
+        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 {
-                window.set_cursor_visible(false);
+                log::debug!("Closing root viewport (ViewportCommand::CancelClose was not sent)");
+                self.close = true;
             }
-        } else {
-            // Remember to set the cursor again once the cursor returns to the screen:
-            self.current_cursor_icon = None;
         }
-    }
-}
-
-pub fn inner_rect_in_points(window: &Window, pixels_per_point: f32) -> Option<Rect> {
-    let pos = window.inner_position().ok()?;
-    let inner_pos_px = egui::emath::Pos2::new(pos.x as f32, pos.y as f32);
-
-    let inner_size_px = {
-        let size = window.inner_size();
-        egui::Vec2::new(size.width as f32, size.height as f32)
-    };
-    let inner_rect_px = egui::Rect::from_min_size(inner_pos_px, inner_size_px);
-
-    Some(inner_rect_px / pixels_per_point)
-}
-
-pub fn outer_rect_in_points(window: &Window, pixels_per_point: f32) -> Option<Rect> {
-    let pos = window.outer_position().ok()?;
-    let outer_pos_px = egui::emath::Pos2::new(pos.x as f32, pos.y as f32);
-
-    let outer_size_px = {
-        let size = window.outer_size();
-        egui::Vec2::new(size.width as f32, size.height as f32)
-    };
-    let outer_rect_px = egui::Rect::from_min_size(outer_pos_px, outer_size_px);
-
-    Some(outer_rect_px / pixels_per_point)
-}
-
-/// Update the given viewport info with the current state of the window.
-///
-/// Call before [`State::take_egui_input`].
-pub fn update_viewport_info(
-    viewport_info: &mut ViewportInfo,
-    egui_ctx: &egui::Context,
-    window: &Window,
-) {
-    crate::profile_function!();
-
-    let pixels_per_point = pixels_per_point(egui_ctx, window);
-
-    let has_a_position = match window.is_minimized() {
-        Some(true) => false,
-        Some(false) | None => true,
-    };
-
-    let inner_rect = if has_a_position {
-        inner_rect_in_points(window, pixels_per_point)
-    } else {
-        None
-    };
-
-    let outer_rect = if has_a_position {
-        outer_rect_in_points(window, pixels_per_point)
-    } else {
-        None
-    };
 
-    let monitor_size = {
-        crate::profile_scope!("monitor_size");
-        if let Some(monitor) = window.current_monitor() {
-            let size = monitor.size().to_logical::<f32>(pixels_per_point.into());
-            Some(egui::vec2(size.width, size.height))
-        } else {
-            None
-        }
-    };
-
-    viewport_info.title = Some(window.title());
-    viewport_info.native_pixels_per_point = Some(window.scale_factor() as f32);
-
-    viewport_info.monitor_size = monitor_size;
-    viewport_info.inner_rect = inner_rect;
-    viewport_info.outer_rect = outer_rect;
-
-    if !cfg!(target_os = "macos") {
-        // It's tempting to do this, but it leads to a deadlock on Mac when running
-        // `cargo run -p custom_window_frame`.
-        // See https://github.com/emilk/egui/issues/3494
-        viewport_info.maximized = Some(window.is_maximized());
-        viewport_info.minimized = Some(window.is_minimized().unwrap_or(false));
+        self.pending_full_output.append(full_output);
+        std::mem::take(&mut self.pending_full_output)
     }
 
-    viewport_info.fullscreen = Some(window.fullscreen().is_some());
-    viewport_info.decorations = Some(window.is_decorated());
-    viewport_info.focused = Some(window.has_focus());
-}
-
-fn open_url_in_browser(_url: &str) {
-    #[cfg(feature = "webbrowser")]
-    if let Err(err) = webbrowser::open(_url) {
-        log::warn!("Failed to open url: {}", err);
-    }
-
-    #[cfg(not(feature = "webbrowser"))]
-    {
-        log::warn!("Cannot open url - feature \"links\" not enabled.");
-    }
-}
-
-/// Winit sends special keys (backspace, delete, F1, …) as characters.
-/// Ignore those.
-/// We also ignore '\r', '\n', '\t'.
-/// Newlines are handled by the `Key::Enter` event.
-fn is_printable_char(chr: char) -> bool {
-    let is_in_private_use_area = '\u{e000}' <= chr && chr <= '\u{f8ff}'
-        || '\u{f0000}' <= chr && chr <= '\u{ffffd}'
-        || '\u{100000}' <= chr && chr <= '\u{10fffd}';
-
-    !is_in_private_use_area && !chr.is_ascii_control()
-}
-
-fn is_cut_command(modifiers: egui::Modifiers, keycode: egui::Key) -> bool {
-    keycode == egui::Key::Cut
-        || (modifiers.command && keycode == egui::Key::X)
-        || (cfg!(target_os = "windows") && modifiers.shift && keycode == egui::Key::Delete)
-}
-
-fn is_copy_command(modifiers: egui::Modifiers, keycode: egui::Key) -> bool {
-    keycode == egui::Key::Copy
-        || (modifiers.command && keycode == egui::Key::C)
-        || (cfg!(target_os = "windows") && modifiers.ctrl && keycode == egui::Key::Insert)
-}
-
-fn is_paste_command(modifiers: egui::Modifiers, keycode: egui::Key) -> bool {
-    keycode == egui::Key::Paste
-        || (modifiers.command && keycode == egui::Key::V)
-        || (cfg!(target_os = "windows") && modifiers.shift && keycode == egui::Key::Insert)
-}
-
-fn translate_mouse_button(button: winit::event::MouseButton) -> Option<egui::PointerButton> {
-    match button {
-        winit::event::MouseButton::Left => Some(egui::PointerButton::Primary),
-        winit::event::MouseButton::Right => Some(egui::PointerButton::Secondary),
-        winit::event::MouseButton::Middle => Some(egui::PointerButton::Middle),
-        winit::event::MouseButton::Back => Some(egui::PointerButton::Extra1),
-        winit::event::MouseButton::Forward => Some(egui::PointerButton::Extra2),
-        winit::event::MouseButton::Other(_) => None,
-    }
-}
-
-fn key_from_winit_key(key: &winit::keyboard::Key) -> Option<egui::Key> {
-    match key {
-        winit::keyboard::Key::Named(named_key) => key_from_named_key(*named_key),
-        winit::keyboard::Key::Character(str) => egui::Key::from_name(str.as_str()),
-        winit::keyboard::Key::Unidentified(_) | winit::keyboard::Key::Dead(_) => None,
+    pub fn report_frame_time(&mut self, seconds: f32) {
+        self.frame.info.cpu_usage = Some(seconds);
     }
-}
-
-fn key_from_named_key(named_key: winit::keyboard::NamedKey) -> Option<egui::Key> {
-    use egui::Key;
-    use winit::keyboard::NamedKey;
-
-    Some(match named_key {
-        NamedKey::Enter => Key::Enter,
-        NamedKey::Tab => Key::Tab,
-        NamedKey::ArrowDown => Key::ArrowDown,
-        NamedKey::ArrowLeft => Key::ArrowLeft,
-        NamedKey::ArrowRight => Key::ArrowRight,
-        NamedKey::ArrowUp => Key::ArrowUp,
-        NamedKey::End => Key::End,
-        NamedKey::Home => Key::Home,
-        NamedKey::PageDown => Key::PageDown,
-        NamedKey::PageUp => Key::PageUp,
-        NamedKey::Backspace => Key::Backspace,
-        NamedKey::Delete => Key::Delete,
-        NamedKey::Insert => Key::Insert,
-        NamedKey::Escape => Key::Escape,
-        NamedKey::Cut => Key::Cut,
-        NamedKey::Copy => Key::Copy,
-        NamedKey::Paste => Key::Paste,
-
-        NamedKey::Space => Key::Space,
-
-        NamedKey::F1 => Key::F1,
-        NamedKey::F2 => Key::F2,
-        NamedKey::F3 => Key::F3,
-        NamedKey::F4 => Key::F4,
-        NamedKey::F5 => Key::F5,
-        NamedKey::F6 => Key::F6,
-        NamedKey::F7 => Key::F7,
-        NamedKey::F8 => Key::F8,
-        NamedKey::F9 => Key::F9,
-        NamedKey::F10 => Key::F10,
-        NamedKey::F11 => Key::F11,
-        NamedKey::F12 => Key::F12,
-        NamedKey::F13 => Key::F13,
-        NamedKey::F14 => Key::F14,
-        NamedKey::F15 => Key::F15,
-        NamedKey::F16 => Key::F16,
-        NamedKey::F17 => Key::F17,
-        NamedKey::F18 => Key::F18,
-        NamedKey::F19 => Key::F19,
-        NamedKey::F20 => Key::F20,
-        NamedKey::F21 => Key::F21,
-        NamedKey::F22 => Key::F22,
-        NamedKey::F23 => Key::F23,
-        NamedKey::F24 => Key::F24,
-        NamedKey::F25 => Key::F25,
-        NamedKey::F26 => Key::F26,
-        NamedKey::F27 => Key::F27,
-        NamedKey::F28 => Key::F28,
-        NamedKey::F29 => Key::F29,
-        NamedKey::F30 => Key::F30,
-        NamedKey::F31 => Key::F31,
-        NamedKey::F32 => Key::F32,
-        NamedKey::F33 => Key::F33,
-        NamedKey::F34 => Key::F34,
-        NamedKey::F35 => Key::F35,
-        _ => {
-            log::trace!("Unknown key: {named_key:?}");
-            return None;
-        }
-    })
-}
-
-fn key_from_key_code(key: winit::keyboard::KeyCode) -> Option<egui::Key> {
-    use egui::Key;
-    use winit::keyboard::KeyCode;
-
-    Some(match key {
-        KeyCode::ArrowDown => Key::ArrowDown,
-        KeyCode::ArrowLeft => Key::ArrowLeft,
-        KeyCode::ArrowRight => Key::ArrowRight,
-        KeyCode::ArrowUp => Key::ArrowUp,
-
-        KeyCode::Escape => Key::Escape,
-        KeyCode::Tab => Key::Tab,
-        KeyCode::Backspace => Key::Backspace,
-        KeyCode::Enter | KeyCode::NumpadEnter => Key::Enter,
-
-        KeyCode::Insert => Key::Insert,
-        KeyCode::Delete => Key::Delete,
-        KeyCode::Home => Key::Home,
-        KeyCode::End => Key::End,
-        KeyCode::PageUp => Key::PageUp,
-        KeyCode::PageDown => Key::PageDown,
-
-        // Punctuation
-        KeyCode::Space => Key::Space,
-        KeyCode::Comma => Key::Comma,
-        KeyCode::Period => Key::Period,
-        // KeyCode::Colon => Key::Colon, // NOTE: there is no physical colon key on an american keyboard
-        KeyCode::Semicolon => Key::Semicolon,
-        KeyCode::Backslash => Key::Backslash,
-        KeyCode::Slash | KeyCode::NumpadDivide => Key::Slash,
-        KeyCode::BracketLeft => Key::OpenBracket,
-        KeyCode::BracketRight => Key::CloseBracket,
-        KeyCode::Backquote => Key::Backtick,
-
-        KeyCode::Cut => Key::Cut,
-        KeyCode::Copy => Key::Copy,
-        KeyCode::Paste => Key::Paste,
-        KeyCode::Minus | KeyCode::NumpadSubtract => Key::Minus,
-        KeyCode::NumpadAdd => Key::Plus,
-        KeyCode::Equal => Key::Equals,
 
-        KeyCode::Digit0 | KeyCode::Numpad0 => Key::Num0,
-        KeyCode::Digit1 | KeyCode::Numpad1 => Key::Num1,
-        KeyCode::Digit2 | KeyCode::Numpad2 => Key::Num2,
-        KeyCode::Digit3 | KeyCode::Numpad3 => Key::Num3,
-        KeyCode::Digit4 | KeyCode::Numpad4 => Key::Num4,
-        KeyCode::Digit5 | KeyCode::Numpad5 => Key::Num5,
-        KeyCode::Digit6 | KeyCode::Numpad6 => Key::Num6,
-        KeyCode::Digit7 | KeyCode::Numpad7 => Key::Num7,
-        KeyCode::Digit8 | KeyCode::Numpad8 => Key::Num8,
-        KeyCode::Digit9 | KeyCode::Numpad9 => Key::Num9,
-
-        KeyCode::KeyA => Key::A,
-        KeyCode::KeyB => Key::B,
-        KeyCode::KeyC => Key::C,
-        KeyCode::KeyD => Key::D,
-        KeyCode::KeyE => Key::E,
-        KeyCode::KeyF => Key::F,
-        KeyCode::KeyG => Key::G,
-        KeyCode::KeyH => Key::H,
-        KeyCode::KeyI => Key::I,
-        KeyCode::KeyJ => Key::J,
-        KeyCode::KeyK => Key::K,
-        KeyCode::KeyL => Key::L,
-        KeyCode::KeyM => Key::M,
-        KeyCode::KeyN => Key::N,
-        KeyCode::KeyO => Key::O,
-        KeyCode::KeyP => Key::P,
-        KeyCode::KeyQ => Key::Q,
-        KeyCode::KeyR => Key::R,
-        KeyCode::KeyS => Key::S,
-        KeyCode::KeyT => Key::T,
-        KeyCode::KeyU => Key::U,
-        KeyCode::KeyV => Key::V,
-        KeyCode::KeyW => Key::W,
-        KeyCode::KeyX => Key::X,
-        KeyCode::KeyY => Key::Y,
-        KeyCode::KeyZ => Key::Z,
-
-        KeyCode::F1 => Key::F1,
-        KeyCode::F2 => Key::F2,
-        KeyCode::F3 => Key::F3,
-        KeyCode::F4 => Key::F4,
-        KeyCode::F5 => Key::F5,
-        KeyCode::F6 => Key::F6,
-        KeyCode::F7 => Key::F7,
-        KeyCode::F8 => Key::F8,
-        KeyCode::F9 => Key::F9,
-        KeyCode::F10 => Key::F10,
-        KeyCode::F11 => Key::F11,
-        KeyCode::F12 => Key::F12,
-        KeyCode::F13 => Key::F13,
-        KeyCode::F14 => Key::F14,
-        KeyCode::F15 => Key::F15,
-        KeyCode::F16 => Key::F16,
-        KeyCode::F17 => Key::F17,
-        KeyCode::F18 => Key::F18,
-        KeyCode::F19 => Key::F19,
-        KeyCode::F20 => Key::F20,
-        KeyCode::F21 => Key::F21,
-        KeyCode::F22 => Key::F22,
-        KeyCode::F23 => Key::F23,
-        KeyCode::F24 => Key::F24,
-        KeyCode::F25 => Key::F25,
-        KeyCode::F26 => Key::F26,
-        KeyCode::F27 => Key::F27,
-        KeyCode::F28 => Key::F28,
-        KeyCode::F29 => Key::F29,
-        KeyCode::F30 => Key::F30,
-        KeyCode::F31 => Key::F31,
-        KeyCode::F32 => Key::F32,
-        KeyCode::F33 => Key::F33,
-        KeyCode::F34 => Key::F34,
-        KeyCode::F35 => Key::F35,
-
-        _ => {
-            return None;
+    pub fn post_rendering(&mut self, window: &winit::window::Window) {
+        crate::profile_function!();
+        if std::mem::take(&mut self.is_first_frame) {
+            // We keep hidden until we've painted something. See https://github.com/emilk/egui/pull/2279
+            window.set_visible(true);
         }
-    })
-}
-
-fn translate_cursor(cursor_icon: egui::CursorIcon) -> Option<winit::window::CursorIcon> {
-    match cursor_icon {
-        egui::CursorIcon::None => None,
-
-        egui::CursorIcon::Alias => Some(winit::window::CursorIcon::Alias),
-        egui::CursorIcon::AllScroll => Some(winit::window::CursorIcon::AllScroll),
-        egui::CursorIcon::Cell => Some(winit::window::CursorIcon::Cell),
-        egui::CursorIcon::ContextMenu => Some(winit::window::CursorIcon::ContextMenu),
-        egui::CursorIcon::Copy => Some(winit::window::CursorIcon::Copy),
-        egui::CursorIcon::Crosshair => Some(winit::window::CursorIcon::Crosshair),
-        egui::CursorIcon::Default => Some(winit::window::CursorIcon::Default),
-        egui::CursorIcon::Grab => Some(winit::window::CursorIcon::Grab),
-        egui::CursorIcon::Grabbing => Some(winit::window::CursorIcon::Grabbing),
-        egui::CursorIcon::Help => Some(winit::window::CursorIcon::Help),
-        egui::CursorIcon::Move => Some(winit::window::CursorIcon::Move),
-        egui::CursorIcon::NoDrop => Some(winit::window::CursorIcon::NoDrop),
-        egui::CursorIcon::NotAllowed => Some(winit::window::CursorIcon::NotAllowed),
-        egui::CursorIcon::PointingHand => Some(winit::window::CursorIcon::Pointer),
-        egui::CursorIcon::Progress => Some(winit::window::CursorIcon::Progress),
-
-        egui::CursorIcon::ResizeHorizontal => Some(winit::window::CursorIcon::EwResize),
-        egui::CursorIcon::ResizeNeSw => Some(winit::window::CursorIcon::NeswResize),
-        egui::CursorIcon::ResizeNwSe => Some(winit::window::CursorIcon::NwseResize),
-        egui::CursorIcon::ResizeVertical => Some(winit::window::CursorIcon::NsResize),
-
-        egui::CursorIcon::ResizeEast => Some(winit::window::CursorIcon::EResize),
-        egui::CursorIcon::ResizeSouthEast => Some(winit::window::CursorIcon::SeResize),
-        egui::CursorIcon::ResizeSouth => Some(winit::window::CursorIcon::SResize),
-        egui::CursorIcon::ResizeSouthWest => Some(winit::window::CursorIcon::SwResize),
-        egui::CursorIcon::ResizeWest => Some(winit::window::CursorIcon::WResize),
-        egui::CursorIcon::ResizeNorthWest => Some(winit::window::CursorIcon::NwResize),
-        egui::CursorIcon::ResizeNorth => Some(winit::window::CursorIcon::NResize),
-        egui::CursorIcon::ResizeNorthEast => Some(winit::window::CursorIcon::NeResize),
-        egui::CursorIcon::ResizeColumn => Some(winit::window::CursorIcon::ColResize),
-        egui::CursorIcon::ResizeRow => Some(winit::window::CursorIcon::RowResize),
-
-        egui::CursorIcon::Text => Some(winit::window::CursorIcon::Text),
-        egui::CursorIcon::VerticalText => Some(winit::window::CursorIcon::VerticalText),
-        egui::CursorIcon::Wait => Some(winit::window::CursorIcon::Wait),
-        egui::CursorIcon::ZoomIn => Some(winit::window::CursorIcon::ZoomIn),
-        egui::CursorIcon::ZoomOut => Some(winit::window::CursorIcon::ZoomOut),
     }
-}
 
-// Helpers for egui Viewports
-// ---------------------------------------------------------------------------
+    // ------------------------------------------------------------------------
+    // Persistence stuff:
 
-pub fn process_viewport_commands(
-    egui_ctx: &egui::Context,
-    info: &mut ViewportInfo,
-    commands: impl IntoIterator<Item = ViewportCommand>,
-    window: &Window,
-    is_viewport_focused: bool,
-    screenshot_requested: &mut bool,
-) {
-    for command in commands {
-        process_viewport_command(
-            egui_ctx,
-            window,
-            command,
-            info,
-            is_viewport_focused,
-            screenshot_requested,
-        );
-    }
-}
-
-fn process_viewport_command(
-    egui_ctx: &egui::Context,
-    window: &Window,
-    command: ViewportCommand,
-    info: &mut ViewportInfo,
-    is_viewport_focused: bool,
-    screenshot_requested: &mut bool,
-) {
-    crate::profile_function!();
-
-    use winit::window::ResizeDirection;
-
-    log::trace!("Processing ViewportCommand::{command:?}");
-
-    let pixels_per_point = pixels_per_point(egui_ctx, window);
-
-    match command {
-        ViewportCommand::Close => {
-            info.close_requested_on();
-            info.close_cancelable_off();
-            // info.close_cancelable = false;
-            info.events.push(egui::ViewportEvent::Close);
-        }
-        ViewportCommand::CancelClose => {
-            // Need to be handled elsewhere
-            info.close_requested_off();
-            // info.close_cancelable_on();
-            // dbg!(&info.events);
-            // info.events.clear();
-            if let Some(position) = info
-                .events
-                .iter()
-                .position(|x| *x == egui::ViewportEvent::Close)
-            {
-                info.events.remove(position);
-            }
-        }
-        ViewportCommand::StartDrag => {
-            // If `is_viewport_focused` is not checked on x11 the input will be permanently taken until the app is killed!
-
-            // TODO(emilk): check that the left mouse-button was pressed down recently,
-            // or we will have bugs on Windows.
-            // See https://github.com/emilk/egui/pull/1108
-            if is_viewport_focused {
-                if let Err(err) = window.drag_window() {
-                    log::warn!("{command:?}: {err}");
-                }
-            }
-        }
-        ViewportCommand::InnerSize(size) => {
-            let width_px = pixels_per_point * size.x.max(1.0);
-            let height_px = pixels_per_point * size.y.max(1.0);
-            if let Some(_inner_size) =
-                window.request_inner_size(PhysicalSize::new(width_px, height_px))
-            {
-                // ViewportCommand::InnerSize, not will be delivered later with the [WindowEvent::Resized]
-                // ex) linux
-                info.inner_rect = inner_rect_in_points(window, pixels_per_point);
-                info.outer_rect = outer_rect_in_points(window, pixels_per_point);
-            } else {
-                // ViewportCommand::InnerSize, will be delivered later with the [WindowEvent::Resized]
-                // ex) Windows, MacOS
-            }
-        }
-        ViewportCommand::BeginResize(direction) => {
-            if let Err(err) = window.drag_resize_window(match direction {
-                egui::viewport::ResizeDirection::North => ResizeDirection::North,
-                egui::viewport::ResizeDirection::South => ResizeDirection::South,
-                egui::viewport::ResizeDirection::East => ResizeDirection::East,
-                egui::viewport::ResizeDirection::West => ResizeDirection::West,
-                egui::viewport::ResizeDirection::NorthEast => ResizeDirection::NorthEast,
-                egui::viewport::ResizeDirection::SouthEast => ResizeDirection::SouthEast,
-                egui::viewport::ResizeDirection::NorthWest => ResizeDirection::NorthWest,
-                egui::viewport::ResizeDirection::SouthWest => ResizeDirection::SouthWest,
-            }) {
-                log::warn!("{command:?}: {err}");
-            }
-        }
-        ViewportCommand::Title(title) => {
-            window.set_title(&title);
-        }
-        ViewportCommand::Transparent(v) => {
-            window.set_transparent(v);
-            info.transparent = Some(v);
-        }
-        ViewportCommand::Visible(v) => window.set_visible(v),
-        ViewportCommand::OuterPosition(pos) => {
-            window.set_outer_position(PhysicalPosition::new(
-                pixels_per_point * pos.x,
-                pixels_per_point * pos.y,
-            ));
-        }
-        ViewportCommand::MinInnerSize(s) => {
-            window.set_min_inner_size((s.is_finite() && s != Vec2::ZERO).then_some(
-                PhysicalSize::new(pixels_per_point * s.x, pixels_per_point * s.y),
-            ));
-        }
-        ViewportCommand::MaxInnerSize(s) => {
-            window.set_max_inner_size((s.is_finite() && s != Vec2::INFINITY).then_some(
-                PhysicalSize::new(pixels_per_point * s.x, pixels_per_point * s.y),
-            ));
-        }
-        ViewportCommand::ResizeIncrements(s) => {
-            window.set_resize_increments(
-                s.map(|s| PhysicalSize::new(pixels_per_point * s.x, pixels_per_point * s.y)),
-            );
-        }
-        ViewportCommand::Resizable(v) => window.set_resizable(v),
-        ViewportCommand::EnableButtons {
-            close,
-            minimized,
-            maximize,
-        } => window.set_enabled_buttons(
-            if close {
-                WindowButtons::CLOSE
-            } else {
-                WindowButtons::empty()
-            } | if minimized {
-                WindowButtons::MINIMIZE
-            } else {
-                WindowButtons::empty()
-            } | if maximize {
-                WindowButtons::MAXIMIZE
-            } else {
-                WindowButtons::empty()
-            },
-        ),
-        ViewportCommand::Minimized(v) => {
-            window.set_minimized(v);
-            info.minimized = Some(v);
-        }
-        ViewportCommand::Maximized(v) => {
-            window.set_maximized(v);
-            info.maximized = Some(v);
-        }
-        ViewportCommand::Fullscreen(v) => {
-            window.set_fullscreen(v.then_some(winit::window::Fullscreen::Borderless(None)));
-        }
-        ViewportCommand::Decorations(v) => {
-            window.set_decorations(v);
-            info.decorations = Some(v);
-        }
-        ViewportCommand::WindowLevel(l) => window.set_window_level(match l {
-            egui::viewport::WindowLevel::AlwaysOnBottom => WindowLevel::AlwaysOnBottom,
-            egui::viewport::WindowLevel::AlwaysOnTop => WindowLevel::AlwaysOnTop,
-            egui::viewport::WindowLevel::Normal => WindowLevel::Normal,
-        }),
-        ViewportCommand::Icon(icon) => {
-            let winit_icon = icon.and_then(|icon| to_winit_icon(&icon));
-            window.set_window_icon(winit_icon);
-        }
-        ViewportCommand::IMERect(rect) => {
-            window.set_ime_cursor_area(
-                PhysicalPosition::new(pixels_per_point * rect.min.x, pixels_per_point * rect.min.y),
-                PhysicalSize::new(
-                    pixels_per_point * rect.size().x,
-                    pixels_per_point * rect.size().y,
-                ),
-            );
-        }
-        ViewportCommand::IMEAllowed(v) => window.set_ime_allowed(v),
-        ViewportCommand::IMEPurpose(p) => window.set_ime_purpose(match p {
-            egui::viewport::IMEPurpose::Password => winit::window::ImePurpose::Password,
-            egui::viewport::IMEPurpose::Terminal => winit::window::ImePurpose::Terminal,
-            egui::viewport::IMEPurpose::Normal => winit::window::ImePurpose::Normal,
-        }),
-        ViewportCommand::Focus => {
-            if !window.has_focus() {
-                window.focus_window();
-            }
-        }
-        ViewportCommand::RequestUserAttention(a) => {
-            window.request_user_attention(match a {
-                egui::UserAttentionType::Reset => None,
-                egui::UserAttentionType::Critical => {
-                    Some(winit::window::UserAttentionType::Critical)
-                }
-                egui::UserAttentionType::Informational => {
-                    Some(winit::window::UserAttentionType::Informational)
+    pub fn maybe_autosave(
+        &mut self,
+        app: &mut dyn epi::App,
+        window: Option<&winit::window::Window>,
+    ) {
+        let now = Instant::now();
+        if now - self.last_auto_save > app.auto_save_interval() {
+            self.save(app, window);
+            self.last_auto_save = now;
+        }
+    }
+
+    #[allow(clippy::unused_self)]
+    pub fn save(&mut self, _app: &mut dyn epi::App, _window: Option<&winit::window::Window>) {
+        #[cfg(feature = "persistence")]
+        if let Some(storage) = self.frame.storage_mut() {
+            crate::profile_function!();
+
+            if let Some(window) = _window {
+                if self.persist_window {
+                    crate::profile_scope!("native_window");
+                    epi::set_value(
+                        storage,
+                        STORAGE_WINDOW_KEY,
+                        &WindowSettings::from_window(self.egui_ctx.zoom_factor(), window),
+                    );
                 }
-            });
-        }
-        ViewportCommand::SetTheme(t) => window.set_theme(match t {
-            egui::SystemTheme::Light => Some(winit::window::Theme::Light),
-            egui::SystemTheme::Dark => Some(winit::window::Theme::Dark),
-            egui::SystemTheme::SystemDefault => None,
-        }),
-        ViewportCommand::ContentProtected(v) => window.set_content_protected(v),
-        ViewportCommand::CursorPosition(pos) => {
-            if let Err(err) = window.set_cursor_position(PhysicalPosition::new(
-                pixels_per_point * pos.x,
-                pixels_per_point * pos.y,
-            )) {
-                log::warn!("{command:?}: {err}");
             }
-        }
-        ViewportCommand::CursorGrab(o) => {
-            if let Err(err) = window.set_cursor_grab(match o {
-                egui::viewport::CursorGrab::None => CursorGrabMode::None,
-                egui::viewport::CursorGrab::Confined => CursorGrabMode::Confined,
-                egui::viewport::CursorGrab::Locked => CursorGrabMode::Locked,
-            }) {
-                log::warn!("{command:?}: {err}");
+            if _app.persist_egui_memory() {
+                crate::profile_scope!("egui_memory");
+                self.egui_ctx
+                    .memory(|mem| epi::set_value(storage, STORAGE_EGUI_MEMORY_KEY, mem));
             }
-        }
-        ViewportCommand::CursorVisible(v) => window.set_cursor_visible(v),
-        ViewportCommand::MousePassthrough(passthrough) => {
-            if let Err(err) = window.set_cursor_hittest(!passthrough) {
-                log::warn!("{command:?}: {err}");
+            {
+                crate::profile_scope!("App::save");
+                _app.save(storage);
             }
-        }
-        ViewportCommand::Screenshot => {
-            *screenshot_requested = true;
+
+            crate::profile_scope!("Storage::flush");
+            storage.flush();
         }
     }
 }
 
-/// Build and intitlaize a window.
-///
-/// Wrapper around `create_winit_window_builder` and `apply_viewport_builder_to_window`.
-pub fn create_window<T>(
-    egui_ctx: &egui::Context,
-    event_loop: &EventLoopWindowTarget<T>,
-    viewport_builder: &ViewportBuilder,
-) -> Result<Window, winit::error::OsError> {
+fn load_default_egui_icon() -> egui::IconData {
     crate::profile_function!();
-
-    let window_builder =
-        create_winit_window_builder(egui_ctx, event_loop, viewport_builder.clone());
-    let window = {
-        crate::profile_scope!("WindowBuilder::build");
-        window_builder.build(event_loop)?
-    };
-    apply_viewport_builder_to_window(egui_ctx, &window, viewport_builder);
-    Ok(window)
+    crate::icon_data::from_png_bytes(&include_bytes!("../../data/icon.png")[..]).unwrap()
 }
 
-pub fn create_winit_window_builder<T>(
-    egui_ctx: &egui::Context,
-    event_loop: &EventLoopWindowTarget<T>,
-    viewport_builder: ViewportBuilder,
-) -> winit::window::WindowBuilder {
-    crate::profile_function!();
-
-    // We set sizes and positions in egui:s own ui points, which depends on the egui
-    // zoom_factor and the native pixels per point, so we need to know that here.
-    // We don't know what monitor the window will appear on though, but
-    // we'll try to fix that after the window is created in the vall to `apply_viewport_builder_to_window`.
-    let native_pixels_per_point = event_loop
-        .primary_monitor()
-        .or_else(|| event_loop.available_monitors().next())
-        .map_or_else(
-            || {
-                log::debug!("Failed to find a monitor - assuming native_pixels_per_point of 1.0");
-                1.0
-            },
-            |m| m.scale_factor() as f32,
-        );
-    let zoom_factor = egui_ctx.zoom_factor();
-    let pixels_per_point = zoom_factor * native_pixels_per_point;
-
-    let ViewportBuilder {
-        title,
-        position,
-        inner_size,
-        min_inner_size,
-        max_inner_size,
-        fullscreen,
-        maximized,
-        resizable,
-        transparent,
-        decorations,
-        icon,
-        active,
-        visible,
-        close_button,
-        minimize_button,
-        maximize_button,
-        window_level,
-
-        // macOS:
-        fullsize_content_view: _fullsize_content_view,
-        title_shown: _title_shown,
-        titlebar_buttons_shown: _titlebar_buttons_shown,
-        titlebar_shown: _titlebar_shown,
-
-        // Windows:
-        drag_and_drop: _drag_and_drop,
-        taskbar: _taskbar,
-
-        // wayland:
-        app_id: _app_id,
-
-        // x11
-        window_type: _window_type,
+#[cfg(feature = "persistence")]
+const STORAGE_EGUI_MEMORY_KEY: &str = "egui";
 
-        mouse_passthrough: _, // handled in `apply_viewport_builder_to_window`
-    } = viewport_builder;
-
-    let mut window_builder = winit::window::WindowBuilder::new()
-        .with_title(title.unwrap_or_else(|| "egui window".to_owned()))
-        .with_transparent(transparent.unwrap_or(false))
-        .with_decorations(decorations.unwrap_or(true))
-        .with_resizable(resizable.unwrap_or(true))
-        .with_visible(visible.unwrap_or(true))
-        .with_maximized(maximized.unwrap_or(false))
-        .with_window_level(match window_level.unwrap_or_default() {
-            egui::viewport::WindowLevel::AlwaysOnBottom => WindowLevel::AlwaysOnBottom,
-            egui::viewport::WindowLevel::AlwaysOnTop => WindowLevel::AlwaysOnTop,
-            egui::viewport::WindowLevel::Normal => WindowLevel::Normal,
-        })
-        .with_fullscreen(
-            fullscreen.and_then(|e| e.then_some(winit::window::Fullscreen::Borderless(None))),
-        )
-        .with_enabled_buttons({
-            let mut buttons = WindowButtons::empty();
-            if minimize_button.unwrap_or(true) {
-                buttons |= WindowButtons::MINIMIZE;
-            }
-            if maximize_button.unwrap_or(true) {
-                buttons |= WindowButtons::MAXIMIZE;
-            }
-            if close_button.unwrap_or(true) {
-                buttons |= WindowButtons::CLOSE;
-            }
-            buttons
-        })
-        .with_active(active.unwrap_or(true));
-
-    if let Some(size) = inner_size {
-        window_builder = window_builder.with_inner_size(PhysicalSize::new(
-            pixels_per_point * size.x,
-            pixels_per_point * size.y,
-        ));
-    }
-
-    if let Some(size) = min_inner_size {
-        window_builder = window_builder.with_min_inner_size(PhysicalSize::new(
-            pixels_per_point * size.x,
-            pixels_per_point * size.y,
-        ));
-    }
-
-    if let Some(size) = max_inner_size {
-        window_builder = window_builder.with_max_inner_size(PhysicalSize::new(
-            pixels_per_point * size.x,
-            pixels_per_point * size.y,
-        ));
-    }
-
-    if let Some(pos) = position {
-        window_builder = window_builder.with_position(PhysicalPosition::new(
-            pixels_per_point * pos.x,
-            pixels_per_point * pos.y,
-        ));
-    }
+#[cfg(feature = "persistence")]
+const STORAGE_WINDOW_KEY: &str = "window";
 
-    if let Some(icon) = icon {
-        let winit_icon = to_winit_icon(&icon);
-        window_builder = window_builder.with_window_icon(winit_icon);
-    }
-
-    #[cfg(all(feature = "wayland", target_os = "linux"))]
-    if let Some(app_id) = _app_id {
-        use winit::platform::wayland::WindowBuilderExtWayland as _;
-        window_builder = window_builder.with_name(app_id, "");
-    }
-
-    #[cfg(all(feature = "x11", target_os = "linux"))]
-    {
-        if let Some(window_type) = _window_type {
-            use winit::platform::x11::WindowBuilderExtX11 as _;
-            use winit::platform::x11::XWindowType;
-            window_builder = window_builder.with_x11_window_type(vec![match window_type {
-                egui::X11WindowType::Normal => XWindowType::Normal,
-                egui::X11WindowType::Utility => XWindowType::Utility,
-                egui::X11WindowType::Dock => XWindowType::Dock,
-                egui::X11WindowType::Desktop => XWindowType::Desktop,
-                egui::X11WindowType::Toolbar => XWindowType::Toolbar,
-                egui::X11WindowType::Menu => XWindowType::Menu,
-                egui::X11WindowType::Splash => XWindowType::Splash,
-                egui::X11WindowType::Dialog => XWindowType::Dialog,
-                egui::X11WindowType::DropdownMenu => XWindowType::DropdownMenu,
-                egui::X11WindowType::PopupMenu => XWindowType::PopupMenu,
-                egui::X11WindowType::Tooltip => XWindowType::Tooltip,
-                egui::X11WindowType::Notification => XWindowType::Notification,
-                egui::X11WindowType::Combo => XWindowType::Combo,
-                egui::X11WindowType::Dnd => XWindowType::Dnd,
-            }]);
-        }
-    }
-
-    #[cfg(target_os = "windows")]
-    {
-        use winit::platform::windows::WindowBuilderExtWindows as _;
-        if let Some(enable) = _drag_and_drop {
-            window_builder = window_builder.with_drag_and_drop(enable);
-        }
-        if let Some(show) = _taskbar {
-            window_builder = window_builder.with_skip_taskbar(!show);
-        }
-    }
-
-    #[cfg(target_os = "macos")]
+pub fn load_window_settings(_storage: Option<&dyn epi::Storage>) -> Option<WindowSettings> {
+    crate::profile_function!();
+    #[cfg(feature = "persistence")]
     {
-        use winit::platform::macos::WindowBuilderExtMacOS as _;
-        window_builder = window_builder
-            .with_title_hidden(!_title_shown.unwrap_or(true))
-            .with_titlebar_buttons_hidden(!_titlebar_buttons_shown.unwrap_or(true))
-            .with_titlebar_transparent(!_titlebar_shown.unwrap_or(true))
-            .with_fullsize_content_view(_fullsize_content_view.unwrap_or(false));
-    }
-
-    window_builder
-}
-
-fn to_winit_icon(icon: &egui::IconData) -> Option<winit::window::Icon> {
-    if icon.is_empty() {
-        None
-    } else {
-        crate::profile_function!();
-        match winit::window::Icon::from_rgba(icon.rgba.clone(), icon.width, icon.height) {
-            Ok(winit_icon) => Some(winit_icon),
-            Err(err) => {
-                log::warn!("Invalid IconData: {err}");
-                None
-            }
-        }
+        epi::get_value(_storage?, STORAGE_WINDOW_KEY)
     }
+    #[cfg(not(feature = "persistence"))]
+    None
 }
 
-/// Applies what `create_winit_window_builder` couldn't
-pub fn apply_viewport_builder_to_window(
-    egui_ctx: &egui::Context,
-    window: &Window,
-    builder: &ViewportBuilder,
-) {
-    if let Some(mouse_passthrough) = builder.mouse_passthrough {
-        if let Err(err) = window.set_cursor_hittest(!mouse_passthrough) {
-            log::warn!("set_cursor_hittest failed: {err}");
-        }
-    }
-
+pub fn load_egui_memory(_storage: Option<&dyn epi::Storage>) -> Option<egui::Memory> {
+    crate::profile_function!();
+    #[cfg(feature = "persistence")]
     {
-        // In `create_winit_window_builder` we didn't know
-        // on what monitor the window would appear, so we didn't know
-        // how to translate egui ui point to native physical pixels.
-        // Now we do know:
-
-        let pixels_per_point = pixels_per_point(egui_ctx, window);
-
-        if let Some(size) = builder.inner_size {
-            if window
-                .request_inner_size(PhysicalSize::new(
-                    pixels_per_point * size.x,
-                    pixels_per_point * size.y,
-                ))
-                .is_some()
-            {
-                log::debug!("Failed to set window size");
-            }
-        }
-        if let Some(size) = builder.min_inner_size {
-            window.set_min_inner_size(Some(PhysicalSize::new(
-                pixels_per_point * size.x,
-                pixels_per_point * size.y,
-            )));
-        }
-        if let Some(size) = builder.max_inner_size {
-            window.set_max_inner_size(Some(PhysicalSize::new(
-                pixels_per_point * size.x,
-                pixels_per_point * size.y,
-            )));
-        }
-        if let Some(pos) = builder.position {
-            let pos = PhysicalPosition::new(pixels_per_point * pos.x, pixels_per_point * pos.y);
-            window.set_outer_position(pos);
-        }
+        epi::get_value(_storage?, STORAGE_EGUI_MEMORY_KEY)
     }
+    #[cfg(not(feature = "persistence"))]
+    None
 }
 
-// ---------------------------------------------------------------------------
-
-/// Short and fast description of an event.
-/// Useful for logging and profiling.
-pub fn short_generic_event_description<T>(event: &winit::event::Event<T>) -> &'static str {
-    use winit::event::{DeviceEvent, Event, StartCause};
-
-    match event {
-        Event::AboutToWait => "Event::AboutToWait",
-        Event::LoopExiting => "Event::LoopExiting",
-        Event::Suspended => "Event::Suspended",
-        Event::Resumed => "Event::Resumed",
-        Event::MemoryWarning => "Event::MemoryWarning",
-        Event::UserEvent(_) => "UserEvent",
-        Event::DeviceEvent { event, .. } => match event {
-            DeviceEvent::Added { .. } => "DeviceEvent::Added",
-            DeviceEvent::Removed { .. } => "DeviceEvent::Removed",
-            DeviceEvent::MouseMotion { .. } => "DeviceEvent::MouseMotion",
-            DeviceEvent::MouseWheel { .. } => "DeviceEvent::MouseWheel",
-            DeviceEvent::Motion { .. } => "DeviceEvent::Motion",
-            DeviceEvent::Button { .. } => "DeviceEvent::Button",
-            DeviceEvent::Key { .. } => "DeviceEvent::Key",
-        },
-        Event::NewEvents(start_cause) => match start_cause {
-            StartCause::ResumeTimeReached { .. } => "NewEvents::ResumeTimeReached",
-            StartCause::WaitCancelled { .. } => "NewEvents::WaitCancelled",
-            StartCause::Poll => "NewEvents::Poll",
-            StartCause::Init => "NewEvents::Init",
-        },
-        Event::WindowEvent { event, .. } => short_window_event_description(event),
-    }
-}
-
-/// Short and fast description of an event.
-/// Useful for logging and profiling.
-pub fn short_window_event_description(event: &winit::event::WindowEvent) -> &'static str {
-    use winit::event::WindowEvent;
-
-    match event {
-        WindowEvent::ActivationTokenDone { .. } => "WindowEvent::ActivationTokenDone",
-        WindowEvent::Resized { .. } => "WindowEvent::Resized",
-        WindowEvent::Moved { .. } => "WindowEvent::Moved",
-        WindowEvent::CloseRequested { .. } => "WindowEvent::CloseRequested",
-        WindowEvent::Destroyed { .. } => "WindowEvent::Destroyed",
-        WindowEvent::DroppedFile { .. } => "WindowEvent::DroppedFile",
-        WindowEvent::HoveredFile { .. } => "WindowEvent::HoveredFile",
-        WindowEvent::HoveredFileCancelled { .. } => "WindowEvent::HoveredFileCancelled",
-        WindowEvent::Focused { .. } => "WindowEvent::Focused",
-        WindowEvent::KeyboardInput { .. } => "WindowEvent::KeyboardInput",
-        WindowEvent::ModifiersChanged { .. } => "WindowEvent::ModifiersChanged",
-        WindowEvent::Ime { .. } => "WindowEvent::Ime",
-        WindowEvent::CursorMoved { .. } => "WindowEvent::CursorMoved",
-        WindowEvent::CursorEntered { .. } => "WindowEvent::CursorEntered",
-        WindowEvent::CursorLeft { .. } => "WindowEvent::CursorLeft",
-        WindowEvent::MouseWheel { .. } => "WindowEvent::MouseWheel",
-        WindowEvent::MouseInput { .. } => "WindowEvent::MouseInput",
-        WindowEvent::TouchpadMagnify { .. } => "WindowEvent::TouchpadMagnify",
-        WindowEvent::RedrawRequested { .. } => "WindowEvent::RedrawRequested",
-        WindowEvent::SmartMagnify { .. } => "WindowEvent::SmartMagnify",
-        WindowEvent::TouchpadRotate { .. } => "WindowEvent::TouchpadRotate",
-        WindowEvent::TouchpadPressure { .. } => "WindowEvent::TouchpadPressure",
-        WindowEvent::AxisMotion { .. } => "WindowEvent::AxisMotion",
-        WindowEvent::Touch { .. } => "WindowEvent::Touch",
-        WindowEvent::ScaleFactorChanged { .. } => "WindowEvent::ScaleFactorChanged",
-        WindowEvent::ThemeChanged { .. } => "WindowEvent::ThemeChanged",
-        WindowEvent::Occluded { .. } => "WindowEvent::Occluded",
-    }
-}
-
-// ---------------------------------------------------------------------------
-
-mod profiling_scopes {
-    #![allow(unused_macros)]
-    #![allow(unused_imports)]
-
-    /// Profiling macro for feature "puffin"
-    macro_rules! profile_function {
-        ($($arg: tt)*) => {
-            #[cfg(feature = "puffin")]
-            #[cfg(not(target_arch = "wasm32"))] // Disabled on web because of the coarse 1ms clock resolution there.
-            puffin::profile_function!($($arg)*);
-        };
-    }
-    pub(crate) use profile_function;
-
-    /// Profiling macro for feature "puffin"
-    macro_rules! profile_scope {
-        ($($arg: tt)*) => {
-            #[cfg(feature = "puffin")]
-            #[cfg(not(target_arch = "wasm32"))] // Disabled on web because of the coarse 1ms clock resolution there.
-            puffin::profile_scope!($($arg)*);
-        };
+pub(crate) fn theme_from_winit_theme(theme: winit::window::Theme) -> Theme {
+    match theme {
+        winit::window::Theme::Dark => Theme::Dark,
+        winit::window::Theme::Light => Theme::Light,
     }
-    pub(crate) use profile_scope;
 }

From b1a0b8996a45dabae7e0ea7b95fdae9912bae8bd Mon Sep 17 00:00:00 2001
From: rustbasic <127506429+rustbasic@users.noreply.github.com>
Date: Fri, 5 Apr 2024 20:53:08 +0900
Subject: [PATCH 08/10] Update input_state.rs

---
 crates/egui/src/input_state.rs | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/crates/egui/src/input_state.rs b/crates/egui/src/input_state.rs
index 9c6103e0a54..03d392de683 100644
--- a/crates/egui/src/input_state.rs
+++ b/crates/egui/src/input_state.rs
@@ -277,6 +277,12 @@ impl InputState {
         self.raw.viewport()
     }
 
+    /// Read-write access to [`ViewportInfo`].
+    #[inline]
+    pub fn viewport_mut(&mut self) -> &mut ViewportInfo {
+        self.raw.viewport_mut()
+    }
+
     #[inline(always)]
     pub fn screen_rect(&self) -> Rect {
         self.screen_rect
@@ -393,6 +399,16 @@ impl InputState {
         self.consume_key(modifiers, logical_key)
     }
 
+    /// Verifies that all modifier keys (e.g. Ctrl, Alt) are not pressed.
+    pub fn modifiers_not_pressed(&self) -> bool {
+        self.modifiers.is_none()
+    }
+
+    /// Was only the given key pressed this frame, with no modifiers?
+    pub fn key_pressed_only(&self, desired_key: Key) -> bool {
+        self.num_presses(desired_key) > 0 && self.modifiers_not_pressed()
+    }
+
     /// Was the given key pressed this frame?
     ///
     /// Includes key-repeat events.
@@ -416,6 +432,18 @@ impl InputState {
             .count()
     }
 
+    /// Is the given key currently held down and no other keys are held down, including modifier keys?
+    pub fn key_down_exclusive(&self, desired_key: Key) -> bool {
+        self.keys_down.contains(&desired_key)
+            && self.keys_down.len() == 1
+            && self.modifiers_not_pressed()
+    }
+
+    /// Is the given key currently held down and no other keys are held down?
+    pub fn key_down_only(&self, desired_key: Key) -> bool {
+        self.keys_down.contains(&desired_key) && self.modifiers_not_pressed()
+    }
+
     /// Is the given key currently held down?
     pub fn key_down(&self, desired_key: Key) -> bool {
         self.keys_down.contains(&desired_key)

From e99b446d5a14c3fbb3b76186aebecf13cc4234f2 Mon Sep 17 00:00:00 2001
From: rustbasic <127506429+rustbasic@users.noreply.github.com>
Date: Fri, 5 Apr 2024 20:58:13 +0900
Subject: [PATCH 09/10] Update input_state.rs

---
 crates/egui/src/input_state.rs | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/crates/egui/src/input_state.rs b/crates/egui/src/input_state.rs
index 03d392de683..898695cbc1e 100644
--- a/crates/egui/src/input_state.rs
+++ b/crates/egui/src/input_state.rs
@@ -277,12 +277,6 @@ impl InputState {
         self.raw.viewport()
     }
 
-    /// Read-write access to [`ViewportInfo`].
-    #[inline]
-    pub fn viewport_mut(&mut self) -> &mut ViewportInfo {
-        self.raw.viewport_mut()
-    }
-
     #[inline(always)]
     pub fn screen_rect(&self) -> Rect {
         self.screen_rect

From 8f66fdfffd1d75c35bc3fdb63afd50768ebae182 Mon Sep 17 00:00:00 2001
From: rustbasic <127506429+rustbasic@users.noreply.github.com>
Date: Sun, 7 Apr 2024 18:29:46 +0900
Subject: [PATCH 10/10] Update input.rs

typo
---
 crates/egui/src/data/input.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/egui/src/data/input.rs b/crates/egui/src/data/input.rs
index f61b9312f89..49b756e1c5b 100644
--- a/crates/egui/src/data/input.rs
+++ b/crates/egui/src/data/input.rs
@@ -664,7 +664,7 @@ impl Modifiers {
     }
 
     /// Checks that the `ctrl/cmd` matches, and that the `shift/alt` of the argument is a subset
-    /// of the pressed ksey (`self`).
+    /// of the pressed key (`self`).
     ///
     /// This means that if the pattern has not set `shift`, then `self` can have `shift` set or not.
     ///