feat: window focus & rename title

JakkuSakura · JakkuSakura · commit d2cc7b778b81 · 2025-12-12T06:28:28.000+08:00
diff --git a/examples/multi_window.rs b/examples/multi_window.rs
@@ -1,7 +1,7 @@
 //! Demonstrate opening additional windows from a pure Dioxus app.
 
 use dioxus::prelude::*;
-use dioxus_native::DioxusWindowHandle;
+use dioxus_native::{DioxusWindowHandle, DioxusWindowInfo, DioxusWindowOptions};
 
 fn main() {
     dioxus_native::launch(app);
@@ -12,27 +12,91 @@ fn app() -> Element {
     let mut counter = use_signal(|| 1u32);
     let open_simple = window_handle.clone();
     let open_with_props = window_handle.clone();
+    let refresh_handle = window_handle.clone();
+    let base_focus_handle = window_handle.clone();
+    let base_rename_handle = window_handle.clone();
+    let mut known_windows: Signal<Vec<DioxusWindowInfo>> =
+        use_signal(|| window_handle.list_windows());
+    let known_windows_signal = known_windows.clone();
+    let refresh_handle_for_list = refresh_handle.clone();
+    let rename_counter = use_signal(|| 1u32);
+    let window_rows = {
+        let windows_snapshot = known_windows();
+        windows_snapshot
+            .into_iter()
+            .map(|info| {
+                let focus_handle = base_focus_handle.clone();
+                let rename_handle = base_rename_handle.clone();
+                let mut rename_counter_signal = rename_counter.clone();
+                let mut update_list_signal = known_windows_signal.clone();
+                let update_source = refresh_handle_for_list.clone();
+                let id = info.id;
+                let title = info.title;
+                rsx! {
+                    li {
+                        "{title} (ID: {id:?})"
+                        button {
+                            onclick: move |_| focus_handle.focus_window(id),
+                            "Focus"
+                        }
+                        button {
+                            onclick: move |_| {
+                                let idx = rename_counter_signal();
+                                rename_handle.set_window_title(id, format!("Renamed {idx}"));
+                                rename_counter_signal += 1;
+                                update_list_signal.set(update_source.list_windows());
+                            },
+                            "Rename"
+                        }
+                    }
+                }
+            })
+            .collect::<Vec<_>>()
+    };
 
     rsx! {
         main {
             style { {PRIMARY_STYLES} }
             h1 { "Blitz multi-window" }
             p { "Click the button to open another RSX window." }
-            button {
-                onclick: move |_| open_simple.open_window(secondary_window),
-                "Open secondary window"
-            }
-            button {
-                onclick: move |_| {
-                    let idx = counter();
-                    open_with_props.open_window_with_props(
-                        message_window,
-                        MessageWindowProps { message: format!("Window #{idx}") },
-                    );
-                    counter += 1;
-                },
-                "Open window with props"
+            div {
+                button {
+                    onclick: move |_| {
+                        open_simple.open_window_with_options(
+                            secondary_window,
+                            DioxusWindowOptions {
+                                title: Some("Secondary window".into()),
+                                ..Default::default()
+                            },
+                        );
+                        known_windows.set(open_simple.list_windows());
+                    },
+                    "Open secondary window"
+                }
+                button {
+                    onclick: move |_| {
+                        let idx = counter();
+                        open_with_props.open_window_with_props_and_options(
+                            message_window,
+                            MessageWindowProps {
+                                message: format!("Window #{idx}"),
+                            },
+                            DioxusWindowOptions {
+                                title: Some(format!("Window #{idx}")),
+                                ..Default::default()
+                            },
+                        );
+                        counter += 1;
+                        known_windows.set(open_with_props.list_windows());
+                    },
+                    "Open window with props"
+                }
+                button {
+                    onclick: move |_| known_windows.set(refresh_handle.list_windows()),
+                    "Refresh list"
+                }
             }
+            ul {{ window_rows.into_iter() }}
         }
     }
 }
diff --git a/packages/dioxus-native/src/dioxus_application.rs b/packages/dioxus-native/src/dioxus_application.rs
@@ -2,14 +2,17 @@ use anyrender::WindowRenderer;
 use blitz_shell::{BlitzApplication, View};
 use dioxus_core::{provide_context, ScopeId};
 use dioxus_history::{History, MemoryHistory};
+use std::cell::RefCell;
 use std::rc::Rc;
 use std::sync::Arc;
 use winit::application::ApplicationHandler;
 use winit::event::{StartCause, WindowEvent};
 use winit::event_loop::{ActiveEventLoop, EventLoopProxy};
 use winit::window::WindowId;
 
-use crate::windowing::{DioxusWindowHandle, DioxusWindowQueue, DioxusWindowTemplate};
+use crate::windowing::{
+    DioxusWindowHandle, DioxusWindowInfo, DioxusWindowQueue, DioxusWindowTemplate,
+};
 use crate::DioxusNativeWindowRenderer;
 use crate::{contexts::DioxusNativeDocument, BlitzShellEvent, DioxusDocument, WindowConfig};
 
@@ -22,6 +25,12 @@ pub enum DioxusNativeEvent {
     /// Internal signal to create queued windows.
     SpawnQueuedWindows,
 
+    /// Focus an existing window by id.
+    FocusWindow { window_id: WindowId },
+
+    /// Update a window's title.
+    SetWindowTitle { window_id: WindowId, title: String },
+
     /// Create a new head element from the Link and Title elements
     ///
     /// todo(jon): these should probabkly be synchronous somehow
@@ -34,26 +43,29 @@ pub enum DioxusNativeEvent {
 }
 
 pub struct DioxusNativeApplication {
-    pending_window: Option<WindowConfig<DioxusNativeWindowRenderer>>,
+    pending_window: Option<(WindowConfig<DioxusNativeWindowRenderer>, String)>,
     inner: BlitzApplication<DioxusNativeWindowRenderer>,
     proxy: EventLoopProxy<BlitzShellEvent>,
     window_template: Arc<DioxusWindowTemplate>,
     window_queue: Rc<DioxusWindowQueue>,
+    window_registry: Rc<RefCell<Vec<DioxusWindowInfo>>>,
 }
 
 impl DioxusNativeApplication {
     pub(crate) fn new(
         proxy: EventLoopProxy<BlitzShellEvent>,
-        config: WindowConfig<DioxusNativeWindowRenderer>,
+        pending_window: (WindowConfig<DioxusNativeWindowRenderer>, String),
         window_template: Arc<DioxusWindowTemplate>,
         window_queue: Rc<DioxusWindowQueue>,
+        window_registry: Rc<RefCell<Vec<DioxusWindowInfo>>>,
     ) -> Self {
         Self {
-            pending_window: Some(config),
+            pending_window: Some(pending_window),
             inner: BlitzApplication::new(proxy.clone()),
             proxy,
             window_template,
             window_queue,
+            window_registry,
         }
     }
 
@@ -64,6 +76,7 @@ impl DioxusNativeApplication {
     fn spawn_window(
         &mut self,
         config: WindowConfig<DioxusNativeWindowRenderer>,
+        label: String,
         event_loop: &ActiveEventLoop,
         auto_resume: bool,
     ) {
@@ -76,6 +89,7 @@ impl DioxusNativeApplication {
             }
         }
         let window_id = window.window_id();
+        self.register_window(window_id, label);
         self.inner.windows.insert(window_id, window);
     }
 
@@ -94,6 +108,7 @@ impl DioxusNativeApplication {
             self.proxy.clone(),
             Arc::clone(&self.window_template),
             Rc::clone(&self.window_queue),
+            Rc::clone(&self.window_registry),
         );
         doc.vdom
             .in_scope(ScopeId::ROOT, || provide_context(window_handle.clone()));
@@ -114,8 +129,29 @@ impl DioxusNativeApplication {
     }
 
     fn drain_window_queue(&mut self, event_loop: &ActiveEventLoop) {
-        for config in self.window_queue.drain() {
-            self.spawn_window(config, event_loop, true);
+        for queued in self.window_queue.drain() {
+            self.spawn_window(queued.config, queued.title, event_loop, true);
+        }
+    }
+
+    fn register_window(&self, window_id: WindowId, title: String) {
+        self.window_registry.borrow_mut().push(DioxusWindowInfo {
+            id: window_id,
+            title,
+        });
+    }
+
+    fn unregister_window(&self, window_id: WindowId) {
+        let mut registry = self.window_registry.borrow_mut();
+        registry.retain(|info| info.id != window_id);
+    }
+
+    fn update_window_title(&self, window_id: WindowId, title: String) {
+        for info in self.window_registry.borrow_mut().iter_mut() {
+            if info.id == window_id {
+                info.title = title.clone();
+                break;
+            }
         }
     }
 
@@ -164,6 +200,19 @@ impl DioxusNativeApplication {
                 }
             }
 
+            DioxusNativeEvent::FocusWindow { window_id } => {
+                if let Some(window) = self.inner.windows.get_mut(window_id) {
+                    window.window.focus_window();
+                }
+            }
+
+            DioxusNativeEvent::SetWindowTitle { window_id, title } => {
+                if let Some(window) = self.inner.windows.get_mut(window_id) {
+                    window.window.set_title(title);
+                    self.update_window_title(*window_id, title.to_string());
+                }
+            }
+
             DioxusNativeEvent::SpawnQueuedWindows => {
                 self.drain_window_queue(event_loop);
             }
@@ -184,8 +233,8 @@ impl ApplicationHandler<BlitzShellEvent> for DioxusNativeApplication {
         #[cfg(feature = "tracing")]
         tracing::debug!("Injecting document provider into all windows");
 
-        if let Some(config) = self.pending_window.take() {
-            self.spawn_window(config, event_loop, false);
+        if let Some((config, label)) = self.pending_window.take() {
+            self.spawn_window(config, label, event_loop, false);
         }
 
         self.drain_window_queue(event_loop);
@@ -206,6 +255,9 @@ impl ApplicationHandler<BlitzShellEvent> for DioxusNativeApplication {
         window_id: WindowId,
         event: WindowEvent,
     ) {
+        if matches!(event, WindowEvent::CloseRequested) {
+            self.unregister_window(window_id);
+        }
         self.inner.window_event(event_loop, window_id, event);
     }
 
diff --git a/packages/dioxus-native/src/lib.rs b/packages/dioxus-native/src/lib.rs
@@ -27,7 +27,7 @@ pub use dioxus_native_dom::*;
 use assets::DioxusNativeNetProvider;
 pub use dioxus_application::{DioxusNativeApplication, DioxusNativeEvent};
 pub use dioxus_renderer::DioxusNativeWindowRenderer;
-pub use windowing::DioxusWindowHandle;
+pub use windowing::{DioxusWindowHandle, DioxusWindowInfo, DioxusWindowOptions};
 
 #[cfg(any(
     feature = "vello",
@@ -45,6 +45,7 @@ use blitz_shell::{create_default_event_loop, BlitzShellEvent, Config, WindowConf
 use dioxus_core::{ComponentFunction, Element, VirtualDom};
 use link_handler::DioxusNativeNavigationProvider;
 use std::any::Any;
+use std::cell::RefCell;
 use std::rc::Rc;
 use std::sync::Arc;
 use windowing::{DioxusWindowQueue, DioxusWindowTemplate};
@@ -220,6 +221,7 @@ pub fn launch_cfg_with_props<P: Clone + 'static, M: 'static>(
         renderer.clone(),
         window_attributes.clone(),
     );
+    let initial_title = window_attributes.title.clone();
     // Create application
     let template = Arc::new(DioxusWindowTemplate::new(
         contexts,
@@ -230,8 +232,14 @@ pub fn launch_cfg_with_props<P: Clone + 'static, M: 'static>(
         navigation_provider.clone(),
     ));
     let window_queue = Rc::new(DioxusWindowQueue::new());
-    let mut application =
-        DioxusNativeApplication::new(event_loop.create_proxy(), config, template, window_queue);
+    let window_registry = Rc::new(RefCell::new(Vec::new()));
+    let mut application = DioxusNativeApplication::new(
+        event_loop.create_proxy(),
+        (config, initial_title),
+        template,
+        window_queue,
+        window_registry,
+    );
 
     // Run event loop
     event_loop.run_app(&mut application).unwrap();
diff --git a/packages/dioxus-native/src/windowing.rs b/packages/dioxus-native/src/windowing.rs
