Updates to TabViewer::{is_closable,on_close}.

Author: Adanos020

examples/hello.rs

@@ -9,6 +9,7 @@ use egui::{
     WidgetText,
 };
 
+use egui_dock::tab_viewer::OnCloseResponse;
 use egui_dock::{
     AllowedSplits, DockArea, DockState, NodeIndex, OverlayType, Style, SurfaceIndex,
     TabInteractionStyle, TabViewer,
@@ -119,13 +120,13 @@ impl TabViewer for MyContext {
         }
     }
 
-    fn closeable(&mut self, tab: &mut Self::Tab) -> bool {
+    fn is_closeable(&self, tab: &mut Self::Tab) -> bool {
         ["Inspector", "Style Editor"].contains(&tab.as_str())
     }
 
-    fn on_close(&mut self, tab: &mut Self::Tab) -> bool {
+    fn on_close(&mut self, tab: &mut Self::Tab) -> OnCloseResponse {
         self.open_tabs.remove(tab);
-        true
+        OnCloseResponse::Close
     }
 }
 

examples/simple.rs

@@ -2,6 +2,7 @@
 
 use eframe::{egui, NativeOptions};
 
+use egui_dock::tab_viewer::OnCloseResponse;
 use egui_dock::{DockArea, DockState, NodeIndex, Style};
 
 fn main() -> eframe::Result<()> {
@@ -25,6 +26,11 @@ impl egui_dock::TabViewer for TabViewer {
     fn ui(&mut self, ui: &mut egui::Ui, tab: &mut Self::Tab) {
         ui.label(format!("Content of {tab}"));
     }
+
+    fn on_close(&mut self, _tab: &mut Self::Tab) -> OnCloseResponse {
+        println!("Closed tab: {_tab}");
+        OnCloseResponse::Focus
+    }
 }
 
 struct MyApp {

src/widgets/dock_area/show/leaf.rs

@@ -16,6 +16,7 @@ use crate::{
 };
 
 use crate::popup::popup_under_widget;
+use crate::tab_viewer::OnCloseResponse;
 
 impl<Tab> DockArea<'_, Tab> {
     pub(super) fn show_leaf(
@@ -205,7 +206,7 @@ impl<Tab> DockArea<'_, Tab> {
                 let disabled = if let Node::Leaf { tabs, .. } =
                     &mut self.dock_state[surface_index][node_index]
                 {
-                    !tabs.iter_mut().all(|tab| tab_viewer.closeable(tab))
+                    !tabs.iter_mut().all(|tab| tab_viewer.is_closeable(tab))
                 } else {
                     unreachable!()
                 };
@@ -214,7 +215,7 @@ impl<Tab> DockArea<'_, Tab> {
                 let close_window_disabled = disabled
                     || !self.dock_state[surface_index].iter_mut().all(|node| {
                         if let Node::Leaf { tabs, .. } = node {
-                            tabs.iter_mut().all(|tab| tab_viewer.closeable(tab))
+                            tabs.iter_mut().all(|tab| tab_viewer.is_closeable(tab))
                         } else {
                             true
                         }
@@ -307,7 +308,7 @@ impl<Tab> DockArea<'_, Tab> {
                     *active == tab_index || is_being_dragged,
                     tab_viewer.title(&mut tabs[tab_index.0]),
                     tab_style.unwrap_or(style.tab.clone()),
-                    tab_viewer.closeable(&mut tabs[tab_index.0]),
+                    tab_viewer.is_closeable(&mut tabs[tab_index.0]),
                 )
             };
 
@@ -392,14 +393,14 @@ impl<Tab> DockArea<'_, Tab> {
                     let close_button =
                         Button::new(&self.dock_state.translations.tab_context_menu.close_button);
 
-                    let Node::Leaf { tabs, active, .. } =
-                        &mut self.dock_state[surface_index][node_index]
-                    else {
-                        unreachable!()
-                    };
-                    let tab = &mut tabs[tab_index.0];
-
                     response.context_menu(|ui| {
+                        let Node::Leaf { tabs, .. } =
+                            &mut self.dock_state[surface_index][node_index]
+                        else {
+                            unreachable!()
+                        };
+                        let tab = &mut tabs[tab_index.0];
+
                         tab_viewer.context_menu(ui, tab, surface_index, node_index);
                         if (surface_index.is_main() || !is_lonely_tab)
                             && tab_viewer.allowed_in_windows(tab)
@@ -409,33 +410,14 @@ impl<Tab> DockArea<'_, Tab> {
                             ui.close_menu();
                         }
                         if show_close_button && ui.add(close_button).clicked() {
-                            if tab_viewer.on_close(tab) {
-                                self.to_remove
-                                    .push((surface_index, node_index, tab_index).into());
-                            } else {
-                                *active = tab_index;
-                                self.new_focused = Some((surface_index, node_index));
-                            }
+                            self.close_tab(tab_viewer, surface_index, node_index, tab_index);
                             ui.close_menu();
                         }
                     });
                 }
 
                 if close_clicked {
-                    let Node::Leaf { tabs, active, .. } =
-                        &mut self.dock_state[surface_index][node_index]
-                    else {
-                        unreachable!()
-                    };
-                    let tab = &mut tabs[tab_index.0];
-
-                    if tab_viewer.on_close(tab) {
-                        self.to_remove
-                            .push((surface_index, node_index, tab_index).into());
-                    } else {
-                        *active = tab_index;
-                        self.new_focused = Some((surface_index, node_index));
-                    }
+                    self.close_tab(tab_viewer, surface_index, node_index, tab_index);
                 }
 
                 if let Some(pos) = state.last_hover_pos {
@@ -477,17 +459,40 @@ impl<Tab> DockArea<'_, Tab> {
                 self.new_focused = Some((surface_index, node_index));
             }
 
-            if self.show_close_buttons && tab_viewer.closeable(tab) && response.middle_clicked() {
-                if tab_viewer.on_close(tab) {
-                    self.to_remove
-                        .push((surface_index, node_index, tab_index).into());
-                } else {
-                    *active = tab_index;
-                    self.new_focused = Some((surface_index, node_index));
-                }
+            tab_viewer.on_tab_button(tab, &response);
+
+            if self.show_close_buttons && tab_viewer.is_closeable(tab) && response.middle_clicked()
+            {
+                self.close_tab(tab_viewer, surface_index, node_index, tab_index);
             }
+        }
+    }
 
-            tab_viewer.on_tab_button(tab, &response);
+    fn close_tab(
+        &mut self,
+        tab_viewer: &mut impl TabViewer<Tab = Tab>,
+        surface_index: SurfaceIndex,
+        node_index: NodeIndex,
+        tab_index: TabIndex,
+    ) {
+        let Node::Leaf { tabs, active, .. } = &mut self.dock_state[surface_index][node_index]
+        else {
+            unreachable!()
+        };
+        let tab = &mut tabs[tab_index.0];
+
+        match tab_viewer.on_close(tab) {
+            OnCloseResponse::Close => {
+                self.to_remove
+                    .push((surface_index, node_index, tab_index).into());
+            }
+            OnCloseResponse::Focus => {
+                *active = tab_index;
+                self.new_focused = Some((surface_index, node_index));
+            }
+            OnCloseResponse::Ignore => {
+                // no-op
+            }
         }
     }
 

src/widgets/tab_viewer.rs

@@ -35,21 +35,35 @@ pub trait TabViewer {
     /// Called after each tab button is shown, so you can add a tooltip, check for clicks, etc.
     fn on_tab_button(&mut self, _tab: &mut Self::Tab, _response: &egui::Response) {}
 
+    /// This is called when the `_tab` gets closed by the user.
+    ///
+    /// Returns an `OnCloseResponse` which determines what happens to the tab after this function gets called.
+    fn on_close(&mut self, _tab: &mut Self::Tab) -> OnCloseResponse {
+        OnCloseResponse::Close
+    }
+
+    /// Returns `true` if the user of your app should be able to close a given `_tab`.
+    ///
+    /// By default, `true` is always returned.
+    fn is_closeable(&self, _tab: &mut Self::Tab) -> bool {
+        true
+    }
+
     /// Returns `true` if the user of your app should be able to close a given `_tab`.
     ///
-    /// By default `true` is always returned.
+    /// By default, `true` is always returned.
+    #[deprecated = "Use the `TabViewer::is_closeable` function instead."]
     fn closeable(&mut self, _tab: &mut Self::Tab) -> bool {
         true
     }
 
-    /// This is called when the `_tab` gets closed by the user.
+    /// This is called every frame after [`ui`](Self::ui) is called, if the `_tab` is active.
     ///
-    /// Returns `true` if the tab should close immediately, otherwise `false`.
+    /// Returns `true` if the tab should be forced to close, `false` otherwise.
     ///
-    /// **Note**: if `false` is returned, [`ui`](Self::ui) will still be called once more if this
-    /// tab is active.
-    fn on_close(&mut self, _tab: &mut Self::Tab) -> bool {
-        true
+    /// In the event this function returns true the tab will be removed without calling `on_close`.
+    fn force_close(&mut self, _tab: &mut Self::Tab) -> bool {
+        false
     }
 
     /// This is called when the add button is pressed.
@@ -64,15 +78,6 @@ pub trait TabViewer {
     /// [`DockArea::show_add_popup`](crate::DockArea::show_add_popup) are set to `true`.
     fn add_popup(&mut self, _ui: &mut Ui, _surface: SurfaceIndex, _node: NodeIndex) {}
 
-    /// This is called every frame after [`ui`](Self::ui) is called, if the `_tab` is active.
-    ///
-    /// Returns `true` if the tab should be forced to close, `false` otherwise.
-    ///
-    /// In the event this function returns true the tab will be removed without calling `on_close`.
-    fn force_close(&mut self, _tab: &mut Self::Tab) -> bool {
-        false
-    }
-
     /// Sets custom style for given tab.
     fn tab_style_override(&self, _tab: &Self::Tab, _global_style: &TabStyle) -> Option<TabStyle> {
         None
@@ -98,3 +103,14 @@ pub trait TabViewer {
         [true, true]
     }
 }
+
+/// Determines what happens to a tab when a user attempts to close it.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum OnCloseResponse {
+    /// Closes the tab.
+    Close,
+    /// Focuses on the tab.
+    Focus,
+    /// Ignores the close request.
+    Ignore,
+}