diff --git a/Cargo.toml b/Cargo.toml
index 2b8fc07..6363e34 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,9 +1,7 @@
 [workspace]
 resolver = "2"
 members = [
-    "crates/egui-dock",
     "crates/egui-term",
-    "crates/egui-theme-switch",
     "crates/egui-toast",
     "nxshell",
 ]
@@ -22,37 +20,33 @@ keywords = ["terminal", "egui"]
 [workspace.dependencies]
 alacritty_terminal = { git = "https://github.com/alacritty/alacritty" }
 anyhow = "1"
-catppuccin-egui = { version = "5.5", default-features = false }
+catppuccin-egui = { version = "5.6", default-features = false }
 chrono = "0.4"
 copypasta = "0.10"
-duplicate = "2"
-eframe = "0.31"
-egui = "0.31"
-egui_extras = "0.31"
-egui_form = "0.5"
-egui-phosphor = "0.9"
-egui-theme-switch = "0.2.3"
-egui-toast = "0.16"
+eframe = "0.32"
+egui = "0.32"
+egui_dock = "0.17"
+egui_extras = "0.32"
+egui_form = "0.6"
+egui-phosphor = "0.10"
+egui-theme-switch = "0.4"
 garde = "0.22"
 homedir = "0.3"
 indexmap = "2"
 open = "5"
 orion = "0.17"
 parking_lot = "0.12"
-paste = "1"
 polling = "3"
 rusqlite = "0.33"
 rustix = "0.38"
-serde = "1"
 signal-hook = "0.3"
 smol = "2"
 thiserror = "2"
 tracing = "0.1"
 tracing-subscriber = "0.3"
-uuid = "1"
-validator = "0.20"
 wezterm-ssh = { git = "https://github.com/iamazy/wezterm.git", branch = "nxssh" }
 windows = "0.59"
+wgpu = "25"
 
 [profile.release]
 strip = true
diff --git a/crates/egui-dock/Cargo.toml b/crates/egui-dock/Cargo.toml
deleted file mode 100644
index 36be865..0000000
--- a/crates/egui-dock/Cargo.toml
+++ /dev/null
@@ -1,31 +0,0 @@
-[package]
-name = "egui_dock"
-description = "Docking system for egui - an immediate-mode GUI library for Rust"
-authors = ["lain-dono", "Adam Gąsior (Adanos020)"]
-version = "0.15.0"
-edition = "2021"
-rust-version = "1.76"
-license = "MIT"
-readme = "README.md"
-repository = "https://github.com/Adanos020/egui_dock"
-categories = ["gui", "game-development"]
-include = ["src/**/*.rs", "Cargo.toml", "LICENSE"]
-
-[features]
-default = []
-
-# Enable serialization of `Tree`.
-serde = ["dep:serde", "egui/serde"]
-
-[dependencies]
-egui = { workspace = true }
-serde = { workspace = true, optional = true, features = ["derive"] }
-duplicate.workspace = true
-paste.workspace = true
-
-[dev-dependencies]
-eframe = { workspace = true, features = [
-    "default",
-    "default_fonts",
-    "glow",
-] }
diff --git a/crates/egui-dock/examples/hello.rs b/crates/egui-dock/examples/hello.rs
deleted file mode 100644
index 1dd63af..0000000
--- a/crates/egui-dock/examples/hello.rs
+++ /dev/null
@@ -1,638 +0,0 @@
-#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
-
-use std::collections::HashSet;
-
-use eframe::NativeOptions;
-use egui::{
-    color_picker::{color_edit_button_srgba, Alpha},
-    vec2, CentralPanel, ComboBox, Frame, Rounding, Slider, TopBottomPanel, Ui, ViewportBuilder,
-    WidgetText,
-};
-
-use egui_dock::{
-    AllowedSplits, DockArea, DockState, NodeIndex, OverlayType, Style, SurfaceIndex,
-    TabInteractionStyle, TabViewer,
-};
-
-/// Adds a widget with a label next to it, can be given an extra parameter in order to show a hover text
-macro_rules! labeled_widget {
-    ($ui:expr, $x:expr, $l:expr) => {
-        $ui.horizontal(|ui| {
-            ui.add($x);
-            ui.label($l);
-        });
-    };
-    ($ui:expr, $x:expr, $l:expr, $d:expr) => {
-        $ui.horizontal(|ui| {
-            ui.add($x).on_hover_text($d);
-            ui.label($l).on_hover_text($d);
-        });
-    };
-}
-
-// Creates a slider which has a unit attached to it
-// When given an extra parameter it will be used as a multiplier (e.g 100.0 when working with percentages)
-macro_rules! unit_slider {
-    ($val:expr, $range:expr) => {
-        egui::Slider::new($val, $range)
-    };
-    ($val:expr, $range:expr, $unit:expr) => {
-        egui::Slider::new($val, $range).custom_formatter(|value, decimal_range| {
-            egui::emath::format_with_decimals_in_range(value, decimal_range) + $unit
-        })
-    };
-    ($val:expr, $range:expr, $unit:expr, $mul:expr) => {
-        egui::Slider::new($val, $range)
-            .custom_formatter(|value, decimal_range| {
-                egui::emath::format_with_decimals_in_range(value * $mul, decimal_range) + $unit
-            })
-            .custom_parser(|string| string.parse::<f64>().ok().map(|valid| valid / $mul))
-    };
-}
-
-fn main() -> eframe::Result<()> {
-    std::env::set_var("RUST_BACKTRACE", "1");
-    let options = NativeOptions {
-        viewport: ViewportBuilder::default().with_inner_size(vec2(1024.0, 1024.0)),
-        ..Default::default()
-    };
-    eframe::run_native(
-        "My egui App",
-        options,
-        Box::new(|_cc| Ok(Box::<MyApp>::default())),
-    )
-}
-
-struct MyContext {
-    pub title: String,
-    pub age: u32,
-    pub style: Option<Style>,
-    open_tabs: HashSet<String>,
-
-    show_close_buttons: bool,
-    show_add_buttons: bool,
-    draggable_tabs: bool,
-    show_tab_name_on_hover: bool,
-    allowed_splits: AllowedSplits,
-    show_leaf_close_all: bool,
-    show_leaf_collapse: bool,
-    show_secondary_button_hint: bool,
-    secondary_button_on_modifier: bool,
-    secondary_button_context_menu: bool,
-}
-
-struct MyApp {
-    context: MyContext,
-    tree: DockState<String>,
-}
-
-impl TabViewer for MyContext {
-    type Tab = String;
-
-    fn title(&mut self, tab: &mut Self::Tab) -> WidgetText {
-        tab.as_str().into()
-    }
-
-    fn ui(&mut self, ui: &mut Ui, tab: &mut Self::Tab) {
-        match tab.as_str() {
-            "Simple Demo" => self.simple_demo(ui),
-            "Style Editor" => self.style_editor(ui),
-            _ => {
-                ui.label(tab.as_str());
-            }
-        }
-    }
-
-    fn context_menu(
-        &mut self,
-        ui: &mut Ui,
-        tab: &mut Self::Tab,
-        _surface: SurfaceIndex,
-        _node: NodeIndex,
-    ) {
-        match tab.as_str() {
-            "Simple Demo" => self.simple_demo_menu(ui),
-            _ => {
-                ui.label(tab.to_string());
-                ui.label("This is a context menu");
-            }
-        }
-    }
-
-    fn closeable(&mut self, tab: &mut Self::Tab) -> bool {
-        ["Inspector", "Style Editor"].contains(&tab.as_str())
-    }
-
-    fn on_close(&mut self, tab: &mut Self::Tab) -> bool {
-        self.open_tabs.remove(tab);
-        true
-    }
-}
-
-impl MyContext {
-    fn simple_demo_menu(&mut self, ui: &mut Ui) {
-        ui.label("Egui widget example");
-        ui.menu_button("Sub menu", |ui| {
-            ui.label("hello :)");
-        });
-    }
-
-    fn simple_demo(&mut self, ui: &mut Ui) {
-        ui.heading("My egui Application");
-
-        ui.horizontal(|ui| {
-            ui.label("Your name: ");
-            ui.text_edit_singleline(&mut self.title);
-        });
-        ui.add(Slider::new(&mut self.age, 0..=120).text("age"));
-        if ui.button("Click each year").clicked() {
-            self.age += 1;
-        }
-        ui.label(format!("Hello '{}', age {}", &self.title, &self.age));
-    }
-
-    fn style_editor(&mut self, ui: &mut Ui) {
-        ui.heading("Style Editor");
-
-        ui.collapsing("DockArea Options", |ui| {
-            ui.checkbox(&mut self.show_close_buttons, "Show close buttons");
-            ui.checkbox(&mut self.show_add_buttons, "Show add buttons");
-            ui.checkbox(&mut self.draggable_tabs, "Draggable tabs");
-            ui.checkbox(&mut self.show_tab_name_on_hover, "Show tab name on hover");
-            ui.checkbox(
-                &mut self.show_leaf_close_all,
-                "Show close all button on tab bars",
-            );
-            ui.checkbox(
-                &mut self.show_leaf_collapse,
-                "Show collaspse button on tab bars",
-            );
-            ui.checkbox(
-                &mut self.secondary_button_on_modifier,
-                "Enable secondary buttons when modifiers (Shift by default) are pressed",
-            );
-            ui.checkbox(
-                &mut self.secondary_button_context_menu,
-                "Enable secondary buttons in right-click context menus",
-            );
-            ui.checkbox(
-                &mut self.show_secondary_button_hint,
-                "Show tooltip hints for secondary buttons",
-            );
-            ComboBox::new("cbox:allowed_splits", "Split direction(s)")
-                .selected_text(format!("{:?}", self.allowed_splits))
-                .show_ui(ui, |ui| {
-                    ui.selectable_value(&mut self.allowed_splits, AllowedSplits::All, "All");
-                    ui.selectable_value(
-                        &mut self.allowed_splits,
-                        AllowedSplits::LeftRightOnly,
-                        "LeftRightOnly",
-                    );
-                    ui.selectable_value(
-                        &mut self.allowed_splits,
-                        AllowedSplits::TopBottomOnly,
-                        "TopBottomOnly",
-                    );
-                    ui.selectable_value(&mut self.allowed_splits, AllowedSplits::None, "None");
-                });
-        });
-
-        let style = self.style.as_mut().unwrap();
-
-        ui.collapsing("Border", |ui| {
-            egui::Grid::new("border").show(ui, |ui| {
-                ui.label("Width:");
-                ui.add(Slider::new(
-                    &mut style.main_surface_border_stroke.width,
-                    1.0..=50.0,
-                ));
-                ui.end_row();
-
-                ui.label("Color:");
-                color_edit_button_srgba(
-                    ui,
-                    &mut style.main_surface_border_stroke.color,
-                    Alpha::OnlyBlend,
-                );
-                ui.end_row();
-
-                ui.label("Rounding:");
-                rounding_ui(ui, &mut style.main_surface_border_rounding);
-                ui.end_row();
-            });
-        });
-
-        ui.collapsing("Separator", |ui| {
-            egui::Grid::new("separator").show(ui, |ui| {
-                ui.label("Width:");
-                ui.add(Slider::new(&mut style.separator.width, 1.0..=50.0));
-                ui.end_row();
-
-                ui.label("Extra Interact Width:");
-                ui.add(Slider::new(
-                    &mut style.separator.extra_interact_width,
-                    0.0..=50.0,
-                ));
-                ui.end_row();
-
-                ui.label("Offset limit:");
-                ui.add(Slider::new(&mut style.separator.extra, 1.0..=300.0));
-                ui.end_row();
-
-                ui.label("Idle color:");
-                color_edit_button_srgba(ui, &mut style.separator.color_idle, Alpha::OnlyBlend);
-                ui.end_row();
-
-                ui.label("Hovered color:");
-                color_edit_button_srgba(ui, &mut style.separator.color_hovered, Alpha::OnlyBlend);
-                ui.end_row();
-
-                ui.label("Dragged color:");
-                color_edit_button_srgba(ui, &mut style.separator.color_dragged, Alpha::OnlyBlend);
-                ui.end_row();
-            });
-        });
-
-        ui.collapsing("Tabs", |ui| {
-            ui.separator();
-
-            ui.checkbox(&mut style.tab_bar.fill_tab_bar, "Expand tabs");
-            ui.checkbox(
-                &mut style.tab_bar.show_scroll_bar_on_overflow,
-                "Show scroll bar on tab overflow",
-            );
-            ui.checkbox(
-                &mut style.tab.hline_below_active_tab_name,
-                "Show a line below the active tab name",
-            );
-            ui.horizontal(|ui| {
-                ui.add(Slider::new(&mut style.tab_bar.height, 20.0..=50.0));
-                ui.label("Tab bar height");
-            });
-
-            ComboBox::new("add_button_align", "Add button align")
-                .selected_text(format!("{:?}", style.buttons.add_tab_align))
-                .show_ui(ui, |ui| {
-                    for align in [egui_dock::TabAddAlign::Left, egui_dock::TabAddAlign::Right] {
-                        ui.selectable_value(
-                            &mut style.buttons.add_tab_align,
-                            align,
-                            format!("{:?}", align),
-                        );
-                    }
-                });
-
-            ui.separator();
-
-            fn tab_style_editor_ui(ui: &mut Ui, tab_style: &mut TabInteractionStyle) {
-                ui.separator();
-
-                ui.label("Rounding");
-                labeled_widget!(
-                    ui,
-                    Slider::new(&mut tab_style.rounding.nw, 0.0..=15.0),
-                    "North-West"
-                );
-                labeled_widget!(
-                    ui,
-                    Slider::new(&mut tab_style.rounding.ne, 0.0..=15.0),
-                    "North-East"
-                );
-                labeled_widget!(
-                    ui,
-                    Slider::new(&mut tab_style.rounding.sw, 0.0..=15.0),
-                    "South-West"
-                );
-                labeled_widget!(
-                    ui,
-                    Slider::new(&mut tab_style.rounding.se, 0.0..=15.0),
-                    "South-East"
-                );
-
-                ui.separator();
-
-                egui::Grid::new("tabs_colors").show(ui, |ui| {
-                    ui.label("Title text color:");
-                    color_edit_button_srgba(ui, &mut tab_style.text_color, Alpha::OnlyBlend);
-                    ui.end_row();
-
-                    ui.label("Outline color:")
-                        .on_hover_text("The outline around the active tab name.");
-                    color_edit_button_srgba(ui, &mut tab_style.outline_color, Alpha::OnlyBlend);
-                    ui.end_row();
-
-                    ui.label("Background color:");
-                    color_edit_button_srgba(ui, &mut tab_style.bg_fill, Alpha::OnlyBlend);
-                    ui.end_row();
-                });
-            }
-
-            ui.collapsing("Active", |ui| {
-                tab_style_editor_ui(ui, &mut style.tab.active);
-            });
-
-            ui.collapsing("Inactive", |ui| {
-                tab_style_editor_ui(ui, &mut style.tab.inactive);
-            });
-
-            ui.collapsing("Focused", |ui| {
-                tab_style_editor_ui(ui, &mut style.tab.focused);
-            });
-
-            ui.collapsing("Hovered", |ui| {
-                tab_style_editor_ui(ui, &mut style.tab.hovered);
-            });
-
-            ui.separator();
-
-            egui::Grid::new("tabs_colors").show(ui, |ui| {
-                ui.label("Close button color unfocused:");
-                color_edit_button_srgba(ui, &mut style.buttons.close_tab_color, Alpha::OnlyBlend);
-                ui.end_row();
-
-                ui.label("Close button color focused:");
-                color_edit_button_srgba(
-                    ui,
-                    &mut style.buttons.close_tab_active_color,
-                    Alpha::OnlyBlend,
-                );
-                ui.end_row();
-
-                ui.label("Close button background color:");
-                color_edit_button_srgba(ui, &mut style.buttons.close_tab_bg_fill, Alpha::OnlyBlend);
-                ui.end_row();
-
-                ui.label("Bar background color:");
-                color_edit_button_srgba(ui, &mut style.tab_bar.bg_fill, Alpha::OnlyBlend);
-                ui.end_row();
-
-                ui.label("Horizontal line color:").on_hover_text(
-                    "The line separating the tab name area from the tab content area",
-                );
-                color_edit_button_srgba(ui, &mut style.tab_bar.hline_color, Alpha::OnlyBlend);
-                ui.end_row();
-            });
-        });
-
-        ui.collapsing("Tab body", |ui| {
-            ui.separator();
-
-            ui.label("Rounding");
-            rounding_ui(ui, &mut style.tab.tab_body.rounding);
-
-            ui.label("Stroke width:");
-            ui.add(Slider::new(
-                &mut style.tab.tab_body.stroke.width,
-                0.0..=10.0,
-            ));
-            ui.end_row();
-
-            egui::Grid::new("tab_body_colors").show(ui, |ui| {
-                ui.label("Stroke color:");
-                color_edit_button_srgba(ui, &mut style.tab.tab_body.stroke.color, Alpha::OnlyBlend);
-                ui.end_row();
-
-                ui.label("Background color:");
-                color_edit_button_srgba(ui, &mut style.tab.tab_body.bg_fill, Alpha::OnlyBlend);
-                ui.end_row();
-            });
-        });
-        ui.collapsing("Overlay", |ui| {
-            let selected_text = match style.overlay.overlay_type {
-                OverlayType::HighlightedAreas => "Highlighted Areas",
-                OverlayType::Widgets => "Widgets",
-            };
-            ui.label("Overlay Style:");
-            ComboBox::new("overlay styles", "")
-                .selected_text(selected_text)
-                .show_ui(ui, |ui| {
-                    ui.selectable_value(
-                        &mut style.overlay.overlay_type,
-                        OverlayType::HighlightedAreas,
-                        "Highlighted Areas",
-                    );
-                    ui.selectable_value(
-                        &mut style.overlay.overlay_type,
-                        OverlayType::Widgets,
-                        "Widgets",
-                    );
-                });
-            ui.collapsing("Feel", |ui|{
-                labeled_widget!(
-                    ui,
-                    unit_slider!(&mut style.overlay.feel.center_drop_coverage, 0.0..=1.0, "%", 100.0),
-                    "Center drop coverage",
-                    "how big the area where dropping a tab into the center of another should be."
-                );
-                labeled_widget!(
-                    ui,
-                    unit_slider!(&mut style.overlay.feel.fade_hold_time, 0.0..=4.0, "s"),
-                    "Fade hold time",
-                    "How long faded windows should hold their fade before unfading, in seconds."
-                );
-                labeled_widget!(
-                    ui,
-                    unit_slider!(&mut style.overlay.feel.max_preference_time, 0.0..=4.0, "s"),
-                    "Max preference time",
-                    "How long the overlay may prefer to stick to a surface despite hovering over another, in seconds."
-                );
-                labeled_widget!(
-                    ui,
-                    unit_slider!(&mut style.overlay.feel.window_drop_coverage, 0.0..=1.0, "%", 100.0),
-                    "Window drop coverage",
-                    "How big the area for undocking a window should be. [is overshadowed by center drop coverage]"
-                );
-                labeled_widget!(
-                    ui,
-                    unit_slider!(&mut style.overlay.feel.interact_expansion, 1.0..=100.0, "ps"),
-                    "Interact expansion",
-                    "How much extra interaction area should be allocated for buttons on the overlay"
-                );
-            });
-
-            ui.collapsing("Visuals", |ui|{
-                labeled_widget!(
-                    ui,
-                    unit_slider!(&mut style.overlay.max_button_size, 10.0..=500.0, "ps"),
-                    "Max button size",
-                    "The max length of a side on a overlay button in egui points"
-                );
-                labeled_widget!(
-                    ui,
-                    unit_slider!(&mut style.overlay.button_spacing, 0.0..=50.0, "ps"),
-                    "Button spacing",
-                    "Spacing between buttons on the overlay, in egui units."
-                );
-                labeled_widget!(
-                    ui,
-                    unit_slider!(&mut style.overlay.surface_fade_opacity, 0.0..=1.0, "%", 100.0),
-                    "Window fade opacity",
-                    "how visible windows are when dragging a tab behind them."
-                );
-                labeled_widget!(
-                    ui,
-                    egui::Slider::new(&mut style.overlay.selection_stroke_width, 0.0..=50.0),
-                    "Selection stroke width",
-                    "width of a selection which uses a outline stroke instead of filled rect."
-                );
-                egui::Grid::new("overlay style preferences").show(ui, |ui| {
-                    ui.label("Button color:");
-                    color_edit_button_srgba(ui, &mut style.overlay.button_color, Alpha::OnlyBlend);
-                    ui.end_row();
-
-                    ui.label("Button border color:");
-                    color_edit_button_srgba(ui, &mut style.overlay.button_border_stroke.color, Alpha::OnlyBlend);
-                    ui.end_row();
-
-                    ui.label("Selection color:");
-                    color_edit_button_srgba(ui, &mut style.overlay.selection_color, Alpha::OnlyBlend);
-                    ui.end_row();
-
-                    ui.label("Button stroke color:");
-                    color_edit_button_srgba(ui, &mut style.overlay.button_border_stroke.color, Alpha::OnlyBlend);
-                    ui.end_row();
-
-                    ui.label("Button stroke width:");
-                    ui.add(Slider::new(&mut style.overlay.button_border_stroke.width, 0.0..=50.0));
-                    ui.end_row();
-                });
-            });
-
-            ui.collapsing("Hover highlight", |ui|{
-                egui::Grid::new("leaf highlighting prefs").show(ui, |ui|{
-                    ui.label("Fill color:");
-                    color_edit_button_srgba(ui, &mut style.overlay.hovered_leaf_highlight.color, Alpha::OnlyBlend);
-                    ui.end_row();
-
-                    ui.label("Stroke color:");
-                    color_edit_button_srgba(ui, &mut style.overlay.hovered_leaf_highlight.stroke.color, Alpha::OnlyBlend);
-                    ui.end_row();
-
-                    ui.label("Stroke width:");
-                    ui.add(Slider::new(&mut style.overlay.hovered_leaf_highlight.stroke.width, 0.0..=50.0));
-                    ui.end_row();
-
-                    ui.label("Expansion:");
-                    ui.add(Slider::new(&mut style.overlay.hovered_leaf_highlight.expansion, -50.0..=50.0));
-                    ui.end_row();
-                });
-                ui.label("Rounding:");
-                rounding_ui(ui, &mut style.overlay.hovered_leaf_highlight.rounding);
-            })
-        });
-    }
-}
-
-impl Default for MyApp {
-    fn default() -> Self {
-        let mut dock_state =
-            DockState::new(vec!["Simple Demo".to_owned(), "Style Editor".to_owned()]);
-        "Undock".clone_into(&mut dock_state.translations.tab_context_menu.eject_button);
-        let [a, b] = dock_state.main_surface_mut().split_left(
-            NodeIndex::root(),
-            0.3,
-            vec!["Inspector".to_owned()],
-        );
-        let [_, _] = dock_state.main_surface_mut().split_below(
-            a,
-            0.7,
-            vec!["File Browser".to_owned(), "Asset Manager".to_owned()],
-        );
-        let [_, _] =
-            dock_state
-                .main_surface_mut()
-                .split_below(b, 0.5, vec!["Hierarchy".to_owned()]);
-
-        let mut open_tabs = HashSet::new();
-
-        for node in dock_state[SurfaceIndex::main()].iter() {
-            if let Some(tabs) = node.tabs() {
-                for tab in tabs {
-                    open_tabs.insert(tab.clone());
-                }
-            }
-        }
-        let context = MyContext {
-            title: "Hello".to_string(),
-            age: 24,
-            style: None,
-            open_tabs,
-
-            show_leaf_close_all: true,
-            show_leaf_collapse: true,
-            show_secondary_button_hint: true,
-            secondary_button_on_modifier: true,
-            secondary_button_context_menu: true,
-            show_close_buttons: true,
-            show_add_buttons: false,
-            draggable_tabs: true,
-            show_tab_name_on_hover: false,
-            allowed_splits: AllowedSplits::default(),
-        };
-
-        Self {
-            context,
-            tree: dock_state,
-        }
-    }
-}
-
-impl eframe::App for MyApp {
-    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
-        TopBottomPanel::top("egui_dock::MenuBar").show(ctx, |ui| {
-            egui::menu::bar(ui, |ui| {
-                ui.menu_button("View", |ui| {
-                    // allow certain tabs to be toggled
-                    for tab in &["File Browser", "Asset Manager"] {
-                        if ui
-                            .selectable_label(self.context.open_tabs.contains(*tab), *tab)
-                            .clicked()
-                        {
-                            if let Some(index) = self.tree.find_tab(&tab.to_string()) {
-                                self.tree.remove_tab(index);
-                                self.context.open_tabs.remove(*tab);
-                            } else {
-                                self.tree[SurfaceIndex::main()]
-                                    .push_to_focused_leaf(tab.to_string());
-                            }
-
-                            ui.close_menu();
-                        }
-                    }
-                });
-            })
-        });
-        CentralPanel::default()
-            // When displaying a DockArea in another UI, it looks better
-            // to set inner margins to 0.
-            .frame(Frame::central_panel(&ctx.style()).inner_margin(0.))
-            .show(ctx, |ui| {
-                let style = self
-                    .context
-                    .style
-                    .get_or_insert(Style::from_egui(ui.style()))
-                    .clone();
-
-                DockArea::new(&mut self.tree)
-                    .style(style)
-                    .show_close_buttons(self.context.show_close_buttons)
-                    .show_add_buttons(self.context.show_add_buttons)
-                    .draggable_tabs(self.context.draggable_tabs)
-                    .show_tab_name_on_hover(self.context.show_tab_name_on_hover)
-                    .allowed_splits(self.context.allowed_splits)
-                    .show_leaf_close_all_buttons(self.context.show_leaf_close_all)
-                    .show_leaf_collapse_buttons(self.context.show_leaf_collapse)
-                    .show_secondary_button_hint(self.context.show_secondary_button_hint)
-                    .secondary_button_on_modifier(self.context.secondary_button_on_modifier)
-                    .secondary_button_context_menu(self.context.secondary_button_context_menu)
-                    .show_inside(ui, &mut self.context);
-            });
-    }
-}
-
-fn rounding_ui(ui: &mut Ui, rounding: &mut Rounding) {
-    labeled_widget!(ui, Slider::new(&mut rounding.nw, 0.0..=15.0), "North-West");
-    labeled_widget!(ui, Slider::new(&mut rounding.ne, 0.0..=15.0), "North-East");
-    labeled_widget!(ui, Slider::new(&mut rounding.sw, 0.0..=15.0), "South-West");
-    labeled_widget!(ui, Slider::new(&mut rounding.se, 0.0..=15.0), "South-East");
-}
diff --git a/crates/egui-dock/examples/reject_windows.rs b/crates/egui-dock/examples/reject_windows.rs
deleted file mode 100644
index 1c71c15..0000000
--- a/crates/egui-dock/examples/reject_windows.rs
+++ /dev/null
@@ -1,115 +0,0 @@
-#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
-
-use eframe::{egui, NativeOptions};
-
-use egui_dock::{DockArea, DockState, NodeIndex, Style};
-
-fn main() -> eframe::Result<()> {
-    let options = NativeOptions::default();
-    eframe::run_native(
-        "My egui App",
-        options,
-        Box::new(|_cc| Ok(Box::<MyApp>::default())),
-    )
-}
-
-struct TabViewer;
-
-struct OpinionatedTab {
-    can_become_window: Result<bool, bool>,
-    title: String,
-    content: String,
-}
-
-impl egui_dock::TabViewer for TabViewer {
-    type Tab = OpinionatedTab;
-
-    fn title(&mut self, tab: &mut Self::Tab) -> egui::WidgetText {
-        (&tab.title).into()
-    }
-
-    fn ui(&mut self, ui: &mut egui::Ui, tab: &mut Self::Tab) {
-        ui.label(&tab.content);
-        match &mut tab.can_become_window {
-            Ok(changing_opinion) => {
-                ui.add(egui::Checkbox::new(
-                    changing_opinion,
-                    "can be turned into window",
-                ));
-            }
-            Err(fixed_opinion) => {
-                if *fixed_opinion {
-                    ui.small("this tab can exist in a window");
-                } else {
-                    ui.small("this tab cannot exist in a window");
-                }
-            }
-        }
-    }
-
-    fn allowed_in_windows(&self, tab: &mut Self::Tab) -> bool {
-        match tab.can_become_window {
-            Ok(opinion) | Err(opinion) => opinion,
-        }
-    }
-}
-
-struct MyApp {
-    tree: DockState<OpinionatedTab>,
-}
-
-impl Default for MyApp {
-    fn default() -> Self {
-        let mut tree = DockState::new(vec![
-            OpinionatedTab {
-                can_become_window: Ok(false),
-                title: "old tab".to_owned(),
-                content: "since when could tabs become windows?".to_string(),
-            },
-            OpinionatedTab {
-                can_become_window: Err(false),
-                title: "grumpy tab".to_owned(),
-                content: "I don't want to be a window!".to_string(),
-            },
-        ]);
-
-        // You can modify the tree before constructing the dock
-        let [a, _] = tree.main_surface_mut().split_right(
-            NodeIndex::root(),
-            0.6,
-            vec![OpinionatedTab {
-                can_become_window: Ok(true),
-                title: "wise tab".to_owned(),
-                content: "egui_dock 0.7!".to_string(),
-            }],
-        );
-        let [_, _] = tree.main_surface_mut().split_below(
-            a,
-            0.4,
-            vec![OpinionatedTab {
-                can_become_window: Ok(true),
-                title: "instructional tab".to_owned(),
-                content: "This demo is meant to showcase the ability for tabs to become/be placed inside windows. 
-                \nindividual tabs have the ability to accept/reject being put/turned into a window. 
-                \nIn this demo some tabs have a fixed opinion on this, others can be swayed with the click of a checkbox. 
-                \n\n In your app you yourself may decide how tabs behave, but for now try dragging some tabs into empty space to turn them into windows!"
-                .to_string(),
-            }],
-        );
-        let _ = tree.add_window(vec![OpinionatedTab {
-            can_become_window: Err(true),
-            title: "egotistical tab".to_owned(),
-            content: "im above you all!".to_string(),
-        }]);
-
-        Self { tree }
-    }
-}
-
-impl eframe::App for MyApp {
-    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
-        DockArea::new(&mut self.tree)
-            .style(Style::from_egui(ctx.style().as_ref()))
-            .show(ctx, &mut TabViewer {});
-    }
-}
diff --git a/crates/egui-dock/examples/simple.rs b/crates/egui-dock/examples/simple.rs
deleted file mode 100644
index 2a7a6d7..0000000
--- a/crates/egui-dock/examples/simple.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
-
-use eframe::{egui, NativeOptions};
-
-use egui_dock::{DockArea, DockState, NodeIndex, Style};
-
-fn main() -> eframe::Result<()> {
-    let options = NativeOptions::default();
-    eframe::run_native(
-        "My egui App",
-        options,
-        Box::new(|_cc| Ok(Box::<MyApp>::default())),
-    )
-}
-
-struct TabViewer {}
-
-impl egui_dock::TabViewer for TabViewer {
-    type Tab = String;
-
-    fn title(&mut self, tab: &mut Self::Tab) -> egui::WidgetText {
-        (&*tab).into()
-    }
-
-    fn ui(&mut self, ui: &mut egui::Ui, tab: &mut Self::Tab) {
-        ui.label(format!("Content of {tab}"));
-    }
-}
-
-struct MyApp {
-    tree: DockState<String>,
-}
-
-impl Default for MyApp {
-    fn default() -> Self {
-        let mut tree = DockState::new(vec!["tab1".to_owned(), "tab2".to_owned()]);
-
-        // You can modify the tree before constructing the dock
-        let [a, b] =
-            tree.main_surface_mut()
-                .split_left(NodeIndex::root(), 0.3, vec!["tab3".to_owned()]);
-        let [_, _] = tree
-            .main_surface_mut()
-            .split_below(a, 0.7, vec!["tab4".to_owned()]);
-        let [_, _] = tree
-            .main_surface_mut()
-            .split_below(b, 0.5, vec!["tab5".to_owned()]);
-
-        Self { tree }
-    }
-}
-
-impl eframe::App for MyApp {
-    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
-        DockArea::new(&mut self.tree)
-            .style(Style::from_egui(ctx.style().as_ref()))
-            .show(ctx, &mut TabViewer {});
-    }
-}
diff --git a/crates/egui-dock/examples/tab_add.rs b/crates/egui-dock/examples/tab_add.rs
deleted file mode 100644
index 19739f1..0000000
--- a/crates/egui-dock/examples/tab_add.rs
+++ /dev/null
@@ -1,79 +0,0 @@
-#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
-
-use eframe::{egui, NativeOptions};
-
-use egui_dock::{DockArea, DockState, NodeIndex, Style, SurfaceIndex};
-
-fn main() -> eframe::Result<()> {
-    let options = NativeOptions::default();
-    eframe::run_native(
-        "My egui App",
-        options,
-        Box::new(|_cc| Ok(Box::<MyApp>::default())),
-    )
-}
-
-struct TabViewer<'a> {
-    added_nodes: &'a mut Vec<(SurfaceIndex, NodeIndex)>,
-}
-
-impl egui_dock::TabViewer for TabViewer<'_> {
-    type Tab = usize;
-
-    fn title(&mut self, tab: &mut Self::Tab) -> egui::WidgetText {
-        format!("Tab {tab}").into()
-    }
-
-    fn ui(&mut self, ui: &mut egui::Ui, tab: &mut Self::Tab) {
-        ui.label(format!("Content of tab {tab}"));
-    }
-
-    fn on_add(&mut self, surface: SurfaceIndex, node: NodeIndex) {
-        self.added_nodes.push((surface, node));
-    }
-}
-
-struct MyApp {
-    tree: DockState<usize>,
-    counter: usize,
-}
-
-impl Default for MyApp {
-    fn default() -> Self {
-        let mut tree = DockState::new(vec![1, 2]);
-
-        // You can modify the tree before constructing the dock
-        let [a, b] = tree
-            .main_surface_mut()
-            .split_left(NodeIndex::root(), 0.3, vec![3]);
-        let [_, _] = tree.main_surface_mut().split_below(a, 0.7, vec![4]);
-        let [_, _] = tree.main_surface_mut().split_below(b, 0.5, vec![5]);
-
-        Self { tree, counter: 6 }
-    }
-}
-
-impl eframe::App for MyApp {
-    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
-        let mut added_nodes = Vec::new();
-        DockArea::new(&mut self.tree)
-            .show_add_buttons(true)
-            .style({
-                let mut style = Style::from_egui(ctx.style().as_ref());
-                style.tab_bar.fill_tab_bar = true;
-                style
-            })
-            .show(
-                ctx,
-                &mut TabViewer {
-                    added_nodes: &mut added_nodes,
-                },
-            );
-
-        added_nodes.drain(..).for_each(|(surface, node)| {
-            self.tree.set_focused_node_and_surface((surface, node));
-            self.tree.push_to_focused_leaf(self.counter);
-            self.counter += 1;
-        });
-    }
-}
diff --git a/crates/egui-dock/examples/tab_add_popup.rs b/crates/egui-dock/examples/tab_add_popup.rs
deleted file mode 100644
index a35a07f..0000000
--- a/crates/egui-dock/examples/tab_add_popup.rs
+++ /dev/null
@@ -1,158 +0,0 @@
-#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
-
-use eframe::{egui, NativeOptions};
-
-use egui::{Color32, RichText};
-use egui_dock::{DockArea, DockState, NodeIndex, Style, SurfaceIndex};
-
-fn main() -> eframe::Result<()> {
-    let options = NativeOptions::default();
-    eframe::run_native(
-        "My egui App",
-        options,
-        Box::new(|_cc| Ok(Box::<MyApp>::default())),
-    )
-}
-
-enum MyTabKind {
-    Regular,
-    Fancy,
-}
-
-struct MyTab {
-    kind: MyTabKind,
-    surface: SurfaceIndex,
-    node: NodeIndex,
-}
-
-impl MyTab {
-    fn regular(surface: SurfaceIndex, node: NodeIndex) -> Self {
-        Self {
-            kind: MyTabKind::Regular,
-            surface,
-            node,
-        }
-    }
-
-    fn fancy(surface: SurfaceIndex, node: NodeIndex) -> Self {
-        Self {
-            kind: MyTabKind::Fancy,
-            surface,
-            node,
-        }
-    }
-
-    fn title(&self) -> String {
-        match self.kind {
-            MyTabKind::Regular => format!("Regular Tab {}", self.node.0),
-            MyTabKind::Fancy => format!("Fancy Tab {}", self.node.0),
-        }
-    }
-
-    fn content(&self) -> RichText {
-        match self.kind {
-            MyTabKind::Regular => {
-                RichText::new(format!("Content of {}. This tab is ho-hum.", self.title()))
-            }
-            MyTabKind::Fancy => RichText::new(format!(
-                "Content of {}. This tab sure is fancy!",
-                self.title()
-            ))
-            .italics()
-            .size(20.0)
-            .color(Color32::from_rgb(255, 128, 64)),
-        }
-    }
-}
-
-struct TabViewer<'a> {
-    added_nodes: &'a mut Vec<MyTab>,
-}
-
-impl egui_dock::TabViewer for TabViewer<'_> {
-    type Tab = MyTab;
-
-    fn title(&mut self, tab: &mut Self::Tab) -> egui::WidgetText {
-        tab.title().into()
-    }
-
-    fn ui(&mut self, ui: &mut egui::Ui, tab: &mut Self::Tab) {
-        ui.label(tab.content());
-    }
-
-    fn add_popup(&mut self, ui: &mut egui::Ui, surface: SurfaceIndex, node: NodeIndex) {
-        ui.set_min_width(120.0);
-        ui.style_mut().visuals.button_frame = false;
-
-        if ui.button("Regular tab").clicked() {
-            self.added_nodes.push(MyTab::regular(surface, node));
-        }
-
-        if ui.button("Fancy tab").clicked() {
-            self.added_nodes.push(MyTab::fancy(surface, node));
-        }
-    }
-}
-
-struct MyApp {
-    dock_state: DockState<MyTab>,
-    counter: usize,
-}
-
-impl Default for MyApp {
-    fn default() -> Self {
-        let mut tree = DockState::new(vec![
-            MyTab::regular(SurfaceIndex::main(), NodeIndex(1)),
-            MyTab::fancy(SurfaceIndex::main(), NodeIndex(2)),
-        ]);
-
-        // You can modify the tree before constructing the dock
-        let [a, b] = tree.main_surface_mut().split_left(
-            NodeIndex::root(),
-            0.3,
-            vec![MyTab::fancy(SurfaceIndex::main(), NodeIndex(3))],
-        );
-        let [_, _] = tree.main_surface_mut().split_below(
-            a,
-            0.7,
-            vec![MyTab::fancy(SurfaceIndex::main(), NodeIndex(4))],
-        );
-        let [_, _] = tree.main_surface_mut().split_below(
-            b,
-            0.5,
-            vec![MyTab::regular(SurfaceIndex::main(), NodeIndex(5))],
-        );
-
-        Self {
-            dock_state: tree,
-            counter: 6,
-        }
-    }
-}
-
-impl eframe::App for MyApp {
-    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
-        let mut added_nodes = Vec::new();
-        DockArea::new(&mut self.dock_state)
-            .show_add_buttons(true)
-            .show_add_popup(true)
-            .style(Style::from_egui(ctx.style().as_ref()))
-            .show(
-                ctx,
-                &mut TabViewer {
-                    added_nodes: &mut added_nodes,
-                },
-            );
-
-        added_nodes.drain(..).for_each(|node| {
-            self.dock_state
-                .set_focused_node_and_surface((node.surface, node.node));
-            self.dock_state.push_to_focused_leaf(MyTab {
-                kind: node.kind,
-                surface: node.surface,
-                node: NodeIndex(self.counter),
-            });
-            self.counter += 1;
-        });
-    }
-}
diff --git a/crates/egui-dock/examples/text_editor.rs b/crates/egui-dock/examples/text_editor.rs
deleted file mode 100644
index f85157a..0000000
--- a/crates/egui-dock/examples/text_editor.rs
+++ /dev/null
@@ -1,87 +0,0 @@
-#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
-
-use std::collections::BTreeMap;
-
-use eframe::{egui, NativeOptions};
-use egui_dock::{DockArea, DockState, Style, TabViewer};
-
-/// We identify tabs by the title of the file we are editing.
-type Title = String;
-
-fn main() -> eframe::Result<()> {
-    let options = NativeOptions::default();
-    eframe::run_native(
-        "Text editor examples",
-        options,
-        Box::new(|_cc| Ok(Box::<MyApp>::default())),
-    )
-}
-
-struct Buffers {
-    buffers: BTreeMap<Title, String>,
-}
-
-impl TabViewer for Buffers {
-    type Tab = Title;
-
-    fn title(&mut self, title: &mut Title) -> egui::WidgetText {
-        egui::WidgetText::from(&*title)
-    }
-
-    fn ui(&mut self, ui: &mut egui::Ui, title: &mut Title) {
-        let text = self.buffers.entry(title.clone()).or_default();
-        egui::TextEdit::multiline(text)
-            .desired_width(f32::INFINITY)
-            .show(ui);
-    }
-}
-
-struct MyApp {
-    buffers: Buffers,
-    tree: DockState<String>,
-}
-
-impl Default for MyApp {
-    fn default() -> Self {
-        let mut buffers = BTreeMap::default();
-        buffers.insert(
-            "CHANGELOG.md".to_owned(),
-            include_str!("../CHANGELOG.md").to_owned(),
-        );
-        buffers.insert("LICENSE".to_owned(), include_str!("../LICENSE").to_owned());
-        buffers.insert(
-            "README.md".to_owned(),
-            include_str!("../README.md").to_owned(),
-        );
-
-        let tree = DockState::new(vec!["README.md".to_owned(), "CHANGELOG.md".to_owned()]);
-
-        Self {
-            buffers: Buffers { buffers },
-            tree,
-        }
-    }
-}
-
-impl eframe::App for MyApp {
-    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
-        egui::SidePanel::left("documents").show(ctx, |ui| {
-            for title in self.buffers.buffers.keys() {
-                let tab_location = self.tree.find_tab(title);
-                let is_open = tab_location.is_some();
-                if ui.selectable_label(is_open, title).clicked() {
-                    if let Some(tab_location) = tab_location {
-                        self.tree.set_active_tab(tab_location);
-                    } else {
-                        // Open the file for editing:
-                        self.tree.push_to_focused_leaf(title.clone());
-                    }
-                }
-            }
-        });
-
-        DockArea::new(&mut self.tree)
-            .style(Style::from_egui(ctx.style().as_ref()))
-            .show(ctx, &mut self.buffers);
-    }
-}
diff --git a/crates/egui-dock/images/demo.gif b/crates/egui-dock/images/demo.gif
deleted file mode 100644
index 7296c8e..0000000
Binary files a/crates/egui-dock/images/demo.gif and /dev/null differ
diff --git a/crates/egui-dock/src/dock_state/mod.rs b/crates/egui-dock/src/dock_state/mod.rs
deleted file mode 100644
index 30646d0..0000000
--- a/crates/egui-dock/src/dock_state/mod.rs
+++ /dev/null
@@ -1,587 +0,0 @@
-/// Wrapper around indices to the collection of surfaces inside a [`DockState`].
-pub mod surface_index;
-
-pub mod tree;
-
-/// Represents an area in which a dock tree is rendered.
-pub mod surface;
-/// Specifies text displayed in different elements of the [`DockArea`](crate::DockArea).
-pub mod translations;
-/// Window states which tells floating tabs how to be displayed inside their window,
-pub mod window_state;
-
-pub use surface::Surface;
-pub use surface_index::SurfaceIndex;
-pub use window_state::WindowState;
-
-use egui::Rect;
-
-use crate::{Node, NodeIndex, Split, TabDestination, TabIndex, TabInsert, Translations, Tree};
-
-/// The heart of `egui_dock`.
-///
-/// This structure holds a collection of surfaces, each of which stores a tree in which tabs are arranged.
-///
-/// Indexing it with a [`SurfaceIndex`] will yield a [`Tree`] which then contains nodes and tabs.
-///
-/// [`DockState`] is generic, so you can use any type of data to represent a tab.
-#[derive(Clone, Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-pub struct DockState<Tab> {
-    surfaces: Vec<Surface<Tab>>,
-    focused_surface: Option<SurfaceIndex>, // Part of the tree which is in focus.
-
-    /// Contains translations of text shown in [`DockArea`](crate::DockArea).
-    pub translations: Translations,
-}
-
-impl<Tab> std::ops::Index<SurfaceIndex> for DockState<Tab> {
-    type Output = Tree<Tab>;
-
-    #[inline(always)]
-    fn index(&self, index: SurfaceIndex) -> &Self::Output {
-        match self.surfaces[index.0].node_tree() {
-            Some(tree) => tree,
-            None => {
-                panic!("There did not exist a tree at surface index {}", index.0);
-            }
-        }
-    }
-}
-
-impl<Tab> std::ops::IndexMut<SurfaceIndex> for DockState<Tab> {
-    #[inline(always)]
-    fn index_mut(&mut self, index: SurfaceIndex) -> &mut Self::Output {
-        match self.surfaces[index.0].node_tree_mut() {
-            Some(tree) => tree,
-            None => {
-                panic!("There did not exist a tree at surface index {}", index.0);
-            }
-        }
-    }
-}
-
-impl<Tab> DockState<Tab> {
-    /// Create a new tree with given tabs at the main surface's root node.
-    pub fn new(tabs: Vec<Tab>) -> Self {
-        Self {
-            surfaces: vec![Surface::Main(Tree::new(tabs))],
-            focused_surface: None,
-            translations: Translations::english(),
-        }
-    }
-
-    /// Sets translations of text later displayed in [`DockArea`](crate::DockArea).
-    pub fn with_translations(mut self, translations: Translations) -> Self {
-        self.translations = translations;
-        self
-    }
-
-    /// Get an immutable borrow to the tree at the main surface.
-    pub fn main_surface(&self) -> &Tree<Tab> {
-        &self[SurfaceIndex::main()]
-    }
-
-    /// Get a mutable borrow to the tree at the main surface.
-    pub fn main_surface_mut(&mut self) -> &mut Tree<Tab> {
-        &mut self[SurfaceIndex::main()]
-    }
-
-    /// Get the [`WindowState`] which corresponds to a [`SurfaceIndex`].
-    ///
-    /// Returns `None` if the surface is [`Empty`](Surface::Empty), [`Main`](Surface::Main), or doesn't exist.
-    ///
-    /// This can be used to modify properties of a window, e.g. size and position.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use egui_dock::DockState;
-    /// # use egui::{Vec2, Pos2};
-    /// let mut dock_state = DockState::new(vec![]);
-    /// let mut surface_index = dock_state.add_window(vec!["Window Tab".to_string()]);
-    /// let window_state = dock_state.get_window_state_mut(surface_index).unwrap();
-    ///
-    /// window_state.set_position(Pos2::ZERO);
-    /// window_state.set_size(Vec2::splat(100.0));
-    /// ```
-    pub fn get_window_state_mut(&mut self, surface: SurfaceIndex) -> Option<&mut WindowState> {
-        match &mut self.surfaces[surface.0] {
-            Surface::Window(_, state) => Some(state),
-            _ => None,
-        }
-    }
-
-    /// Get the [`WindowState`] which corresponds to a [`SurfaceIndex`].
-    ///
-    /// Returns `None` if the surface is an [`Empty`](Surface::Empty), [`Main`](Surface::Main), or doesn't exist.
-    pub fn get_window_state(&mut self, surface: SurfaceIndex) -> Option<&WindowState> {
-        match &self.surfaces[surface.0] {
-            Surface::Window(_, state) => Some(state),
-            _ => None,
-        }
-    }
-
-    /// Returns the viewport [`Rect`] and the `Tab` inside the focused leaf node or `None` if no node is in focus.
-    #[inline]
-    pub fn find_active_focused(&mut self) -> Option<(Rect, &mut Tab)> {
-        self.focused_surface
-            .and_then(|surface| self[surface].find_active_focused())
-    }
-
-    /// Get a mutable borrow to the raw surface from a surface index.
-    #[inline]
-    pub fn get_surface_mut(&mut self, surface: SurfaceIndex) -> Option<&mut Surface<Tab>> {
-        self.surfaces.get_mut(surface.0)
-    }
-
-    /// Get an immutable borrow to the raw surface from a surface index.
-    #[inline]
-    pub fn get_surface(&self, surface: SurfaceIndex) -> Option<&Surface<Tab>> {
-        self.surfaces.get(surface.0)
-    }
-
-    /// Returns true if the specified surface exists and isn't [`Empty`](Surface::Empty).
-    #[inline]
-    pub fn is_surface_valid(&self, surface_index: SurfaceIndex) -> bool {
-        self.surfaces
-            .get(surface_index.0)
-            .is_some_and(|surface| !surface.is_empty())
-    }
-
-    /// Returns a list of all valid [`SurfaceIndex`]es.
-    #[inline]
-    pub(crate) fn valid_surface_indices(&self) -> Box<[SurfaceIndex]> {
-        (0..self.surfaces.len())
-            .filter_map(|index| {
-                let index = SurfaceIndex(index);
-                self.is_surface_valid(index).then_some(index)
-            })
-            .collect()
-    }
-
-    /// Remove a surface based on its [`SurfaceIndex`]
-    ///
-    /// Returns the removed surface or `None` if it didn't exist.
-    ///
-    /// # Panics
-    ///
-    /// Panics if you try to remove the main surface: `SurfaceIndex::main()`.
-    pub fn remove_surface(&mut self, surface_index: SurfaceIndex) -> Option<Surface<Tab>> {
-        assert!(!surface_index.is_main());
-        (surface_index.0 < self.surfaces.len()).then(|| {
-            self.focused_surface = Some(SurfaceIndex::main());
-            if surface_index.0 == self.surfaces.len() - 1 {
-                self.surfaces.pop().unwrap()
-            } else {
-                let dest = &mut self.surfaces[surface_index.0];
-                std::mem::replace(dest, Surface::Empty)
-            }
-        })
-    }
-
-    /// Sets which is the active tab within a specific node on a given surface.
-    #[inline]
-    pub fn set_active_tab(
-        &mut self,
-        (surface_index, node_index, tab_index): (SurfaceIndex, NodeIndex, TabIndex),
-    ) {
-        if let Some(Node::Leaf { active, .. }) = self[surface_index].nodes.get_mut(node_index.0) {
-            *active = tab_index;
-        }
-    }
-
-    /// Sets the currently focused leaf to `node_index` if the node at `node_index` is a leaf.
-    #[inline]
-    pub fn set_focused_node_and_surface(
-        &mut self,
-        (surface_index, node_index): (SurfaceIndex, NodeIndex),
-    ) {
-        if self.is_surface_valid(surface_index) && node_index.0 < self[surface_index].len() {
-            // I don't want this code to be evaluated until im absolutely sure the surface index is valid.
-            if self[surface_index][node_index].is_leaf() {
-                self.focused_surface = Some(surface_index);
-                self[surface_index].set_focused_node(node_index);
-                return;
-            }
-        }
-        self.focused_surface = None;
-    }
-
-    /// Moves a tab from a node to another node.
-    /// You need to specify with [`TabDestination`] how the tab should be moved.
-    pub fn move_tab(
-        &mut self,
-        (src_surface, src_node, src_tab): (SurfaceIndex, NodeIndex, TabIndex),
-        dst_tab: impl Into<TabDestination>,
-    ) {
-        match dst_tab.into() {
-            TabDestination::Window(position) => {
-                self.detach_tab((src_surface, src_node, src_tab), position);
-                return;
-            }
-            TabDestination::Node(dst_surface, dst_node, dst_tab) => {
-                // Moving a single tab inside its own node is a no-op
-                if src_surface == dst_surface
-                    && src_node == dst_node
-                    && self[src_surface][src_node].tabs_count() == 1
-                {
-                    return;
-                }
-
-                // Call `Node::remove_tab` to avoid auto remove of the node by `Tree::remove_tab` from Tree.
-                let tab = self[src_surface][src_node].remove_tab(src_tab).unwrap();
-                match dst_tab {
-                    TabInsert::Split(split) => {
-                        self[dst_surface].split(dst_node, split, 0.5, Node::leaf(tab));
-                    }
-
-                    TabInsert::Insert(index) => self[dst_surface][dst_node].insert_tab(index, tab),
-                    TabInsert::Append => self[dst_surface][dst_node].append_tab(tab),
-                }
-            }
-            TabDestination::EmptySurface(dst_surface) => {
-                assert!(self[dst_surface].is_empty());
-                let tab = self[src_surface][src_node].remove_tab(src_tab).unwrap();
-                self[dst_surface] = Tree::new(vec![tab])
-            }
-        }
-        if self[src_surface][src_node].is_leaf() && self[src_surface][src_node].tabs_count() == 0 {
-            self[src_surface].remove_leaf(src_node);
-        }
-        if self[src_surface].is_empty() && !src_surface.is_main() {
-            self.remove_surface(src_surface);
-        }
-    }
-
-    /// Takes a tab out of its current surface and puts it in a new window.
-    /// Returns the surface index of the new window.
-    pub fn detach_tab(
-        &mut self,
-        (src_surface, src_node, src_tab): (SurfaceIndex, NodeIndex, TabIndex),
-        window_rect: Rect,
-    ) -> SurfaceIndex {
-        // Remove the tab from the tree and it add to a new window.
-        let tab = self[src_surface][src_node].remove_tab(src_tab).unwrap();
-        let surface_index = self.add_window(vec![tab]);
-
-        // Set the window size and position to match `window_rect`.
-        let state = self.get_window_state_mut(surface_index).unwrap();
-        state.set_position(window_rect.min);
-        if src_surface.is_main() {
-            state.set_size(window_rect.size() * 0.8);
-        } else {
-            state.set_size(window_rect.size());
-        }
-
-        // Clean up any empty leaves and surfaces which may be left behind from the detachment.
-        if self[src_surface][src_node].is_leaf() && self[src_surface][src_node].tabs_count() == 0 {
-            self[src_surface].remove_leaf(src_node);
-        }
-        if self[src_surface].is_empty() && !src_surface.is_main() {
-            self.remove_surface(src_surface);
-        }
-        surface_index
-    }
-
-    /// Currently focused leaf.
-    #[inline]
-    pub fn focused_leaf(&self) -> Option<(SurfaceIndex, NodeIndex)> {
-        let surface = self.focused_surface?;
-        self[surface].focused_leaf().map(|leaf| (surface, leaf))
-    }
-
-    /// Remove a tab at the specified surface, node, and tab index.
-    /// This method will yield the removed tab, or `None` if it doesn't exist.
-    pub fn remove_tab(
-        &mut self,
-        (surface_index, node_index, tab_index): (SurfaceIndex, NodeIndex, TabIndex),
-    ) -> Option<Tab> {
-        let removed_tab = self[surface_index].remove_tab((node_index, tab_index));
-        if !surface_index.is_main() && self[surface_index].is_empty() {
-            self.remove_surface(surface_index);
-        }
-        removed_tab
-    }
-
-    /// Creates two new nodes by splitting a given `parent` node and assigns them as its children. The first (old) node
-    /// inherits content of the `parent` from before the split, and the second (new) has `tabs`.
-    ///
-    /// `fraction` (in range 0..=1) specifies how much of the `parent` node's area the old node will occupy after the
-    /// split.
-    ///
-    /// The new node is placed relatively to the old node, in the direction specified by `split`.
-    ///
-    /// Returns the indices of the old node and the new node.
-    pub fn split(
-        &mut self,
-        (surface, parent): (SurfaceIndex, NodeIndex),
-        split: Split,
-        fraction: f32,
-        new: Node<Tab>,
-    ) -> [NodeIndex; 2] {
-        let index = self[surface].split(parent, split, fraction, new);
-        self.focused_surface = Some(surface);
-        index
-    }
-
-    /// Adds a window with its own list of tabs.
-    ///
-    /// Returns the [`SurfaceIndex`] of the new window, which will remain constant through the windows lifetime.
-    pub fn add_window(&mut self, tabs: Vec<Tab>) -> SurfaceIndex {
-        let surface = Surface::Window(Tree::new(tabs), WindowState::new());
-        let index = self.find_empty_surface_index();
-        if index.0 < self.surfaces.len() {
-            self.surfaces[index.0] = surface;
-        } else {
-            self.surfaces.push(surface);
-        }
-        index
-    }
-
-    /// Finds the first empty surface index which may be used.
-    ///
-    /// **WARNING**: in cases where one isn't found, `SurfaceIndex(self.surfaces.len())` is used.
-    /// therefore it's not inherently safe to index the [`DockState`] with this index, as it may panic.
-    fn find_empty_surface_index(&self) -> SurfaceIndex {
-        // Find the first possible empty surface to insert our window into.
-        // Starts at 1 as 0 is always the main surface.
-        for i in 1..self.surfaces.len() {
-            if self.surfaces[i].is_empty() {
-                return SurfaceIndex(i);
-            }
-        }
-        SurfaceIndex(self.surfaces.len())
-    }
-
-    /// Pushes `tab` to the currently focused leaf.
-    ///
-    /// If no leaf is focused it will be pushed to the first available leaf.
-    ///
-    /// If no leaf is available then a new leaf will be created.
-    pub fn push_to_focused_leaf(&mut self, tab: Tab) {
-        if let Some(surface) = self.focused_surface {
-            self[surface].push_to_focused_leaf(tab)
-        } else {
-            self[SurfaceIndex::main()].push_to_focused_leaf(tab)
-        }
-    }
-
-    /// Push a tab to the first available `Leaf` or create a new leaf if an `Empty` node is encountered.
-    pub fn push_to_first_leaf(&mut self, tab: Tab) {
-        self[SurfaceIndex::main()].push_to_first_leaf(tab);
-    }
-
-    /// Returns the current number of surfaces.
-    pub fn surfaces_count(&self) -> usize {
-        self.surfaces.len()
-    }
-
-    /// Returns an [`Iterator`] over all surfaces.
-    pub fn iter_surfaces(&self) -> impl Iterator<Item = &Surface<Tab>> {
-        self.surfaces.iter()
-    }
-
-    /// Returns a mutable [`Iterator`] over all surfaces.
-    pub fn iter_surfaces_mut(&mut self) -> impl Iterator<Item = &mut Surface<Tab>> {
-        self.surfaces.iter_mut()
-    }
-
-    /// Returns an [`Iterator`] of **all** underlying nodes in the dock state,
-    /// and the indices of containing surfaces.
-    pub fn iter_all_nodes(&self) -> impl Iterator<Item = (SurfaceIndex, &Node<Tab>)> {
-        self.iter_surfaces()
-            .enumerate()
-            .flat_map(|(surface_index, surface)| {
-                surface
-                    .iter_nodes()
-                    .map(move |node| (SurfaceIndex(surface_index), node))
-            })
-    }
-
-    /// Returns a mutable [`Iterator`] of **all** underlying nodes in the dock state,
-    /// and the indices of containing surfaces.
-    pub fn iter_all_nodes_mut(&mut self) -> impl Iterator<Item = (SurfaceIndex, &mut Node<Tab>)> {
-        self.iter_surfaces_mut()
-            .enumerate()
-            .flat_map(|(surface_index, surface)| {
-                surface
-                    .iter_nodes_mut()
-                    .map(move |node| (SurfaceIndex(surface_index), node))
-            })
-    }
-
-    /// Returns an [`Iterator`] of **all** tabs in the dock state,
-    /// and the indices of containing surfaces and nodes.
-    pub fn iter_all_tabs(&self) -> impl Iterator<Item = ((SurfaceIndex, NodeIndex), &Tab)> {
-        self.iter_surfaces()
-            .enumerate()
-            .flat_map(|(surface_index, surface)| {
-                surface
-                    .iter_all_tabs()
-                    .map(move |(node_index, tab)| ((SurfaceIndex(surface_index), node_index), tab))
-            })
-    }
-
-    /// Returns a mutable [`Iterator`] of **all** tabs in the dock state,
-    /// and the indices of containing surfaces and nodes.
-    pub fn iter_all_tabs_mut(
-        &mut self,
-    ) -> impl Iterator<Item = ((SurfaceIndex, NodeIndex), &mut Tab)> {
-        self.iter_surfaces_mut()
-            .enumerate()
-            .flat_map(|(surface_index, surface)| {
-                surface
-                    .iter_all_tabs_mut()
-                    .map(move |(node_index, tab)| ((SurfaceIndex(surface_index), node_index), tab))
-            })
-    }
-
-    /// Returns an [`Iterator`] of the underlying collection of nodes on the main surface.
-    #[deprecated = "Use `dock_state.main_surface().iter()` instead"]
-    pub fn iter_main_surface_nodes(&self) -> impl Iterator<Item = &Node<Tab>> {
-        self[SurfaceIndex::main()].iter()
-    }
-
-    /// Returns a mutable [`Iterator`] of the underlying collection of nodes on the main surface.
-    #[deprecated = "Use `dock_state.main_surface_mut().iter_mut()` instead"]
-    pub fn iter_main_surface_nodes_mut(&mut self) -> impl Iterator<Item = &mut Node<Tab>> {
-        self[SurfaceIndex::main()].iter_mut()
-    }
-
-    /// Returns an [`Iterator`] of **all** underlying nodes in the dock state and all subsequent trees.
-    #[deprecated = "Use `iter_all_nodes` instead"]
-    pub fn iter_nodes(&self) -> impl Iterator<Item = &Node<Tab>> {
-        self.surfaces
-            .iter()
-            .filter_map(|surface| surface.node_tree())
-            .flat_map(|nodes| nodes.iter())
-    }
-
-    /// Returns a new [`DockState`] while mapping and filtering the tab type.
-    /// Any remaining empty [`Node`]s and [`Surface`]s are removed.
-    ///
-    /// ```
-    /// # use egui_dock::{DockState, Node};
-    /// let dock_state = DockState::new(vec![1, 2, 3]);
-    /// let mapped_dock_state = dock_state.filter_map_tabs(|tab| (tab % 2 == 1).then(|| tab.to_string()));
-    ///
-    /// let tabs: Vec<_> = mapped_dock_state.iter_all_tabs().map(|(_, tab)| tab.to_owned()).collect();
-    /// assert_eq!(tabs, vec!["1".to_string(), "3".to_string()]);
-    /// ```
-    pub fn filter_map_tabs<F, NewTab>(&self, mut function: F) -> DockState<NewTab>
-    where
-        F: FnMut(&Tab) -> Option<NewTab>,
-    {
-        let DockState {
-            surfaces,
-            focused_surface,
-            translations,
-        } = self;
-        let surfaces = surfaces
-            .iter()
-            .filter_map(|surface| {
-                let surface = surface.filter_map_tabs(&mut function);
-                (!surface.is_empty()).then_some(surface)
-            })
-            .collect();
-        DockState {
-            surfaces,
-            focused_surface: *focused_surface,
-            translations: translations.clone(),
-        }
-    }
-
-    /// Returns a new [`DockState`] while mapping the tab type.
-    ///
-    /// ```
-    /// # use egui_dock::{DockState, Node};
-    /// let dock_state = DockState::new(vec![1, 2, 3]);
-    /// let mapped_dock_state = dock_state.map_tabs(|tab| tab.to_string());
-    ///
-    /// let tabs: Vec<_> = mapped_dock_state.iter_all_tabs().map(|(_, tab)| tab.to_owned()).collect();
-    /// assert_eq!(tabs, vec!["1".to_string(), "2".to_string(), "3".to_string()]);
-    /// ```
-    pub fn map_tabs<F, NewTab>(&self, mut function: F) -> DockState<NewTab>
-    where
-        F: FnMut(&Tab) -> NewTab,
-    {
-        self.filter_map_tabs(move |tab| Some(function(tab)))
-    }
-
-    /// Returns a new [`DockState`] while filtering the tab type.
-    /// Any remaining empty [`Node`]s and [`Surface`]s are removed.
-    ///
-    /// ```
-    /// # use egui_dock::{DockState, Node};
-    /// let dock_state = DockState::new(["tab1", "tab2", "outlier"].map(str::to_string).to_vec());
-    /// let filtered_dock_state = dock_state.filter_tabs(|tab| tab.starts_with("tab"));
-    ///
-    /// let tabs: Vec<_> = filtered_dock_state.iter_all_tabs().map(|(_, tab)| tab.to_owned()).collect();
-    /// assert_eq!(tabs, vec!["tab1".to_string(), "tab2".to_string()]);
-    /// ```
-    pub fn filter_tabs<F>(&self, mut predicate: F) -> DockState<Tab>
-    where
-        F: FnMut(&Tab) -> bool,
-        Tab: Clone,
-    {
-        self.filter_map_tabs(move |tab| predicate(tab).then(|| tab.clone()))
-    }
-
-    /// Removes all tabs for which `predicate` returns `false`.
-    /// Any remaining empty [`Node`]s and [`Surface`]s are also removed.
-    ///
-    /// ```
-    /// # use egui_dock::{DockState, Node};
-    /// let mut dock_state = DockState::new(["tab1", "tab2", "outlier"].map(str::to_string).to_vec());
-    /// dock_state.retain_tabs(|tab| tab.starts_with("tab"));
-    ///
-    /// let tabs: Vec<_> = dock_state.iter_all_tabs().map(|(_, tab)| tab.to_owned()).collect();
-    /// assert_eq!(tabs, vec!["tab1".to_string(), "tab2".to_string()]);
-    /// ```
-    pub fn retain_tabs<F>(&mut self, mut predicate: F)
-    where
-        F: FnMut(&mut Tab) -> bool,
-    {
-        self.surfaces.retain_mut(|surface| {
-            surface.retain_tabs(&mut predicate);
-            !surface.is_empty()
-        });
-    }
-}
-
-impl<Tab> DockState<Tab>
-where
-    Tab: PartialEq,
-{
-    /// Find the given tab.
-    ///
-    /// Returns in which node and where in that node the tab is.
-    ///
-    /// The returned [`NodeIndex`] will always point to a [`Node::Leaf`].
-    ///
-    /// In case there are several hits, only the first is returned.
-    ///
-    /// See also: [`find_main_surface_tab`](DockState::find_main_surface_tab)
-    pub fn find_tab(&self, needle_tab: &Tab) -> Option<(SurfaceIndex, NodeIndex, TabIndex)> {
-        for &surface_index in self.valid_surface_indices().iter() {
-            if !self.surfaces[surface_index.0].is_empty() {
-                if let Some((node_index, tab_index)) = self[surface_index].find_tab(needle_tab) {
-                    return Some((surface_index, node_index, tab_index));
-                }
-            }
-        }
-        None
-    }
-
-    /// Find the given tab on the main surface.
-    ///
-    /// Returns which node and where in that node the tab is.
-    ///
-    /// The returned [`NodeIndex`] will always point to a [`Node::Leaf`].
-    ///
-    /// In case there are several hits, only the first is returned.
-    pub fn find_main_surface_tab(&self, needle_tab: &Tab) -> Option<(NodeIndex, TabIndex)> {
-        self[SurfaceIndex::main()].find_tab(needle_tab)
-    }
-}
diff --git a/crates/egui-dock/src/dock_state/surface.rs b/crates/egui-dock/src/dock_state/surface.rs
deleted file mode 100644
index 169145f..0000000
--- a/crates/egui-dock/src/dock_state/surface.rs
+++ /dev/null
@@ -1,135 +0,0 @@
-use crate::{Node, NodeIndex, Tree, WindowState};
-
-/// A [`Surface`] is the highest level component in a [`DockState`](crate::DockState). [`Surface`]s represent an area
-/// in which nodes are placed.
-///
-/// Typically, you're only using one surface, which is the main surface. However, if you drag
-/// a tab out in a way which creates a window, you also create a new surface in which nodes can appear.
-#[derive(Clone, Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-pub enum Surface<Tab> {
-    /// An empty surface, with nothing inside (practically, a null surface).
-    Empty,
-
-    /// The main surface of a [`DockState`](crate::DockState), only one should exist at surface index 0 at any one time.
-    Main(Tree<Tab>),
-
-    /// A windowed surface with a state.
-    Window(Tree<Tab>, WindowState),
-}
-
-impl<Tab> Surface<Tab> {
-    /// Is this surface [`Empty`](Self::Empty) (in practice null)?
-    pub const fn is_empty(&self) -> bool {
-        matches!(self, Self::Empty)
-    }
-
-    /// Get access to the node tree of this surface.
-    pub fn node_tree(&self) -> Option<&Tree<Tab>> {
-        match self {
-            Surface::Empty => None,
-            Surface::Main(tree) => Some(tree),
-            Surface::Window(tree, _) => Some(tree),
-        }
-    }
-
-    /// Get mutable access to the node tree of this surface.
-    pub fn node_tree_mut(&mut self) -> Option<&mut Tree<Tab>> {
-        match self {
-            Surface::Empty => None,
-            Surface::Main(tree) => Some(tree),
-            Surface::Window(tree, _) => Some(tree),
-        }
-    }
-
-    /// Returns an [`Iterator`] of nodes in this surface's tree.
-    ///
-    /// If the surface is [`Empty`](Self::Empty), then the returned [`Iterator`] will be empty.
-    pub fn iter_nodes(&self) -> impl Iterator<Item = &Node<Tab>> {
-        match self.node_tree() {
-            Some(tree) => tree.iter(),
-            None => core::slice::Iter::default(),
-        }
-    }
-
-    /// Returns a mutable [`Iterator`] of nodes in this surface's tree.
-    ///
-    /// If the surface is [`Empty`](Self::Empty), then the returned [`Iterator`] will be empty.
-    pub fn iter_nodes_mut(&mut self) -> impl Iterator<Item = &mut Node<Tab>> {
-        match self.node_tree_mut() {
-            Some(tree) => tree.iter_mut(),
-            None => core::slice::IterMut::default(),
-        }
-    }
-
-    /// Returns an [`Iterator`] of **all** tabs in this surface's tree,
-    /// and indices of containing nodes.
-    pub fn iter_all_tabs(&self) -> impl Iterator<Item = (NodeIndex, &Tab)> {
-        self.iter_nodes()
-            .enumerate()
-            .flat_map(|(index, node)| node.iter_tabs().map(move |tab| (NodeIndex(index), tab)))
-    }
-
-    /// Returns a mutable [`Iterator`] of **all** tabs in this surface's tree,
-    /// and indices of containing nodes.
-    pub fn iter_all_tabs_mut(&mut self) -> impl Iterator<Item = (NodeIndex, &mut Tab)> {
-        self.iter_nodes_mut()
-            .enumerate()
-            .flat_map(|(index, node)| node.iter_tabs_mut().map(move |tab| (NodeIndex(index), tab)))
-    }
-
-    /// Returns a new [`Surface`] while mapping and filtering the tab type.
-    /// Any remaining empty [`Node`]s and are removed, and if this [`Surface`] remains empty,
-    /// it'll change to [`Surface::Empty`].
-    pub fn filter_map_tabs<F, NewTab>(&self, function: F) -> Surface<NewTab>
-    where
-        F: FnMut(&Tab) -> Option<NewTab>,
-    {
-        match self {
-            Surface::Empty => Surface::Empty,
-            Surface::Main(tree) => Surface::Main(tree.filter_map_tabs(function)),
-            Surface::Window(tree, window_state) => {
-                let tree = tree.filter_map_tabs(function);
-                if tree.is_empty() {
-                    Surface::Empty
-                } else {
-                    Surface::Window(tree, window_state.clone())
-                }
-            }
-        }
-    }
-
-    /// Returns a new [`Surface`] while mapping the tab type.
-    pub fn map_tabs<F, NewTab>(&self, mut function: F) -> Surface<NewTab>
-    where
-        F: FnMut(&Tab) -> NewTab,
-    {
-        self.filter_map_tabs(move |tab| Some(function(tab)))
-    }
-
-    /// Returns a new [`Surface`] while filtering the tab type.
-    /// Any remaining empty [`Node`]s and are removed, and if this [`Surface`] remains empty,
-    /// it'll change to [`Surface::Empty`].
-    pub fn filter_tabs<F>(&self, mut predicate: F) -> Surface<Tab>
-    where
-        F: FnMut(&Tab) -> bool,
-        Tab: Clone,
-    {
-        self.filter_map_tabs(move |tab| predicate(tab).then(|| tab.clone()))
-    }
-
-    /// Removes all tabs for which `predicate` returns `false`.
-    /// Any remaining empty [`Node`]s and are also removed, and if this [`Surface`] remains empty,
-    /// it'll change to [`Surface::Empty`].
-    pub fn retain_tabs<F>(&mut self, predicate: F)
-    where
-        F: FnMut(&mut Tab) -> bool,
-    {
-        if let Surface::Main(tree) | Surface::Window(tree, _) = self {
-            tree.retain_tabs(predicate);
-            if tree.is_empty() {
-                *self = Surface::Empty;
-            }
-        }
-    }
-}
diff --git a/crates/egui-dock/src/dock_state/surface_index.rs b/crates/egui-dock/src/dock_state/surface_index.rs
deleted file mode 100644
index ae4f1c8..0000000
--- a/crates/egui-dock/src/dock_state/surface_index.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-/// Wrapper around indices to the collection of Surfaces inside a [`DockState`](crate::DockState).
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-pub struct SurfaceIndex(pub usize);
-
-impl From<usize> for SurfaceIndex {
-    #[inline(always)]
-    fn from(index: usize) -> Self {
-        SurfaceIndex(index)
-    }
-}
-
-impl SurfaceIndex {
-    /// Returns the index of the main surface.
-    #[inline(always)]
-    pub const fn main() -> Self {
-        Self(0)
-    }
-
-    /// Returns if this index is `SurfaceIndex::main()`.
-    #[inline(always)]
-    pub const fn is_main(self) -> bool {
-        self.0 == Self::main().0
-    }
-}
diff --git a/crates/egui-dock/src/dock_state/translations.rs b/crates/egui-dock/src/dock_state/translations.rs
deleted file mode 100644
index b6ca1e2..0000000
--- a/crates/egui-dock/src/dock_state/translations.rs
+++ /dev/null
@@ -1,101 +0,0 @@
-/// Groups together labels from different elements of the [`DockArea`](crate::DockArea).
-#[derive(Clone, Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-pub struct Translations {
-    /// Text overrides for buttons in tab context menus.
-    pub tab_context_menu: TabContextMenuTranslations,
-    /// Text overrides for buttons in windows.
-    pub leaf: LeafTranslations,
-}
-
-/// Specifies text in buttons displayed in the context menu displayed upon right-clicking on a tab.
-#[derive(Clone, Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-pub struct TabContextMenuTranslations {
-    /// Button that closes the tab.
-    pub close_button: String,
-    /// Button that undocks the tab into a new window.
-    pub eject_button: String,
-}
-
-/// Specifies text displayed in the primary buttons on a tab bar.
-#[derive(Clone, Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-pub struct LeafTranslations {
-    /// Message in the tooltip shown while hovering over a grayed out X button of a leaf
-    /// containing non-closable tabs.
-    pub close_button_disabled_tooltip: String,
-    /// Button that closes the entire window.
-    pub close_all_button: String,
-    /// Message in the tooltip shown while hovering over an X button of a window.
-    /// Used when the secondary buttons are accessible from the context menu.
-    pub close_all_button_menu_hint: String,
-    /// Message in the tooltip shown while hovering over an X button of a window.
-    /// Used when the secondary buttons are accessible using modifiers.
-    pub close_all_button_modifier_hint: String,
-    /// Message in the tooltip shown while hovering over an X button of a window.
-    /// Used when the secondary buttons are accessible using modifiers and from the context menu.
-    pub close_all_button_modifier_menu_hint: String,
-    /// Message in the tooltip shown while hovering over a grayed out close window button of a window
-    /// containing non-closable tabs.
-    pub close_all_button_disabled_tooltip: String,
-    /// Button that minimizes the window.
-    pub minimize_button: String,
-    /// Message in the tooltip shown while hovering over a collapse button of a leaf.
-    /// Used when the secondary buttons are accessible from the context menu.
-    pub minimize_button_menu_hint: String,
-    /// Message in the tooltip shown while hovering over a collapse button of a leaf.
-    /// Used when the secondary buttons are accessible using modifiers.
-    pub minimize_button_modifier_hint: String,
-    /// Message in the tooltip shown while hovering over a collapse button of a leaf.
-    /// Used when the secondary buttons are accessible using modifiers and from the context menu.
-    pub minimize_button_modifier_menu_hint: String,
-}
-
-impl Translations {
-    /// Default English translations.
-    pub fn english() -> Self {
-        Self {
-            tab_context_menu: TabContextMenuTranslations::english(),
-            leaf: LeafTranslations::english(),
-        }
-    }
-}
-
-impl TabContextMenuTranslations {
-    /// Default English translations.
-    pub fn english() -> Self {
-        Self {
-            close_button: String::from("Close"),
-            eject_button: String::from("Eject"),
-        }
-    }
-}
-
-impl LeafTranslations {
-    /// Default English translations.
-    pub fn english() -> Self {
-        Self {
-            close_button_disabled_tooltip: String::from("This leaf contains non-closable tabs."),
-            close_all_button: String::from("Close window"),
-            close_all_button_menu_hint: String::from("Right click to close this window."),
-            close_all_button_modifier_hint: String::from(
-                "Press modifier keys (Shift by default) to close this window.",
-            ),
-            close_all_button_modifier_menu_hint: String::from(
-                "Press modifier keys (Shift by default) or right click to close this window.",
-            ),
-            close_all_button_disabled_tooltip: String::from(
-                "This window contains non-closable tabs.",
-            ),
-            minimize_button: String::from("Minimize window"),
-            minimize_button_menu_hint: String::from("Right click to minimize this window."),
-            minimize_button_modifier_hint: String::from(
-                "Press modifier keys (Shift by default) to minimize this window.",
-            ),
-            minimize_button_modifier_menu_hint: String::from(
-                "Press modifier keys (Shift by default) or right click to minimize this window.",
-            ),
-        }
-    }
-}
diff --git a/crates/egui-dock/src/dock_state/tree/mod.rs b/crates/egui-dock/src/dock_state/tree/mod.rs
deleted file mode 100644
index fd3bb7b..0000000
--- a/crates/egui-dock/src/dock_state/tree/mod.rs
+++ /dev/null
@@ -1,931 +0,0 @@
-//! Binary tree representing the relationships between [`Node`]s.
-//!
-//! # Implementation details
-//!
-//! The binary tree is stored in a [`Vec`] indexed by [`NodeIndex`].
-//! The root is always at index *0*.
-//! For a given node *n*:
-//!  - left child of *n* will be at index *n * 2 + 1*.
-//!  - right child of *n* will be at index *n * 2 + 2*.
-
-/// Iterates over all tabs in a [`Tree`].
-pub mod tab_iter;
-
-/// Identifies a tab within a [`Node`].
-pub mod tab_index;
-
-/// Represents an abstract node of a [`Tree`].
-pub mod node;
-
-/// Wrapper around indices to the collection of nodes inside a [`Tree`].
-pub mod node_index;
-
-pub use node::Node;
-pub use node_index::NodeIndex;
-pub use tab_index::TabIndex;
-pub use tab_iter::TabIter;
-
-use egui::ahash::HashSet;
-use egui::Rect;
-use std::{
-    cmp::max,
-    fmt,
-    ops::{Index, IndexMut},
-    slice::{Iter, IterMut},
-};
-
-use crate::SurfaceIndex;
-
-// ----------------------------------------------------------------------------
-
-/// Direction in which a new node is created relatively to the parent node at which the split occurs.
-#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
-#[allow(missing_docs)]
-pub enum Split {
-    Left,
-    Right,
-    Above,
-    Below,
-}
-
-impl Split {
-    /// Returns whether the split is vertical.
-    pub const fn is_top_bottom(self) -> bool {
-        matches!(self, Split::Above | Split::Below)
-    }
-
-    /// Returns whether the split is horizontal.
-    pub const fn is_left_right(self) -> bool {
-        matches!(self, Split::Left | Split::Right)
-    }
-}
-
-/// Specify how a tab should be added to a Node.
-pub enum TabInsert {
-    /// Split the node in the given direction.
-    Split(Split),
-
-    /// Insert the tab at the given index.
-    Insert(TabIndex),
-
-    /// Append the tab to the node.
-    Append,
-}
-
-/// The destination for a tab which is being moved.
-pub enum TabDestination {
-    /// Move to a new window with this rect.
-    Window(Rect),
-
-    /// Move to a an existing node with this insertion.
-    Node(SurfaceIndex, NodeIndex, TabInsert),
-
-    /// Move to an empty surface.
-    EmptySurface(SurfaceIndex),
-}
-
-impl From<(SurfaceIndex, NodeIndex, TabInsert)> for TabDestination {
-    fn from(value: (SurfaceIndex, NodeIndex, TabInsert)) -> TabDestination {
-        TabDestination::Node(value.0, value.1, value.2)
-    }
-}
-
-impl From<SurfaceIndex> for TabDestination {
-    fn from(value: SurfaceIndex) -> TabDestination {
-        TabDestination::EmptySurface(value)
-    }
-}
-
-impl TabDestination {
-    /// Returns if this tab destination is a [`Window`](TabDestination::Window).
-    pub fn is_window(&self) -> bool {
-        matches!(self, Self::Window(_))
-    }
-}
-
-/// Binary tree representing the relationships between [`Node`]s.
-///
-/// # Implementation details
-///
-/// The binary tree is stored in a [`Vec`] indexed by [`NodeIndex`].
-/// The root is always at index *0*.
-/// For a given node *n*:
-///  - left child of *n* will be at index *n * 2 + 1*.
-///  - right child of *n* will be at index *n * 2 + 2*.
-///
-/// For "Horizontal" nodes:
-///  - left child contains Left node.
-///  - right child contains Right node.
-///
-/// For "Vertical" nodes:
-///  - left child contains Top node.
-///  - right child contains Bottom node.
-#[derive(Clone)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-pub struct Tree<Tab> {
-    // Binary tree vector
-    pub(super) nodes: Vec<Node<Tab>>,
-    focused_node: Option<NodeIndex>,
-    // Whether all subnodes of the tree is collapsed
-    collapsed: bool,
-    collapsed_leaf_count: i32,
-}
-
-impl<Tab> fmt::Debug for Tree<Tab> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Tree").finish_non_exhaustive()
-    }
-}
-
-impl<Tab> Default for Tree<Tab> {
-    fn default() -> Self {
-        Self {
-            nodes: Vec::new(),
-            focused_node: None,
-            collapsed: false,
-            collapsed_leaf_count: 0,
-        }
-    }
-}
-
-impl<Tab> Index<NodeIndex> for Tree<Tab> {
-    type Output = Node<Tab>;
-
-    #[inline(always)]
-    fn index(&self, index: NodeIndex) -> &Self::Output {
-        &self.nodes[index.0]
-    }
-}
-
-impl<Tab> IndexMut<NodeIndex> for Tree<Tab> {
-    #[inline(always)]
-    fn index_mut(&mut self, index: NodeIndex) -> &mut Self::Output {
-        &mut self.nodes[index.0]
-    }
-}
-
-impl<Tab> Tree<Tab> {
-    /// Creates a new [`Tree`] with given `Vec` of `Tab`s in its root node.
-    #[inline(always)]
-    pub fn new(tabs: Vec<Tab>) -> Self {
-        let root = Node::leaf_with(tabs);
-        Self {
-            nodes: vec![root],
-            focused_node: None,
-            collapsed: false,
-            collapsed_leaf_count: 0,
-        }
-    }
-
-    /// Returns the viewport [`Rect`] and the `Tab` inside the first leaf node,
-    /// or `None` if no leaf exists in the [`Tree`].
-    #[inline]
-    pub fn find_active(&mut self) -> Option<(Rect, &mut Tab)> {
-        self.nodes.iter_mut().find_map(|node| match node {
-            Node::Leaf {
-                tabs,
-                active,
-                viewport,
-                ..
-            } => tabs.get_mut(active.0).map(|tab| (viewport.to_owned(), tab)),
-            _ => None,
-        })
-    }
-
-    /// Returns the number of nodes in the [`Tree`].
-    ///
-    /// This includes [`Empty`](Node::Empty) nodes.
-    #[inline(always)]
-    pub fn len(&self) -> usize {
-        self.nodes.len()
-    }
-
-    /// Returns `true` if the number of nodes in the tree is 0, otherwise `false`.
-    #[inline(always)]
-    pub fn is_empty(&self) -> bool {
-        self.nodes.is_empty()
-    }
-
-    /// Returns an [`Iterator`] of the underlying collection of nodes.
-    ///
-    /// This includes [`Empty`](Node::Empty) nodes.
-    #[inline(always)]
-    pub fn iter(&self) -> Iter<'_, Node<Tab>> {
-        self.nodes.iter()
-    }
-
-    /// Returns [`IterMut`] of the underlying collection of nodes.
-    ///
-    /// This includes [`Empty`](Node::Empty) nodes.
-    #[inline(always)]
-    pub fn iter_mut(&mut self) -> IterMut<'_, Node<Tab>> {
-        self.nodes.iter_mut()
-    }
-
-    /// Returns an [`Iterator`] of [`NodeIndex`] ordered in a breadth first manner.
-    #[inline(always)]
-    pub(crate) fn breadth_first_index_iter(&self) -> impl Iterator<Item = NodeIndex> {
-        (0..self.nodes.len()).map(NodeIndex)
-    }
-
-    /// Returns an iterator over all tabs in arbitrary order.
-    #[inline(always)]
-    pub fn tabs(&self) -> TabIter<'_, Tab> {
-        TabIter::new(self)
-    }
-
-    /// Counts and returns the number of tabs in the whole tree.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use egui_dock::{DockState, NodeIndex, TabIndex};
-    /// let mut dock_state = DockState::new(vec!["node 1", "node 2", "node 3"]);
-    /// assert_eq!(dock_state.main_surface().num_tabs(), 3);
-    ///
-    /// let [a, b] = dock_state.main_surface_mut().split_left(NodeIndex::root(), 0.5, vec!["tab 4", "tab 5"]);
-    /// assert_eq!(dock_state.main_surface().num_tabs(), 5);
-    ///
-    /// dock_state.main_surface_mut().remove_leaf(a);
-    /// assert_eq!(dock_state.main_surface().num_tabs(), 2);
-    /// ```
-    #[inline]
-    pub fn num_tabs(&self) -> usize {
-        let mut count = 0;
-        for node in self.nodes.iter() {
-            if let Node::Leaf { tabs, .. } = node {
-                count += tabs.len();
-            }
-        }
-        count
-    }
-
-    /// Acquire a immutable borrow to the [`Node`] at the root of the tree.
-    /// Returns [`None`] if the tree is empty.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use egui_dock::DockState;
-    /// let mut dock_state = DockState::new(vec!["single tab"]);
-    /// let root_node = dock_state.main_surface().root_node().unwrap();
-    ///
-    /// assert_eq!(root_node.tabs(), Some(["single tab"].as_slice()));
-    /// ```
-    pub fn root_node(&self) -> Option<&Node<Tab>> {
-        self.nodes.first()
-    }
-
-    /// Acquire a mutable borrow to the [`Node`] at the root of the tree.
-    /// Returns [`None`] if the tree is empty.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use egui_dock::{DockState, Node};
-    /// let mut dock_state = DockState::new(vec!["single tab"]);
-    /// let root_node = dock_state.main_surface_mut().root_node_mut().unwrap();
-    /// if let Node::Leaf { tabs, ..} = root_node {
-    ///     tabs.push("partner tab");
-    /// }
-    /// assert_eq!(root_node.tabs(), Some(["single tab", "partner tab"].as_slice()));
-    /// ```
-    pub fn root_node_mut(&mut self) -> Option<&mut Node<Tab>> {
-        self.nodes.first_mut()
-    }
-
-    /// Creates two new nodes by splitting a given `parent` node and assigns them as its children. The first (old) node
-    /// inherits content of the `parent` from before the split, and the second (new) gets the `tabs`.
-    ///
-    /// `fraction` (in range 0..=1) specifies how much of the `parent` node's area the old node will occupy after the
-    /// split.
-    ///
-    /// The new node is placed relatively to the old node, in the direction specified by `split`.
-    ///
-    /// Returns the indices of the old node and the new node.
-    ///
-    /// # Panics
-    ///
-    /// If `fraction` isn't in range 0..=1.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// # use egui_dock::{DockState, SurfaceIndex, NodeIndex, Split};
-    /// let mut dock_state = DockState::new(vec!["tab 1", "tab 2"]);
-    ///
-    /// // At this point, the main surface only contains the leaf with tab 1 and 2.
-    /// assert!(dock_state.main_surface().root_node().unwrap().is_leaf());
-    ///
-    /// // Split the node, giving 50% of the space to the new nodes and 50% to the old ones.
-    /// let [old, new] = dock_state.main_surface_mut()
-    ///     .split_tabs(NodeIndex::root(), Split::Below, 0.5, vec!["tab 3"]);
-    ///
-    /// assert!(dock_state.main_surface().root_node().unwrap().is_parent());
-    /// assert!(dock_state[SurfaceIndex::main()][old].is_leaf());
-    /// assert!(dock_state[SurfaceIndex::main()][new].is_leaf());
-    /// ```
-    #[inline(always)]
-    pub fn split_tabs(
-        &mut self,
-        parent: NodeIndex,
-        split: Split,
-        fraction: f32,
-        tabs: Vec<Tab>,
-    ) -> [NodeIndex; 2] {
-        self.split(parent, split, fraction, Node::leaf_with(tabs))
-    }
-
-    /// Creates two new nodes by splitting a given `parent` node and assigns them as its children. The first (old) node
-    /// inherits content of the `parent` from before the split, and the second (new) gets the `tabs`.
-    ///
-    /// This is a shorthand for using `split_tabs` with [`Split::Above`].
-    ///
-    /// `fraction` (in range 0..=1) specifies how much of the `parent` node's area the old node will occupy after the
-    /// split.
-    ///
-    /// The new node is placed *above* the old node.
-    ///
-    /// Returns the indices of the old node and the new node.
-    ///
-    /// # Panics
-    ///
-    /// If `fraction` isn't in range 0..=1.
-    #[inline(always)]
-    pub fn split_above(
-        &mut self,
-        parent: NodeIndex,
-        fraction: f32,
-        tabs: Vec<Tab>,
-    ) -> [NodeIndex; 2] {
-        self.split(parent, Split::Above, fraction, Node::leaf_with(tabs))
-    }
-
-    /// Creates two new nodes by splitting a given `parent` node and assigns them as its children. The first (old) node
-    /// inherits content of the `parent` from before the split, and the second (new) gets the `tabs`.
-    ///
-    /// This is a shorthand for using `split_tabs` with [`Split::Below`].
-    ///
-    /// `fraction` (in range 0..=1) specifies how much of the `parent` node's area the old node will occupy after the
-    /// split.
-    ///
-    /// The new node is placed *below* the old node.
-    ///
-    /// Returns the indices of the old node and the new node.
-    ///
-    /// # Panics
-    ///
-    /// If `fraction` isn't in range 0..=1.
-    #[inline(always)]
-    pub fn split_below(
-        &mut self,
-        parent: NodeIndex,
-        fraction: f32,
-        tabs: Vec<Tab>,
-    ) -> [NodeIndex; 2] {
-        self.split(parent, Split::Below, fraction, Node::leaf_with(tabs))
-    }
-
-    /// Creates two new nodes by splitting a given `parent` node and assigns them as its children. The first (old) node
-    /// inherits content of the `parent` from before the split, and the second (new) gets the `tabs`.
-    ///
-    /// This is a shorthand for using `split_tabs` with [`Split::Left`].
-    ///
-    /// `fraction` (in range 0..=1) specifies how much of the `parent` node's area the old node will occupy after the
-    /// split.
-    ///
-    /// The new node is placed to the *left* of the old node.
-    ///
-    /// Returns the indices of the old node and the new node.
-    ///
-    /// # Panics
-    ///
-    /// If `fraction` isn't in range 0..=1.
-    #[inline(always)]
-    pub fn split_left(
-        &mut self,
-        parent: NodeIndex,
-        fraction: f32,
-        tabs: Vec<Tab>,
-    ) -> [NodeIndex; 2] {
-        self.split(parent, Split::Left, fraction, Node::leaf_with(tabs))
-    }
-
-    /// Creates two new nodes by splitting a given `parent` node and assigns them as its children. The first (old) node
-    /// inherits content of the `parent` from before the split, and the second (new) gets the `tabs`.
-    ///
-    /// This is a shorthand for using `split_tabs` with [`Split::Right`].
-    ///
-    /// `fraction` (in range 0..=1) specifies how much of the `parent` node's area the old node will occupy after the
-    /// split.
-    ///
-    /// The new node is placed to the *right* of the old node.
-    ///
-    /// Returns the indices of the old node and the new node.
-    ///
-    /// # Panics
-    ///
-    /// If `fraction` isn't in range 0..=1.
-    #[inline(always)]
-    pub fn split_right(
-        &mut self,
-        parent: NodeIndex,
-        fraction: f32,
-        tabs: Vec<Tab>,
-    ) -> [NodeIndex; 2] {
-        self.split(parent, Split::Right, fraction, Node::leaf_with(tabs))
-    }
-
-    /// Creates two new nodes by splitting a given `parent` node and assigns them as its children. The first (old) node
-    /// inherits content of the `parent` from before the split, and the second (new) uses `new`.
-    ///
-    /// `fraction` (in range 0..=1) specifies how much of the `parent` node's area the old node will occupy after the
-    /// split.
-    ///
-    /// The new node is placed relatively to the old node, in the direction specified by `split`.
-    ///
-    /// Returns the indices of the old node and the new node.
-    ///
-    /// # Panics
-    ///
-    /// If `fraction` isn't in range 0..=1.
-    ///
-    /// If `new` is an [`Empty`](Node::Empty), [`Horizontal`](Node::Horizontal) or [`Vertical`](Node::Vertical) node.
-    ///
-    /// If `new` is a [`Leaf`](Node::Leaf) node without any tabs.
-    ///
-    /// If `parent` points to an [`Empty`](Node::Empty) node.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// # use egui_dock::{DockState, SurfaceIndex, NodeIndex, Split, Node};
-    /// let mut dock_state = DockState::new(vec!["tab 1", "tab 2"]);
-    ///
-    /// // At this point, the main surface only contains the leaf with tab 1 and 2.
-    /// assert!(dock_state.main_surface().root_node().unwrap().is_leaf());
-    ///
-    /// // Splits the node, giving 50% of the space to the new nodes and 50% to the old ones.
-    /// let [old, new] = dock_state.main_surface_mut()
-    ///     .split(NodeIndex::root(), Split::Below, 0.5, Node::leaf_with(vec!["tab 3"]));
-    ///
-    /// assert!(dock_state.main_surface().root_node().unwrap().is_parent());
-    /// assert!(dock_state[SurfaceIndex::main()][old].is_leaf());
-    /// assert!(dock_state[SurfaceIndex::main()][new].is_leaf());
-    /// ```
-    pub fn split(
-        &mut self,
-        parent: NodeIndex,
-        split: Split,
-        fraction: f32,
-        new: Node<Tab>,
-    ) -> [NodeIndex; 2] {
-        let old = self[parent].split(split, fraction);
-        assert!(old.is_leaf() || old.is_parent());
-        assert_ne!(new.tabs_count(), 0);
-        // Resize vector to fit the new size of the binary tree.
-        {
-            let index = self.nodes.iter().rposition(|n| !n.is_empty()).unwrap_or(0);
-            let level = NodeIndex(index).level();
-            self.nodes
-                .resize_with((1 << (level + 1)) - 1, || Node::Empty);
-        }
-
-        let index = match split {
-            Split::Left | Split::Above => [parent.right(), parent.left()],
-            Split::Right | Split::Below => [parent.left(), parent.right()],
-        };
-
-        // If the node were splitting is a parent, all it's children need to be moved.
-        if old.is_parent() {
-            let levels_to_move = NodeIndex(self.nodes.len()).level() - index[0].level();
-
-            // Level 0 is ourself, which is done when we assign self[index[0]] = old, so start at 1.
-            for level in (1..levels_to_move).rev() {
-                // Old child indices for this level
-                let old_start = parent.children_at(level).start;
-                // New child indices for this level
-                let new_start = index[0].children_at(level).start;
-
-                // Children to be moved this level change
-                let len = 1 << level;
-
-                // Swap self[old_start..(old_start+len)] with self[new_start..(new_start+len)]
-                // (the new part will only contain empty entries).
-                let (old_range, new_range) = {
-                    let (first_part, second_part) = self.nodes.split_at_mut(new_start);
-                    // Cut to length.
-                    (
-                        &mut first_part[old_start..old_start + len],
-                        &mut second_part[..len],
-                    )
-                };
-                old_range.swap_with_slice(new_range);
-            }
-        }
-
-        self[index[0]] = old;
-        self[index[1]] = new;
-
-        self.focused_node = Some(index[1]);
-        self.node_update_collapsed(index[1]);
-
-        index
-    }
-
-    fn first_leaf(&self, top: NodeIndex) -> Option<NodeIndex> {
-        let left = top.left();
-        let right = top.right();
-        match (self.nodes.get(left.0), self.nodes.get(right.0)) {
-            (Some(&Node::Leaf { .. }), _) => Some(left),
-            (_, Some(&Node::Leaf { .. })) => Some(right),
-
-            (
-                Some(Node::Horizontal { .. } | Node::Vertical { .. }),
-                Some(Node::Horizontal { .. } | Node::Vertical { .. }),
-            ) => self.first_leaf(left).or(self.first_leaf(right)),
-            (Some(Node::Horizontal { .. } | Node::Vertical { .. }), _) => self.first_leaf(left),
-            (_, Some(Node::Horizontal { .. } | Node::Vertical { .. })) => self.first_leaf(right),
-
-            (None, None)
-            | (Some(&Node::Empty), None)
-            | (None, Some(&Node::Empty))
-            | (Some(&Node::Empty), Some(&Node::Empty)) => None,
-        }
-    }
-
-    /// Returns the viewport [`Rect`] and the `Tab` inside the focused leaf node or [`None`] if it does not exist.
-    #[inline]
-    pub fn find_active_focused(&mut self) -> Option<(Rect, &mut Tab)> {
-        match self.focused_node.and_then(|idx| self.nodes.get_mut(idx.0)) {
-            Some(Node::Leaf {
-                tabs,
-                active,
-                viewport,
-                ..
-            }) => tabs.get_mut(active.0).map(|tab| (*viewport, tab)),
-            _ => None,
-        }
-    }
-
-    /// Gets the node index of currently focused leaf node; returns [`None`] when no leaf is focused.
-    #[inline]
-    pub fn focused_leaf(&self) -> Option<NodeIndex> {
-        self.focused_node
-    }
-
-    /// Sets the currently focused leaf to `node_index` if the node at `node_index` is a leaf.
-    ///
-    /// This method will not never panic and instead removes focus from all nodes when given an invalid index.
-    #[inline]
-    pub fn set_focused_node(&mut self, node_index: NodeIndex) {
-        self.focused_node = self
-            .nodes
-            .get(node_index.0)
-            .filter(|node| node.is_leaf())
-            .map(|_| node_index);
-    }
-
-    /// Removes the given node from the [`Tree`].
-    ///
-    /// # Panics
-    ///
-    /// - If the tree is empty.
-    /// - If the node at index `node` is not a [`Leaf`](Node::Leaf).
-    pub fn remove_leaf(&mut self, node: NodeIndex) {
-        assert!(!self.is_empty());
-        assert!(self[node].is_leaf());
-
-        let Some(parent) = node.parent() else {
-            self.nodes.clear();
-            return;
-        };
-
-        if Some(node) == self.focused_node {
-            self.focused_node = None;
-            let mut node = node;
-            while let Some(parent) = node.parent() {
-                let next = if node.is_left() {
-                    parent.right()
-                } else {
-                    parent.left()
-                };
-                if self.nodes.get(next.0).is_some_and(|node| node.is_leaf()) {
-                    self.focused_node = Some(next);
-                    break;
-                }
-                if let Some(node) = self.first_leaf(next) {
-                    self.focused_node = Some(node);
-                    break;
-                }
-                node = parent;
-            }
-        }
-
-        self[parent] = Node::Empty;
-        self[node] = Node::Empty;
-
-        let mut level = 0;
-
-        if node.is_left() {
-            'left_end: loop {
-                let dst = parent.children_at(level);
-                let src = parent.children_right(level + 1);
-                for (dst, src) in dst.zip(src) {
-                    if src >= self.nodes.len() {
-                        break 'left_end;
-                    }
-                    if Some(NodeIndex(src)) == self.focused_node {
-                        self.focused_node = Some(NodeIndex(dst));
-                    }
-                    self.nodes[dst] = std::mem::replace(&mut self.nodes[src], Node::Empty);
-                }
-                level += 1;
-            }
-        } else {
-            'right_end: loop {
-                let dst = parent.children_at(level);
-                let src = parent.children_left(level + 1);
-                for (dst, src) in dst.zip(src) {
-                    if src >= self.nodes.len() {
-                        break 'right_end;
-                    }
-                    if Some(NodeIndex(src)) == self.focused_node {
-                        self.focused_node = Some(NodeIndex(dst));
-                    }
-                    self.nodes[dst] = std::mem::replace(&mut self.nodes[src], Node::Empty);
-                }
-                level += 1;
-            }
-        }
-    }
-
-    /// Pushes a tab to the first `Leaf` it finds or create a new leaf if an `Empty` node is encountered.
-    pub fn push_to_first_leaf(&mut self, tab: Tab) {
-        for (index, node) in &mut self.nodes.iter_mut().enumerate() {
-            match node {
-                Node::Leaf { tabs, active, .. } => {
-                    *active = TabIndex(tabs.len());
-                    tabs.push(tab);
-                    self.focused_node = Some(NodeIndex(index));
-                    return;
-                }
-                Node::Empty => {
-                    *node = Node::leaf(tab);
-                    self.focused_node = Some(NodeIndex(index));
-                    return;
-                }
-                _ => {}
-            }
-        }
-        assert!(self.nodes.is_empty());
-        self.nodes.push(Node::leaf_with(vec![tab]));
-        self.focused_node = Some(NodeIndex(0));
-    }
-
-    /// Sets which is the active tab within a specific node.
-    #[inline]
-    pub fn set_active_tab(&mut self, node_index: NodeIndex, tab_index: TabIndex) {
-        if let Some(Node::Leaf { active, .. }) = self.nodes.get_mut(node_index.0) {
-            *active = tab_index;
-        }
-    }
-
-    /// Pushes `tab` to the currently focused leaf.
-    ///
-    /// If no leaf is focused it will be pushed to the first available leaf.
-    ///
-    /// If no leaf is available then a new leaf will be created.
-    pub fn push_to_focused_leaf(&mut self, tab: Tab) {
-        match self.focused_node {
-            Some(node) => {
-                if self.nodes.is_empty() {
-                    self.nodes.push(Node::leaf(tab));
-                    self.focused_node = Some(NodeIndex::root());
-                } else {
-                    match &mut self[node] {
-                        Node::Empty => {
-                            self[node] = Node::leaf(tab);
-                            self.focused_node = Some(node);
-                        }
-                        Node::Leaf { tabs, active, .. } => {
-                            *active = TabIndex(tabs.len());
-                            tabs.push(tab);
-                            self.focused_node = Some(node);
-                        }
-                        _ => {
-                            self.push_to_first_leaf(tab);
-                        }
-                    }
-                }
-            }
-            None => {
-                if self.nodes.is_empty() {
-                    self.nodes.push(Node::leaf(tab));
-                    self.focused_node = Some(NodeIndex::root());
-                } else {
-                    self.push_to_first_leaf(tab);
-                }
-            }
-        }
-    }
-
-    /// Removes the tab at the given ([`NodeIndex`], [`TabIndex`]) pair.
-    ///
-    /// If the node is emptied after the tab is removed, the node will also be removed.
-    ///
-    /// Returns the removed tab if it exists, or `None` otherwise.
-    pub fn remove_tab(&mut self, (node_index, tab_index): (NodeIndex, TabIndex)) -> Option<Tab> {
-        let node = &mut self[node_index];
-        let tab = node.remove_tab(tab_index);
-        if node.tabs_count() == 0 {
-            self.remove_leaf(node_index);
-        }
-        tab
-    }
-
-    /// Returns a new [`Tree`] while mapping and filtering the tab type.
-    /// Any remaining empty [`Node`]s are removed.
-    pub fn filter_map_tabs<F, NewTab>(&self, mut function: F) -> Tree<NewTab>
-    where
-        F: FnMut(&Tab) -> Option<NewTab>,
-    {
-        let Tree {
-            focused_node,
-            nodes,
-            collapsed,
-            collapsed_leaf_count,
-        } = self;
-        let mut emptied_nodes = HashSet::default();
-        let nodes = nodes
-            .iter()
-            .enumerate()
-            .map(|(index, node)| {
-                let filtered_node = node.filter_map_tabs(&mut function);
-                if filtered_node.is_empty() && !node.is_empty() {
-                    emptied_nodes.insert(NodeIndex(index));
-                }
-                filtered_node
-            })
-            .collect();
-        let mut new_tree = Tree {
-            nodes,
-            focused_node: *focused_node,
-            collapsed: *collapsed,
-            collapsed_leaf_count: *collapsed_leaf_count,
-        };
-        new_tree.balance(emptied_nodes);
-        new_tree
-    }
-
-    /// Returns a new [`Tree`] while mapping the tab type.
-    pub fn map_tabs<F, NewTab>(&self, mut function: F) -> Tree<NewTab>
-    where
-        F: FnMut(&Tab) -> NewTab,
-    {
-        self.filter_map_tabs(move |tab| Some(function(tab)))
-    }
-
-    /// Returns a new [`Tree`] while filtering the tab type.
-    /// Any remaining empty [`Node`]s are removed.
-    pub fn filter_tabs<F>(&self, mut predicate: F) -> Tree<Tab>
-    where
-        F: FnMut(&Tab) -> bool,
-        Tab: Clone,
-    {
-        self.filter_map_tabs(move |tab| predicate(tab).then(|| tab.clone()))
-    }
-
-    /// Removes all tabs for which `predicate` returns `false`.
-    /// Any remaining empty [`Node`]s are also removed.
-    pub fn retain_tabs<F>(&mut self, mut predicate: F)
-    where
-        F: FnMut(&mut Tab) -> bool,
-    {
-        let mut emptied_nodes = HashSet::default();
-        for (index, node) in self.nodes.iter_mut().enumerate() {
-            node.retain_tabs(&mut predicate);
-            if node.is_empty() {
-                emptied_nodes.insert(NodeIndex(index));
-            }
-        }
-        self.balance(emptied_nodes);
-    }
-
-    /// Sets the collapsing state of the [`Tree`].
-    pub(crate) fn set_collapsed(&mut self, collapsed: bool) {
-        self.collapsed = collapsed;
-    }
-
-    /// Returns whether the [`Tree`] is collapsed.
-    pub(crate) fn is_collapsed(&self) -> bool {
-        self.collapsed
-    }
-
-    /// Sets the number of collapsed layers of leaf subnodes in the [`Tree`].
-    pub(crate) fn set_collapsed_leaf_count(&mut self, collapsed_leaf_count: i32) {
-        self.collapsed_leaf_count = collapsed_leaf_count;
-    }
-
-    /// Returns the number of collapsed layers of leaf subnodes in the [`Tree`].
-    pub(crate) fn collapsed_leaf_count(&self) -> i32 {
-        self.collapsed_leaf_count
-    }
-
-    fn balance(&mut self, emptied_nodes: HashSet<NodeIndex>) {
-        let mut emptied_parents = HashSet::default();
-        for parent_index in emptied_nodes.into_iter().filter_map(|ni| ni.parent()) {
-            if self[parent_index.left()].is_empty() && self[parent_index.right()].is_empty() {
-                self[parent_index] = Node::Empty;
-                emptied_parents.insert(parent_index);
-            } else if self[parent_index.left()].is_empty() {
-                self.nodes.swap(parent_index.0, parent_index.right().0);
-                self[parent_index.right()] = Node::Empty;
-            } else if self[parent_index.right()].is_empty() {
-                self.nodes.swap(parent_index.0, parent_index.left().0);
-                self[parent_index.left()] = Node::Empty;
-            }
-        }
-        if !emptied_parents.is_empty() {
-            self.balance(emptied_parents);
-        }
-    }
-
-    /// Updates the collapsed state of the node and its parents.
-    pub(crate) fn node_update_collapsed(&mut self, node_index: NodeIndex) {
-        let collapsed = self[node_index].is_collapsed();
-        if !collapsed {
-            // Recursively notify parent nodes that the leaf has expanded
-            let mut parent_index_option = node_index.parent();
-            while let Some(parent_index) = parent_index_option {
-                parent_index_option = parent_index.parent();
-
-                // Update collapsed leaf count and collapse status
-                let left_count = self[parent_index.left()].collapsed_leaf_count();
-                let right_count = self[parent_index.right()].collapsed_leaf_count();
-                self[parent_index].set_collapsed(false);
-
-                if self[parent_index].is_horizontal() {
-                    self[parent_index].set_collapsed_leaf_count(max(left_count, right_count));
-                } else {
-                    self[parent_index].set_collapsed_leaf_count(left_count + right_count);
-                }
-            }
-            self.set_collapsed(false);
-            let root_index = NodeIndex::root();
-            self.set_collapsed_leaf_count(self[root_index].collapsed_leaf_count());
-        } else {
-            // Recursively notify parent nodes that the leaf has collapsed
-            let mut parent_index_option = node_index.parent();
-            while let Some(parent_index) = parent_index_option {
-                parent_index_option = parent_index.parent();
-
-                // Update collapsed leaf count and collapse status
-                let left_count = self[parent_index.left()].collapsed_leaf_count();
-                let right_count = self[parent_index.right()].collapsed_leaf_count();
-
-                if self[parent_index].is_horizontal() {
-                    self[parent_index].set_collapsed_leaf_count(max(left_count, right_count));
-                } else {
-                    self[parent_index].set_collapsed_leaf_count(left_count + right_count);
-                }
-
-                if self[parent_index.left()].is_collapsed()
-                    && self[parent_index.right()].is_collapsed()
-                {
-                    self[parent_index].set_collapsed(true);
-                }
-            }
-            if self.root_node().is_some_and(|root| root.is_collapsed()) {
-                self.set_collapsed(true);
-                let root_index = NodeIndex::root();
-                self.set_collapsed_leaf_count(self[root_index].collapsed_leaf_count());
-            }
-        }
-    }
-}
-
-impl<Tab> Tree<Tab>
-where
-    Tab: PartialEq,
-{
-    /// Find the given tab.
-    ///
-    /// Returns in which node and where in that node the tab is.
-    ///
-    /// The returned [`NodeIndex`] will always point to a [`Node::Leaf`].
-    ///
-    /// In case there are several hits, only the first is returned.
-    pub fn find_tab(&self, needle_tab: &Tab) -> Option<(NodeIndex, TabIndex)> {
-        for (node_index, node) in self.nodes.iter().enumerate() {
-            if let Some(tabs) = node.tabs() {
-                for (tab_index, tab) in tabs.iter().enumerate() {
-                    if tab == needle_tab {
-                        return Some((node_index.into(), tab_index.into()));
-                    }
-                }
-            }
-        }
-        None
-    }
-}
diff --git a/crates/egui-dock/src/dock_state/tree/node.rs b/crates/egui-dock/src/dock_state/tree/node.rs
deleted file mode 100644
index b2f1cd7..0000000
--- a/crates/egui-dock/src/dock_state/tree/node.rs
+++ /dev/null
@@ -1,481 +0,0 @@
-use crate::{Split, TabIndex};
-use egui::Rect;
-
-/// Represents an abstract node of a [`Tree`](crate::Tree).
-#[derive(Clone, Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-pub enum Node<Tab> {
-    /// Empty node.
-    Empty,
-
-    /// Contains the actual tabs.
-    Leaf {
-        /// The full rectangle - tab bar plus tab body.
-        rect: Rect,
-
-        /// The tab body rectangle.
-        viewport: Rect,
-
-        /// All the tabs in this node.
-        tabs: Vec<Tab>,
-
-        /// The opened tab.
-        active: TabIndex,
-
-        /// Scroll amount of the tab bar.
-        scroll: f32,
-
-        /// Whether the leaf is collapsed.
-        collapsed: bool,
-    },
-
-    /// Parent node in the vertical orientation.
-    Vertical {
-        /// The rectangle in which all children of this node are drawn.
-        rect: Rect,
-
-        /// The fraction taken by the top child of this node.
-        fraction: f32,
-
-        /// Whether all subnodes are collapsed.
-        fully_collapsed: bool,
-
-        /// The number of collapsed leaf subnodes.
-        collapsed_leaf_count: i32,
-    },
-
-    /// Parent node in the horizontal orientation.
-    Horizontal {
-        /// The rectangle in which all children of this node are drawn.
-        rect: Rect,
-
-        /// The fraction taken by the left child of this node.
-        fraction: f32,
-
-        /// Whether all subnodes are collapsed.
-        fully_collapsed: bool,
-
-        /// The number of collapsed leaf subnodes.
-        collapsed_leaf_count: i32,
-    },
-}
-
-impl<Tab> Node<Tab> {
-    /// Constructs a leaf node with a given `tab`.
-    #[inline(always)]
-    pub fn leaf(tab: Tab) -> Self {
-        Self::Leaf {
-            rect: Rect::NOTHING,
-            viewport: Rect::NOTHING,
-            tabs: vec![tab],
-            active: TabIndex(0),
-            scroll: 0.0,
-            collapsed: false,
-        }
-    }
-
-    /// Constructs a leaf node with a given list of `tabs`.
-    #[inline(always)]
-    pub const fn leaf_with(tabs: Vec<Tab>) -> Self {
-        Self::Leaf {
-            rect: Rect::NOTHING,
-            viewport: Rect::NOTHING,
-            tabs,
-            active: TabIndex(0),
-            scroll: 0.0,
-            collapsed: false,
-        }
-    }
-
-    /// Sets the area occupied by the node.
-    #[inline]
-    pub fn set_rect(&mut self, new_rect: Rect) {
-        match self {
-            Self::Empty => (),
-            Self::Leaf { rect, .. }
-            | Self::Vertical { rect, .. }
-            | Self::Horizontal { rect, .. } => *rect = new_rect,
-        }
-    }
-
-    /// Get a [`Rect`] occupied by the node, could be used e.g. to draw a highlight rect around a node.
-    ///
-    /// Returns [`None`] if node is of the [`Empty`](Node::Empty) variant.
-    #[inline]
-    pub fn rect(&self) -> Option<Rect> {
-        match self {
-            Node::Empty => None,
-            Node::Leaf { rect, .. }
-            | Node::Vertical { rect, .. }
-            | Node::Horizontal { rect, .. } => Some(*rect),
-        }
-    }
-
-    /// Returns `true` if the node is a [`Empty`](Node::Empty), otherwise `false`.
-    #[inline(always)]
-    pub const fn is_empty(&self) -> bool {
-        matches!(self, Self::Empty)
-    }
-
-    /// Returns `true` if the node is a [`Leaf`](Node::Leaf), otherwise `false`.
-    #[inline(always)]
-    pub const fn is_leaf(&self) -> bool {
-        matches!(self, Self::Leaf { .. })
-    }
-
-    /// Returns `true` if the node is a [`Horizontal`](Node::Horizontal), otherwise `false`.
-    #[inline(always)]
-    pub const fn is_horizontal(&self) -> bool {
-        matches!(self, Self::Horizontal { .. })
-    }
-
-    /// Returns `true` if the node is a [`Vertical`](Node::Vertical), otherwise `false`.
-    #[inline(always)]
-    pub const fn is_vertical(&self) -> bool {
-        matches!(self, Self::Vertical { .. })
-    }
-
-    /// Returns `true` if the node is either [`Horizontal`](Node::Horizontal) or [`Vertical`](Node::Vertical),
-    /// otherwise `false`.
-    #[inline(always)]
-    pub const fn is_parent(&self) -> bool {
-        self.is_horizontal() || self.is_vertical()
-    }
-
-    /// Returns `true` if the node is collapsed, otherwise `false`.
-    #[inline(always)]
-    pub fn is_collapsed(&self) -> bool {
-        match self {
-            Node::Leaf { collapsed, .. } => *collapsed,
-            Node::Vertical {
-                fully_collapsed, ..
-            } => *fully_collapsed,
-            Node::Horizontal {
-                fully_collapsed, ..
-            } => *fully_collapsed,
-            Node::Empty => false,
-        }
-    }
-
-    /// Returns the number of layers of collapsed leaf subnodes.
-    pub fn collapsed_leaf_count(&self) -> i32 {
-        match self {
-            Node::Vertical {
-                collapsed_leaf_count,
-                ..
-            } => *collapsed_leaf_count,
-            Node::Horizontal {
-                collapsed_leaf_count,
-                ..
-            } => *collapsed_leaf_count,
-            Node::Leaf { collapsed, .. } => {
-                if *collapsed {
-                    1
-                } else {
-                    0
-                }
-            }
-            Node::Empty => 0,
-        }
-    }
-
-    /// Replaces the node with [`Horizontal`](Node::Horizontal) or [`Vertical`](Node::Vertical) (depending on `split`)
-    /// and assigns an empty rect to it.
-    ///
-    /// # Panics
-    ///
-    /// If `fraction` isn't in range 0..=1.
-    #[inline]
-    pub fn split(&mut self, split: Split, fraction: f32) -> Self {
-        assert!((0.0..=1.0).contains(&fraction));
-        let rect = Rect::NOTHING;
-        let src = match split {
-            Split::Left | Split::Right => Node::Horizontal {
-                fraction,
-                rect,
-                fully_collapsed: self.is_collapsed(),
-                collapsed_leaf_count: self.collapsed_leaf_count(),
-            },
-            Split::Above | Split::Below => Node::Vertical {
-                fraction,
-                rect,
-                fully_collapsed: self.is_collapsed(),
-                collapsed_leaf_count: self.collapsed_leaf_count(),
-            },
-        };
-        std::mem::replace(self, src)
-    }
-
-    /// Provides an immutable slice of the tabs inside this node.
-    ///
-    /// Returns [`None`] if the node is not a [`Leaf`](Node::Leaf).
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use egui_dock::{DockState, NodeIndex};
-    /// let mut dock_state = DockState::new(vec![1, 2, 3, 4, 5, 6]);
-    /// assert!(dock_state.main_surface().root_node().unwrap().tabs().unwrap().contains(&4));
-    /// ```
-    #[inline]
-    pub fn tabs(&self) -> Option<&[Tab]> {
-        match self {
-            Node::Leaf { tabs, .. } => Some(tabs),
-            _ => None,
-        }
-    }
-
-    /// Provides an mutable slice of the tabs inside this node.
-    ///
-    /// Returns [`None`] if the node is not a [`Leaf`](Node::Leaf).
-    ///
-    /// # Examples
-    ///
-    /// Modifying tabs inside a node:
-    /// ```rust
-    /// # use egui_dock::{DockState, NodeIndex};
-    /// let mut dock_state = DockState::new(vec![1, 2, 3, 4, 5, 6]);
-    /// let mut tabs = dock_state
-    ///     .main_surface_mut()
-    ///     .root_node_mut()
-    ///     .unwrap()
-    ///     .tabs_mut()
-    ///     .unwrap();
-    ///
-    /// tabs[0] = 7;
-    /// tabs[5] = 8;
-    ///
-    /// assert_eq!(&tabs, &[7, 2, 3, 4, 5, 8]);
-    /// ```
-    #[inline]
-    pub fn tabs_mut(&mut self) -> Option<&mut [Tab]> {
-        match self {
-            Node::Leaf { tabs, .. } => Some(tabs),
-            _ => None,
-        }
-    }
-
-    /// Returns an [`Iterator`] of tabs in this node.
-    ///
-    /// If this node is not a [`Leaf`](Self::Leaf), then the returned [`Iterator`] will be empty.
-    #[inline]
-    pub fn iter_tabs(&self) -> impl Iterator<Item = &Tab> {
-        match self.tabs() {
-            Some(tabs) => tabs.iter(),
-            None => core::slice::Iter::default(),
-        }
-    }
-
-    /// Returns a mutable [`Iterator`] of tabs in this node.
-    ///
-    /// If this node is not a [`Leaf`](Self::Leaf), then the returned [`Iterator`] will be empty.
-    #[inline]
-    pub fn iter_tabs_mut(&mut self) -> impl Iterator<Item = &mut Tab> {
-        match self.tabs_mut() {
-            Some(tabs) => tabs.iter_mut(),
-            None => core::slice::IterMut::default(),
-        }
-    }
-
-    /// Adds `tab` to the node and sets it as the active tab.
-    ///
-    /// # Panics
-    ///
-    /// If the new capacity of `tabs` exceeds `isize::MAX` bytes.
-    ///
-    /// If `self` is not a [`Leaf`](Node::Leaf) node.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use egui_dock::{DockState, NodeIndex};
-    /// let mut dock_state = DockState::new(vec!["a tab"]);
-    /// assert_eq!(dock_state.main_surface().root_node().unwrap().tabs_count(), 1);
-    ///
-    /// dock_state.main_surface_mut().root_node_mut().unwrap().append_tab("another tab");
-    /// assert_eq!(dock_state.main_surface().root_node().unwrap().tabs_count(), 2);
-    /// ```
-    #[track_caller]
-    #[inline]
-    pub fn append_tab(&mut self, tab: Tab) {
-        match self {
-            Node::Leaf { tabs, active, .. } => {
-                *active = TabIndex(tabs.len());
-                tabs.push(tab);
-            }
-            _ => panic!("node was not a leaf"),
-        }
-    }
-
-    /// Sets the collapsing state of the node.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `self` is an [`Empty`](Node::Empty) node.
-    #[inline]
-    pub fn set_collapsed(&mut self, collapsed: bool) {
-        match self {
-            Node::Leaf { collapsed: c, .. } => *c = collapsed,
-            Node::Vertical {
-                fully_collapsed, ..
-            } => *fully_collapsed = collapsed,
-            Node::Horizontal {
-                fully_collapsed, ..
-            } => *fully_collapsed = collapsed,
-            Node::Empty => panic!("node was empty"),
-        }
-    }
-
-    /// Sets the number of layers of collapsed leaf subnodes.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `self` is neither a [`Vertical`](Node::Vertical) nor a [`Horizontal`](Node::Horizontal) node.
-    #[inline]
-    pub fn set_collapsed_leaf_count(&mut self, count: i32) {
-        match self {
-            Node::Vertical {
-                collapsed_leaf_count,
-                ..
-            } => *collapsed_leaf_count = count,
-            Node::Horizontal {
-                collapsed_leaf_count,
-                ..
-            } => *collapsed_leaf_count = count,
-            _ => panic!("node was neither vertical nor horizontal"),
-        }
-    }
-
-    /// Adds a `tab` to the node.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the new capacity of `tabs` exceeds `isize::MAX` bytes, or `index > tabs_count()`.
-    #[track_caller]
-    #[inline]
-    pub fn insert_tab(&mut self, index: TabIndex, tab: Tab) {
-        match self {
-            Node::Leaf { tabs, active, .. } => {
-                tabs.insert(index.0, tab);
-                *active = index;
-            }
-            _ => unreachable!(),
-        }
-    }
-
-    /// Removes a tab at given `index` from the node.
-    /// Returns the removed tab if the node is a `Leaf`, or `None` otherwise.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `index` is out of bounds.
-    #[inline]
-    pub fn remove_tab(&mut self, tab_index: TabIndex) -> Option<Tab> {
-        match self {
-            Node::Leaf { tabs, active, .. } => {
-                if tab_index <= *active {
-                    active.0 = active.0.saturating_sub(1);
-                }
-
-                Some(tabs.remove(tab_index.0))
-            }
-            _ => None,
-        }
-    }
-
-    /// Gets the number of tabs in the node.
-    #[inline]
-    pub fn tabs_count(&self) -> usize {
-        match self {
-            Node::Leaf { tabs, .. } => tabs.len(),
-            _ => Default::default(),
-        }
-    }
-
-    /// Returns a new [`Node`] while mapping and filtering the tab type.
-    /// If this [`Node`] remains empty, it will change to [`Node::Empty`].
-    pub fn filter_map_tabs<F, NewTab>(&self, function: F) -> Node<NewTab>
-    where
-        F: FnMut(&Tab) -> Option<NewTab>,
-    {
-        match self {
-            Node::Leaf {
-                rect,
-                viewport,
-                tabs,
-                active,
-                scroll,
-                collapsed,
-            } => {
-                let tabs: Vec<_> = tabs.iter().filter_map(function).collect();
-                if tabs.is_empty() {
-                    Node::Empty
-                } else {
-                    Node::Leaf {
-                        rect: *rect,
-                        viewport: *viewport,
-                        tabs,
-                        active: *active,
-                        scroll: *scroll,
-                        collapsed: *collapsed,
-                    }
-                }
-            }
-            Node::Empty => Node::Empty,
-            Node::Vertical {
-                rect,
-                fraction,
-                fully_collapsed,
-                collapsed_leaf_count,
-            } => Node::Vertical {
-                rect: *rect,
-                fraction: *fraction,
-                fully_collapsed: *fully_collapsed,
-                collapsed_leaf_count: *collapsed_leaf_count,
-            },
-            Node::Horizontal {
-                rect,
-                fraction,
-                fully_collapsed,
-                collapsed_leaf_count,
-            } => Node::Horizontal {
-                rect: *rect,
-                fraction: *fraction,
-                fully_collapsed: *fully_collapsed,
-                collapsed_leaf_count: *collapsed_leaf_count,
-            },
-        }
-    }
-
-    /// Returns a new [`Node`] while mapping the tab type.
-    pub fn map_tabs<F, NewTab>(&self, mut function: F) -> Node<NewTab>
-    where
-        F: FnMut(&Tab) -> NewTab,
-    {
-        self.filter_map_tabs(move |tab| Some(function(tab)))
-    }
-
-    /// Returns a new [`Node`] while filtering the tab type.
-    /// If this [`Node`] remains empty, it will change to [`Node::Empty`].
-    pub fn filter_tabs<F>(&self, mut predicate: F) -> Node<Tab>
-    where
-        F: FnMut(&Tab) -> bool,
-        Tab: Clone,
-    {
-        self.filter_map_tabs(move |tab| predicate(tab).then(|| tab.clone()))
-    }
-
-    /// Removes all tabs for which `predicate` returns `false`.
-    /// If this [`Node`] remains empty, it will change to [`Node::Empty`].
-    pub fn retain_tabs<F>(&mut self, predicate: F)
-    where
-        F: FnMut(&mut Tab) -> bool,
-    {
-        if let Node::Leaf { tabs, .. } = self {
-            tabs.retain_mut(predicate);
-            if tabs.is_empty() {
-                *self = Node::Empty;
-            }
-        }
-    }
-}
diff --git a/crates/egui-dock/src/dock_state/tree/node_index.rs b/crates/egui-dock/src/dock_state/tree/node_index.rs
deleted file mode 100644
index acf0eab..0000000
--- a/crates/egui-dock/src/dock_state/tree/node_index.rs
+++ /dev/null
@@ -1,96 +0,0 @@
-use std::ops::Range;
-
-/// Wrapper around indices to the collection of nodes inside a [`Tree`](crate::Tree).
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-pub struct NodeIndex(pub usize);
-
-impl From<usize> for NodeIndex {
-    #[inline(always)]
-    fn from(index: usize) -> Self {
-        NodeIndex(index)
-    }
-}
-
-impl NodeIndex {
-    /// Returns the index of the root node.
-    ///
-    /// In the context of a [`Tree`](crate::Tree), this will be the node that contains all other nodes.
-    ///
-    /// # Examples
-    ///
-    /// Splitting the current tree in two.
-    /// ```rust
-    /// # use egui_dock::{DockState, NodeIndex};
-    /// let mut dock_state = DockState::new(vec!["tab 1", "tab 2"]);
-    /// let _ = dock_state.main_surface_mut().split_left(NodeIndex::root(), 0.5, vec!["tab 3", "tab 4"]);
-    /// ```
-    #[inline(always)]
-    pub const fn root() -> Self {
-        Self(0)
-    }
-
-    /// Returns the index of the node to the left of the current one.
-    #[inline(always)]
-    pub const fn left(self) -> Self {
-        Self(self.0 * 2 + 1)
-    }
-
-    /// Returns the index of the node to the right of the current one.
-    #[inline(always)]
-    pub const fn right(self) -> Self {
-        Self(self.0 * 2 + 2)
-    }
-
-    /// Returns the index of the parent node or `None` if current node is the root.
-    #[inline]
-    pub const fn parent(self) -> Option<Self> {
-        if self.0 > 0 {
-            Some(Self((self.0 - 1) / 2))
-        } else {
-            None
-        }
-    }
-
-    /// Returns the number of nodes leading from the root to the current node, including `self`.
-    #[inline(always)]
-    pub const fn level(self) -> usize {
-        (usize::BITS - (self.0 + 1).leading_zeros()) as usize
-    }
-
-    /// Returns `true` if current node is the left child of its parent, otherwise `false`.
-    #[inline(always)]
-    pub const fn is_left(self) -> bool {
-        self.0 % 2 != 0
-    }
-
-    /// Returns `true` if current node is the right child of its parent, otherwise `false`.
-    #[inline(always)]
-    pub const fn is_right(self) -> bool {
-        self.0 % 2 == 0
-    }
-
-    #[inline]
-    pub(super) const fn children_at(self, level: usize) -> Range<usize> {
-        let base = 1 << level;
-        let s = (self.0 + 1) * base - 1;
-        let e = (self.0 + 2) * base - 1;
-        s..e
-    }
-
-    #[inline]
-    pub(super) const fn children_left(self, level: usize) -> Range<usize> {
-        let base = 1 << level;
-        let s = (self.0 + 1) * base - 1;
-        let e = (self.0 + 1) * base + (base / 2) - 1;
-        s..e
-    }
-
-    #[inline]
-    pub(super) const fn children_right(self, level: usize) -> Range<usize> {
-        let base = 1 << level;
-        let s = (self.0 + 1) * base + (base / 2) - 1;
-        let e = (self.0 + 2) * base - 1;
-        s..e
-    }
-}
diff --git a/crates/egui-dock/src/dock_state/tree/tab_index.rs b/crates/egui-dock/src/dock_state/tree/tab_index.rs
deleted file mode 100644
index 14688f7..0000000
--- a/crates/egui-dock/src/dock_state/tree/tab_index.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-/// Identifies a tab within a [`Node`](crate::Node).
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Ord, PartialOrd)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-pub struct TabIndex(pub usize);
-
-impl From<usize> for TabIndex {
-    #[inline]
-    fn from(index: usize) -> Self {
-        TabIndex(index)
-    }
-}
diff --git a/crates/egui-dock/src/dock_state/tree/tab_iter.rs b/crates/egui-dock/src/dock_state/tree/tab_iter.rs
deleted file mode 100644
index d428837..0000000
--- a/crates/egui-dock/src/dock_state/tree/tab_iter.rs
+++ /dev/null
@@ -1,70 +0,0 @@
-use crate::Tree;
-
-/// Iterates over all tabs in a [`Tree`].
-pub struct TabIter<'a, Tab> {
-    tree: &'a Tree<Tab>,
-    node_idx: usize,
-    tab_idx: usize,
-}
-
-impl<'a, Tab> TabIter<'a, Tab> {
-    pub(super) fn new(tree: &'a Tree<Tab>) -> Self {
-        Self {
-            tree,
-            node_idx: 0,
-            tab_idx: 0,
-        }
-    }
-}
-
-impl<'a, Tab> Iterator for TabIter<'a, Tab> {
-    type Item = &'a Tab;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        loop {
-            match self.tree.nodes.get(self.node_idx)?.tabs() {
-                Some(tabs) => match tabs.get(self.tab_idx) {
-                    Some(tab) => {
-                        self.tab_idx += 1;
-                        return Some(tab);
-                    }
-                    None => {
-                        self.node_idx += 1;
-                        self.tab_idx = 0;
-                    }
-                },
-                None => {
-                    self.node_idx += 1;
-                    self.tab_idx = 0;
-                }
-            }
-        }
-    }
-}
-
-impl<Tab> std::fmt::Debug for TabIter<'_, Tab> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("TabIter").finish_non_exhaustive()
-    }
-}
-
-#[test]
-fn test_tabs_iter() {
-    fn tabs(tree: &Tree<i32>) -> Vec<i32> {
-        tree.tabs().copied().collect()
-    }
-
-    let mut tree = Tree::new(vec![1, 2, 3]);
-    assert_eq!(tabs(&tree), vec![1, 2, 3]);
-
-    tree.push_to_first_leaf(4);
-    assert_eq!(tabs(&tree), vec![1, 2, 3, 4]);
-
-    tree.push_to_first_leaf(5);
-    assert_eq!(tabs(&tree), vec![1, 2, 3, 4, 5]);
-
-    tree.push_to_focused_leaf(6);
-    assert_eq!(tabs(&tree), vec![1, 2, 3, 4, 5, 6]);
-
-    assert_eq!(tree.num_tabs(), tree.tabs().count());
-}
diff --git a/crates/egui-dock/src/dock_state/window_state.rs b/crates/egui-dock/src/dock_state/window_state.rs
deleted file mode 100644
index f036b17..0000000
--- a/crates/egui-dock/src/dock_state/window_state.rs
+++ /dev/null
@@ -1,139 +0,0 @@
-use egui::{Id, Pos2, Rect, Vec2};
-
-/// The state of a [`Surface::Window`](crate::Surface::Window).
-///
-/// Doubles as a handle for the surface, allowing the user to set its size and position.
-#[derive(Clone, Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-pub struct WindowState {
-    /// The [`Rect`] that this window was last taking up.
-    screen_rect: Option<Rect>,
-
-    /// Was this window dragged in the last frame?
-    dragged: bool,
-
-    /// The next position this window should be set to next frame.
-    next_position: Option<Pos2>,
-
-    /// The next size this window should be set to next frame.
-    next_size: Option<Vec2>,
-
-    /// The height of the window before it was fully collapsed
-    expanded_height: Option<f32>,
-
-    /// True the first frame this window is drawn.
-    /// handles expanding after being fully collapsed, etc.
-    new: bool,
-
-    /// True if the window is minimized
-    minimized: bool,
-}
-
-impl Default for WindowState {
-    fn default() -> Self {
-        Self {
-            screen_rect: None,
-            dragged: false,
-            next_position: None,
-            next_size: None,
-            expanded_height: None,
-            new: true,
-            minimized: false,
-        }
-    }
-}
-
-impl WindowState {
-    /// Create a default window state.
-    pub(crate) fn new() -> Self {
-        Self::default()
-    }
-
-    /// Set the position for this window in screen coordinates.
-    pub fn set_position(&mut self, position: Pos2) -> &mut Self {
-        self.next_position = Some(position);
-        self
-    }
-
-    /// Set the size of this window in egui points.
-    pub fn set_size(&mut self, size: Vec2) -> &mut Self {
-        self.next_size = Some(size);
-        self
-    }
-
-    /// Get the [`Rect`] which this window occupies.
-    /// If this window hasn't been shown before, this will be [`Rect::NOTHING`].
-    pub fn rect(&self) -> Rect {
-        // The reason why we're unwrapping an Option with a default value instead of
-        // just storing Rect::NOTHING for the None variant is that deserializing Rect::NOTHING
-        // with serde_json causes a panic, because f32::INFINITY serializes into null in JSON.
-        self.screen_rect.unwrap_or(Rect::NOTHING)
-    }
-
-    /// Returns if this window is currently being dragged or not.
-    pub fn dragged(&self) -> bool {
-        self.dragged
-    }
-
-    /// Set the height of this window when it is expanded.
-    #[inline(always)]
-    pub(crate) fn set_expanded_height(&mut self, height: f32) -> &mut Self {
-        self.expanded_height = Some(height);
-        self
-    }
-
-    #[inline(always)]
-    pub(crate) fn set_new(&mut self, new: bool) -> &mut Self {
-        self.new = new;
-        self
-    }
-
-    #[inline(always)]
-    pub(crate) fn next_position(&mut self) -> Option<Pos2> {
-        self.next_position.take()
-    }
-
-    #[inline(always)]
-    pub(crate) fn next_size(&mut self) -> Option<Vec2> {
-        self.next_size.take()
-    }
-
-    #[inline(always)]
-    pub(crate) fn expanded_height(&mut self) -> Option<f32> {
-        self.expanded_height.take()
-    }
-
-    #[inline(always)]
-    pub(crate) fn toggle_minimized(&mut self) {
-        self.minimized = !self.minimized;
-    }
-
-    #[inline(always)]
-    pub(crate) fn is_minimized(&self) -> bool {
-        self.minimized
-    }
-
-    //the 'static in this case means that the `open` field is always `None`
-    pub(crate) fn create_window(&mut self, id: Id, bounds: Rect) -> egui::Window<'static> {
-        let new = self.new;
-        let mut window_constructor = egui::Window::new("")
-            .id(id)
-            .constrain_to(bounds)
-            .title_bar(false);
-
-        if let Some(position) = self.next_position() {
-            window_constructor = window_constructor.current_pos(position);
-        }
-        if let Some(size) = self.next_size() {
-            window_constructor = window_constructor.fixed_size(size);
-        }
-        // Reset the height of the window if it is now expanded
-        if new {
-            if let Some(height) = self.expanded_height() {
-                window_constructor = window_constructor.max_height(height).min_height(height);
-            }
-        }
-        self.new = false;
-        window_constructor
-    }
-}
diff --git a/crates/egui-dock/src/lib.rs b/crates/egui-dock/src/lib.rs
deleted file mode 100644
index 9806a0a..0000000
--- a/crates/egui-dock/src/lib.rs
+++ /dev/null
@@ -1,253 +0,0 @@
-//! # `egui_dock`: docking support for `egui`
-//!
-//! Originally created by [@lain-dono](https://github.com/lain-dono), this library provides docking support for `egui`.
-//! It lets you open and close tabs, freely move them around, resize them, and undock them into new egui windows which
-//! can also have other tabs docked in them.
-//!
-//! ## Basic usage
-//!
-//! The library is centered around the [`DockState`].
-//! It contains a series of [`Surface`]s which all have their own [`Tree`].
-//! Each [`Tree`] stores a hierarchy of [`Node`]s which contain the splits and tabs.
-//!
-//! [`DockState`] is generic (`DockState<Tab>`) so you can use any data to represent a tab.
-//! You show the tabs using [`DockArea`] and specify how they are shown by implementing [`TabViewer`].
-//!
-//! ```rust
-//! use egui_dock::{DockArea, DockState, NodeIndex, Style, TabViewer};
-//! use egui::{Ui, WidgetText};
-//!
-//! // First, let's pick a type that we'll use to attach some data to each tab.
-//! // It can be any type.
-//! type Tab = String;
-//!
-//! // To define the contents and properties of individual tabs, we implement the `TabViewer`
-//! // trait. Only three things are mandatory: the `Tab` associated type, and the `ui` and
-//! // `title` methods. There are more methods in `TabViewer` which you can also override.
-//! struct MyTabViewer;
-//!
-//! impl TabViewer for MyTabViewer {
-//!     // This associated type is used to attach some data to each tab.
-//!     type Tab = Tab;
-//!
-//!     // Returns the current `tab`'s title.
-//!     fn title(&mut self, tab: &mut Self::Tab) -> WidgetText {
-//!         tab.as_str().into()
-//!     }
-//!
-//!     // Defines the contents of a given `tab`.
-//!     fn ui(&mut self, ui: &mut Ui, tab: &mut Self::Tab) {
-//!         ui.label(format!("Content of {tab}"));
-//!     }
-//! }
-//!
-//! // Here is a simple example of how you can manage a `DockState` of your application.
-//! struct MyTabs {
-//!     dock_state: DockState<Tab>
-//! }
-//!
-//! impl MyTabs {
-//!     pub fn new() -> Self {
-//!         // Create a `DockState` with an initial tab "tab1" in the main `Surface`'s root node.
-//!         let tabs = ["tab1", "tab2", "tab3"].map(str::to_string).into_iter().collect();
-//!         let dock_state = DockState::new(tabs);
-//!         Self { dock_state }
-//!     }
-//!
-//!     fn ui(&mut self, ui: &mut Ui) {
-//!         // Here we just display the `DockState` using a `DockArea`.
-//!         // This is where egui handles rendering and all the integrations.
-//!         //
-//!         // We can specify a custom `Style` for the `DockArea`, or just inherit
-//!         // all of it from egui.
-//!         DockArea::new(&mut self.dock_state)
-//!             .style(Style::from_egui(ui.style().as_ref()))
-//!             .show_inside(ui, &mut MyTabViewer);
-//!     }
-//! }
-//!
-//! # let mut my_tabs = MyTabs::new();
-//! # egui::__run_test_ctx(|ctx| {
-//! #     egui::CentralPanel::default().show(ctx, |ui| my_tabs.ui(ui));
-//! # });
-//! ```
-//!
-//! ## Look and feel customization
-//!
-//! `egui_dock` exposes the [`Style`] struct that lets you change how tabs and the [`DockArea`]
-//! should look and feel. [`Style`] is divided into several, more specialized structs that handle
-//! individual elements of the UI.
-//!
-//! Your [`Style`] can inherit all its properties from an [`egui::Style`] through the
-//! [`Style::from_egui`] function.
-//!
-//! Example:
-//!
-//! ```rust
-//! # use egui_dock::{DockArea, DockState, OverlayType, Style, TabAddAlign, TabViewer};
-//! # use egui::{Ui, WidgetText};
-//! # struct MyTabViewer;
-//! # impl TabViewer for MyTabViewer {
-//! #     type Tab = ();
-//! #     fn title(&mut self, tab: &mut Self::Tab) -> WidgetText { WidgetText::default() }
-//! #     fn ui(&mut self, ui: &mut Ui, tab: &mut Self::Tab) {}
-//! # }
-//! # egui::__run_test_ctx(|ctx| {
-//! # egui::CentralPanel::default().show(ctx, |ui| {
-//! # let mut dock_state = DockState::new(vec![]);
-//! // Inherit the look and feel from egui.
-//! let mut style = Style::from_egui(ui.style());
-//!
-//! // Modify a few fields.
-//! style.overlay.overlay_type = OverlayType::HighlightedAreas;
-//! style.buttons.add_tab_align = TabAddAlign::Left;
-//!
-//! // Use the style with the `DockArea`.
-//! DockArea::new(&mut dock_state)
-//!     .style(style)
-//!     .show_inside(ui, &mut MyTabViewer);
-//! # });
-//! # });
-//! #
-//! ```
-//!
-//! ## Surfaces
-//!
-//! A [`Surface`] is an abstraction for any tab hierarchy. There are two kinds of
-//! non-empty surfaces: `Main` and `Window`.
-//!
-//! There can only be one `Main` surface. It's the one surface that is rendered inside the
-//! [`Ui`](egui::Ui) you've passed to [`DockArea::show_inside`], or inside the
-//! [`egui::CentralPanel`] created by [`DockArea::show`].
-//!
-//! On the other hand, there can be multiple `Window` surfaces. Those represent surfaces that were
-//! created by undocking tabs from the `Main` surface, and each of them is rendered inside
-//! a [`egui::Window`] - hence their name.
-//!
-//! While most of surface management will be done by the user of your application, you can also do it
-//! programatically using the [`DockState`] API.
-//!
-//! Example:
-//!
-//! ```rust
-//! # use egui_dock::DockState;
-//! # use egui::{Pos2, Vec2};
-//! # let mut dock_state = DockState::new(vec![]);
-//! // Create a new window `Surface` with one tab inside it.
-//! let mut surface_index = dock_state.add_window(vec!["Window Tab".to_string()]);
-//!
-//! // Access the window state by its surface index and then move and resize it.
-//! let window_state = dock_state.get_window_state_mut(surface_index).unwrap();
-//! window_state.set_position(Pos2::ZERO);
-//! window_state.set_size(Vec2::splat(100.0));
-//! ```
-//!
-//! For more details, see: [`DockState`].
-//!
-//! ## Trees
-//!
-//! In each [`Surface`] there is a [`Tree`] which actually stores the tabs. As the name suggests,
-//! tabs and splits are represented with a binary tree.
-//!
-//! The [`Tree`] API allows you to programatically manipulate the dock layout.
-//!
-//! Example:
-//!
-//! ```rust
-//! # use egui_dock::{DockState, NodeIndex};
-//! // Create a `DockState` with an initial tab "tab1" in the main `Surface`'s root node.
-//! let mut dock_state = DockState::new(vec!["tab1".to_string()]);
-//!
-//! // Currently, the `DockState` only has one `Surface`: the main one.
-//! // Let's get mutable access to add more nodes in it.
-//! let surface = dock_state.main_surface_mut();
-//!
-//! // Insert "tab2" to the left of "tab1", where the width of "tab2"
-//! // is 20% of root node's width.
-//! let [_old_node, new_node] =
-//!     surface.split_left(NodeIndex::root(), 0.20, vec!["tab2".to_string()]);
-//!
-//! // Insert "tab3" below "tab2" with both tabs having equal size.
-//! surface.split_below(new_node, 0.5, vec!["tab3".to_string()]);
-//!
-//! // The layout will look similar to this:
-//! // +--------+--------------------------------+
-//! // |        |                                |
-//! // |  tab2  |                                |
-//! // |        |                                |
-//! // +--------+              tab1              |
-//! // |        |                                |
-//! // |  tab3  |                                |
-//! // |        |                                |
-//! // +--------+--------------------------------+
-//! ```
-//!
-//! ## Translations
-//!
-//! Some parts of the [`DockArea`] contain text that has nothing to do with tab content (currently it's just the
-//! tab context menus, but that might change in the future). The [`translations`] module provides an API for defining
-//! an alternative for each text element. This is especially useful when your application's interface is in any
-//! language other than English, but can also be used in any other way, e.g. to add icons.
-//!
-//! Example usage:
-//!
-//! ```rust
-//! # use egui_dock::{DockState, TabContextMenuTranslations, Translations, LeafTranslations};
-//! # type Tab = ();
-//! let translations_pl = Translations {
-//!     tab_context_menu: TabContextMenuTranslations {
-//!         close_button: "Zamknij zakładkę".to_string(),
-//!         eject_button: "Przenieś zakładkę do nowego okna".to_string(),
-//!     },
-//!     leaf: LeafTranslations {
-//!         close_button_disabled_tooltip: "Ten węzeł zawiera niezamykalne zakładki.".to_string(),
-//!         close_all_button: "Zamknij okno".to_string(),
-//!         close_all_button_menu_hint: "Kliknij prawym przyciskiem myszy, aby zamknąć to okno.".to_string(),
-//!         close_all_button_modifier_hint: "Naciśnij klawisze modyfikujące (domyślnie Shift), aby zamknąć to okno.".to_string(),
-//!         close_all_button_modifier_menu_hint: "Naciśnij klawisze modyfikujące (domyślnie Shift) lub kliknij prawym przyciskiem myszy, aby zamknąć to okno.".to_string(),
-//!         close_all_button_disabled_tooltip: "To okno zawiera zakładki, których nie można zamknąć.".to_string(),
-//!         minimize_button: "Zminimalizuj okno".to_string(),
-//!         minimize_button_menu_hint: "Kliknij prawym przyciskiem myszy, aby zminimalizować to okno.".to_string(),
-//!         minimize_button_modifier_hint: "Naciśnij klawisze modyfikujące (domyślnie Shift), aby zminimalizować to okno.".to_string(),
-//!         minimize_button_modifier_menu_hint: "Naciśnij klawisze modyfikujące (domyślnie Shift) lub kliknij prawym przyciskiem myszy, aby zminimalizować to okno.".to_string(),
-//!     }
-//! };
-//! let dock_state = DockState::<Tab>::new(vec![]).with_translations(translations_pl);
-//!
-//! // Alternatively:
-//! let mut dock_state = DockState::<Tab>::new(vec![]);
-//! dock_state.translations.tab_context_menu.close_button = "タブを閉じる".to_string();
-//! dock_state.translations.tab_context_menu.eject_button = "タブを新しいウィンドウへ移動".to_string();
-//! dock_state.translations.leaf.close_button_disabled_tooltip = "このノードは閉じられないタブがある".to_string();
-//! dock_state.translations.leaf.close_all_button = "ウィンドウを閉じる".to_string();
-//! dock_state.translations.leaf.close_all_button_menu_hint = "右クリックでこのウィンドウを閉じる".to_string();
-//! dock_state.translations.leaf.close_all_button_modifier_hint = "修飾キー（デフォルトではShift）を押して、このウィンドウを閉じます".to_string();
-//! dock_state.translations.leaf.close_all_button_modifier_menu_hint = "修飾キー（デフォルトではShift）を押すか、右クリックしてこのウィンドウを閉じます".to_string();
-//! dock_state.translations.leaf.close_all_button_disabled_tooltip = "このウィンドウは閉じられないタブがある".to_string();
-//! dock_state.translations.leaf.minimize_button = "ウィンドウを最小化する".to_string();
-//! dock_state.translations.leaf.minimize_button_menu_hint = "右クリックでウィンドウを最小化する".to_string();
-//! dock_state.translations.leaf.minimize_button_modifier_hint = "修飾キー（デフォルトではShift）を押すと、このウィンドウが最小化されます".to_string();
-//! dock_state.translations.leaf.minimize_button_modifier_menu_hint = "修飾キー（デフォルトではShift）を押すか、右クリックしてこのウィンドウを最小化する".to_string();
-//! ```
-
-#![warn(missing_docs)]
-#![forbid(unsafe_code)]
-
-#[allow(deprecated)]
-pub use dock_state::*;
-pub use egui;
-pub use style::*;
-pub use translations::*;
-pub use tree::*;
-pub use widgets::*;
-
-/// The main structure of the library.
-pub mod dock_state;
-
-/// Look and feel.
-pub mod style;
-
-/// Widgets provided by the library.
-pub mod widgets;
-
-mod utils;
diff --git a/crates/egui-dock/src/style.rs b/crates/egui-dock/src/style.rs
deleted file mode 100644
index 6bcc087..0000000
--- a/crates/egui-dock/src/style.rs
+++ /dev/null
@@ -1,810 +0,0 @@
-use egui::{ecolor::*, CornerRadius, Margin, Stroke};
-
-/// Left or right alignment for tab add button.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-#[allow(missing_docs)]
-pub enum TabAddAlign {
-    Left,
-    Right,
-}
-
-/// Lets you change how tabs and the [`DockArea`](crate::DockArea) should look and feel.
-/// [`Style`] is divided into several, more specialized structs that handle individual
-/// elements of the UI.
-///
-/// Your [`Style`] can inherit all its properties from an [`egui::Style`] through the
-/// [`Style::from_egui`] function.
-///
-/// Example:
-///
-/// ```rust
-/// # use egui_dock::{DockArea, DockState, OverlayType, Style, TabAddAlign, TabViewer};
-/// # use egui::{Ui, WidgetText};
-/// # struct MyTabViewer;
-/// # impl TabViewer for MyTabViewer {
-/// #     type Tab = ();
-/// #     fn title(&mut self, tab: &mut Self::Tab) -> WidgetText { WidgetText::default() }
-/// #     fn ui(&mut self, ui: &mut Ui, tab: &mut Self::Tab) {}
-/// # }
-/// # egui::__run_test_ctx(|ctx| {
-/// # egui::CentralPanel::default().show(ctx, |ui| {
-/// # let mut dock_state = DockState::new(vec![]);
-/// // Inherit the look and feel from egui.
-/// let mut style = Style::from_egui(ui.style());
-///
-/// // Modify a few fields.
-/// style.overlay.overlay_type = OverlayType::HighlightedAreas;
-/// style.buttons.add_tab_align = TabAddAlign::Left;
-///
-/// // Use the style with the `DockArea`.
-/// DockArea::new(&mut dock_state)
-///     .style(style)
-///     .show_inside(ui, &mut MyTabViewer);
-/// # });
-/// # });
-/// #
-/// ```
-#[derive(Clone, Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-#[allow(missing_docs)]
-pub struct Style {
-    /// Sets padding to indent from the edges of the window. By `Default` it's `None`.
-    pub dock_area_padding: Option<Margin>,
-
-    pub main_surface_border_stroke: Stroke,
-    pub main_surface_border_rounding: CornerRadius,
-
-    pub buttons: ButtonsStyle,
-    pub separator: SeparatorStyle,
-    pub tab_bar: TabBarStyle,
-    pub tab: TabStyle,
-    pub overlay: OverlayStyle,
-}
-
-/// Specifies the look and feel of buttons.
-#[derive(Clone, Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-pub struct ButtonsStyle {
-    /// Color of the close tab button.
-    pub close_tab_color: Color32,
-
-    /// Color of the active close tab button.
-    pub close_tab_active_color: Color32,
-
-    /// Color of the background close tab button.
-    pub close_tab_bg_fill: Color32,
-
-    /// Left or right aligning of the add tab button.
-    pub add_tab_align: TabAddAlign,
-
-    /// Color of the add tab button.
-    pub add_tab_color: Color32,
-
-    /// Color of the active add tab button.
-    pub add_tab_active_color: Color32,
-
-    /// Color of the add tab button's background.
-    pub add_tab_bg_fill: Color32,
-
-    /// Color of the add tab button's left border.
-    pub add_tab_border_color: Color32,
-
-    /// Color of the close all tabs button.
-    pub close_all_tabs_color: Color32,
-
-    /// Color of the active close all tabs button.
-    pub close_all_tabs_active_color: Color32,
-
-    /// Color of the close all tabs button's background.
-    pub close_all_tabs_bg_fill: Color32,
-
-    /// Color of the close all tabs button's left border.
-    pub close_all_tabs_border_color: Color32,
-
-    /// Color of disabled close all tabs button.
-    pub close_all_tabs_disabled_color: Color32,
-
-    /// Color of the collapse tabs button.
-    pub collapse_tabs_color: Color32,
-
-    /// Color of the active collapse tabs button.
-    pub collapse_tabs_active_color: Color32,
-
-    /// Color of the collapse tabs button's background.
-    pub collapse_tabs_bg_fill: Color32,
-
-    /// Color of the collapse tabs button's left border.
-    pub collapse_tabs_border_color: Color32,
-
-    /// Color of the minimize window button.
-    pub minimize_window_color: Color32,
-
-    /// Color of the active minimize window button.
-    pub minimize_window_active_color: Color32,
-
-    /// Color of the minimize window button's background.
-    pub minimize_window_bg_fill: Color32,
-
-    /// Color of the minimize window button's left border.
-    pub minimize_window_border_color: Color32,
-}
-
-/// Specifies the look and feel of node separators.
-#[derive(Clone, Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-pub struct SeparatorStyle {
-    /// Width of the rectangle separator between nodes. By `Default` it's `1.0`.
-    pub width: f32,
-
-    /// Extra width added to the "logical thickness" of the rectangle so it's
-    /// easier to grab. By `Default` it's `4.0`.
-    pub extra_interact_width: f32,
-
-    /// Limit for the allowed area for the separator offset. By `Default` it's `175.0`.
-    /// `bigger value > less allowed offset` for the current window size.
-    pub extra: f32,
-
-    /// Idle color of the rectangle separator. By `Default` it's [`Color32::BLACK`].
-    pub color_idle: Color32,
-
-    /// Hovered color of the rectangle separator. By `Default` it's [`Color32::GRAY`].
-    pub color_hovered: Color32,
-
-    /// Dragged color of the rectangle separator. By `Default` it's [`Color32::WHITE`].
-    pub color_dragged: Color32,
-}
-
-/// Specifies the look and feel of tab bars.
-#[derive(Clone, Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-pub struct TabBarStyle {
-    /// Background color of tab bar. By `Default` it's [`Color32::WHITE`].
-    pub bg_fill: Color32,
-
-    /// Height of the tab bar. By `Default` it's `24.0`.
-    pub height: f32,
-
-    /// Show a scroll bar when tab bar overflows. By `Default` it's `true`.
-    pub show_scroll_bar_on_overflow: bool,
-
-    /// Tab rounding. By `Default` it's [`Rounding::default`].
-    pub rounding: CornerRadius,
-
-    /// Color of the line separating the tab name area from the tab content area.
-    /// By `Default` it's [`Color32::BLACK`].
-    pub hline_color: Color32,
-
-    /// Whether tab titles expand to fill the width of their tab bars.
-    /// By `Default` it's `false`.
-    pub fill_tab_bar: bool,
-}
-
-/// Specifies the look and feel of an individual tab.
-#[derive(Clone, Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-pub struct TabStyle {
-    /// Style of the tab when it is active.
-    pub active: TabInteractionStyle,
-
-    /// Style of the tab when it is inactive.
-    pub inactive: TabInteractionStyle,
-
-    /// Style of the tab when it is focused.
-    pub focused: TabInteractionStyle,
-
-    /// Style of the tab when it is hovered.
-    pub hovered: TabInteractionStyle,
-
-    /// Style of the tab when it is inactive and has keyboard focus.
-    pub inactive_with_kb_focus: TabInteractionStyle,
-
-    /// Style of the tab when it is active and has keyboard focus.
-    pub active_with_kb_focus: TabInteractionStyle,
-
-    /// Style of the tab when it is focused and has keyboard focus.
-    pub focused_with_kb_focus: TabInteractionStyle,
-
-    /// Style for the tab body.
-    pub tab_body: TabBodyStyle,
-
-    /// If `true`, show the hline below the active tabs name.
-    /// If `false`, show the active tab as merged with the tab ui area.
-    /// By `Default` it's `false`.
-    pub hline_below_active_tab_name: bool,
-
-    /// The minimum width of the tab.
-    ///
-    /// The tab title or [`TabBarStyle::fill_tab_bar`] may make the tab
-    /// wider than this but never shorter.
-    pub minimum_width: Option<f32>,
-}
-
-/// Specifies the look and feel of individual tabs while they are being interacted with.
-#[derive(Clone, Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-pub struct TabInteractionStyle {
-    /// Color of the outline around tabs. By `Default` it's [`Color32::BLACK`].
-    pub outline_color: Color32,
-
-    /// Tab rounding. By `Default` it's [`Rounding::default`].
-    pub rounding: CornerRadius,
-
-    /// Colour of the tab's background. By `Default` it's [`Color32::WHITE`].
-    pub bg_fill: Color32,
-
-    /// Color of the title text.
-    pub text_color: Color32,
-}
-
-/// Specifies the look and feel of the tab body.
-#[derive(Clone, Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-pub struct TabBodyStyle {
-    /// Inner margin of tab body. By `Default` it's `Margin::same(4.0)`.
-    pub inner_margin: Margin,
-
-    /// The stroke of the tabs border. By `Default` it's ['Stroke::default'].
-    pub stroke: Stroke,
-
-    /// Tab rounding. By `Default` it's [`Rounding::default`].
-    pub rounding: CornerRadius,
-
-    /// Colour of the tab's background. By `Default` it's [`Color32::WHITE`].
-    pub bg_fill: Color32,
-}
-
-/// Specifies the look and feel of the tab drop overlay.
-#[derive(Clone, Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-pub struct OverlayStyle {
-    /// Sets selection color for the placing area of the tab where this tab targeted on it.
-    /// By `Default` it's `(0, 191, 255)` (light blue) with `0.5` capacity.
-    pub selection_color: Color32,
-
-    /// Width of stroke when a selection uses an outline instead of filled rectangle.
-    pub selection_stroke_width: f32,
-
-    /// Units of padding between each button.
-    pub button_spacing: f32,
-
-    /// Max side length of a button on the overlay.
-    pub max_button_size: f32,
-
-    /// Style of the additional highlighting rectangle drawn on the surface which you're attempting to drop a tab in.
-    ///
-    /// By default this value shows no highlighting.
-    pub hovered_leaf_highlight: LeafHighlighting,
-
-    /// Opacity which surfaces will fade to in a range of `0.0..=1.0`.
-    pub surface_fade_opacity: f32,
-
-    /// The color of the overlay buttons.
-    pub button_color: Color32,
-
-    /// The stroke of the button border.
-    pub button_border_stroke: Stroke,
-
-    /// The type of overlay used.
-    pub overlay_type: OverlayType,
-
-    /// The feel of the overlay, timings, detection, etc.
-    pub feel: OverlayFeel,
-}
-
-/// Specifies the feel of the tab drop overlay, i.e anything non visual about the overlay.
-#[derive(Clone, Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-pub struct OverlayFeel {
-    /// range is `0.0..=1.0`.
-    pub window_drop_coverage: f32,
-
-    /// range is `0.0..=1.0`.
-    pub center_drop_coverage: f32,
-
-    /// The amount of time windows should stay faded despite not needing to, prevents quick mouse movements from causing flashing.
-    pub fade_hold_time: f32,
-
-    /// Amount of time the overlay waits before dropping a preference it may have for a node.
-    pub max_preference_time: f32,
-
-    /// Units which the buttons interact area will be expanded by.
-    pub interact_expansion: f32,
-}
-
-/// Specifies the type of overlay used.
-#[derive(Copy, Clone, Debug, PartialEq)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-pub enum OverlayType {
-    /// Shows highlighted areas predicting where a dropped tab would land were it to be dropped this frame.
-    ///
-    /// Always used when hovering over tabs and tab head.
-    HighlightedAreas,
-
-    /// Shows icons indicating the possible drop positions which the user may hover over to drop a tab at that given location.
-    ///
-    /// This is the default type of overlay for leaves.
-    Widgets,
-}
-
-/// Highlighting on the currently hovered leaf.
-#[derive(Clone, Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
-pub struct LeafHighlighting {
-    /// Fill color.
-    pub color: Color32,
-
-    /// Rounding of the resulting rectangle.
-    pub rounding: CornerRadius,
-
-    /// Stroke.
-    pub stroke: Stroke,
-
-    /// Amount of egui units which each side should expand.
-    pub expansion: f32,
-}
-
-impl Default for Style {
-    fn default() -> Self {
-        Self {
-            dock_area_padding: None,
-            main_surface_border_stroke: Stroke::new(f32::default(), Color32::BLACK),
-            main_surface_border_rounding: CornerRadius::default(),
-            buttons: ButtonsStyle::default(),
-            separator: SeparatorStyle::default(),
-            tab_bar: TabBarStyle::default(),
-            tab: TabStyle::default(),
-            overlay: OverlayStyle::default(),
-        }
-    }
-}
-
-impl Default for ButtonsStyle {
-    fn default() -> Self {
-        Self {
-            close_tab_color: Color32::WHITE,
-            close_tab_active_color: Color32::WHITE,
-            close_tab_bg_fill: Color32::GRAY,
-
-            add_tab_align: TabAddAlign::Right,
-            add_tab_color: Color32::WHITE,
-            add_tab_active_color: Color32::WHITE,
-            add_tab_bg_fill: Color32::GRAY,
-            add_tab_border_color: Color32::BLACK,
-
-            close_all_tabs_color: Color32::WHITE,
-            close_all_tabs_active_color: Color32::WHITE,
-            close_all_tabs_bg_fill: Color32::GRAY,
-            close_all_tabs_border_color: Color32::BLACK,
-            close_all_tabs_disabled_color: Color32::LIGHT_GRAY,
-
-            collapse_tabs_color: Color32::WHITE,
-            collapse_tabs_active_color: Color32::WHITE,
-            collapse_tabs_bg_fill: Color32::GRAY,
-            collapse_tabs_border_color: Color32::BLACK,
-
-            minimize_window_color: Color32::WHITE,
-            minimize_window_active_color: Color32::WHITE,
-            minimize_window_bg_fill: Color32::GRAY,
-            minimize_window_border_color: Color32::BLACK,
-        }
-    }
-}
-
-impl Default for SeparatorStyle {
-    fn default() -> Self {
-        Self {
-            width: 1.0,
-            extra_interact_width: 2.0,
-            extra: 175.0,
-            color_idle: Color32::BLACK,
-            color_hovered: Color32::GRAY,
-            color_dragged: Color32::WHITE,
-        }
-    }
-}
-
-impl Default for TabBarStyle {
-    fn default() -> Self {
-        Self {
-            bg_fill: Color32::WHITE,
-            height: 24.0,
-            show_scroll_bar_on_overflow: true,
-            rounding: CornerRadius::default(),
-            hline_color: Color32::BLACK,
-            fill_tab_bar: false,
-        }
-    }
-}
-
-impl Default for TabStyle {
-    fn default() -> Self {
-        Self {
-            active: TabInteractionStyle::default(),
-            inactive: TabInteractionStyle {
-                text_color: Color32::DARK_GRAY,
-                ..Default::default()
-            },
-            focused: TabInteractionStyle {
-                text_color: Color32::BLACK,
-                ..Default::default()
-            },
-            hovered: TabInteractionStyle {
-                text_color: Color32::BLACK,
-                ..Default::default()
-            },
-            active_with_kb_focus: TabInteractionStyle::default(),
-            inactive_with_kb_focus: TabInteractionStyle {
-                text_color: Color32::DARK_GRAY,
-                ..Default::default()
-            },
-            focused_with_kb_focus: TabInteractionStyle {
-                text_color: Color32::BLACK,
-                ..Default::default()
-            },
-            tab_body: TabBodyStyle::default(),
-            hline_below_active_tab_name: false,
-            minimum_width: None,
-        }
-    }
-}
-
-impl Default for TabInteractionStyle {
-    fn default() -> Self {
-        Self {
-            bg_fill: Color32::WHITE,
-            outline_color: Color32::BLACK,
-            rounding: CornerRadius::default(),
-            text_color: Color32::DARK_GRAY,
-        }
-    }
-}
-
-impl Default for TabBodyStyle {
-    fn default() -> Self {
-        Self {
-            inner_margin: Margin::same(4),
-            stroke: Stroke::default(),
-            rounding: CornerRadius::default(),
-            bg_fill: Color32::WHITE,
-        }
-    }
-}
-
-impl Default for OverlayStyle {
-    fn default() -> Self {
-        Self {
-            selection_color: Color32::from_rgb(0, 191, 255).linear_multiply(0.5),
-            selection_stroke_width: 1.0,
-            button_spacing: 10.0,
-            max_button_size: 100.0,
-
-            surface_fade_opacity: 0.1,
-
-            hovered_leaf_highlight: Default::default(),
-            button_color: Color32::from_gray(140),
-            button_border_stroke: Stroke::new(1.0, Color32::from_gray(60)),
-            overlay_type: OverlayType::Widgets,
-            feel: Default::default(),
-        }
-    }
-}
-
-impl Default for OverlayFeel {
-    fn default() -> Self {
-        Self {
-            max_preference_time: 0.3,
-            window_drop_coverage: 0.5,
-            center_drop_coverage: 0.25,
-            fade_hold_time: 0.2,
-            interact_expansion: 20.0,
-        }
-    }
-}
-
-impl Default for LeafHighlighting {
-    fn default() -> Self {
-        Self {
-            color: Color32::TRANSPARENT,
-            rounding: CornerRadius::same(0),
-            stroke: Stroke::NONE,
-            expansion: 0.0,
-        }
-    }
-}
-
-impl Style {
-    pub(crate) const TAB_ADD_BUTTON_SIZE: f32 = 24.0;
-    pub(crate) const TAB_ADD_PLUS_SIZE: f32 = 12.0;
-    pub(crate) const TAB_CLOSE_BUTTON_SIZE: f32 = 24.0;
-    pub(crate) const TAB_CLOSE_X_SIZE: f32 = 9.0;
-    pub(crate) const TAB_CLOSE_ALL_BUTTON_SIZE: f32 = 24.0;
-    pub(crate) const TAB_CLOSE_ALL_SIZE: f32 = 10.0;
-    pub(crate) const TAB_COLLAPSE_BUTTON_SIZE: f32 = 24.0;
-    pub(crate) const TAB_COLLAPSE_ARROW_SIZE: f32 = 10.0;
-    pub(crate) const TAB_EXPAND_BUTTON_SIZE: f32 = 24.0;
-    pub(crate) const TAB_EXPAND_ARROW_SIZE: f32 = 10.0;
-}
-
-impl Style {
-    /// Derives relevant fields from `egui::Style` and sets the remaining fields to their default values.
-    ///
-    /// Fields overwritten by [`egui::Style`] are:
-    /// - [`Style::main_surface_border_stroke`]
-    ///
-    /// See also: [`ButtonsStyle::from_egui`], [`SeparatorStyle::from_egui`], [`TabBarStyle::from_egui`],
-    /// [`TabStyle::from_egui`]
-    pub fn from_egui(style: &egui::Style) -> Self {
-        Self {
-            main_surface_border_stroke: Stroke::NONE,
-            main_surface_border_rounding: CornerRadius::ZERO,
-            buttons: ButtonsStyle::from_egui(style),
-            separator: SeparatorStyle::from_egui(style),
-            tab_bar: TabBarStyle::from_egui(style),
-            tab: TabStyle::from_egui(style),
-            overlay: OverlayStyle::from_egui(style),
-            ..Self::default()
-        }
-    }
-}
-
-impl ButtonsStyle {
-    /// Derives relevant fields from `egui::Style` and sets the remaining fields to their default values.
-    ///
-    /// Fields overwritten by [`egui::Style`] are:
-    /// - [`ButtonsStyle::close_tab_bg_fill`]
-    /// - [`ButtonsStyle::close_tab_color`]
-    /// - [`ButtonsStyle::close_tab_active_color`]
-    /// - [`ButtonsStyle::add_tab_bg_fill`]
-    /// - [`ButtonsStyle::add_tab_color`]
-    /// - [`ButtonsStyle::add_tab_active_color`]
-    /// - [`ButtonsStyle::add_tab_border_color`]
-    /// - [`ButtonsStyle::close_all_tabs_bg_fill`]
-    /// - [`ButtonsStyle::close_all_tabs_color`]
-    /// - [`ButtonsStyle::close_all_tabs_active_color`]
-    /// - [`ButtonsStyle::close_all_tabs_border_color`]
-    /// - [`ButtonsStyle::collapse_tabs_bg_fill`]
-    /// - [`ButtonsStyle::collapse_tabs_color`]
-    /// - [`ButtonsStyle::collapse_tabs_active_color`]
-    /// - [`ButtonsStyle::collapse_tabs_border_color`]
-    pub fn from_egui(style: &egui::Style) -> Self {
-        Self {
-            close_tab_bg_fill: style.visuals.widgets.hovered.bg_fill,
-            close_tab_color: style.visuals.text_color(),
-            close_tab_active_color: style.visuals.strong_text_color(),
-            add_tab_bg_fill: style.visuals.widgets.hovered.bg_fill,
-            add_tab_color: style.visuals.text_color(),
-            add_tab_active_color: style.visuals.strong_text_color(),
-            add_tab_border_color: style.visuals.widgets.noninteractive.bg_fill,
-            close_all_tabs_bg_fill: style.visuals.widgets.hovered.bg_fill,
-            close_all_tabs_color: style.visuals.text_color(),
-            close_all_tabs_active_color: style.visuals.strong_text_color(),
-            close_all_tabs_border_color: style.visuals.widgets.noninteractive.bg_fill,
-            close_all_tabs_disabled_color: style.visuals.widgets.inactive.bg_fill,
-            collapse_tabs_bg_fill: style.visuals.widgets.hovered.bg_fill,
-            collapse_tabs_color: style.visuals.text_color(),
-            collapse_tabs_active_color: style.visuals.strong_text_color(),
-            collapse_tabs_border_color: style.visuals.widgets.noninteractive.bg_fill,
-            minimize_window_bg_fill: style.visuals.widgets.hovered.bg_fill,
-            minimize_window_color: style.visuals.text_color(),
-            minimize_window_active_color: style.visuals.strong_text_color(),
-            minimize_window_border_color: style.visuals.widgets.noninteractive.bg_fill,
-            ..ButtonsStyle::default()
-        }
-    }
-}
-
-impl SeparatorStyle {
-    /// Derives relevant fields from `egui::Style` and sets the remaining fields to their default values.
-    ///
-    /// Fields overwritten by [`egui::Style`] are:
-    /// - [`SeparatorStyle::color_idle`]
-    /// - [`SeparatorStyle::color_hovered`]
-    /// - [`SeparatorStyle::color_dragged`]
-    pub fn from_egui(style: &egui::Style) -> Self {
-        Self {
-            // Same as egui panel resize colors:
-            color_idle: style.visuals.widgets.noninteractive.bg_stroke.color, // dim
-            color_hovered: style.visuals.widgets.hovered.fg_stroke.color,     // bright
-            color_dragged: style.visuals.widgets.active.fg_stroke.color,      // bright
-            ..SeparatorStyle::default()
-        }
-    }
-}
-
-impl TabBarStyle {
-    /// Derives relevant fields from `egui::Style` and sets the remaining fields to their default values.
-    ///
-    /// Fields overwritten by [`egui::Style`] are:
-    /// - [`TabBarStyle::bg_fill`]
-    /// - [`TabBarStyle::rounding`]
-    /// - [`TabBarStyle::hline_color`]
-    pub fn from_egui(style: &egui::Style) -> Self {
-        Self {
-            bg_fill: style.visuals.extreme_bg_color,
-            rounding: CornerRadius {
-                nw: style.visuals.widgets.inactive.corner_radius.nw + 2,
-                ne: style.visuals.widgets.inactive.corner_radius.ne + 2,
-                sw: 0,
-                se: 0,
-            },
-            hline_color: style.visuals.widgets.noninteractive.bg_stroke.color,
-            ..TabBarStyle::default()
-        }
-    }
-}
-
-impl TabStyle {
-    /// Derives tab styles from `egui::Style`.
-    ///
-    /// See also: [`TabInteractionStyle::from_egui_active`], [`TabInteractionStyle::from_egui_inactive`],
-    /// [`TabInteractionStyle::from_egui_focused`], [`TabInteractionStyle::from_egui_hovered`], [`TabBodyStyle::from_egui`],
-    pub fn from_egui(style: &egui::Style) -> TabStyle {
-        Self {
-            active: TabInteractionStyle::from_egui_active(style),
-            inactive: TabInteractionStyle::from_egui_inactive(style),
-            focused: TabInteractionStyle::from_egui_focused(style),
-            hovered: TabInteractionStyle::from_egui_hovered(style),
-            active_with_kb_focus: TabInteractionStyle::from_egui_active_with_kb_focus(style),
-            inactive_with_kb_focus: TabInteractionStyle::from_egui_inactive_with_kb_focus(style),
-            focused_with_kb_focus: TabInteractionStyle::from_egui_focused_with_kb_focus(style),
-            tab_body: TabBodyStyle::from_egui(style),
-            ..Default::default()
-        }
-    }
-}
-
-impl TabInteractionStyle {
-    /// Derives relevant fields from `egui::Style` for an active tab and sets the remaining fields to their default values.
-    ///
-    /// Fields overwritten by [`egui::Style`] are:
-    /// - [`TabInteractionStyle::outline_color`]
-    /// - [`TabInteractionStyle::bg_fill`]
-    /// - [`TabInteractionStyle::text_color`]
-    /// - [`TabInteractionStyle::rounding`]
-    pub fn from_egui_active(style: &egui::Style) -> Self {
-        Self {
-            outline_color: style.visuals.widgets.noninteractive.bg_stroke.color,
-            bg_fill: style.visuals.window_fill(),
-            text_color: style.visuals.text_color(),
-            rounding: CornerRadius {
-                sw: 0,
-                se: 0,
-                ..style.visuals.widgets.active.corner_radius
-            },
-        }
-    }
-
-    /// Derives relevant fields from `egui::Style` for an inactive tab and sets the remaining fields to their default values.
-    ///
-    /// Fields overwritten by [`egui::Style`] are:
-    /// - [`TabInteractionStyle::outline_color`]
-    /// - [`TabInteractionStyle::bg_fill`]
-    /// - [`TabInteractionStyle::text_color`]
-    /// - [`TabInteractionStyle::rounding`]
-    pub fn from_egui_inactive(style: &egui::Style) -> Self {
-        Self {
-            text_color: style.visuals.text_color(),
-            bg_fill: egui::ecolor::tint_color_towards(
-                style.visuals.window_fill,
-                style.visuals.extreme_bg_color,
-            ),
-            outline_color: egui::ecolor::tint_color_towards(
-                style.visuals.widgets.noninteractive.bg_stroke.color,
-                style.visuals.extreme_bg_color,
-            ),
-            ..TabInteractionStyle::from_egui_active(style)
-        }
-    }
-
-    /// Derives relevant fields from `egui::Style` for a focused tab and sets the remaining fields to their default values.
-    ///
-    /// Fields overwritten by [`egui::Style`] are:
-    /// - [`TabInteractionStyle::outline_color`]
-    /// - [`TabInteractionStyle::bg_fill`]
-    /// - [`TabInteractionStyle::text_color`]
-    /// - [`TabInteractionStyle::rounding`]
-    pub fn from_egui_focused(style: &egui::Style) -> Self {
-        Self {
-            text_color: style.visuals.strong_text_color(),
-            ..TabInteractionStyle::from_egui_active(style)
-        }
-    }
-
-    /// Derives relevant fields from `egui::Style` for a hovered tab and sets the remaining fields to their default values.
-    ///
-    /// Fields overwritten by [`egui::Style`] are:
-    /// - [`TabInteractionStyle::outline_color`]
-    /// - [`TabInteractionStyle::bg_fill`]
-    /// - [`TabInteractionStyle::text_color`]
-    /// - [`TabInteractionStyle::rounding`]
-    pub fn from_egui_hovered(style: &egui::Style) -> Self {
-        Self {
-            text_color: style.visuals.strong_text_color(),
-            outline_color: style.visuals.widgets.hovered.bg_stroke.color,
-            ..TabInteractionStyle::from_egui_inactive(style)
-        }
-    }
-
-    /// Derives relevant fields from `egui::Style` for an active tab with keyboard focus and sets the remaining fields to their default values.
-    ///
-    /// Fields overwritten by [`egui::Style`] are:
-    /// - [`TabInteractionStyle::outline_color`]
-    /// - [`TabInteractionStyle::bg_fill`]
-    /// - [`TabInteractionStyle::text_color`]
-    /// - [`TabInteractionStyle::rounding`]
-    pub fn from_egui_active_with_kb_focus(style: &egui::Style) -> Self {
-        Self {
-            text_color: style.visuals.strong_text_color(),
-            outline_color: style.visuals.widgets.hovered.bg_stroke.color,
-            ..TabInteractionStyle::from_egui_active(style)
-        }
-    }
-
-    /// Derives relevant fields from `egui::Style` for an inactive tab with keyboard focus and sets the remaining fields to their default values.
-    ///
-    /// Fields overwritten by [`egui::Style`] are:
-    /// - [`TabInteractionStyle::outline_color`]
-    /// - [`TabInteractionStyle::bg_fill`]
-    /// - [`TabInteractionStyle::text_color`]
-    /// - [`TabInteractionStyle::rounding`]
-    pub fn from_egui_inactive_with_kb_focus(style: &egui::Style) -> Self {
-        Self {
-            text_color: style.visuals.strong_text_color(),
-            outline_color: style.visuals.widgets.hovered.bg_stroke.color,
-            ..TabInteractionStyle::from_egui_inactive(style)
-        }
-    }
-
-    /// Derives relevant fields from `egui::Style` for a focused tab with keyboard focus and sets the remaining fields to their default values.
-    ///
-    /// Fields overwritten by [`egui::Style`] are:
-    /// - [`TabInteractionStyle::outline_color`]
-    /// - [`TabInteractionStyle::bg_fill`]
-    /// - [`TabInteractionStyle::text_color`]
-    /// - [`TabInteractionStyle::rounding`]
-    pub fn from_egui_focused_with_kb_focus(style: &egui::Style) -> Self {
-        Self {
-            text_color: style.visuals.strong_text_color(),
-            outline_color: style.visuals.widgets.hovered.bg_stroke.color,
-            ..TabInteractionStyle::from_egui_focused(style)
-        }
-    }
-}
-
-impl TabBodyStyle {
-    /// Derives relevant fields from `egui::Style` and sets the remaining fields to their default values.
-    ///
-    /// Fields overwritten by [`egui::Style`] are:
-    /// - [`TabBodyStyle::inner_margin`]
-    /// - [`TabBodyStyle::stroke]
-    /// - [`TabBodyStyle::rounding`]
-    /// - [`TabBodyStyle::bg_fill`]
-    pub fn from_egui(style: &egui::Style) -> Self {
-        Self {
-            inner_margin: style.spacing.window_margin,
-            stroke: style.visuals.widgets.noninteractive.bg_stroke,
-            rounding: style.visuals.widgets.active.corner_radius,
-            bg_fill: style.visuals.window_fill(),
-        }
-    }
-}
-
-impl OverlayStyle {
-    /// Derives relevant fields from `egui::Style` and sets the remaining fields to their default values.
-    ///
-    /// Fields overwritten by [`egui::Style`] are:
-    /// - [`OverlayStyle::selection_color`]
-    /// - [`OverlayStyle::button_spacing]
-    /// - [`OverlayStyle::button_color`]
-    /// - [`OverlayStyle::button_border_stroke`]
-    pub fn from_egui(style: &egui::Style) -> Self {
-        Self {
-            selection_color: style.visuals.selection.bg_fill.linear_multiply(0.5),
-            button_spacing: style.spacing.icon_spacing,
-            button_color: style.visuals.widgets.noninteractive.fg_stroke.color,
-            button_border_stroke: style.visuals.widgets.noninteractive.bg_stroke,
-            ..Default::default()
-        }
-    }
-}
diff --git a/crates/egui-dock/src/utils.rs b/crates/egui-dock/src/utils.rs
deleted file mode 100644
index a7099ac..0000000
--- a/crates/egui-dock/src/utils.rs
+++ /dev/null
@@ -1,121 +0,0 @@
-use egui::emath::*;
-
-use crate::{
-    ButtonsStyle, SeparatorStyle, Style, TabBarStyle, TabBodyStyle, TabInteractionStyle, TabStyle,
-};
-use egui::style::{Visuals, WidgetVisuals, Widgets};
-
-#[inline(always)]
-pub fn expand_to_pixel(mut rect: Rect, ppi: f32) -> Rect {
-    rect.min = map_to_pixel_pos(rect.min, ppi, f32::floor);
-    rect.max = map_to_pixel_pos(rect.max, ppi, f32::ceil);
-    rect
-}
-
-#[inline(always)]
-pub fn map_to_pixel_pos(mut pos: Pos2, ppi: f32, map: fn(f32) -> f32) -> Pos2 {
-    pos.x = map_to_pixel(pos.x, ppi, map);
-    pos.y = map_to_pixel(pos.y, ppi, map);
-    pos
-}
-
-#[inline(always)]
-pub fn map_to_pixel(point: f32, ppi: f32, map: fn(f32) -> f32) -> f32 {
-    map(point * ppi) / ppi
-}
-
-pub fn rect_set_size_centered(rect: &mut Rect, size: Vec2) {
-    let center = rect.center();
-    rect.set_width(size.x);
-    rect.set_height(size.y);
-    rect.set_center(center);
-}
-
-/// Shrink a rectangle so that the stroke is fully contained inside
-/// the original rectangle.
-pub fn rect_stroke_box(rect: Rect, width: f32) -> Rect {
-    rect.expand(-f32::ceil(width / 2.0))
-}
-
-/// Fade a `egui_dock::Style` to a certain opacity
-pub(super) fn fade_dock_style(style: &mut Style, factor: f32) {
-    style.main_surface_border_stroke.color = style
-        .main_surface_border_stroke
-        .color
-        .linear_multiply(factor);
-    fade_tab_style(&mut style.tab, factor);
-    fade_button_style(&mut style.buttons, factor);
-    fade_seperator_style(&mut style.separator, factor);
-    fade_tab_bar_style(&mut style.tab_bar, factor);
-}
-
-fn fade_tab_bar_style(style: &mut TabBarStyle, factor: f32) {
-    style.hline_color = style.hline_color.linear_multiply(factor);
-    style.bg_fill = style.bg_fill.linear_multiply(factor);
-}
-
-fn fade_seperator_style(style: &mut SeparatorStyle, factor: f32) {
-    style.color_idle = style.color_idle.linear_multiply(factor);
-    style.color_hovered = style.color_hovered.linear_multiply(factor);
-    style.color_dragged = style.color_dragged.linear_multiply(factor);
-}
-
-fn fade_button_style(style: &mut ButtonsStyle, factor: f32) {
-    style.close_tab_color = style.close_tab_color.linear_multiply(factor);
-    style.close_tab_active_color = style.close_tab_active_color.linear_multiply(factor);
-    style.close_tab_bg_fill = style.close_tab_bg_fill.linear_multiply(factor);
-    style.add_tab_color = style.add_tab_color.linear_multiply(factor);
-    style.add_tab_active_color = style.add_tab_active_color.linear_multiply(factor);
-    style.add_tab_bg_fill = style.add_tab_bg_fill.linear_multiply(factor);
-    style.add_tab_border_color = style.add_tab_border_color.linear_multiply(factor);
-}
-
-fn fade_tab_style(style: &mut TabStyle, factor: f32) {
-    fade_tab_interaction_style(&mut style.active, factor);
-    fade_tab_interaction_style(&mut style.inactive, factor);
-    fade_tab_interaction_style(&mut style.focused, factor);
-    fade_tab_interaction_style(&mut style.hovered, factor);
-    fade_tab_body_style(&mut style.tab_body, factor);
-}
-
-fn fade_tab_interaction_style(style: &mut TabInteractionStyle, factor: f32) {
-    style.outline_color = style.outline_color.linear_multiply(factor);
-    style.bg_fill = style.bg_fill.linear_multiply(factor);
-    style.text_color = style.text_color.linear_multiply(factor);
-}
-
-fn fade_tab_body_style(style: &mut TabBodyStyle, factor: f32) {
-    style.stroke.color = style.stroke.color.linear_multiply(factor);
-    style.bg_fill = style.bg_fill.linear_multiply(factor);
-}
-
-/// Fade a `egui::style::Visuals` to a certain opacity
-pub(super) fn fade_visuals(visuals: &mut Visuals, factor: f32) {
-    if let Some(override_text_color) = &mut visuals.override_text_color {
-        *override_text_color = override_text_color.linear_multiply(factor);
-    }
-    visuals.hyperlink_color = visuals.hyperlink_color.linear_multiply(factor);
-    visuals.faint_bg_color = visuals.faint_bg_color.linear_multiply(factor);
-    visuals.extreme_bg_color = visuals.extreme_bg_color.linear_multiply(factor);
-    visuals.code_bg_color = visuals.code_bg_color.linear_multiply(factor);
-    visuals.warn_fg_color = visuals.warn_fg_color.linear_multiply(factor);
-    visuals.error_fg_color = visuals.error_fg_color.linear_multiply(factor);
-    visuals.window_fill = visuals.window_fill.linear_multiply(factor);
-    visuals.panel_fill = visuals.window_fill.linear_multiply(factor);
-    fade_widgets(&mut visuals.widgets, factor);
-}
-
-fn fade_widgets(widgets: &mut Widgets, factor: f32) {
-    fade_widget_visuals(&mut widgets.noninteractive, factor);
-    fade_widget_visuals(&mut widgets.inactive, factor);
-    fade_widget_visuals(&mut widgets.hovered, factor);
-    fade_widget_visuals(&mut widgets.active, factor);
-    fade_widget_visuals(&mut widgets.open, factor);
-}
-
-fn fade_widget_visuals(visuals: &mut WidgetVisuals, factor: f32) {
-    visuals.bg_fill = visuals.bg_fill.linear_multiply(factor);
-    visuals.weak_bg_fill = visuals.weak_bg_fill.linear_multiply(factor);
-    visuals.bg_stroke.color = visuals.bg_stroke.color.linear_multiply(factor);
-    visuals.fg_stroke.color = visuals.fg_stroke.color.linear_multiply(factor);
-}
diff --git a/crates/egui-dock/src/widgets/dock_area/allowed_splits.rs b/crates/egui-dock/src/widgets/dock_area/allowed_splits.rs
deleted file mode 100644
index 4f72198..0000000
--- a/crates/egui-dock/src/widgets/dock_area/allowed_splits.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-/// What directions can this dock be split in?
-#[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]
-pub enum AllowedSplits {
-    #[default]
-    /// Allow splits in any direction (horizontal and vertical).
-    All = 0b11,
-
-    /// Only allow split in a horizontal directions.
-    LeftRightOnly = 0b10,
-
-    /// Only allow splits in a vertical directions.
-    TopBottomOnly = 0b01,
-
-    /// Don't allow splits at all.
-    None = 0b00,
-}
-
-impl std::ops::BitAnd for AllowedSplits {
-    type Output = Self;
-
-    fn bitand(self, rhs: Self) -> Self::Output {
-        Self::from_u8(self as u8 & rhs as u8)
-    }
-}
-
-impl AllowedSplits {
-    /// Create allowed splits from a u8, panics if an invalid value is given.
-    #[inline(always)]
-    fn from_u8(u8: u8) -> Self {
-        match u8 {
-            0b11 => AllowedSplits::All,
-            0b10 => AllowedSplits::LeftRightOnly,
-            0b01 => AllowedSplits::TopBottomOnly,
-            0b00 => AllowedSplits::None,
-            _ => panic!("Provided an invalid value for allowed splits: {u8:0x}"),
-        }
-    }
-}
diff --git a/crates/egui-dock/src/widgets/dock_area/drag_and_drop.rs b/crates/egui-dock/src/widgets/dock_area/drag_and_drop.rs
deleted file mode 100644
index c3549ec..0000000
--- a/crates/egui-dock/src/widgets/dock_area/drag_and_drop.rs
+++ /dev/null
@@ -1,477 +0,0 @@
-use crate::{
-    AllowedSplits, NodeIndex, Split, Style, SurfaceIndex, TabDestination, TabIndex, TabInsert,
-};
-use egui::emath::GuiRounding;
-use egui::{
-    emath::inverse_lerp, vec2, Context, Id, LayerId, NumExt, Order, Painter, Pos2, Rect, Stroke,
-    StrokeKind, Ui, Vec2,
-};
-use std::ops::BitOrAssign;
-
-#[derive(Debug, Clone)]
-pub(super) struct HoverData {
-    /// Rect of the hovered element.
-    pub rect: Rect,
-
-    /// The "address" of the tab/node being hovered over.
-    pub dst: TreeComponent,
-
-    /// If a tab title or the tab head is hovered, this is the rect of it.
-    pub tab: Option<Rect>,
-}
-
-/// Specifies the location of a tab on the tree, used when moving tabs.
-#[derive(Debug, Clone)]
-pub(super) struct DragData {
-    pub src: TreeComponent,
-    pub rect: Rect,
-}
-
-#[derive(Debug, Clone)]
-pub(super) enum TreeComponent {
-    Surface(SurfaceIndex),
-    Node(SurfaceIndex, NodeIndex),
-    Tab(SurfaceIndex, NodeIndex, TabIndex),
-}
-
-impl TreeComponent {
-    pub(super) fn as_tab_destination(&self) -> TabDestination {
-        match *self {
-            TreeComponent::Surface(surface) => TabDestination::EmptySurface(surface),
-            TreeComponent::Node(dst_surf, dst_node) => {
-                TabDestination::Node(dst_surf, dst_node, TabInsert::Append)
-            }
-            TreeComponent::Tab(dst_surf, dst_node, tab_index) => {
-                TabDestination::Node(dst_surf, dst_node, TabInsert::Insert(tab_index))
-            }
-        }
-    }
-
-    pub(super) fn node_address(&self) -> (SurfaceIndex, Option<NodeIndex>) {
-        match *self {
-            TreeComponent::Surface(surface) => (surface, None),
-            TreeComponent::Node(dst_surf, dst_node) => (dst_surf, Some(dst_node)),
-            TreeComponent::Tab(dst_surf, dst_node, _) => (dst_surf, Some(dst_node)),
-        }
-    }
-
-    pub(super) fn surface_address(&self) -> SurfaceIndex {
-        match *self {
-            TreeComponent::Surface(surface)
-            | TreeComponent::Node(surface, _)
-            | TreeComponent::Tab(surface, _, _) => surface,
-        }
-    }
-
-    pub(super) fn is_surface(&self) -> bool {
-        matches!(self, TreeComponent::Surface(_))
-    }
-}
-
-fn make_overlay_painter(ui: &Ui) -> Painter {
-    let id = Id::new("overlay");
-    let layer_id = LayerId::new(Order::Foreground, id);
-    ui.ctx().layer_painter(layer_id)
-}
-
-fn draw_highlight_rect(rect: Rect, ui: &Ui, style: &Style) {
-    let painter = make_overlay_painter(ui);
-    painter.rect(
-        rect.expand(style.overlay.hovered_leaf_highlight.expansion),
-        style.overlay.hovered_leaf_highlight.rounding,
-        style.overlay.hovered_leaf_highlight.color,
-        style.overlay.hovered_leaf_highlight.stroke,
-        StrokeKind::Inside,
-    );
-}
-
-// Draws one of the Tab drop destination icons inside `rect`, which one you get is specified by `is_top_bottom`.
-fn button_ui(
-    rect: Rect,
-    ui: &Ui,
-    lock: &mut bool,
-    mouse_pos: Pos2,
-    style: &Style,
-    split: Option<Split>,
-) -> bool {
-    let visuals = &style.overlay;
-    let button_stroke = Stroke::new(1.0, visuals.button_color);
-    let painter = make_overlay_painter(ui);
-    painter.rect_stroke(rect, 0.0, visuals.button_border_stroke, StrokeKind::Inside);
-    let rect = rect.shrink(rect.width() * 0.1);
-    painter.rect_stroke(rect, 0.0, button_stroke, StrokeKind::Inside);
-    let rim = { Rect::from_two_pos(rect.min, rect.lerp_inside(vec2(1.0, 0.1))) };
-    painter.rect(
-        rim,
-        0.0,
-        visuals.button_color,
-        Stroke::NONE,
-        StrokeKind::Inside,
-    );
-
-    if let Some(split) = split {
-        for line in DASHED_LINE_ALPHAS.chunks(2) {
-            let start = rect.lerp_inside(lerp_vec(split, line[0]));
-            let end = rect.lerp_inside(lerp_vec(split, line[1]));
-            painter.line_segment([start, end], button_stroke);
-        }
-    }
-    let is_mouse_over = rect
-        .expand(style.overlay.feel.interact_expansion)
-        .contains(mouse_pos);
-    if is_mouse_over && !*lock {
-        let vertical_alphas = vec2(1.0, 0.5);
-        let horizontal_alphas = vec2(0.5, 1.0);
-        let rect = match split {
-            Some(Split::Above) => Rect::from_min_size(rect.min, rect.size() * vertical_alphas),
-            Some(Split::Left) => Rect::from_min_size(rect.min, rect.size() * horizontal_alphas),
-            Some(Split::Below) => {
-                let min = rect.lerp_inside(lerp_vec(Split::Below, 0.0));
-                Rect::from_min_size(min, rect.size() * vertical_alphas)
-            }
-            Some(Split::Right) => {
-                let min = rect.lerp_inside(lerp_vec(Split::Right, 0.0));
-                Rect::from_min_size(min, rect.size() * horizontal_alphas)
-            }
-            _ => rect,
-        };
-        painter.rect_filled(rect, 0.0, style.overlay.selection_color);
-    }
-    lock.bitor_assign(is_mouse_over);
-    is_mouse_over
-}
-
-const DASHED_LINE_ALPHAS: [f32; 8] = [
-    0.0625, 0.1875, 0.3125, 0.4375, 0.5625, 0.6875, 0.8125, 0.9375,
-];
-
-#[derive(PartialEq, Eq)]
-enum LockState {
-    /// Lock is unlocked.
-    Unlocked,
-
-    /// Lock remains locked, but can be unlocked.
-    SoftLock,
-
-    /// Lock is locked forever.  
-    HardLock,
-}
-
-#[derive(Debug, Clone)]
-pub(super) struct DragDropState {
-    pub hover: HoverData,
-    pub drag: DragData,
-    pub pointer: Pos2,
-    /// Is some when the pointer is over rect, f64 holds the time when the lock was last active.
-    pub locked: Option<f64>,
-}
-
-impl DragDropState {
-    // Determines if the hover data implies we're hovering over a tab or the tab title bar.
-    pub(super) fn is_on_title_bar(&self) -> bool {
-        self.hover.tab.is_some()
-    }
-
-    pub(super) fn resolve_icon_based(
-        &mut self,
-        ui: &Ui,
-        style: &Style,
-        allowed_splits: AllowedSplits,
-        windows_allowed: bool,
-        window_bounds: Rect,
-    ) -> Option<TabDestination> {
-        assert!(!self.is_on_title_bar());
-
-        draw_highlight_rect(self.hover.rect, ui, style);
-        let mut hovering_buttons = false;
-        let total_button_spacing = style.overlay.button_spacing * 2.0;
-        let (rect, pointer) = (self.hover.rect, self.pointer);
-        let rect = rect.shrink(style.overlay.button_spacing);
-        let shortest_side = ((rect.width() - total_button_spacing) / 3.0)
-            .min((rect.height() - total_button_spacing) / 3.0)
-            .min(style.overlay.max_button_size);
-
-        let mut destination: Option<TabDestination> = windows_allowed
-            .then(|| TabDestination::Window(Rect::from_min_size(pointer, self.drag.rect.size())));
-
-        let center = rect.center();
-        let rect = Rect::from_center_size(center, Vec2::splat(shortest_side));
-
-        if button_ui(rect, ui, &mut hovering_buttons, pointer, style, None) {
-            match self.hover.dst {
-                TreeComponent::Node(surface, node) => {
-                    destination = Some(TabDestination::Node(surface, node, TabInsert::Append))
-                }
-                TreeComponent::Surface(surface) => {
-                    destination = Some(TabDestination::EmptySurface(surface))
-                }
-                _ => (),
-            }
-        }
-
-        for split in [Split::Below, Split::Right, Split::Above, Split::Left] {
-            match allowed_splits {
-                AllowedSplits::TopBottomOnly if !split.is_top_bottom() => continue,
-                AllowedSplits::LeftRightOnly if !split.is_left_right() => continue,
-                AllowedSplits::None => continue,
-                _ => {
-                    let offset_value = shortest_side + style.overlay.button_spacing;
-                    let offset_vector = match split {
-                        Split::Above => vec2(0.0, -offset_value),
-                        Split::Below => vec2(0.0, offset_value),
-                        Split::Left => vec2(-offset_value, 0.0),
-                        Split::Right => vec2(offset_value, 0.0),
-                    };
-                    if button_ui(
-                        Rect::from_center_size(center + offset_vector, Vec2::splat(shortest_side)),
-                        ui,
-                        &mut hovering_buttons,
-                        pointer,
-                        style,
-                        Some(split),
-                    ) {
-                        if let TreeComponent::Node(surface, node) = self.hover.dst {
-                            destination =
-                                Some(TabDestination::Node(surface, node, TabInsert::Split(split)))
-                        }
-                    }
-                }
-            }
-        }
-        let hovering_rect = self.hover.rect.contains(pointer);
-        let target_lock_state = match (hovering_rect, hovering_buttons) {
-            (false, false) => LockState::Unlocked,
-            (_, true) => LockState::HardLock,
-            (true, _) => LockState::SoftLock,
-        };
-        self.update_lock(target_lock_state, style, ui.ctx());
-        if let Some(TabDestination::Window(rect)) = destination {
-            let rect = self.window_preview_rect(rect);
-            let rect_bounded = constrain_rect_to_area(ui, rect, window_bounds);
-            draw_window_rect(rect_bounded, ui, style);
-        }
-        destination
-    }
-
-    pub(super) fn resolve_traditional(
-        &mut self,
-        ui: &Ui,
-        style: &Style,
-        allowed_splits: AllowedSplits,
-        windows_allowed: bool,
-        window_bounds: Rect,
-    ) -> Option<TabDestination> {
-        // If windows are not allowed, any hover over a window is immediately disallowed.
-        if !windows_allowed && self.hover.dst.surface_address() != SurfaceIndex::main() {
-            return None;
-        }
-        draw_highlight_rect(self.hover.rect, ui, style);
-
-        // Deals with hovers over tab bar and tab titles.
-        if let Some(rect) = self.hover.tab {
-            draw_drop_rect(rect, ui, style);
-            let target_lock_state = if rect.contains(self.pointer) {
-                LockState::SoftLock
-            } else {
-                LockState::Unlocked
-            };
-            self.update_lock(target_lock_state, style, ui.ctx());
-            return Some(self.hover.dst.as_tab_destination());
-        }
-
-        // Main cases, splits, window creations, etc.
-        let (hover_rect, pointer) = (self.hover.rect, self.pointer);
-        let center = hover_rect.center();
-
-        let (tab_insertion, overlay_rect) = {
-            // A reverse lerp of the pointers position relative to the hovered leaf rect.
-            // Range is (-0.5, -0.5) to (0.5, 0.5)
-            let a_pos = (Pos2::new(
-                inverse_lerp(hover_rect.x_range().into(), pointer.x).unwrap(),
-                inverse_lerp(hover_rect.y_range().into(), pointer.y).unwrap(),
-            ) - Pos2::new(0.5, 0.5))
-            .to_pos2();
-
-            let center_drop_rect = Rect::from_center_size(
-                Pos2::ZERO,
-                Vec2::splat(style.overlay.feel.center_drop_coverage),
-            );
-            let window_drop_rect = Rect::from_center_size(
-                Pos2::ZERO,
-                Vec2::splat(style.overlay.feel.window_drop_coverage),
-            );
-
-            // Find out what kind of tab insertion (if any) should be used to move this widget.
-            if center_drop_rect.contains(a_pos) {
-                (Some(TabInsert::Append), Rect::EVERYTHING)
-            } else if window_drop_rect.contains(a_pos) {
-                match windows_allowed {
-                    true => (None, Rect::NOTHING),
-                    false => (Some(TabInsert::Append), Rect::EVERYTHING),
-                }
-            } else {
-                // Assessing if were above/below the two linear functions x-y=0 and -x-y=0 determines
-                // what "diagonal" quadrant were in.
-                let a_pos = match allowed_splits {
-                    AllowedSplits::All => a_pos,
-                    AllowedSplits::LeftRightOnly => Pos2::new(a_pos.x, 0.0),
-                    AllowedSplits::TopBottomOnly => Pos2::new(0.0, a_pos.y),
-                    AllowedSplits::None => Pos2::ZERO,
-                };
-                if a_pos == Pos2::ZERO {
-                    match windows_allowed {
-                        true => (None, Rect::NOTHING),
-                        false => (Some(TabInsert::Append), Rect::EVERYTHING),
-                    }
-                } else {
-                    match (a_pos.x - a_pos.y > 0., -a_pos.x - a_pos.y > 0.) {
-                        (true, true) => (
-                            Some(TabInsert::Split(Split::Above)),
-                            Rect::everything_above(center.y),
-                        ),
-                        (false, true) => (
-                            Some(TabInsert::Split(Split::Left)),
-                            Rect::everything_left_of(center.x),
-                        ),
-                        (true, false) => (
-                            Some(TabInsert::Split(Split::Right)),
-                            Rect::everything_right_of(center.x),
-                        ),
-                        (false, false) => (
-                            Some(TabInsert::Split(Split::Below)),
-                            Rect::everything_below(center.y),
-                        ),
-                    }
-                }
-            }
-        };
-
-        let default_value = windows_allowed
-            .then(|| TabDestination::Window(Rect::from_min_size(pointer, self.drag.rect.size())));
-        let final_result = tab_insertion.map_or(default_value, |tab| match self.hover.dst {
-            TreeComponent::Surface(surface) => Some(TabDestination::EmptySurface(surface)),
-            TreeComponent::Node(surface, node) => Some(TabDestination::Node(surface, node, tab)),
-            _ => None,
-        });
-
-        self.update_lock(LockState::SoftLock, style, ui.ctx());
-
-        // Draw the overlay
-        match final_result {
-            Some(TabDestination::Window(rect)) => {
-                let rect = self.window_preview_rect(rect);
-                let rect_bounded = constrain_rect_to_area(ui, rect, window_bounds);
-                draw_window_rect(rect_bounded, ui, style);
-            }
-            Some(_) => {
-                draw_drop_rect(hover_rect.intersect(overlay_rect), ui, style);
-            }
-            None => (),
-        }
-
-        final_result
-    }
-
-    fn update_lock(&mut self, target_state: LockState, style: &Style, ctx: &Context) {
-        match self.locked.as_mut() {
-            Some(lock_time) => {
-                if target_state == LockState::HardLock {
-                    *lock_time = ctx.input(|i| i.time);
-                }
-                let window_hold = if !self.hover.dst.surface_address().is_main() {
-                    ctx.request_repaint();
-                    self.is_locked(style, ctx)
-                } else {
-                    false
-                };
-                if target_state == LockState::Unlocked && !window_hold {
-                    self.locked = None;
-                }
-            }
-            None => {
-                if target_state != LockState::Unlocked {
-                    self.locked = Some(ctx.input(|i| i.time));
-                }
-            }
-        }
-    }
-
-    pub(super) fn is_locked(&self, style: &Style, ctx: &Context) -> bool {
-        match self.locked.as_ref() {
-            Some(lock_time) => {
-                let elapsed = ctx.input(|i| (i.time - lock_time) as f32);
-                ctx.request_repaint();
-                elapsed < style.overlay.feel.max_preference_time
-            }
-            None => false,
-        }
-    }
-
-    fn window_preview_rect(&self, rect: Rect) -> Rect {
-        if self.drag.src.surface_address() == SurfaceIndex::main() {
-            Rect::from_min_size(rect.min, rect.size() * 0.8)
-        } else {
-            rect
-        }
-    }
-}
-
-#[inline(always)]
-const fn lerp_vec(split: Split, alpha: f32) -> Vec2 {
-    if split.is_top_bottom() {
-        vec2(alpha, 0.5)
-    } else {
-        vec2(0.5, alpha)
-    }
-}
-
-// Draws a filled rect describing where a tab will be dropped.
-#[inline(always)]
-fn draw_drop_rect(rect: Rect, ui: &Ui, style: &Style) {
-    let painter = make_overlay_painter(ui);
-    painter.rect_filled(rect, 0.0, style.overlay.selection_color);
-}
-
-// Draws a stroked rect describing where a tab will be dropped.
-#[inline(always)]
-fn draw_window_rect(rect: Rect, ui: &Ui, style: &Style) {
-    let painter = make_overlay_painter(ui);
-    painter.rect_stroke(
-        rect,
-        0.0,
-        Stroke::new(
-            style.overlay.selection_stroke_width,
-            style.overlay.selection_color,
-        ),
-        StrokeKind::Inside,
-    );
-}
-
-/// An adapted version of the [`egui::Area`]s code for restricting an area rect to a bound.
-fn constrain_rect_to_area(ui: &Ui, rect: Rect, mut bounds: Rect) -> Rect {
-    if rect.width() > bounds.width() {
-        // Allow overlapping side bars.
-        let screen_rect = ui.ctx().screen_rect();
-        (bounds.min.x, bounds.max.x) = (screen_rect.min.x, screen_rect.max.x);
-    }
-    if rect.height() > bounds.height() {
-        // Allow overlapping top/bottom bars:
-        let screen_rect = ui.ctx().screen_rect();
-        (bounds.min.y, bounds.max.y) = (screen_rect.min.y, screen_rect.max.y);
-    }
-
-    let mut pos = rect.min;
-
-    // Constrain to screen, unless window is too large to fit:
-    let margin_x = (rect.width() - bounds.width()).at_least(0.0);
-    let margin_y = (rect.height() - bounds.height()).at_least(0.0);
-
-    pos.x = pos.x.at_most(bounds.right() + margin_x - rect.width()); // move left if needed
-    pos.x = pos.x.at_least(bounds.left() - margin_x); // move right if needed
-    pos.y = pos.y.at_most(bounds.bottom() + margin_y - rect.height()); // move right if needed
-    pos.y = pos.y.at_least(bounds.top() - margin_y); // move down if needed
-
-    pos = pos.round_to_pixels(ui.painter().pixels_per_point());
-
-    Rect::from_min_size(pos, rect.size())
-}
diff --git a/crates/egui-dock/src/widgets/dock_area/mod.rs b/crates/egui-dock/src/widgets/dock_area/mod.rs
deleted file mode 100644
index a16aad5..0000000
--- a/crates/egui-dock/src/widgets/dock_area/mod.rs
+++ /dev/null
@@ -1,216 +0,0 @@
-/// Due to there being a lot of code to show a dock in a ui every complementing
-/// method to ``show`` and ``show_inside`` is put in ``show_extra``.
-/// Otherwise ``mod.rs`` would be humongous.
-mod show;
-
-// Various components of the `DockArea` which is used when rendering
-mod allowed_splits;
-mod drag_and_drop;
-mod state;
-mod tab_removal;
-
-use crate::{dock_state::DockState, NodeIndex, Style, SurfaceIndex, TabIndex};
-pub use allowed_splits::AllowedSplits;
-use tab_removal::TabRemoval;
-
-use egui::{emath::*, Id, Modifiers};
-
-/// Displays a [`DockState`] in `egui`.
-pub struct DockArea<'tree, Tab> {
-    id: Id,
-    dock_state: &'tree mut DockState<Tab>,
-    style: Option<Style>,
-    show_add_popup: bool,
-    show_add_buttons: bool,
-    show_close_buttons: bool,
-    tab_context_menus: bool,
-    draggable_tabs: bool,
-    show_tab_name_on_hover: bool,
-    show_window_close_buttons: bool,
-    show_window_collapse_buttons: bool,
-    show_leaf_close_all_buttons: bool,
-    show_leaf_collapse_buttons: bool,
-    show_secondary_button_hint: bool,
-    secondary_button_modifiers: Modifiers,
-    secondary_button_on_modifier: bool,
-    secondary_button_context_menu: bool,
-    allowed_splits: AllowedSplits,
-    window_bounds: Option<Rect>,
-
-    to_remove: Vec<TabRemoval>,
-    to_detach: Vec<(SurfaceIndex, NodeIndex, TabIndex)>,
-    new_focused: Option<(SurfaceIndex, NodeIndex)>,
-    tab_hover_rect: Option<(Rect, TabIndex)>,
-}
-
-// Builder
-impl<'tree, Tab> DockArea<'tree, Tab> {
-    /// Creates a new [`DockArea`] from the provided [`DockState`].
-    #[inline(always)]
-    pub fn new(tree: &'tree mut DockState<Tab>) -> DockArea<'tree, Tab> {
-        Self {
-            id: Id::new("egui_dock::DockArea"),
-            dock_state: tree,
-            style: None,
-            show_add_popup: false,
-            show_add_buttons: false,
-            show_close_buttons: true,
-            tab_context_menus: true,
-            draggable_tabs: true,
-            show_tab_name_on_hover: false,
-            allowed_splits: AllowedSplits::default(),
-            to_remove: Vec::new(),
-            to_detach: Vec::new(),
-            new_focused: None,
-            tab_hover_rect: None,
-            window_bounds: None,
-            show_window_close_buttons: true,
-            show_window_collapse_buttons: true,
-            show_leaf_close_all_buttons: true,
-            show_leaf_collapse_buttons: true,
-            show_secondary_button_hint: true,
-            secondary_button_modifiers: Modifiers::SHIFT,
-            secondary_button_on_modifier: true,
-            secondary_button_context_menu: true,
-        }
-    }
-
-    /// Sets the [`DockArea`] ID. Useful if you have more than one [`DockArea`].
-    #[inline(always)]
-    pub fn id(mut self, id: Id) -> Self {
-        self.id = id;
-        self
-    }
-
-    /// Sets the look and feel of the [`DockArea`].
-    #[inline(always)]
-    pub fn style(mut self, style: Style) -> Self {
-        self.style = Some(style);
-        self
-    }
-
-    /// Shows or hides the add button popup.
-    /// By default it's `false`.
-    pub fn show_add_popup(mut self, show_add_popup: bool) -> Self {
-        self.show_add_popup = show_add_popup;
-        self
-    }
-
-    /// Shows or hides the tab add buttons.
-    /// By default it's `false`.
-    pub fn show_add_buttons(mut self, show_add_buttons: bool) -> Self {
-        self.show_add_buttons = show_add_buttons;
-        self
-    }
-
-    /// Shows or hides the tab close buttons.
-    /// By default it's `true`.
-    pub fn show_close_buttons(mut self, show_close_buttons: bool) -> Self {
-        self.show_close_buttons = show_close_buttons;
-        self
-    }
-
-    /// Whether tabs show a context menu when right-clicked.
-    /// By default it's `true`.
-    pub fn tab_context_menus(mut self, tab_context_menus: bool) -> Self {
-        self.tab_context_menus = tab_context_menus;
-        self
-    }
-
-    /// Whether tabs can be dragged between nodes and reordered on the tab bar.
-    /// By default it's `true`.
-    pub fn draggable_tabs(mut self, draggable_tabs: bool) -> Self {
-        self.draggable_tabs = draggable_tabs;
-        self
-    }
-
-    /// Whether tabs show their name when hovered over them.
-    /// By default it's `false`.
-    pub fn show_tab_name_on_hover(mut self, show_tab_name_on_hover: bool) -> Self {
-        self.show_tab_name_on_hover = show_tab_name_on_hover;
-        self
-    }
-
-    /// What directions can a node be split in: left-right, top-bottom, all, or none.
-    /// By default it's all.
-    pub fn allowed_splits(mut self, allowed_splits: AllowedSplits) -> Self {
-        self.allowed_splits = allowed_splits;
-        self
-    }
-
-    /// Whether tooltip hints are shown for secondary buttons on tab bars.
-    /// By default it's `true`.
-    pub fn show_secondary_button_hint(mut self, show_secondary_button_hint: bool) -> Self {
-        self.show_secondary_button_hint = show_secondary_button_hint;
-        self
-    }
-
-    /// The key combination used to activate secondary buttons on tab bars.
-    /// By default it's [`Modifiers::SHIFT`].
-    pub fn secondary_button_modifiers(mut self, secondary_button_modifiers: Modifiers) -> Self {
-        self.secondary_button_modifiers = secondary_button_modifiers;
-        self
-    }
-
-    /// Whether the secondary buttons on tab bars are activated by the modifier key.
-    /// By default it's `true`.
-    pub fn secondary_button_on_modifier(mut self, secondary_button_on_modifier: bool) -> Self {
-        self.secondary_button_on_modifier = secondary_button_on_modifier;
-        self
-    }
-
-    /// Whether the secondary buttons on tab bars are activated from a context value by right-clicking primary buttons.
-    /// By default it's `true`.
-    pub fn secondary_button_context_menu(mut self, secondary_button_context_menu: bool) -> Self {
-        self.secondary_button_context_menu = secondary_button_context_menu;
-        self
-    }
-
-    /// The bounds for any windows inside the [`DockArea`]. Defaults to the screen rect.
-    /// By default it's set to [`egui::Context::screen_rect`].
-    #[inline(always)]
-    pub fn window_bounds(mut self, bounds: Rect) -> Self {
-        self.window_bounds = Some(bounds);
-        self
-    }
-
-    /// Enables or disables the close button on windows.
-    /// By default it's `true`.
-    #[inline(always)]
-    #[deprecated = "consider using `show_leaf_close_buttons` instead."]
-    pub fn show_window_close_buttons(mut self, show_window_close_buttons: bool) -> Self {
-        self.show_window_close_buttons = show_window_close_buttons;
-        self
-    }
-
-    /// Enables or disables the collapsing header on windows.
-    /// By default it's `true`.
-    #[inline(always)]
-    #[deprecated = "consider using `show_leaf_collapse_buttons` instead."]
-    pub fn show_window_collapse_buttons(mut self, show_window_collapse_buttons: bool) -> Self {
-        self.show_window_collapse_buttons = show_window_collapse_buttons;
-        self
-    }
-
-    /// Enables or disables the close all tabs button on tab bars.
-    /// By default it's `true`.
-    #[inline(always)]
-    pub fn show_leaf_close_all_buttons(mut self, show_leaf_close_all_buttons: bool) -> Self {
-        self.show_leaf_close_all_buttons = show_leaf_close_all_buttons;
-        self
-    }
-
-    /// Enables or disables the collapse tabs button on tab bars.
-    /// By default it's `true`.
-    #[inline(always)]
-    pub fn show_leaf_collapse_buttons(mut self, show_leaf_collapse_buttons: bool) -> Self {
-        self.show_leaf_collapse_buttons = show_leaf_collapse_buttons;
-        self
-    }
-}
-
-impl<Tab> std::fmt::Debug for DockArea<'_, Tab> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("DockArea").finish_non_exhaustive()
-    }
-}
diff --git a/crates/egui-dock/src/widgets/dock_area/show/leaf.rs b/crates/egui-dock/src/widgets/dock_area/show/leaf.rs
deleted file mode 100644
index c442a0a..0000000
--- a/crates/egui-dock/src/widgets/dock_area/show/leaf.rs
+++ /dev/null
@@ -1,1320 +0,0 @@
-use egui::{
-    emath::TSTransform, epaint::TextShape, lerp, pos2, vec2, Align, Align2, Button, Color32,
-    CornerRadius, CursorIcon, Frame, Id, Key, LayerId, Layout, NumExt, Order, Rect, Response,
-    ScrollArea, Sense, Shape, Stroke, StrokeKind, TextStyle, Ui, UiBuilder, Vec2, WidgetText,
-};
-use std::ops::RangeInclusive;
-
-use crate::dock_area::tab_removal::TabRemoval;
-use crate::{
-    dock_area::{
-        drag_and_drop::{DragData, DragDropState, HoverData, TreeComponent},
-        state::State,
-    },
-    utils::{fade_visuals, rect_set_size_centered, rect_stroke_box},
-    DockArea, Node, NodeIndex, Style, SurfaceIndex, TabAddAlign, TabIndex, TabStyle, TabViewer,
-};
-
-use crate::popup::popup_under_widget;
-
-impl<Tab> DockArea<'_, Tab> {
-    pub(super) fn show_leaf(
-        &mut self,
-        ui: &mut Ui,
-        state: &mut State,
-        (surface_index, node_index): (SurfaceIndex, NodeIndex),
-        tab_viewer: &mut impl TabViewer<Tab = Tab>,
-        fade_style: Option<(&Style, f32)>,
-    ) {
-        assert!(self.dock_state[surface_index][node_index].is_leaf());
-        let collapsed = self.dock_state[surface_index][node_index].is_collapsed();
-
-        let rect = self.dock_state[surface_index][node_index]
-            .rect()
-            .expect("This node must be a leaf");
-        let ui = &mut ui.new_child(
-            UiBuilder::new()
-                .max_rect(rect)
-                .layout(Layout::top_down_justified(Align::Min))
-                .id_salt((node_index, "node")),
-        );
-        let spacing = ui.spacing().item_spacing;
-        ui.spacing_mut().item_spacing = Vec2::ZERO;
-        ui.set_clip_rect(rect);
-
-        if self.dock_state[surface_index][node_index].tabs_count() == 0 {
-            return;
-        }
-        let tabbar_rect = self.tab_bar(
-            ui,
-            state,
-            (surface_index, node_index),
-            tab_viewer,
-            fade_style.map(|(style, _)| style),
-            collapsed,
-        );
-        self.tab_body(
-            ui,
-            state,
-            (surface_index, node_index),
-            tab_viewer,
-            spacing,
-            tabbar_rect,
-            fade_style,
-            collapsed,
-        );
-
-        let tabs = self.dock_state[surface_index][node_index]
-            .tabs_mut()
-            .expect("This node must be a leaf here");
-        for (tab_index, tab) in tabs.iter_mut().enumerate() {
-            if tab_viewer.force_close(tab) {
-                self.to_remove
-                    .push((surface_index, node_index, TabIndex(tab_index)).into());
-            }
-        }
-    }
-
-    fn tab_bar(
-        &mut self,
-        ui: &mut Ui,
-        state: &mut State,
-        (surface_index, node_index): (SurfaceIndex, NodeIndex),
-        tab_viewer: &mut impl TabViewer<Tab = Tab>,
-        fade_style: Option<&Style>,
-        collapsed: bool,
-    ) -> Rect {
-        assert!(self.dock_state[surface_index][node_index].is_leaf());
-
-        let style = fade_style.unwrap_or_else(|| self.style.as_ref().unwrap());
-        let (tabbar_outer_rect, tabbar_response) = ui.allocate_exact_size(
-            vec2(ui.available_width(), style.tab_bar.height),
-            Sense::hover(),
-        );
-        ui.painter().rect_filled(
-            tabbar_outer_rect,
-            style.tab_bar.rounding,
-            style.tab_bar.bg_fill,
-        );
-
-        let mut available_width = tabbar_outer_rect.width();
-        let scroll_bar_width = available_width;
-        if available_width == 0.0 {
-            return tabbar_outer_rect;
-        }
-
-        // Reserve space for the buttons at the ends of the tab bar.
-
-        if self.show_add_buttons {
-            available_width -= Style::TAB_ADD_BUTTON_SIZE;
-        }
-
-        if self.show_leaf_close_all_buttons {
-            available_width -= Style::TAB_CLOSE_ALL_BUTTON_SIZE;
-        }
-
-        if self.show_leaf_collapse_buttons {
-            available_width -= Style::TAB_COLLAPSE_BUTTON_SIZE;
-        }
-
-        let actual_width = {
-            let Node::Leaf { tabs, scroll, .. } = &mut self.dock_state[surface_index][node_index]
-            else {
-                unreachable!()
-            };
-
-            let tabbar_inner_rect = Rect::from_min_size(
-                (tabbar_outer_rect.min - pos2(-*scroll, 0.0)
-                    + vec2(
-                        if self.show_leaf_collapse_buttons {
-                            Style::TAB_COLLAPSE_BUTTON_SIZE
-                        } else {
-                            0.0
-                        },
-                        0.0,
-                    ))
-                .to_pos2(),
-                vec2(tabbar_outer_rect.width(), tabbar_outer_rect.height()),
-            );
-
-            let tabs_ui = &mut ui.new_child(
-                UiBuilder::new()
-                    .max_rect(tabbar_inner_rect)
-                    .layout(Layout::left_to_right(Align::Center))
-                    .id_salt("tabs"),
-            );
-
-            let mut clip_rect = tabbar_outer_rect;
-            clip_rect.set_width(available_width);
-            if self.show_leaf_collapse_buttons {
-                clip_rect = clip_rect.translate(vec2(Style::TAB_COLLAPSE_BUTTON_SIZE, 0.0));
-            }
-            tabs_ui.set_clip_rect(clip_rect);
-
-            // Desired size for tabs in "expanded" mode.
-            let prefered_width = style
-                .tab_bar
-                .fill_tab_bar
-                .then_some(available_width / (tabs.len() as f32));
-
-            self.tabs(
-                tabs_ui,
-                state,
-                (surface_index, node_index),
-                tab_viewer,
-                tabbar_outer_rect,
-                prefered_width,
-                fade_style,
-            );
-
-            // Draw hline from tab end to edge of tab bar.
-            let px = ui.ctx().pixels_per_point().recip();
-            let style = fade_style.unwrap_or_else(|| self.style.as_ref().unwrap());
-
-            ui.painter().hline(
-                tabs_ui.min_rect().right().min(clip_rect.right())..=tabbar_outer_rect.right(),
-                tabbar_outer_rect.bottom() - px,
-                (px, style.tab_bar.hline_color),
-            );
-
-            // Add button at the ends of the tab bar.
-            if self.show_add_buttons {
-                let offset = match style.buttons.add_tab_align {
-                    TabAddAlign::Left => {
-                        (clip_rect.width() - tabs_ui.min_rect().width()).at_least(0.0)
-                    }
-                    TabAddAlign::Right => 0.0,
-                } + if self.show_leaf_close_all_buttons {
-                    Style::TAB_CLOSE_ALL_BUTTON_SIZE
-                } else {
-                    0.0
-                };
-                self.tab_plus(
-                    ui,
-                    surface_index,
-                    node_index,
-                    tab_viewer,
-                    tabbar_outer_rect,
-                    offset,
-                    fade_style,
-                );
-            }
-
-            if self.show_leaf_close_all_buttons {
-                // Current leaf contains non-closable tabs.
-                let disabled = if let Node::Leaf { tabs, .. } =
-                    &mut self.dock_state[surface_index][node_index]
-                {
-                    !tabs.iter_mut().all(|tab| tab_viewer.closeable(tab))
-                } else {
-                    unreachable!()
-                };
-
-                // Current window contains non-closable tabs.
-                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))
-                        } else {
-                            true
-                        }
-                    });
-
-                self.tab_close_all(
-                    ui,
-                    surface_index,
-                    node_index,
-                    tabbar_outer_rect,
-                    fade_style,
-                    disabled,
-                    close_window_disabled,
-                )
-            }
-
-            if self.show_leaf_collapse_buttons {
-                self.tab_collapse(
-                    ui,
-                    surface_index,
-                    node_index,
-                    tabbar_outer_rect,
-                    fade_style,
-                    collapsed,
-                )
-            }
-
-            tabs_ui.min_rect().width()
-        };
-
-        self.tab_bar_scroll(
-            ui,
-            state,
-            (surface_index, node_index),
-            actual_width,
-            available_width,
-            scroll_bar_width,
-            &tabbar_response,
-            fade_style,
-        );
-
-        tabbar_outer_rect
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    fn tabs(
-        &mut self,
-        tabs_ui: &mut Ui,
-        state: &mut State,
-        (surface_index, node_index): (SurfaceIndex, NodeIndex),
-        tab_viewer: &mut impl TabViewer<Tab = Tab>,
-        tabbar_outer_rect: Rect,
-        preferred_width: Option<f32>,
-        fade: Option<&Style>,
-    ) {
-        assert!(self.dock_state[surface_index][node_index].is_leaf());
-
-        let focused = self.dock_state.focused_leaf();
-        let tabs_len = {
-            let tabs = self.dock_state[surface_index][node_index]
-                .tabs()
-                .expect("This node must be a leaf here");
-            tabs.len()
-        };
-
-        for tab_index in 0..tabs_len {
-            let id = self
-                .id
-                .with((surface_index, "surface"))
-                .with((node_index, "node"))
-                .with((tab_index, "tab"));
-            let tab_index = TabIndex(tab_index);
-            let is_being_dragged = tabs_ui.ctx().is_being_dragged(id)
-                && tabs_ui.input(|i| i.pointer.is_decidedly_dragging())
-                && self.draggable_tabs;
-
-            if is_being_dragged {
-                tabs_ui.output_mut(|o| o.cursor_icon = CursorIcon::Grabbing);
-            }
-
-            let (is_active, label, tab_style, closeable) = {
-                let Node::Leaf { tabs, active, .. } =
-                    &mut self.dock_state[surface_index][node_index]
-                else {
-                    unreachable!()
-                };
-                let style = fade.unwrap_or_else(|| self.style.as_ref().unwrap());
-                let tab_style = tab_viewer.tab_style_override(&tabs[tab_index.0], &style.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]),
-                )
-            };
-
-            let show_close_button = self.show_close_buttons && closeable;
-
-            let (response, title_id) = if is_being_dragged {
-                let layer_id = LayerId::new(Order::Tooltip, id);
-                let response = tabs_ui
-                    .scope_builder(UiBuilder::new().layer_id(layer_id), |ui| {
-                        self.tab_title(
-                            ui,
-                            &tab_style,
-                            id,
-                            label,
-                            is_active && Some((surface_index, node_index)) == focused,
-                            is_active,
-                            is_being_dragged,
-                            preferred_width,
-                            show_close_button,
-                            fade,
-                        )
-                    })
-                    .response;
-                let title_id = response.id;
-
-                let response =
-                    tabs_ui.interact(response.rect, id.with("dragged"), Sense::click_and_drag());
-
-                if let Some(pointer_pos) = tabs_ui.ctx().pointer_interact_pos() {
-                    let start = *state.drag_start.get_or_insert(pointer_pos);
-                    let delta = pointer_pos - start;
-                    if delta.x.abs() > 30.0 || delta.y.abs() > 6.0 {
-                        tabs_ui
-                            .ctx()
-                            .transform_layer_shapes(layer_id, TSTransform::new(delta, 1.0));
-
-                        tabs_ui.memory_mut(|mem| {
-                            mem.data.insert_temp(
-                                self.id.with("drag_data"),
-                                Some(DragData {
-                                    src: TreeComponent::Tab(surface_index, node_index, tab_index),
-                                    rect: self.dock_state[surface_index][node_index]
-                                        .rect()
-                                        .unwrap(),
-                                }),
-                            );
-                        });
-                    }
-                }
-
-                (response, title_id)
-            } else {
-                let (mut response, close_response) = self.tab_title(
-                    tabs_ui,
-                    &tab_style,
-                    id,
-                    label,
-                    is_active && Some((surface_index, node_index)) == focused,
-                    is_active,
-                    is_being_dragged,
-                    preferred_width,
-                    show_close_button,
-                    fade,
-                );
-                let title_id = response.id;
-                let close_clicked = close_response.is_some_and(|res| res.clicked());
-                let is_lonely_tab = self.dock_state[surface_index].num_tabs() == 1;
-
-                if self.show_tab_name_on_hover {
-                    let tabs = self.dock_state[surface_index][node_index]
-                        .tabs_mut()
-                        .expect("This node must be a leaf");
-                    let tab = &mut tabs[tab_index.0];
-                    response = response.on_hover_ui(|ui| {
-                        ui.label(tab_viewer.title(tab));
-                    });
-                }
-
-                if self.tab_context_menus {
-                    let eject_button =
-                        Button::new(&self.dock_state.translations.tab_context_menu.eject_button);
-                    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| {
-                        tab_viewer.context_menu(ui, tab, surface_index, node_index);
-                        if (surface_index.is_main() || !is_lonely_tab)
-                            && tab_viewer.allowed_in_windows(tab)
-                            && ui.add(eject_button).clicked()
-                        {
-                            self.to_detach.push((surface_index, node_index, tab_index));
-                            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));
-                            }
-                            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));
-                    }
-                }
-
-                if let Some(pos) = state.last_hover_pos {
-                    // Use response.rect.contains instead of
-                    // response.hovered as the dragged tab covers
-                    // the underlying tab
-                    if state.drag_start.is_some() && response.rect.contains(pos) {
-                        self.tab_hover_rect = Some((response.rect, tab_index));
-                    }
-                }
-
-                (response, title_id)
-            };
-
-            // Paint hline below each tab unless its active (or option says otherwise).
-            let Node::Leaf { tabs, active, .. } = &mut self.dock_state[surface_index][node_index]
-            else {
-                unreachable!()
-            };
-            let tab = &mut tabs[tab_index.0];
-            let style = fade.unwrap_or_else(|| self.style.as_ref().unwrap());
-            let tab_style = tab_viewer.tab_style_override(tab, &style.tab);
-            let tab_style = tab_style.as_ref().unwrap_or(&style.tab);
-
-            if !is_active || tab_style.hline_below_active_tab_name {
-                let px = tabs_ui.ctx().pixels_per_point().recip();
-                tabs_ui.painter().hline(
-                    response.rect.x_range(),
-                    tabbar_outer_rect.bottom() - px,
-                    (px, style.tab_bar.hline_color),
-                );
-            }
-
-            if response.clicked()
-                || (tabs_ui.memory(|m| m.has_focus(title_id))
-                    && tabs_ui.input(|i| i.key_pressed(Key::Enter) || i.key_pressed(Key::Space)))
-            {
-                *active = tab_index;
-                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);
-        }
-    }
-
-    /// Draws the tab add button.
-    #[allow(clippy::too_many_arguments)]
-    fn tab_plus(
-        &mut self,
-        ui: &mut Ui,
-        surface_index: SurfaceIndex,
-        node_index: NodeIndex,
-        tab_viewer: &mut impl TabViewer<Tab = Tab>,
-        tabbar_outer_rect: Rect,
-        offset: f32,
-        fade_style: Option<&Style>,
-    ) {
-        let rect = Rect::from_min_max(
-            tabbar_outer_rect.right_top() - vec2(Style::TAB_ADD_BUTTON_SIZE + offset, 0.0),
-            tabbar_outer_rect.right_bottom() - vec2(offset, 2.0),
-        );
-
-        let ui = &mut ui.new_child(
-            UiBuilder::new()
-                .max_rect(rect)
-                .layout(Layout::left_to_right(Align::Center))
-                .id_salt((node_index, "tab_add")),
-        );
-
-        let (rect, mut response) = ui.allocate_exact_size(ui.available_size(), Sense::click());
-
-        response = response.on_hover_cursor(CursorIcon::PointingHand);
-
-        let style = fade_style.unwrap_or_else(|| self.style.as_ref().unwrap());
-        let color = if response.hovered() || response.has_focus() {
-            ui.painter()
-                .rect_filled(rect, CornerRadius::ZERO, style.buttons.add_tab_bg_fill);
-            style.buttons.add_tab_active_color
-        } else {
-            style.buttons.add_tab_color
-        };
-
-        let mut plus_rect = rect;
-
-        rect_set_size_centered(&mut plus_rect, Vec2::splat(Style::TAB_ADD_PLUS_SIZE));
-
-        ui.painter().line_segment(
-            [plus_rect.center_top(), plus_rect.center_bottom()],
-            Stroke::new(1.0, color),
-        );
-        ui.painter().line_segment(
-            [plus_rect.right_center(), plus_rect.left_center()],
-            Stroke::new(1.0, color),
-        );
-
-        // Draw button left border.
-        ui.painter().vline(
-            rect.left(),
-            rect.y_range(),
-            Stroke::new(
-                ui.ctx().pixels_per_point().recip(),
-                style.buttons.add_tab_border_color,
-            ),
-        );
-
-        let popup_id = ui.id().with("tab_add_popup");
-        popup_under_widget(ui, popup_id, &response, |ui| {
-            tab_viewer.add_popup(ui, surface_index, node_index);
-        });
-
-        if response.clicked() {
-            if self.show_add_popup {
-                ui.memory_mut(|mem| mem.toggle_popup(popup_id));
-            }
-            tab_viewer.on_add(surface_index, node_index);
-        }
-    }
-
-    /// Draws the close all button.
-    #[allow(clippy::too_many_arguments)]
-    #[allow(unused_assignments)]
-    fn tab_close_all(
-        &mut self,
-        ui: &mut Ui,
-        surface_index: SurfaceIndex,
-        node_index: NodeIndex,
-        tabbar_outer_rect: Rect,
-        fade_style: Option<&Style>,
-        disabled: bool,
-        close_window_disabled: bool,
-    ) {
-        let rect = Rect::from_min_max(
-            tabbar_outer_rect.right_top() - vec2(Style::TAB_CLOSE_ALL_BUTTON_SIZE, 0.0),
-            tabbar_outer_rect.right_bottom() - vec2(0.0, 2.0),
-        );
-
-        let ui = &mut ui.new_child(
-            UiBuilder::new()
-                .max_rect(rect)
-                .layout(Layout::left_to_right(Align::Center))
-                .id_salt((node_index, "tab_close_all")),
-        );
-
-        let (rect, mut response) = ui.allocate_exact_size(ui.available_size(), Sense::click());
-
-        let style = fade_style.unwrap_or_else(|| self.style.as_ref().unwrap());
-
-        // Whether we're on "secondary button mode" due to modifier keys
-        let on_secondary_button = self.is_on_secondary_button(surface_index, ui, &response);
-
-        let mut stroke_color = if disabled {
-            style.buttons.close_all_tabs_disabled_color
-        } else if response.hovered() || response.has_focus() {
-            if !(close_window_disabled && on_secondary_button) {
-                ui.painter().rect_filled(
-                    rect,
-                    CornerRadius::ZERO,
-                    style.buttons.close_all_tabs_bg_fill,
-                );
-            }
-            style.buttons.close_all_tabs_active_color
-        } else {
-            style.buttons.close_all_tabs_color
-        };
-
-        let mut close_all_rect = rect;
-
-        rect_set_size_centered(&mut close_all_rect, Vec2::splat(Style::TAB_CLOSE_ALL_SIZE));
-
-        if !disabled {
-            response = response.on_hover_cursor(CursorIcon::PointingHand);
-        }
-
-        if on_secondary_button {
-            // Close the entire window
-            if close_window_disabled {
-                stroke_color = style.buttons.close_all_tabs_disabled_color;
-                response = response
-                    .on_hover_cursor(CursorIcon::NotAllowed)
-                    .on_hover_text(
-                        self.dock_state
-                            .translations
-                            .leaf
-                            .close_all_button_disabled_tooltip
-                            .as_str(),
-                    );
-            }
-            Self::draw_close_window_symbol(ui, stroke_color, close_all_rect);
-        } else {
-            // Close all tabs in this leaf
-            if !disabled {
-                if !surface_index.is_main() && self.secondary_button_context_menu {
-                    response.context_menu(|ui| {
-                        ui.add_enabled_ui(!close_window_disabled, |ui| {
-                            if ui
-                                .button(&self.dock_state.translations.leaf.close_all_button)
-                                .on_disabled_hover_text(
-                                    self.dock_state
-                                        .translations
-                                        .leaf
-                                        .close_all_button_disabled_tooltip
-                                        .as_str(),
-                                )
-                                .clicked()
-                            {
-                                self.to_remove.push(TabRemoval::Window(surface_index));
-                            }
-                        });
-                    });
-                }
-            } else {
-                response = response
-                    .on_hover_cursor(CursorIcon::NotAllowed)
-                    .on_hover_text(
-                        self.dock_state
-                            .translations
-                            .leaf
-                            .close_button_disabled_tooltip
-                            .as_str(),
-                    );
-            }
-
-            if response.clicked() {
-                if on_secondary_button {
-                    if !close_window_disabled {
-                        self.to_remove.push(TabRemoval::Window(surface_index));
-                    }
-                } else if !disabled {
-                    self.to_remove.push((surface_index, node_index).into());
-                }
-            }
-
-            ui.painter().line_segment(
-                [close_all_rect.left_top(), close_all_rect.right_bottom()],
-                Stroke::new(1.0, stroke_color),
-            );
-            ui.painter().line_segment(
-                [close_all_rect.right_top(), close_all_rect.left_bottom()],
-                Stroke::new(1.0, stroke_color),
-            );
-        }
-
-        // Draw button left border.
-        ui.painter().vline(
-            rect.left(),
-            rect.y_range(),
-            Stroke::new(
-                ui.ctx().pixels_per_point().recip(),
-                style.buttons.close_all_tabs_border_color,
-            ),
-        );
-
-        if !disabled && !on_secondary_button {
-            response = self.show_tooltip_hints(surface_index, response);
-        }
-    }
-
-    /// Draws the collapse button.
-    fn tab_collapse(
-        &mut self,
-        ui: &mut Ui,
-        surface_index: SurfaceIndex,
-        node_index: NodeIndex,
-        tabbar_outer_rect: Rect,
-        fade_style: Option<&Style>,
-        collapsed: bool,
-    ) {
-        let rect = Rect::from_min_max(
-            tabbar_outer_rect.left_top(),
-            tabbar_outer_rect.left_bottom() + vec2(Style::TAB_COLLAPSE_BUTTON_SIZE, 0.0),
-        );
-
-        let ui = &mut ui.new_child(
-            UiBuilder::new()
-                .max_rect(rect)
-                .layout(Layout::left_to_right(Align::Center))
-                .id_salt((node_index, "tab_collapse")),
-        );
-
-        let (rect, mut response) = ui.allocate_exact_size(ui.available_size(), Sense::click());
-
-        response = response.on_hover_cursor(CursorIcon::PointingHand);
-
-        let style = fade_style.unwrap_or_else(|| self.style.as_ref().unwrap());
-
-        // Whether we're on "secondary button mode" due to modifier keys
-        let on_secondary_button = self.is_on_secondary_button(surface_index, ui, &response);
-
-        let color = if response.hovered() || response.has_focus() {
-            ui.painter().rect_filled(
-                rect,
-                CornerRadius::ZERO,
-                style.buttons.collapse_tabs_bg_fill,
-            );
-            style.buttons.collapse_tabs_active_color
-        } else {
-            style.buttons.collapse_tabs_color
-        };
-
-        let mut arrow_rect = rect;
-        rect_set_size_centered(&mut arrow_rect, Vec2::splat(Style::TAB_COLLAPSE_ARROW_SIZE));
-
-        if on_secondary_button {
-            // Collapse the entire window
-            Self::draw_chevron_down(ui, style, color, arrow_rect);
-        } else {
-            // Draw arrow.
-            Self::draw_arrow(collapsed, ui, color, arrow_rect);
-        }
-
-        // Draw button right border.
-        ui.painter().vline(
-            rect.right(),
-            rect.y_range(),
-            Stroke::new(
-                ui.ctx().pixels_per_point().recip(),
-                style.buttons.collapse_tabs_border_color,
-            ),
-        );
-
-        if response.clicked() {
-            if on_secondary_button {
-                self.window_toggle_minimized(surface_index);
-            } else {
-                self.dock_state[surface_index][node_index].set_collapsed(!collapsed);
-                self.dock_state[surface_index].node_update_collapsed(node_index);
-                self.window_update_collapsed(surface_index, node_index);
-            }
-        }
-
-        if !surface_index.is_main() && self.secondary_button_context_menu {
-            response.context_menu(|ui| {
-                if ui
-                    .button(&self.dock_state.translations.leaf.minimize_button)
-                    .clicked()
-                {
-                    ui.close_menu();
-                    self.window_toggle_minimized(surface_index);
-                }
-            });
-        }
-
-        if !on_secondary_button {
-            self.show_tooltip_hints(surface_index, response);
-        }
-    }
-
-    fn show_tooltip_hints(&mut self, surface_index: SurfaceIndex, response: Response) -> Response {
-        if !surface_index.is_main()
-            && self.show_secondary_button_hint
-            && (self.secondary_button_context_menu || self.secondary_button_on_modifier)
-        {
-            let hint = if self.secondary_button_context_menu && self.secondary_button_on_modifier {
-                &self
-                    .dock_state
-                    .translations
-                    .leaf
-                    .minimize_button_modifier_menu_hint
-            } else if self.secondary_button_context_menu {
-                &self.dock_state.translations.leaf.minimize_button_menu_hint
-            } else {
-                &self
-                    .dock_state
-                    .translations
-                    .leaf
-                    .minimize_button_modifier_hint
-            };
-            return response.on_hover_text(hint);
-        }
-        response
-    }
-
-    fn is_on_secondary_button(
-        &self,
-        surface_index: SurfaceIndex,
-        ui: &mut Ui,
-        response: &Response,
-    ) -> bool {
-        !surface_index.is_main()
-            && self.secondary_button_on_modifier
-            && ui.input(|i| {
-                i.modifiers
-                    .matches_logically(self.secondary_button_modifiers)
-            })
-            && (response.hovered() || response.has_focus() || response.is_pointer_button_down_on())
-    }
-
-    fn draw_close_window_symbol(ui: &mut Ui, stroke_color: Color32, close_all_rect: Rect) {
-        ui.painter().add(Shape::line(
-            vec![
-                close_all_rect
-                    .right_center()
-                    .lerp(close_all_rect.right_bottom(), 0.5),
-                close_all_rect.right_bottom(),
-                close_all_rect.left_bottom(),
-                close_all_rect.left_top(),
-                close_all_rect
-                    .center_top()
-                    .lerp(close_all_rect.left_top(), 0.5),
-            ],
-            Stroke::new(1.0, stroke_color),
-        ));
-        ui.painter().line_segment(
-            [close_all_rect.center_top(), close_all_rect.right_center()],
-            Stroke::new(1.0, stroke_color),
-        );
-        ui.painter().line_segment(
-            [close_all_rect.center(), close_all_rect.right_top()],
-            Stroke::new(1.0, stroke_color),
-        );
-    }
-
-    fn draw_arrow(collapsed: bool, ui: &mut Ui, color: Color32, arrow_rect: Rect) {
-        ui.painter().add(Shape::convex_polygon(
-            if collapsed {
-                // Arrow pointing rightwards.
-                vec![
-                    arrow_rect.left_top(),
-                    arrow_rect.right_center(),
-                    arrow_rect.left_bottom(),
-                ]
-            } else {
-                // Arrow pointing downwards.
-                vec![
-                    arrow_rect.left_top(),
-                    arrow_rect.right_top(),
-                    arrow_rect.center_bottom(),
-                ]
-            },
-            color,
-            Stroke::NONE,
-        ));
-    }
-
-    fn draw_chevron_down(ui: &mut Ui, style: &Style, color: Color32, arrow_rect: Rect) {
-        ui.painter().add(Shape::convex_polygon(
-            // Arrow pointing downwards.
-            vec![
-                arrow_rect.left_top(),
-                arrow_rect.right_top(),
-                arrow_rect.center(),
-            ],
-            color,
-            Stroke::NONE,
-        ));
-
-        // Chevron pointing downwards.
-        ui.painter().add(Shape::convex_polygon(
-            vec![
-                arrow_rect.left_center(),
-                arrow_rect.right_center(),
-                arrow_rect.center_bottom(),
-            ],
-            color,
-            Stroke::NONE,
-        ));
-        let color = style.buttons.minimize_window_bg_fill;
-        ui.painter().add(Shape::convex_polygon(
-            vec![
-                arrow_rect
-                    .left_center()
-                    .lerp(arrow_rect.right_center(), 0.25),
-                arrow_rect
-                    .left_center()
-                    .lerp(arrow_rect.right_center(), 0.75),
-                arrow_rect.center().lerp(arrow_rect.center_bottom(), 0.5),
-            ],
-            color,
-            Stroke::NONE,
-        ));
-    }
-
-    /// Updates the collapsed state of the node and its parents.
-    fn window_update_collapsed(&mut self, surface_index: SurfaceIndex, node_index: NodeIndex) {
-        let surface = &mut self.dock_state[surface_index];
-        let collapsed = surface[node_index].is_collapsed();
-        if !collapsed {
-            if let Some(window_state) = self.dock_state.get_window_state_mut(surface_index) {
-                window_state.set_new(true);
-            }
-        } else if surface.root_node().is_some_and(|root| root.is_collapsed()) {
-            let root_index = NodeIndex::root();
-            let surface_height = if surface.root_node().is_some() {
-                surface[root_index].rect().unwrap().height()
-            } else {
-                0.0
-            };
-            if let Some(window_state) = self.dock_state.get_window_state_mut(surface_index) {
-                window_state.set_expanded_height(surface_height);
-            }
-        }
-    }
-
-    /// * `active` means "the tab that is opened in the parent panel".
-    /// * `focused` means "the tab that was last interacted with".
-    ///
-    /// Returns the main button response plus the response of the close button, if any.
-    #[allow(clippy::too_many_arguments)]
-    fn tab_title(
-        &mut self,
-        ui: &mut Ui,
-        tab_style: &TabStyle,
-        id: Id,
-        label: WidgetText,
-        focused: bool,
-        active: bool,
-        is_being_dragged: bool,
-        preferred_width: Option<f32>,
-        show_close_button: bool,
-        fade: Option<&Style>,
-    ) -> (Response, Option<Response>) {
-        let style = fade.unwrap_or_else(|| self.style.as_ref().unwrap());
-        let galley = label.into_galley(ui, None, f32::INFINITY, TextStyle::Button);
-        let x_spacing = 8.0;
-        let text_width = galley.size().x + 2.0 * x_spacing;
-        let close_button_size = if show_close_button {
-            Style::TAB_CLOSE_BUTTON_SIZE.min(style.tab_bar.height)
-        } else {
-            0.0
-        };
-
-        // Compute total width of the tab bar.
-        let minimum_width = tab_style
-            .minimum_width
-            .unwrap_or(0.0)
-            .at_least(text_width + close_button_size);
-        let tab_width = preferred_width.unwrap_or(0.0).at_least(minimum_width);
-
-        let (_, tab_rect) = ui.allocate_space(vec2(tab_width, ui.available_height()));
-        let mut response = ui.interact(tab_rect, id, Sense::click_and_drag());
-        if ui.ctx().dragged_id().is_none() && self.draggable_tabs {
-            response = response.on_hover_cursor(CursorIcon::Grab);
-        }
-
-        let tab_style = if focused || is_being_dragged {
-            if response.has_focus() {
-                &tab_style.focused_with_kb_focus
-            } else {
-                &tab_style.focused
-            }
-        } else if active {
-            if response.has_focus() {
-                &tab_style.active_with_kb_focus
-            } else {
-                &tab_style.active
-            }
-        } else if response.hovered() {
-            &tab_style.hovered
-        } else if response.has_focus() {
-            &tab_style.inactive_with_kb_focus
-        } else {
-            &tab_style.inactive
-        };
-
-        // Draw the full tab first and then the stroke on top to avoid the stroke
-        // mixing with the background color.
-        ui.painter()
-            .rect_filled(tab_rect, tab_style.rounding, tab_style.bg_fill);
-        let stroke_rect = rect_stroke_box(tab_rect, 1.0);
-        ui.painter().rect_stroke(
-            stroke_rect,
-            tab_style.rounding,
-            Stroke::new(1.0, tab_style.outline_color),
-            StrokeKind::Inside,
-        );
-        if !is_being_dragged {
-            // Make the tab name area connect with the tab ui area.
-            ui.painter().hline(
-                RangeInclusive::new(
-                    stroke_rect.min.x + f32::max(tab_style.rounding.sw as f32, 1.5),
-                    stroke_rect.max.x - f32::max(tab_style.rounding.se as f32, 1.5),
-                ),
-                stroke_rect.bottom(),
-                Stroke::new(2.0, tab_style.bg_fill),
-            );
-        }
-
-        let mut text_rect = tab_rect;
-        text_rect.set_width(text_rect.width() - close_button_size);
-        let text_pos = {
-            let pos = Align2::CENTER_CENTER.pos_in_rect(&text_rect.shrink2(vec2(x_spacing, 0.0)));
-            pos - galley.size() / 2.0
-        };
-
-        ui.painter()
-            .add(TextShape::new(text_pos, galley, tab_style.text_color));
-
-        let close_response = show_close_button.then(|| {
-            let mut close_button_rect = tab_rect;
-            close_button_rect.set_left(text_rect.right());
-            close_button_rect =
-                Rect::from_center_size(close_button_rect.center(), Vec2::splat(close_button_size));
-
-            let close_response = ui
-                .interact(close_button_rect, id.with("close-button"), Sense::click())
-                .on_hover_cursor(CursorIcon::PointingHand);
-
-            let color = if close_response.hovered() || close_response.has_focus() {
-                style.buttons.close_tab_active_color
-            } else {
-                style.buttons.close_tab_color
-            };
-
-            if close_response.hovered() || close_response.has_focus() {
-                let mut rounding = tab_style.rounding;
-                rounding.nw = 0;
-                rounding.sw = 0;
-
-                ui.painter().rect_filled(
-                    close_button_rect,
-                    rounding,
-                    style.buttons.add_tab_bg_fill,
-                );
-            }
-
-            let mut x_rect = close_button_rect;
-            rect_set_size_centered(&mut x_rect, Vec2::splat(Style::TAB_CLOSE_X_SIZE));
-            ui.painter().line_segment(
-                [x_rect.left_top(), x_rect.right_bottom()],
-                Stroke::new(1.0, color),
-            );
-            ui.painter().line_segment(
-                [x_rect.right_top(), x_rect.left_bottom()],
-                Stroke::new(1.0, color),
-            );
-
-            close_response
-        });
-
-        (response, close_response)
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    fn tab_bar_scroll(
-        &mut self,
-        ui: &mut Ui,
-        state: &State,
-        (surface_index, node_index): (SurfaceIndex, NodeIndex),
-        actual_width: f32,
-        available_width: f32,
-        scroll_bar_width: f32,
-        tabbar_response: &Response,
-        fade_style: Option<&Style>,
-    ) {
-        assert_ne!(available_width, 0.0);
-
-        let Node::Leaf { scroll, .. } = &mut self.dock_state[surface_index][node_index] else {
-            unreachable!()
-        };
-        let overflow = (actual_width - available_width).at_least(0.0);
-        let style = fade_style.unwrap_or_else(|| self.style.as_ref().unwrap());
-
-        // Compare to 1.0 and not 0.0 to avoid drawing a scroll bar due
-        // to floating point precision issue during tab drawing.
-        if overflow > 1.0 {
-            if style.tab_bar.show_scroll_bar_on_overflow {
-                // Draw scroll bar
-                let bar_height = 7.5;
-                let (scroll_bar_rect, _scroll_bar_response) = ui.allocate_exact_size(
-                    vec2(scroll_bar_width, bar_height),
-                    Sense::click_and_drag(),
-                );
-
-                // Compute scroll bar handle position and size.
-                let overflow_ratio = actual_width / available_width;
-                let scroll_ratio = -*scroll / overflow;
-
-                let scroll_bar_handle_size = overflow_ratio.recip() * scroll_bar_rect.width();
-                let scroll_bar_handle_start = lerp(
-                    scroll_bar_rect.left()..=scroll_bar_rect.right() - scroll_bar_handle_size,
-                    scroll_ratio,
-                );
-                let scroll_bar_handle_rect = Rect::from_min_size(
-                    pos2(scroll_bar_handle_start, scroll_bar_rect.min.y),
-                    vec2(scroll_bar_handle_size, bar_height),
-                );
-
-                let scroll_bar_handle_response = ui.interact(
-                    scroll_bar_handle_rect,
-                    self.id.with((node_index, "node")),
-                    Sense::drag(),
-                );
-
-                // Coefficient to apply to input displacements so that we move the scroll by the correct amount.
-                let points_to_scroll_coefficient =
-                    overflow / (scroll_bar_rect.width() - scroll_bar_handle_size);
-
-                *scroll -= scroll_bar_handle_response.drag_delta().x * points_to_scroll_coefficient;
-
-                if let Some(pos) = state.last_hover_pos {
-                    if scroll_bar_rect.contains(pos) {
-                        *scroll += ui.input(|i| i.smooth_scroll_delta.y + i.smooth_scroll_delta.x)
-                            * points_to_scroll_coefficient;
-                    }
-                }
-
-                // Draw the bar.
-                ui.painter()
-                    .rect_filled(scroll_bar_rect, 0.0, ui.visuals().extreme_bg_color);
-
-                ui.painter().rect_filled(
-                    scroll_bar_handle_rect,
-                    bar_height / 2.0,
-                    ui.visuals()
-                        .widgets
-                        .style(&scroll_bar_handle_response)
-                        .bg_fill,
-                );
-            }
-
-            // Handle user input.
-            if tabbar_response.hovered() {
-                *scroll += ui.input(|i| i.smooth_scroll_delta.y + i.smooth_scroll_delta.x);
-            }
-        }
-
-        *scroll = scroll.clamp(-overflow, 0.0);
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    fn tab_body(
-        &mut self,
-        ui: &mut Ui,
-        state: &State,
-        (surface_index, node_index): (SurfaceIndex, NodeIndex),
-        tab_viewer: &mut impl TabViewer<Tab = Tab>,
-        spacing: Vec2,
-        tabbar_rect: Rect,
-        fade: Option<(&Style, f32)>,
-        collapsed: bool,
-    ) {
-        let (body_rect, _body_response) =
-            ui.allocate_exact_size(ui.available_size_before_wrap(), Sense::hover());
-
-        let Node::Leaf {
-            rect,
-            tabs,
-            active,
-            viewport,
-            ..
-        } = &mut self.dock_state[surface_index][node_index]
-        else {
-            unreachable!();
-        };
-
-        if !collapsed {
-            if let Some(tab) = tabs.get_mut(active.0) {
-                *viewport = body_rect;
-
-                if ui.input(|i| i.pointer.any_click()) {
-                    if let Some(pos) = state.last_hover_pos {
-                        if body_rect.contains(pos)
-                            && Some(ui.layer_id()) == ui.ctx().layer_id_at(pos)
-                        {
-                            self.new_focused = Some((surface_index, node_index));
-                        }
-                    }
-                }
-
-                let (style, fade_factor) =
-                    fade.unwrap_or_else(|| (self.style.as_ref().unwrap(), 1.0));
-                let tabs_styles = tab_viewer.tab_style_override(tab, &style.tab);
-
-                let tabs_style = tabs_styles.as_ref().unwrap_or(&style.tab);
-
-                if tab_viewer.clear_background(tab) {
-                    ui.painter().rect_filled(
-                        body_rect,
-                        tabs_style.tab_body.rounding,
-                        tabs_style.tab_body.bg_fill,
-                    );
-                }
-
-                // Construct a new ui with the correct tab id.
-                //
-                // We are forced to use `Ui::new` because other methods (eg: push_id) always mix
-                // the provided id with their own which would cause tabs to change id when moved
-                // from node to node.
-                let id = self.id.with(tab_viewer.id(tab));
-                ui.ctx().check_for_id_clash(id, body_rect, "a tab with id");
-                let ui = &mut Ui::new(
-                    ui.ctx().clone(),
-                    id,
-                    UiBuilder::new().max_rect(body_rect).layer_id(ui.layer_id()),
-                );
-                ui.set_clip_rect(Rect::from_min_max(ui.cursor().min, ui.clip_rect().max));
-
-                // Use initial spacing for ui.
-                ui.spacing_mut().item_spacing = spacing;
-
-                // Offset the background rectangle up to hide the top border behind the clip rect.
-                // To avoid anti-aliasing lines when the stroke width is not divisible by two, we
-                // need to calculate the effective anti-aliased stroke width.
-                let effective_stroke_width = (tabs_style.tab_body.stroke.width / 2.0).ceil() * 2.0;
-                let tab_body_rect = Rect::from_min_max(
-                    ui.clip_rect().min - vec2(0.0, effective_stroke_width),
-                    ui.clip_rect().max,
-                );
-                ui.painter().rect_stroke(
-                    rect_stroke_box(tab_body_rect, tabs_style.tab_body.stroke.width),
-                    tabs_style.tab_body.rounding,
-                    tabs_style.tab_body.stroke,
-                    StrokeKind::Inside,
-                );
-
-                ScrollArea::new(tab_viewer.scroll_bars(tab)).show(ui, |ui| {
-                    Frame::NONE
-                        .inner_margin(tabs_style.tab_body.inner_margin)
-                        .show(ui, |ui| {
-                            if fade_factor != 1.0 {
-                                fade_visuals(ui.visuals_mut(), fade_factor);
-                            }
-                            let available_rect = ui.available_rect_before_wrap();
-                            ui.expand_to_include_rect(available_rect);
-                            tab_viewer.ui(ui, tab);
-                        });
-                });
-            }
-        }
-
-        // change hover destination
-        if let Some(pointer) = state.last_hover_pos {
-            // Prevent borrow checker issues.
-            let rect = rect.to_owned();
-
-            // if the dragged tab isn't allowed in a window,
-            // it's unnecessary to change the hover state
-            let is_dragged_valid = match &state.dnd {
-                Some(DragDropState {
-                    drag: DragData { src, .. },
-                    ..
-                }) => match *src {
-                    TreeComponent::Tab(d_surf, d_node, d_tab) => {
-                        if let Node::Leaf { tabs, .. } = &mut self.dock_state[d_surf][d_node] {
-                            tab_viewer.allowed_in_windows(&mut tabs[d_tab.0])
-                                || surface_index == SurfaceIndex::main()
-                        } else {
-                            true
-                        }
-                    }
-                    _ => unreachable!("collections of nodes can't be dragged (yet)"),
-                },
-                _ => true,
-            };
-
-            // Use rect.contains instead of response.hovered as the dragged tab covers
-            // the underlying responses.
-            if state.drag_start.is_some() && rect.contains(pointer) && is_dragged_valid {
-                let on_title_bar = tabbar_rect.contains(pointer);
-                let (dst, tab) = {
-                    match self.tab_hover_rect {
-                        Some((rect, tab_index)) => (
-                            TreeComponent::Tab(surface_index, node_index, tab_index),
-                            Some(rect),
-                        ),
-                        None => (
-                            TreeComponent::Node(surface_index, node_index),
-                            on_title_bar.then_some(tabbar_rect),
-                        ),
-                    }
-                };
-
-                ui.memory_mut(|mem| {
-                    mem.data.insert_temp(
-                        self.id.with("hover_data"),
-                        Some(HoverData { rect, dst, tab }),
-                    );
-                });
-            }
-        }
-    }
-}
diff --git a/crates/egui-dock/src/widgets/dock_area/show/main_surface.rs b/crates/egui-dock/src/widgets/dock_area/show/main_surface.rs
deleted file mode 100644
index 323576a..0000000
--- a/crates/egui-dock/src/widgets/dock_area/show/main_surface.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-use egui::{Sense, Ui};
-
-use crate::{
-    dock_area::{
-        drag_and_drop::{HoverData, TreeComponent},
-        state::State,
-    },
-    DockArea, SurfaceIndex, TabViewer,
-};
-
-impl<Tab> DockArea<'_, Tab> {
-    pub(super) fn show_root_surface_inside(
-        &mut self,
-        ui: &mut Ui,
-        tab_viewer: &mut impl TabViewer<Tab = Tab>,
-        state: &mut State,
-    ) {
-        let surf_index = SurfaceIndex::main();
-
-        if self.dock_state.main_surface().is_empty() {
-            let rect = ui.available_rect_before_wrap();
-            let response = ui.allocate_rect(rect, Sense::hover());
-            if response.contains_pointer() {
-                ui.memory_mut(|mem| {
-                    mem.data.insert_temp(
-                        self.id.with("hover_data"),
-                        Some(HoverData {
-                            rect,
-                            dst: TreeComponent::Surface(surf_index),
-                            tab: None,
-                        }),
-                    );
-                });
-            }
-            return;
-        }
-
-        self.render_nodes(ui, tab_viewer, state, surf_index, None);
-    }
-}
diff --git a/crates/egui-dock/src/widgets/dock_area/show/mod.rs b/crates/egui-dock/src/widgets/dock_area/show/mod.rs
deleted file mode 100644
index 0e84689..0000000
--- a/crates/egui-dock/src/widgets/dock_area/show/mod.rs
+++ /dev/null
@@ -1,553 +0,0 @@
-use egui::{
-    CentralPanel, Color32, Context, CornerRadius, CursorIcon, EventFilter, Frame, Key, Pos2, Rect,
-    Sense, StrokeKind, Ui, Vec2,
-};
-
-use duplicate::duplicate;
-use paste::paste;
-
-use crate::{
-    utils::{expand_to_pixel, fade_dock_style, map_to_pixel},
-    AllowedSplits, DockArea, Node, NodeIndex, OverlayType, Style, SurfaceIndex, TabDestination,
-    TabViewer,
-};
-
-use super::{drag_and_drop::TreeComponent, state::State, tab_removal::TabRemoval};
-
-mod leaf;
-mod main_surface;
-mod window_surface;
-
-impl<Tab> DockArea<'_, Tab> {
-    /// Show the `DockArea` at the top level.
-    ///
-    /// This is the same as doing:
-    ///
-    /// ```
-    /// # use egui_dock::{DockArea, DockState};
-    /// # use egui::{CentralPanel, Frame};
-    /// # struct TabViewer {}
-    /// # impl egui_dock::TabViewer for TabViewer {
-    /// #     type Tab = String;
-    /// #     fn title(&mut self, tab: &mut Self::Tab) -> egui::WidgetText { (&*tab).into() }
-    /// #     fn ui(&mut self, ui: &mut egui::Ui, tab: &mut Self::Tab) {}
-    /// # }
-    /// # let mut tree: DockState<String> = DockState::new(vec![]);
-    /// # let mut tab_viewer = TabViewer {};
-    /// # egui::__run_test_ctx(|ctx| {
-    /// CentralPanel::default()
-    ///     .frame(Frame::central_panel(&ctx.style()).inner_margin(0.))
-    ///     .show(ctx, |ui| {
-    ///         DockArea::new(&mut tree).show_inside(ui, &mut tab_viewer);
-    ///     });
-    /// # });
-    /// ```
-    ///
-    /// So you can't use the [`CentralPanel::show`] when using `DockArea`'s one.
-    ///
-    /// See also [`show_inside`](Self::show_inside).
-    #[inline]
-    pub fn show(self, ctx: &Context, tab_viewer: &mut impl TabViewer<Tab = Tab>) {
-        CentralPanel::default()
-            .frame(
-                Frame::central_panel(&ctx.style())
-                    .inner_margin(0.)
-                    .fill(Color32::TRANSPARENT),
-            )
-            .show(ctx, |ui| {
-                self.show_inside(ui, tab_viewer);
-            });
-    }
-
-    /// Shows the docking hierarchy inside a [`Ui`].
-    ///
-    /// See also [`show`](Self::show).
-    pub fn show_inside(mut self, ui: &mut Ui, tab_viewer: &mut impl TabViewer<Tab = Tab>) {
-        self.style
-            .get_or_insert(Style::from_egui(ui.style().as_ref()));
-        self.window_bounds.get_or_insert(ui.ctx().screen_rect());
-
-        let mut state = State::load(ui.ctx(), self.id);
-
-        // Delay hover position one frame. On touch screens hover_pos() is None when any_released()
-        if !ui.input(|i| i.pointer.any_released()) {
-            state.last_hover_pos = ui.input(|i| i.pointer.hover_pos());
-        }
-
-        let (drag_data, hover_data) = ui.memory_mut(|mem| {
-            (
-                mem.data.remove_temp(self.id.with("drag_data")).flatten(),
-                mem.data.remove_temp(self.id.with("hover_data")).flatten(),
-            )
-        });
-
-        if let (Some(source), Some(hover)) = (drag_data, hover_data) {
-            let style = self.style.as_ref().unwrap();
-            state.set_drag_and_drop(source, hover, ui.ctx(), style);
-            let tab_dst = self.show_drag_drop_overlay(ui, &mut state, tab_viewer);
-            if ui.input(|i| i.pointer.primary_released()) {
-                if let Some(destination) = tab_dst {
-                    let source = {
-                        match state.dnd.as_ref().unwrap().drag.src {
-                            TreeComponent::Tab(src_surf, src_node, src_tab) => {
-                                (src_surf, src_node, src_tab)
-                            }
-                            _ => todo!(
-                                "collections of tabs, like nodes and surfaces can't be docked (yet)"
-                            ),
-                        }
-                    };
-                    self.dock_state.move_tab(source, destination);
-                }
-            }
-        }
-
-        if ui.input(|i| i.pointer.primary_released()) {
-            state.reset_drag();
-        }
-
-        let style = self.style.as_ref().unwrap();
-        let fade_surface =
-            self.hovered_window_surface(&mut state, style.overlay.feel.fade_hold_time, ui.ctx());
-        let fade_style = {
-            fade_surface.is_some().then(|| {
-                let mut fade_style = style.clone();
-                fade_dock_style(&mut fade_style, style.overlay.surface_fade_opacity);
-                (fade_style, style.overlay.surface_fade_opacity)
-            })
-        };
-
-        for &surface_index in self.dock_state.valid_surface_indices().iter() {
-            self.show_surface_inside(
-                surface_index,
-                ui,
-                tab_viewer,
-                &mut state,
-                fade_style.as_ref().map(|(style, factor)| {
-                    (style, *factor, fade_surface.unwrap_or(SurfaceIndex::main()))
-                }),
-            );
-        }
-
-        for index in self.to_remove.drain(..).rev() {
-            match index {
-                TabRemoval::Node(surface, node, tab) => {
-                    self.dock_state[surface].remove_tab((node, tab));
-                    if self.dock_state[surface].is_empty() && !surface.is_main() {
-                        self.dock_state.remove_surface(surface);
-                    }
-                }
-                TabRemoval::Leaf(surface, node) => {
-                    self.dock_state[surface].remove_leaf(node);
-                    if self.dock_state[surface].is_empty() && !surface.is_main() {
-                        self.dock_state.remove_surface(surface);
-                    }
-                }
-                TabRemoval::Window(index) => {
-                    self.dock_state.remove_surface(index);
-                }
-            }
-        }
-
-        for (surface_index, node_index, tab_index) in self.to_detach.drain(..).rev() {
-            let mouse_pos = state.last_hover_pos;
-            self.dock_state.detach_tab(
-                (surface_index, node_index, tab_index),
-                Rect::from_min_size(
-                    mouse_pos.unwrap_or(Pos2::ZERO),
-                    self.dock_state[surface_index][node_index]
-                        .rect()
-                        .map_or(Vec2::new(100., 150.), |rect| rect.size()),
-                ),
-            );
-        }
-
-        if let Some(focused) = self.new_focused {
-            self.dock_state.set_focused_node_and_surface(focused);
-        }
-
-        state.store(ui.ctx(), self.id);
-    }
-
-    /// Returns some when windows are fading, and what surface index is being hovered over
-    #[inline(always)]
-    fn hovered_window_surface(
-        &self,
-        state: &mut State,
-        hold_time: f32,
-        ctx: &Context,
-    ) -> Option<SurfaceIndex> {
-        if let Some(dnd_state) = &state.dnd {
-            if dnd_state.is_locked(self.style.as_ref().unwrap(), ctx) {
-                state.window_fade =
-                    Some((ctx.input(|i| i.time), dnd_state.hover.dst.surface_address()));
-            }
-        }
-
-        state.window_fade.and_then(|(time, surface)| {
-            ctx.request_repaint();
-            (hold_time > (ctx.input(|i| i.time) - time) as f32).then_some(surface)
-        })
-    }
-
-    /// Resolve where a dragged tab would land given it's dropped this frame, returns `None` when the resulting drop is an invalid move.
-    fn show_drag_drop_overlay(
-        &mut self,
-        ui: &Ui,
-        state: &mut State,
-        tab_viewer: &impl TabViewer<Tab = Tab>,
-    ) -> Option<TabDestination> {
-        let drag_state = state.dnd.as_mut().unwrap();
-        let style = self.style.as_ref().unwrap();
-
-        let deserted_node = {
-            match (
-                drag_state.drag.src.node_address(),
-                drag_state.hover.dst.node_address(),
-            ) {
-                ((src_surf, Some(src_node)), (dst_surf, Some(dst_node))) => {
-                    src_surf == dst_surf
-                        && src_node == dst_node
-                        && self.dock_state[src_surf][src_node].tabs_count() == 1
-                }
-                _ => false,
-            }
-        };
-
-        // Not all scenarios can house all splits.
-        let restricted_splits = if drag_state.hover.dst.is_surface() || deserted_node {
-            AllowedSplits::None
-        } else {
-            AllowedSplits::All
-        };
-        let allowed_splits = self.allowed_splits & restricted_splits;
-
-        let allowed_in_window = match drag_state.drag.src {
-            TreeComponent::Tab(surface, node, tab) => {
-                let Node::Leaf { tabs, .. } = &mut self.dock_state[surface][node] else {
-                    unreachable!("tab drags can only come from leaf nodes")
-                };
-                tab_viewer.allowed_in_windows(&mut tabs[tab.0])
-            }
-            _ => todo!("collections of tabs, like nodes or surfaces, can't be dragged! (yet)"),
-        };
-
-        if let Some(pointer) = state.last_hover_pos {
-            drag_state.pointer = pointer;
-        }
-
-        let window_bounds = self.window_bounds.unwrap();
-        match (style.overlay.overlay_type, drag_state.is_on_title_bar()) {
-            (OverlayType::HighlightedAreas, _) | (_, true) => drag_state.resolve_traditional(
-                ui,
-                style,
-                allowed_splits,
-                allowed_in_window,
-                window_bounds,
-            ),
-            (OverlayType::Widgets, false) => drag_state.resolve_icon_based(
-                ui,
-                style,
-                allowed_splits,
-                allowed_in_window,
-                window_bounds,
-            ),
-        }
-    }
-
-    /// Show a single surface of a [`DockState`].
-    fn show_surface_inside(
-        &mut self,
-        surf_index: SurfaceIndex,
-        ui: &mut Ui,
-        tab_viewer: &mut impl TabViewer<Tab = Tab>,
-        state: &mut State,
-        fade_style: Option<(&Style, f32, SurfaceIndex)>,
-    ) {
-        if surf_index.is_main() {
-            self.show_root_surface_inside(ui, tab_viewer, state);
-        } else {
-            self.show_window_surface(ui, surf_index, tab_viewer, state, fade_style);
-        }
-    }
-
-    fn render_nodes(
-        &mut self,
-        ui: &mut Ui,
-        tab_viewer: &mut impl TabViewer<Tab = Tab>,
-        state: &mut State,
-        surf_index: SurfaceIndex,
-        fade_style: Option<(&Style, f32)>,
-    ) {
-        // First compute all rect sizes in the node graph.
-        let max_rect = self.allocate_area_for_root_node(ui, surf_index);
-        for node_index in self.dock_state[surf_index].breadth_first_index_iter() {
-            if self.dock_state[surf_index][node_index].is_parent() {
-                self.compute_rect_sizes(ui, (surf_index, node_index), max_rect);
-            }
-        }
-
-        // Then, draw the bodies of each leaves.
-        for node_index in self.dock_state[surf_index].breadth_first_index_iter() {
-            if self.dock_state[surf_index][node_index].is_leaf() {
-                self.show_leaf(ui, state, (surf_index, node_index), tab_viewer, fade_style);
-            }
-        }
-
-        // Finally, draw separators so that their "interaction zone" is above
-        // bodies (see `SeparatorStyle::extra_interact_width`).
-        let fade_style = fade_style.map(|(style, _)| style);
-        for node_index in self.dock_state[surf_index].breadth_first_index_iter() {
-            if self.dock_state[surf_index][node_index].is_parent() {
-                self.show_separator(ui, (surf_index, node_index), fade_style);
-            }
-        }
-    }
-
-    fn allocate_area_for_root_node(&mut self, ui: &mut Ui, surface: SurfaceIndex) -> Rect {
-        let style = self.style.as_ref().unwrap();
-        let mut rect = ui.available_rect_before_wrap();
-
-        if let Some(margin) = style.dock_area_padding {
-            rect.min += margin.left_top();
-            rect.max -= margin.right_bottom();
-        }
-
-        ui.painter().rect_stroke(
-            rect,
-            style.main_surface_border_rounding,
-            style.main_surface_border_stroke,
-            StrokeKind::Inside,
-        );
-        if surface == SurfaceIndex::main() {
-            rect = rect.expand(-style.main_surface_border_stroke.width / 2.0);
-        }
-        ui.allocate_rect(rect, Sense::hover());
-
-        if self.dock_state[surface].is_empty() {
-            return rect;
-        }
-        self.dock_state[surface][NodeIndex::root()].set_rect(rect);
-        rect
-    }
-
-    fn compute_rect_sizes(
-        &mut self,
-        ui: &Ui,
-        (surface_index, node_index): (SurfaceIndex, NodeIndex),
-        max_rect: Rect,
-    ) {
-        assert!(self.dock_state[surface_index][node_index].is_parent());
-
-        let style = self.style.as_ref().unwrap();
-        let pixels_per_point = ui.ctx().pixels_per_point();
-
-        let left_collapsed_count =
-            self.dock_state[surface_index][node_index.left()].collapsed_leaf_count();
-        let right_collapsed_count =
-            self.dock_state[surface_index][node_index.right()].collapsed_leaf_count();
-        let left_collapsed = self.dock_state[surface_index][node_index.left()].is_collapsed();
-        let right_collapsed = self.dock_state[surface_index][node_index.right()].is_collapsed();
-
-        if left_collapsed || right_collapsed {
-            if let Node::Vertical { rect, .. } = &mut self.dock_state[surface_index][node_index] {
-                debug_assert!(!rect.any_nan() && rect.is_finite());
-                let rect = expand_to_pixel(*rect, pixels_per_point);
-
-                if left_collapsed {
-                    // EITHER only left collapsed OR left and right both collapsed
-                    let border_y =
-                        rect.min.y + (left_collapsed_count as f32) * style.tab_bar.height;
-                    let left_separator_border = map_to_pixel(
-                        border_y - style.separator.width * 0.5,
-                        pixels_per_point,
-                        f32::round,
-                    );
-                    let right_separator_border = map_to_pixel(
-                        border_y + style.separator.width * 0.5,
-                        pixels_per_point,
-                        f32::round,
-                    );
-                    let left = rect
-                        .intersect(Rect::everything_above(left_separator_border))
-                        .intersect(max_rect);
-                    let right = rect
-                        .intersect(Rect::everything_below(right_separator_border))
-                        .intersect(max_rect);
-                    self.dock_state[surface_index][node_index.left()].set_rect(left);
-                    self.dock_state[surface_index][node_index.right()].set_rect(right);
-                } else {
-                    // Only right collapsed
-                    let border_y =
-                        rect.max.y - (right_collapsed_count as f32) * style.tab_bar.height;
-                    let left_separator_border = map_to_pixel(
-                        border_y - style.separator.width * 0.5,
-                        pixels_per_point,
-                        f32::round,
-                    );
-                    let right_separator_border = map_to_pixel(
-                        border_y + style.separator.width * 0.5,
-                        pixels_per_point,
-                        f32::round,
-                    );
-                    let left = rect
-                        .intersect(Rect::everything_above(left_separator_border))
-                        .intersect(max_rect);
-                    let right = rect
-                        .intersect(Rect::everything_below(right_separator_border))
-                        .intersect(max_rect);
-                    self.dock_state[surface_index][node_index.left()].set_rect(left);
-                    self.dock_state[surface_index][node_index.right()].set_rect(right);
-                }
-                return;
-            }
-        }
-
-        duplicate! {
-            [
-                orientation   dim_point  dim_size  left_of    right_of;
-                [Horizontal]  [x]        [width]   [left_of]  [right_of];
-                [Vertical]    [y]        [height]  [above]    [below];
-            ]
-            if let Node::orientation { fraction, rect, .. } = &mut self.dock_state[surface_index][node_index] {
-                debug_assert!(!rect.any_nan() && rect.is_finite());
-                let rect = expand_to_pixel(*rect, pixels_per_point);
-
-                let midpoint = rect.min.dim_point + rect.dim_size() * *fraction;
-                let left_separator_border = map_to_pixel(
-                    midpoint - style.separator.width * 0.5,
-                    pixels_per_point,
-                    f32::round
-                );
-                let right_separator_border = map_to_pixel(
-                    midpoint + style.separator.width * 0.5,
-                    pixels_per_point,
-                    f32::round
-                );
-
-                paste! {
-                    let left = rect.intersect(Rect::[<everything_ left_of>](left_separator_border)).intersect(max_rect);
-                    let right = rect.intersect(Rect::[<everything_ right_of>](right_separator_border)).intersect(max_rect);
-                }
-
-                self.dock_state[surface_index][node_index.left()].set_rect(left);
-                self.dock_state[surface_index][node_index.right()].set_rect(right);
-            }
-        }
-    }
-
-    fn show_separator(
-        &mut self,
-        ui: &mut Ui,
-        (surface_index, node_index): (SurfaceIndex, NodeIndex),
-        fade_style: Option<&Style>,
-    ) {
-        assert!(self.dock_state[surface_index][node_index].is_parent());
-
-        // If either of the children is collapsed, we don't want the user to interact with the separator
-        if (self.dock_state[surface_index][node_index.left()].is_collapsed()
-            || self.dock_state[surface_index][node_index.right()].is_collapsed())
-            && self.dock_state[surface_index][node_index].is_vertical()
-        {
-            return;
-        }
-
-        let style = fade_style.unwrap_or_else(|| self.style.as_ref().unwrap());
-        let pixels_per_point = ui.ctx().pixels_per_point();
-
-        duplicate! {
-            [
-                orientation   dim_point  dim_size;
-                [Horizontal]  [x]        [width];
-                [Vertical]    [y]        [height];
-            ]
-            if let Node::orientation { fraction, ref rect, .. } = &mut self.dock_state[surface_index][node_index] {
-                let mut separator = *rect;
-
-                let midpoint = rect.min.dim_point + rect.dim_size() * *fraction;
-                separator.min.dim_point = midpoint - style.separator.width * 0.5;
-                separator.max.dim_point = midpoint + style.separator.width * 0.5;
-
-                let mut expand = Vec2::ZERO;
-                expand.dim_point += style.separator.extra_interact_width / 2.0;
-                let interact_rect = separator.expand2(expand);
-
-                let response = ui.allocate_rect(interact_rect, Sense::click_and_drag())
-                    .on_hover_and_drag_cursor(paste!{ CursorIcon::[<Resize orientation>]});
-
-                let should_respond_to_arrow_keys = ui.input(|i| i.modifiers.command || i.modifiers.shift);
-
-                if response.has_focus() {
-                    // Prevent the default behaviour of removing focus from the separators when the
-                    // arrow keys are pressed
-                    ui.memory_mut(|m| m.set_focus_lock_filter(response.id, EventFilter {
-                        horizontal_arrows: should_respond_to_arrow_keys,
-                        vertical_arrows: should_respond_to_arrow_keys,
-                        tab: false,
-                        escape: false
-                    }));
-                }
-
-                let arrow_key_offset = if response.has_focus() && should_respond_to_arrow_keys {
-                    if ui.input(|i| i.key_pressed(Key::ArrowUp)) {
-                        Some(egui::vec2(0., -16.))
-                    } else if ui.input(|i| i.key_pressed(Key::ArrowDown)) {
-                        Some(egui::vec2(0., 16.))
-                    } else if ui.input(|i| i.key_pressed(Key::ArrowLeft)) {
-                        Some(egui::vec2(-16., 0.))
-                    } else if ui.input(|i| i.key_pressed(Key::ArrowRight)) {
-                        Some(egui::vec2(16., 0.))
-                    } else {
-                        None
-                    }
-                } else {
-                    None
-                };
-
-                let midpoint = rect.min.dim_point + rect.dim_size() * *fraction;
-                separator.min.dim_point = map_to_pixel(
-                    midpoint - style.separator.width * 0.5,
-                    pixels_per_point,
-                    f32::round,
-                );
-                separator.max.dim_point = map_to_pixel(
-                    midpoint + style.separator.width * 0.5,
-                    pixels_per_point,
-                    f32::round,
-                );
-
-                let color = if response.dragged() {
-                    style.separator.color_dragged
-                } else if response.hovered() || response.has_focus() {
-                    style.separator.color_hovered
-                } else {
-                    style.separator.color_idle
-                };
-
-                ui.painter().rect_filled(separator, CornerRadius::ZERO, color);
-
-                // Update 'fraction' interaction after drawing separator,
-                // otherwise it may overlap on other separator / bodies when
-                // shrunk fast.
-                if let Some(pos) = response.interact_pointer_pos().or(arrow_key_offset.map(|v| separator.center() + v)) {
-                    let dim_point = pos.dim_point;
-                    let delta = arrow_key_offset.unwrap_or(response.drag_delta()).dim_point;
-
-                    if (delta > 0. && dim_point > midpoint && dim_point < rect.max.dim_point)
-                        || (delta < 0. && dim_point < midpoint && dim_point > rect.min.dim_point)
-                    {
-                        let range = rect.max.dim_point - rect.min.dim_point;
-                        let min = (style.separator.extra / range).min(1.0);
-                        let max = 1.0 - min;
-                        let (min, max) = (min.min(max), max.max(min));
-                        *fraction = (*fraction + delta / range).clamp(min, max);
-                    }
-                }
-
-                if response.double_clicked() {
-                    *fraction = 0.5;
-                }
-            }
-        }
-    }
-}
diff --git a/crates/egui-dock/src/widgets/dock_area/show/window_surface.rs b/crates/egui-dock/src/widgets/dock_area/show/window_surface.rs
deleted file mode 100644
index f0294b1..0000000
--- a/crates/egui-dock/src/widgets/dock_area/show/window_surface.rs
+++ /dev/null
@@ -1,290 +0,0 @@
-use egui::{
-    vec2, Align, Color32, CornerRadius, CursorIcon, Frame, Layout, Rect, Response, RichText, Sense,
-    Shape, Stroke, Ui, UiBuilder, Vec2, WidgetText,
-};
-
-use crate::{
-    dock_area::{state::State, tab_removal::TabRemoval},
-    utils::{fade_visuals, rect_set_size_centered},
-    DockArea, Node, NodeIndex, Style, SurfaceIndex, TabViewer,
-};
-
-impl<Tab> DockArea<'_, Tab> {
-    pub(super) fn show_window_surface(
-        &mut self,
-        ui: &Ui,
-        surf_index: SurfaceIndex,
-        tab_viewer: &mut impl TabViewer<Tab = Tab>,
-        state: &mut State,
-        fade_style: Option<(&Style, f32, SurfaceIndex)>,
-    ) {
-        // Construct egui window
-        let id = format!("window {surf_index:?}").into();
-        let bounds = self.window_bounds.unwrap();
-        let open = true;
-        let window = self
-            .dock_state
-            .get_window_state_mut(surf_index)
-            .unwrap()
-            .create_window(id, bounds);
-
-        // Calculate fading of the window (if any)
-        let (fade_factor, fade_style) = match fade_style {
-            Some((style, factor, surface_index)) => {
-                if surface_index == surf_index {
-                    (1.0, None)
-                } else {
-                    (factor, Some((style, factor)))
-                }
-            }
-            None => (1.0, None),
-        };
-
-        // Get galley of currently selected node as a window title
-        let title = {
-            let node_id = self.dock_state[surf_index]
-                .focused_leaf()
-                .unwrap_or_else(|| {
-                    for node_index in self.dock_state[surf_index].breadth_first_index_iter() {
-                        if self.dock_state[surf_index][node_index].is_leaf() {
-                            return node_index;
-                        }
-                    }
-                    unreachable!("a window surface should never be empty")
-                });
-            let Node::Leaf { tabs, active, .. } = &mut self.dock_state[surf_index][node_id] else {
-                unreachable!()
-            };
-            tab_viewer
-                .title(&mut tabs[active.0])
-                .color(ui.visuals().widgets.noninteractive.fg_stroke.color)
-        };
-
-        // Iterate through every node in dock_state[surf_index], and sum up the number of tabs in them
-        let mut tab_count = 0;
-        for node_index in self.dock_state[surf_index].breadth_first_index_iter() {
-            if self.dock_state[surf_index][node_index].is_leaf() {
-                tab_count += self.dock_state[surf_index][node_index].tabs_count();
-            }
-        }
-
-        // Fade window frame (if necessary)
-        let mut frame = Frame::window(ui.style());
-        if fade_factor != 1.0 {
-            frame.fill = frame.fill.linear_multiply(fade_factor);
-            frame.stroke.color = frame.stroke.color.linear_multiply(fade_factor);
-            frame.shadow.color = frame.shadow.color.linear_multiply(fade_factor);
-        }
-
-        let tab_bar_height = self.style.as_ref().unwrap().tab_bar.height;
-        let minimized = self
-            .dock_state
-            .get_window_state(surf_index)
-            .unwrap()
-            .is_minimized();
-        if minimized {
-            let height = tab_bar_height;
-            window
-                .resizable([true, false])
-                .max_height(height)
-                .min_height(height)
-        } else if self.dock_state[surf_index].is_collapsed() {
-            let height = self.dock_state[surf_index].collapsed_leaf_count() as f32 * tab_bar_height;
-            window
-                .resizable([true, false])
-                .max_height(height)
-                .min_height(height)
-        } else {
-            window
-        }
-        .frame(frame)
-        .show(ui.ctx(), |ui| {
-            // Fade inner ui (if necessary)
-            if fade_factor != 1.0 {
-                fade_visuals(ui.visuals_mut(), fade_factor);
-            }
-            if minimized {
-                self.minimized_body(
-                    ui,
-                    surf_index,
-                    fade_style.map(|(style, _)| style),
-                    title,
-                    tab_count,
-                )
-            } else {
-                self.render_nodes(ui, tab_viewer, state, surf_index, fade_style);
-            }
-        });
-
-        if !open {
-            self.to_remove.push(TabRemoval::Window(surf_index));
-        }
-    }
-
-    fn minimized_body(
-        &mut self,
-        ui: &mut Ui,
-        surface_index: SurfaceIndex,
-        fade_style: Option<&Style>,
-        title: WidgetText,
-        tab_count: usize,
-    ) {
-        ui.horizontal(|ui| {
-            let style = fade_style.unwrap_or_else(|| self.style.as_ref().unwrap());
-            let (tabbar_outer_rect, _) = ui.allocate_exact_size(
-                vec2(Style::TAB_EXPAND_BUTTON_SIZE, style.tab_bar.height),
-                Sense::hover(),
-            );
-            ui.painter().rect_filled(
-                tabbar_outer_rect,
-                style.tab_bar.rounding,
-                style.tab_bar.bg_fill,
-            );
-            self.window_expand(ui, surface_index, tabbar_outer_rect, fade_style);
-            ui.label(title);
-            if tab_count > 1 {
-                ui.label(
-                    RichText::new(format!("+{}", tab_count - 1))
-                        .color(ui.visuals().weak_text_color()),
-                );
-            }
-            ui.allocate_space(ui.available_size());
-        });
-    }
-
-    /// Draws the expand window button.
-    fn window_expand(
-        &mut self,
-        ui: &mut Ui,
-        surface_index: SurfaceIndex,
-        tabbar_outer_rect: Rect,
-        fade_style: Option<&Style>,
-    ) {
-        let rect = tabbar_outer_rect;
-
-        let ui = &mut ui.new_child(
-            UiBuilder::new()
-                .max_rect(rect)
-                .layout(Layout::left_to_right(Align::Center))
-                .id_salt((surface_index, "window_expand")),
-        );
-
-        let (rect, mut response) = ui.allocate_exact_size(ui.available_size(), Sense::click());
-
-        response = response.on_hover_cursor(CursorIcon::PointingHand);
-
-        let style = fade_style.unwrap_or_else(|| self.style.as_ref().unwrap());
-        let color = if response.hovered() || response.has_focus() {
-            ui.painter().rect_filled(
-                rect,
-                CornerRadius::ZERO,
-                style.buttons.minimize_window_bg_fill,
-            );
-            style.buttons.minimize_window_active_color
-        } else {
-            style.buttons.minimize_window_color
-        };
-
-        let mut arrow_rect = rect;
-
-        rect_set_size_centered(&mut arrow_rect, Vec2::splat(Style::TAB_EXPAND_ARROW_SIZE));
-
-        Self::draw_chevron_right(ui, &mut response, style, color, arrow_rect);
-
-        // Draw button right border.
-        ui.painter().vline(
-            rect.right(),
-            rect.y_range(),
-            Stroke::new(
-                ui.ctx().pixels_per_point().recip(),
-                style.buttons.minimize_window_border_color,
-            ),
-        );
-
-        if response.clicked() {
-            self.window_toggle_minimized(surface_index);
-        }
-    }
-
-    fn draw_chevron_right(
-        ui: &mut Ui,
-        response: &mut Response,
-        style: &Style,
-        color: Color32,
-        arrow_rect: Rect,
-    ) {
-        ui.painter().add(Shape::convex_polygon(
-            // Arrow pointing rightwards.
-            vec![
-                arrow_rect.left_top(),
-                arrow_rect.center(),
-                arrow_rect.left_bottom(),
-            ],
-            color,
-            Stroke::NONE,
-        ));
-
-        // Chevron pointing rightwards.
-        ui.painter().add(Shape::convex_polygon(
-            vec![
-                arrow_rect.center_top(),
-                arrow_rect.right_center(),
-                arrow_rect.center_bottom(),
-            ],
-            color,
-            Stroke::NONE,
-        ));
-        let color = if response.hovered() || response.has_focus() {
-            style.buttons.minimize_window_bg_fill
-        } else {
-            style.tab_bar.bg_fill
-        };
-        ui.painter().add(Shape::convex_polygon(
-            vec![
-                arrow_rect
-                    .center_top()
-                    .lerp(arrow_rect.center_bottom(), 0.25),
-                arrow_rect.center().lerp(arrow_rect.right_center(), 0.5),
-                arrow_rect
-                    .center_top()
-                    .lerp(arrow_rect.center_bottom(), 0.75),
-            ],
-            color,
-            Stroke::NONE,
-        ));
-    }
-
-    pub(super) fn window_toggle_minimized(&mut self, surf_index: SurfaceIndex) {
-        let minimized = self
-            .dock_state
-            .get_window_state(surf_index)
-            .unwrap()
-            .is_minimized();
-        let surface = &mut self.dock_state[surf_index];
-
-        if surface.root_node().is_some_and(|node| node.is_collapsed()) {
-            // The window is already fully collapsed,
-            // so `expanded_height` has already been set.
-            // We don't need to set `new` either.
-            if let Some(window_state) = self.dock_state.get_window_state_mut(surf_index) {
-                window_state.toggle_minimized();
-            }
-        } else if minimized {
-            if let Some(window_state) = self.dock_state.get_window_state_mut(surf_index) {
-                window_state.set_new(true);
-                window_state.toggle_minimized();
-            }
-        } else {
-            let root_index = NodeIndex::root();
-            let surface_height = if surface.root_node().is_some() {
-                surface[root_index].rect().unwrap().height()
-            } else {
-                0.0
-            };
-            if let Some(window_state) = self.dock_state.get_window_state_mut(surf_index) {
-                window_state.set_expanded_height(surface_height);
-                window_state.toggle_minimized();
-            }
-        }
-    }
-}
diff --git a/crates/egui-dock/src/widgets/dock_area/state.rs b/crates/egui-dock/src/widgets/dock_area/state.rs
deleted file mode 100644
index 84b40e1..0000000
--- a/crates/egui-dock/src/widgets/dock_area/state.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-use egui::{Context, Id, Pos2};
-
-use crate::{Style, SurfaceIndex};
-
-use super::drag_and_drop::{DragData, DragDropState, HoverData};
-
-#[derive(Clone, Debug, Default)]
-pub(super) struct State {
-    pub drag_start: Option<Pos2>,
-    pub last_hover_pos: Option<Pos2>,
-    pub dnd: Option<DragDropState>,
-    pub window_fade: Option<(f64, SurfaceIndex)>,
-}
-
-impl State {
-    #[inline(always)]
-    pub(super) fn load(ctx: &Context, id: Id) -> Self {
-        ctx.data_mut(|d| d.get_temp(id)).unwrap_or(Self {
-            drag_start: None,
-            last_hover_pos: None,
-            dnd: None,
-            window_fade: None,
-        })
-    }
-
-    #[inline(always)]
-    pub(super) fn store(self, ctx: &Context, id: Id) {
-        ctx.data_mut(|d| d.insert_temp(id, self));
-    }
-
-    pub(super) fn reset_drag(&mut self) {
-        self.dnd = None;
-        self.window_fade = None;
-        self.drag_start = None;
-    }
-
-    pub(super) fn set_drag_and_drop(
-        &mut self,
-        drag: DragData,
-        drop: HoverData,
-        ctx: &Context,
-        style: &Style,
-    ) {
-        if !self.is_drag_drop_locked(ctx, style) {
-            self.dnd = Some(DragDropState {
-                hover: drop,
-                drag,
-                pointer: ctx.pointer_hover_pos().unwrap_or(Pos2::ZERO),
-                locked: None,
-            })
-        }
-    }
-
-    #[inline(always)]
-    fn is_drag_drop_locked(&self, ctx: &Context, style: &Style) -> bool {
-        self.dnd
-            .as_ref()
-            .is_some_and(|drag_drop_state| drag_drop_state.is_locked(style, ctx))
-    }
-}
diff --git a/crates/egui-dock/src/widgets/dock_area/tab_removal.rs b/crates/egui-dock/src/widgets/dock_area/tab_removal.rs
deleted file mode 100644
index ec3681d..0000000
--- a/crates/egui-dock/src/widgets/dock_area/tab_removal.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-use crate::{NodeIndex, SurfaceIndex, TabIndex};
-
-/// An enum expressing an entry in the `to_remove` field in [`DockArea`].
-#[derive(Debug, Clone, Copy)]
-pub(super) enum TabRemoval {
-    Node(SurfaceIndex, NodeIndex, TabIndex),
-    Leaf(SurfaceIndex, NodeIndex),
-    Window(SurfaceIndex),
-}
-
-impl From<SurfaceIndex> for TabRemoval {
-    fn from(index: SurfaceIndex) -> Self {
-        TabRemoval::Window(index)
-    }
-}
-
-impl From<(SurfaceIndex, NodeIndex)> for TabRemoval {
-    fn from((si, ni): (SurfaceIndex, NodeIndex)) -> TabRemoval {
-        TabRemoval::Leaf(si, ni)
-    }
-}
-
-impl From<(SurfaceIndex, NodeIndex, TabIndex)> for TabRemoval {
-    fn from((si, ni, ti): (SurfaceIndex, NodeIndex, TabIndex)) -> TabRemoval {
-        TabRemoval::Node(si, ni, ti)
-    }
-}
diff --git a/crates/egui-dock/src/widgets/mod.rs b/crates/egui-dock/src/widgets/mod.rs
deleted file mode 100644
index 874839d..0000000
--- a/crates/egui-dock/src/widgets/mod.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-/// Container for dockable tabs.
-pub mod dock_area;
-
-pub(crate) mod popup;
-
-/// Trait for tab-viewing types.
-pub mod tab_viewer;
-
-pub use dock_area::{AllowedSplits, DockArea};
-pub use tab_viewer::TabViewer;
diff --git a/crates/egui-dock/src/widgets/popup.rs b/crates/egui-dock/src/widgets/popup.rs
deleted file mode 100644
index 5ba8026..0000000
--- a/crates/egui-dock/src/widgets/popup.rs
+++ /dev/null
@@ -1,104 +0,0 @@
-use egui::{containers::*, emath::*, Id, Key, Layout, Order, Response, Ui};
-
-#[derive(Clone, Default, Debug)]
-struct State {
-    size: Vec2,
-}
-
-// This code was taken from the example here: https://github.com/emilk/egui/pull/1653#issuecomment-1133671051.
-// It's needed because `egui`'s `popup_below_widget` currently doesn't respect window edges and will fall outside
-// of them if near the right or bottom edge. It should be replaced with `egui` functions when this is fixed.
-//
-// All credit goes to https://github.com/zicklag.
-
-/// Like `egui::popup_under_widget`, but pops up to the left, so that the popup doesn't go off the screen.
-pub(crate) fn popup_under_widget<R>(
-    ui: &Ui,
-    popup_id: Id,
-    widget_response: &Response,
-    add_contents: impl FnOnce(&mut Ui) -> R,
-) -> Option<R> {
-    if !ui.memory(|mem| mem.is_popup_open(popup_id)) {
-        return None;
-    }
-
-    let state: Option<State> = ui.data_mut(|d| d.get_temp(popup_id));
-
-    // If this is the first draw, we don't know the popup size yet, so we don't know how to
-    // position the popup
-    if state.is_none() {
-        ui.ctx().request_repaint();
-    }
-
-    let mut state = state.unwrap_or_default();
-
-    let rect = Rect {
-        min: widget_response.rect.left_bottom(),
-        max: widget_response.rect.left_bottom() + state.size,
-    };
-    let inner = Area::new(popup_id)
-        .order(Order::Foreground)
-        .fixed_pos(constrain_window_rect_to_area(ui.ctx(), rect, None).min)
-        .movable(true)
-        .show(ui.ctx(), |ui| {
-            // Note: we use a separate clip-rect for this area, so the popup can be outside the parent.
-            // See https://github.com/emilk/egui/issues/825
-            let frame = Frame::popup(ui.style());
-            let frame_margin = frame.inner_margin + frame.outer_margin;
-            let result = frame
-                .show(ui, |ui| {
-                    ui.with_layout(Layout::top_down_justified(Align::LEFT), |ui| {
-                        ui.set_width(widget_response.rect.width() - frame_margin.sum().x);
-                        add_contents(ui)
-                    })
-                    .inner
-                })
-                .inner;
-
-            state.size = ui.min_rect().size();
-
-            result
-        })
-        .inner;
-
-    ui.data_mut(|d| *d.get_temp_mut_or_default(popup_id) = state);
-
-    if ui.input(|i| i.key_pressed(Key::Escape)) || widget_response.clicked_elsewhere() {
-        ui.memory_mut(|mem| mem.close_popup());
-    }
-    Some(inner)
-}
-
-/// Copied egui because it is a private function on `egui::Context`
-pub(crate) fn constrain_window_rect_to_area(
-    ctx: &egui::Context,
-    window: Rect,
-    area: Option<Rect>,
-) -> Rect {
-    let mut area = area.unwrap_or_else(|| ctx.available_rect());
-
-    if window.width() > area.width() {
-        // Allow overlapping side bars.
-        // This is important for small screens, e.g. mobiles running the web demo.
-        area.max.x = ctx.input(|i| i.screen_rect()).max.x;
-        area.min.x = ctx.input(|i| i.screen_rect()).min.x;
-    }
-    if window.height() > area.height() {
-        // Allow overlapping top/bottom bars:
-        area.max.y = ctx.input(|i| i.screen_rect()).max.y;
-        area.min.y = ctx.input(|i| i.screen_rect()).min.y;
-    }
-
-    let mut pos = window.min;
-
-    // Constrain to screen, unless window is too large to fit:
-    let margin_x = (window.width() - area.width()).at_least(0.0);
-    let margin_y = (window.height() - area.height()).at_least(0.0);
-
-    pos.x = pos.x.at_most(area.right() + margin_x - window.width()); // move left if needed
-    pos.x = pos.x.at_least(area.left() - margin_x); // move right if needed
-    pos.y = pos.y.at_most(area.bottom() + margin_y - window.height()); // move right if needed
-    pos.y = pos.y.at_least(area.top() - margin_y); // move down if needed
-
-    Rect::from_min_size(pos, window.size())
-}
diff --git a/crates/egui-dock/src/widgets/tab_viewer.rs b/crates/egui-dock/src/widgets/tab_viewer.rs
deleted file mode 100644
index de1788a..0000000
--- a/crates/egui-dock/src/widgets/tab_viewer.rs
+++ /dev/null
@@ -1,100 +0,0 @@
-use crate::{NodeIndex, SurfaceIndex, TabStyle};
-use egui::{Id, Ui, WidgetText};
-
-/// Defines how a tab should behave and be rendered inside a [`Tree`](crate::Tree).
-pub trait TabViewer {
-    /// The type of tab in which you can store state to be drawn in your tabs.
-    type Tab;
-
-    /// The title to be displayed in the tab bar.
-    fn title(&mut self, tab: &mut Self::Tab) -> WidgetText;
-
-    /// Actual tab content.
-    fn ui(&mut self, ui: &mut Ui, tab: &mut Self::Tab);
-
-    /// Content inside the context menu shown when the tab is right-clicked.
-    ///
-    /// `_surface` and `_node` specify which [`Surface`](crate::Surface) and [`Node`](crate::Node)
-    /// that this particular context menu belongs to.
-    fn context_menu(
-        &mut self,
-        _ui: &mut Ui,
-        _tab: &mut Self::Tab,
-        _surface: SurfaceIndex,
-        _node: NodeIndex,
-    ) {
-    }
-
-    /// Unique ID for this tab.
-    ///
-    /// If not implemented, uses tab title text as an ID source.
-    fn id(&mut self, tab: &mut Self::Tab) -> Id {
-        Id::new(self.title(tab).text())
-    }
-
-    /// 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) {}
-
-    /// Returns `true` if the user of your app should be able to close a given `_tab`.
-    ///
-    /// By default `true` is always returned.
-    fn closeable(&mut self, _tab: &mut Self::Tab) -> bool {
-        true
-    }
-
-    /// This is called when the `_tab` gets closed by the user.
-    ///
-    /// Returns `true` if the tab should close immediately, otherwise `false`.
-    ///
-    /// **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
-    }
-
-    /// This is called when the add button is pressed.
-    ///
-    /// `_surface` and `_node` specify which [`Surface`](crate::Surface) and on which
-    /// [`Node`](crate::Node) this particular add button was pressed.
-    fn on_add(&mut self, _surface: SurfaceIndex, _node: NodeIndex) {}
-
-    /// Content of the popup under the add button. Useful for selecting what type of tab to add.
-    ///
-    /// This requires that [`DockArea::show_add_buttons`](crate::DockArea::show_add_buttons) and
-    /// [`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
-    }
-
-    /// Specifies a tab's ability to be shown in a window.
-    ///
-    /// Returns `false` if this tab should never be turned into a window.
-    fn allowed_in_windows(&self, _tab: &mut Self::Tab) -> bool {
-        true
-    }
-
-    /// Whether the tab body will be cleared with the color specified in
-    /// [`TabBarStyle::bg_fill`](crate::TabBarStyle::bg_fill).
-    fn clear_background(&self, _tab: &Self::Tab) -> bool {
-        true
-    }
-
-    /// Returns `true` if the horizontal and vertical scroll bars will be shown for `tab`.
-    ///
-    /// By default, both scroll bars are shown.
-    fn scroll_bars(&self, _tab: &Self::Tab) -> [bool; 2] {
-        [true, true]
-    }
-}
diff --git a/crates/egui-term/src/alacritty/mod.rs b/crates/egui-term/src/alacritty/mod.rs
index 44f5c70..87449de 100644
--- a/crates/egui-term/src/alacritty/mod.rs
+++ b/crates/egui-term/src/alacritty/mod.rs
@@ -238,7 +238,7 @@ impl Terminal {
             RegexSearch::new(url_regex).map_err(|err| IoError::new(ErrorKind::InvalidData, err))?;
         let _pty_event_loop_thread = pty_event_loop.spawn();
         let _pty_event_subscription = std::thread::Builder::new()
-            .name(format!("pty_event_subscription_{}", id))
+            .name(format!("pty_event_subscription_{id}"))
             .spawn(move || while let Ok(event) = event_receiver.recv() {
                 pty_event_proxy_sender
                     .send((id, event.clone()))
@@ -347,7 +347,7 @@ impl<'a> TerminalContext<'a> {
         self.terminal
             .selection
             .as_ref()
-            .map_or(true, Selection::is_empty)
+            .is_none_or(Selection::is_empty)
     }
 
     pub fn write_data<I: Into<Cow<'static, [u8]>>>(&mut self, data: I) {
diff --git a/crates/egui-term/src/display/mod.rs b/crates/egui-term/src/display/mod.rs
index 56ecef8..38c1a91 100644
--- a/crates/egui-term/src/display/mod.rs
+++ b/crates/egui-term/src/display/mod.rs
@@ -176,7 +176,7 @@ impl TerminalView<'_> {
         if ui.add(copy_btn).clicked() {
             let data = self.term_ctx.selection_content();
             layout.ctx.copy_text(data);
-            ui.close_menu();
+            ui.close();
         }
     }
 
@@ -192,7 +192,7 @@ impl TerminalView<'_> {
                 self.term_ctx.write_data(data.into_bytes());
                 self.term_ctx.terminal.selection = None;
             }
-            ui.close_menu();
+            ui.close();
         }
     }
 
@@ -205,7 +205,7 @@ impl TerminalView<'_> {
         let select_all_btn = context_btn("Select All", btn_width, Some(select_all_shortcut));
         if ui.add(select_all_btn).clicked() {
             self.term_ctx.select_all();
-            ui.close_menu();
+            ui.close();
         }
     }
 }
diff --git a/crates/egui-term/src/lib.rs b/crates/egui-term/src/lib.rs
index 26e1956..fcd299a 100644
--- a/crates/egui-term/src/lib.rs
+++ b/crates/egui-term/src/lib.rs
@@ -4,6 +4,7 @@ mod display;
 mod errors;
 mod font;
 mod input;
+mod scroll_bar;
 mod ssh;
 mod theme;
 mod types;
@@ -13,6 +14,7 @@ pub use alacritty::{PtyEvent, TermType, Terminal, TerminalContext};
 pub use alacritty_terminal::term::TermMode;
 pub use bindings::{Binding, BindingAction, InputKind, KeyboardBinding};
 pub use font::{FontSettings, TerminalFont};
+pub use scroll_bar::{InteractiveScrollbar, ScrollbarState};
 pub use ssh::{Authentication, SshOptions};
 pub use theme::{ColorPalette, TerminalTheme};
 pub use view::{TerminalOptions, TerminalView};
diff --git a/crates/egui-term/src/scroll_bar.rs b/crates/egui-term/src/scroll_bar.rs
new file mode 100644
index 0000000..5831eff
--- /dev/null
+++ b/crates/egui-term/src/scroll_bar.rs
@@ -0,0 +1,88 @@
+use egui::{Color32, NumExt, Pos2, Rect, Sense, Ui, Vec2};
+
+#[derive(Clone)]
+pub struct ScrollbarState {
+    pub scroll_pixels: f32,
+}
+
+impl Default for ScrollbarState {
+    fn default() -> Self {
+        Self { scroll_pixels: 0.0 }
+    }
+}
+
+pub struct InteractiveScrollbar {
+    pub first_row_pos: f32,
+    pub new_first_row_pos: Option<f32>,
+    pub background: Color32,
+}
+
+impl InteractiveScrollbar {
+    pub fn new(background: Color32) -> Self {
+        Self {
+            first_row_pos: 0.0,
+            new_first_row_pos: None,
+            background,
+        }
+    }
+
+    pub fn set_first_row_pos(&mut self, row: f32) {
+        self.first_row_pos = row;
+    }
+
+    pub const WIDTH: f32 = 8.0;
+    pub const MARGIN: f32 = 0.0;
+}
+
+impl InteractiveScrollbar {
+    pub fn ui(&mut self, total_height: f32, ui: &mut Ui) {
+        let mut position: f32;
+        let scrollbar_width = InteractiveScrollbar::WIDTH;
+        let margin = InteractiveScrollbar::MARGIN;
+
+        let available_rect = ui.available_rect_before_wrap();
+        let height = available_rect.bottom() - available_rect.top();
+        let y_min = available_rect.top() + margin;
+        let scrollbar_rect = Rect::from_min_size(
+            Pos2::new(available_rect.right() - scrollbar_width - margin, y_min),
+            Vec2::new(scrollbar_width, height),
+        );
+
+        let ratio = (height / total_height).min(1.0);
+        let slider_height = (height * ratio).at_least(64.0);
+        let max_value = total_height - height;
+        let max_scroll_top = height - slider_height;
+        let scroll_pos = max_scroll_top - self.first_row_pos * max_scroll_top / max_value;
+        let slider_rect = Rect::from_min_size(
+            scrollbar_rect.min + Vec2::new(0.0, scroll_pos),
+            Vec2::new(scrollbar_width, slider_height),
+        );
+
+        ui.painter()
+            .rect_filled(scrollbar_rect, 0.0, self.background);
+        ui.painter()
+            .rect_filled(slider_rect, 0.0, Color32::DARK_GRAY);
+
+        let response = ui.allocate_rect(slider_rect, Sense::click_and_drag());
+        let scrollbar_response = ui.allocate_rect(scrollbar_rect, Sense::click());
+
+        if response.dragged() {
+            if let Some(pos) = response.hover_pos() {
+                let new_position = pos.y - scrollbar_rect.top();
+                position = new_position.clamp(0.0, height);
+                let new_first_row_pos = max_value - position * max_value / max_scroll_top;
+                self.new_first_row_pos = Some(new_first_row_pos);
+            }
+        }
+
+        if scrollbar_response.clicked() {
+            if let Some(click_pos) = scrollbar_response.interact_pointer_pos() {
+                let click_y = click_pos.y - scrollbar_rect.top();
+                position = click_y.clamp(0.0, height);
+                let new_first_row_pos = max_value - position * max_value / max_scroll_top;
+                self.new_first_row_pos = Some(new_first_row_pos);
+            }
+        }
+        ui.ctx().request_repaint();
+    }
+}
diff --git a/crates/egui-term/src/theme.rs b/crates/egui-term/src/theme.rs
index 4a49df4..86d7b7f 100644
--- a/crates/egui-term/src/theme.rs
+++ b/crates/egui-term/src/theme.rs
@@ -148,8 +148,7 @@ impl TerminalTheme {
                         _ => &self.palette.background,
                     };
 
-                    return hex_to_color(color)
-                        .unwrap_or_else(|_| panic!("invalid color {}", color));
+                    return hex_to_color(color).unwrap_or_else(|_| panic!("invalid color {color}"));
                 }
 
                 // Other colors
@@ -197,7 +196,7 @@ impl TerminalTheme {
                     _ => &self.palette.background,
                 };
 
-                hex_to_color(color).unwrap_or_else(|_| panic!("invalid color {}", color))
+                hex_to_color(color).unwrap_or_else(|_| panic!("invalid color {color}"))
             }
         }
     }
diff --git a/crates/egui-term/src/view.rs b/crates/egui-term/src/view.rs
index e707e57..cb6f578 100644
--- a/crates/egui-term/src/view.rs
+++ b/crates/egui-term/src/view.rs
@@ -3,9 +3,12 @@ use crate::bindings::Binding;
 use crate::bindings::{BindingAction, Bindings, InputKind};
 use crate::font::TerminalFont;
 use crate::input::InputAction;
+use crate::scroll_bar::{InteractiveScrollbar, ScrollbarState};
 use crate::theme::TerminalTheme;
 use crate::types::Size;
+use alacritty_terminal::grid::{Dimensions, Scroll};
 use alacritty_terminal::index::Point;
+use alacritty_terminal::vte::ansi::{Color, NamedColor};
 use egui::ImeEvent;
 use egui::Widget;
 use egui::{Context, Event};
@@ -22,6 +25,7 @@ pub struct TerminalViewState {
     pub cursor_position: Option<Pos2>,
     // ime_enabled: bool,
     // ime_cursor_range: CursorRange,
+    pub scrollbar_state: ScrollbarState,
 }
 
 impl TerminalViewState {
@@ -57,38 +61,66 @@ pub struct TerminalOptions<'a> {
 
 impl Widget for TerminalView<'_> {
     fn ui(mut self, ui: &mut egui::Ui) -> Response {
-        let (layout, painter) = ui.allocate_painter(self.size, egui::Sense::click());
-
         let widget_id = self.widget_id;
         let mut state = TerminalViewState::load(ui.ctx(), widget_id);
+        let mut layout_opt = None;
 
-        if layout.contains_pointer() {
-            *self.options.active_tab_id = Some(self.widget_id);
-            layout.ctx.set_cursor_icon(CursorIcon::Text);
-        } else {
-            layout.ctx.set_cursor_icon(CursorIcon::Default);
-        }
+        ui.horizontal(|ui| {
+            let size_p = Vec2::new(self.size.x - InteractiveScrollbar::WIDTH, self.size.y);
+            let (layout, painter) = ui.allocate_painter(size_p, egui::Sense::click());
 
-        if self.options.active_tab_id.is_none() {
-            self.has_focus = false;
-        }
+            if layout.contains_pointer() {
+                *self.options.active_tab_id = Some(self.widget_id);
+                layout.ctx.set_cursor_icon(CursorIcon::Text);
+            } else {
+                layout.ctx.set_cursor_icon(CursorIcon::Default);
+            }
 
-        // context menu
-        if let Some(pos) = state.cursor_position {
-            self.context_menu(pos, &layout, ui);
-        }
-        if ui.input(|input_state| input_state.pointer.primary_clicked()) {
-            state.cursor_position = None;
-            ui.close_menu();
-        }
+            if self.options.active_tab_id.is_none() {
+                self.has_focus = false;
+            }
+
+            // context menu
+            if let Some(pos) = state.cursor_position {
+                self.context_menu(pos, &layout, ui);
+            }
+            if ui.input(|input_state| input_state.pointer.primary_clicked()) {
+                state.cursor_position = None;
+                ui.close();
+            }
+
+            let background = self.theme().get_color(Color::Named(NamedColor::Background));
+
+            let mut term = self
+                .focus(&layout)
+                .resize(&layout)
+                .process_input(&mut state, &layout);
+
+            let grid = term.term_ctx.terminal.grid_mut();
+            let total_lines = grid.total_lines() as f32;
+            let display_offset = grid.display_offset() as f32;
+            let cell_height = term.term_ctx.size.cell_height as f32;
+            let total_height = cell_height * total_lines;
+            let display_offset_pos = display_offset * cell_height;
+
+            let mut scrollbar = InteractiveScrollbar::new(background);
+            scrollbar.set_first_row_pos(display_offset_pos);
+            scrollbar.ui(total_height, ui);
+            if let Some(new_first_row_pos) = scrollbar.new_first_row_pos {
+                let total_row_pos = new_first_row_pos + state.scrollbar_state.scroll_pixels;
+                let new_pos = total_row_pos / cell_height;
+                state.scrollbar_state.scroll_pixels = total_row_pos % cell_height;
+                let line_diff = new_pos - display_offset;
+                let line_delta = Scroll::Delta(line_diff.ceil() as i32);
+                grid.scroll_display(line_delta);
+            }
 
-        self.focus(&layout)
-            .resize(&layout)
-            .process_input(&mut state, &layout)
-            .show(&mut state, &layout, &painter);
+            term.show(&mut state, &layout, &painter);
 
-        state.store(ui.ctx(), widget_id);
-        layout
+            state.store(ui.ctx(), widget_id);
+            layout_opt = Some(layout);
+        });
+        layout_opt.unwrap()
     }
 }
 
diff --git a/crates/egui-theme-switch/Cargo.toml b/crates/egui-theme-switch/Cargo.toml
deleted file mode 100644
index ef79ce0..0000000
--- a/crates/egui-theme-switch/Cargo.toml
+++ /dev/null
@@ -1,15 +0,0 @@
-[package]
-name = "egui-theme-switch"
-version = "0.2.3"
-edition = "2021"
-rust-version = "1.80.0"
-license = "MIT OR Apache-2.0"
-readme = "readme.md"
-repository = "https://github.com/bash/egui-theme-switch"
-description = "A pretty theme switch for your egui app"
-keywords = ["egui", "widget", "dark-light", "switch"]
-categories = ["gui"]
-exclude = [".github", "doc/*.py", "doc/*.png", "deny.toml"]
-
-[dependencies]
-egui.workspace = true
diff --git a/crates/egui-theme-switch/src/arc.rs b/crates/egui-theme-switch/src/arc.rs
deleted file mode 100644
index c42ffc9..0000000
--- a/crates/egui-theme-switch/src/arc.rs
+++ /dev/null
@@ -1,82 +0,0 @@
-use egui::emath::{vec2, Pos2, Vec2};
-use egui::epaint::{Color32, CubicBezierShape, Stroke};
-use std::f32::consts::FRAC_PI_2;
-use std::ops::RangeInclusive;
-
-pub(crate) fn approximate_with_beziers(
-    center: impl Into<Pos2>,
-    radius: impl Into<f32>,
-    range: impl Into<RangeInclusive<f32>>,
-    fill: impl Into<Color32>,
-    stroke: impl Into<Stroke>,
-) -> impl Iterator<Item = CubicBezierShape> + Clone {
-    let fill = fill.into();
-    let stroke = stroke.into();
-    approximate_with_beziers_impl(center.into(), radius.into(), range.into())
-        .map(move |p| CubicBezierShape::from_points_stroke(p, false, fill, stroke))
-}
-
-// Implementation based on:
-// Riškus, Aleksas. (2006). Approximation of a cubic bezier curve by circular arcs and vice versa.
-// Information Technology and Control. 35.
-
-fn approximate_with_beziers_impl(
-    center: Pos2,
-    radius: f32,
-    range: RangeInclusive<f32>,
-) -> impl Iterator<Item = [Pos2; 4]> + Clone {
-    QuarterTurnsIter(Some(range))
-        .map(move |r| approximate_with_bezier(center, radius, *r.start(), *r.end()))
-}
-
-fn approximate_with_bezier(center: Pos2, radius: f32, start: f32, end: f32) -> [Pos2; 4] {
-    let p1 = center + radius * Vec2::angled(start);
-    let p4 = center + radius * Vec2::angled(end);
-
-    let a = p1 - center;
-    let b = p4 - center;
-    let q1 = a.length_sq();
-    let q2 = q1 + a.dot(b);
-    let k2 = (4.0 / 3.0) * ((2.0 * q1 * q2).sqrt() - q2) / (a.x * b.y - a.y * b.x);
-
-    let p2 = center + vec2(a.x - k2 * a.y, a.y + k2 * a.x);
-    let p3 = center + vec2(b.x + k2 * b.y, b.y - k2 * b.x);
-
-    [p1, p2, p3, p4]
-}
-
-// We can approximate at most one quadrant of the circle
-// so we divide it up into individual chunks that we then approximate
-// using bezier curves.
-#[derive(Clone)]
-struct QuarterTurnsIter(Option<RangeInclusive<f32>>);
-
-const QUARTER_TURN: f32 = FRAC_PI_2;
-
-impl Iterator for QuarterTurnsIter {
-    type Item = RangeInclusive<f32>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let (start, end) = self.0.clone()?.into_inner();
-        let distance = end - start;
-        if distance < QUARTER_TURN {
-            self.0 = None;
-            Some(start..=end)
-        } else {
-            let new_start = start + (QUARTER_TURN * distance.signum());
-            self.0 = Some(new_start..=end);
-            Some(start..=new_start)
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        if let Some((start, end)) = self.0.clone().map(|x| x.into_inner()) {
-            let turns = (start - end).abs() / QUARTER_TURN;
-            let lower = turns.floor() as usize;
-            let upper = turns.ceil() as usize;
-            (lower, Some(upper))
-        } else {
-            (0, None)
-        }
-    }
-}
diff --git a/crates/egui-theme-switch/src/cogwheel.rs b/crates/egui-theme-switch/src/cogwheel.rs
deleted file mode 100644
index e1d7e24..0000000
--- a/crates/egui-theme-switch/src/cogwheel.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-use super::rotated_rect::draw_rotated_rect;
-use crate::Painter;
-use egui::emath::{vec2, Pos2, Rect, Rot2};
-use egui::epaint::Color32;
-use egui::CornerRadius;
-use std::f32::consts::TAU;
-
-pub(crate) fn cogwheel(painter: &Painter, center: Pos2, radius: f32, color: Color32) {
-    let inner_radius = 0.3 * radius;
-    let outer_radius = 0.8 * radius;
-    let thickness = 0.3 * radius;
-
-    painter.circle(
-        center,
-        inner_radius + thickness / 2.,
-        Color32::TRANSPARENT,
-        (thickness, color),
-    );
-
-    let cogs = 8;
-    let cog_width = radius / 2.5;
-    let cog_rounding = radius / 16.;
-    let cog_length = radius - outer_radius + thickness / 2.;
-
-    for n in 0..cogs {
-        let cog_center = center - vec2(0., outer_radius + cog_length / 2. - thickness / 2.);
-        let cog_size = vec2(cog_width, cog_length);
-        let rotation = Rot2::from_angle(TAU / cogs as f32 * n as f32);
-        let rect = Rect::from_center_size(cog_center, cog_size);
-        let rounding = CornerRadius {
-            nw: cog_rounding as u8,
-            ne: cog_rounding as u8,
-            ..Default::default()
-        };
-        draw_rotated_rect(painter, rect, rounding, color, rotation, center);
-    }
-}
diff --git a/crates/egui-theme-switch/src/lib.rs b/crates/egui-theme-switch/src/lib.rs
deleted file mode 100644
index 4c4b49d..0000000
--- a/crates/egui-theme-switch/src/lib.rs
+++ /dev/null
@@ -1,412 +0,0 @@
-#![deny(clippy::dbg_macro, clippy::unwrap_used)]
-
-//! A *very* pretty theme switch widget for your egui app.
-//! It allows you to choose between dark, light and follow system.
-//!
-#![cfg_attr(doc, doc = include_str!("../doc/preview.md"))]
-//!
-//! ## Example
-//! ```
-//! use egui::ThemePreference;
-//! use egui_theme_switch::global_theme_switch;
-//!
-//! # egui::__run_test_ui(|ui| {
-//! global_theme_switch(ui);
-//! # });
-//! ```
-
-use egui::emath::{Pos2, Rect};
-use egui::epaint::Color32;
-use egui::{Painter, Response, ThemePreference, Ui, Widget};
-
-mod arc;
-mod cogwheel;
-mod moon;
-mod rotated_rect;
-mod sun;
-
-/// A switch control to configure the global theme preference.
-pub fn global_theme_switch(ui: &mut Ui) {
-    let mut preference = ui.ctx().options(|opt| opt.theme_preference);
-    if ui.add(ThemeSwitch::new(&mut preference)).changed() {
-        ui.ctx().set_theme(preference);
-    }
-}
-
-/// A switch control that allows choosing the theme
-/// preference (dark, light or follow system).
-///
-/// ```
-/// use egui::ThemePreference;
-/// use egui_theme_switch::ThemeSwitch;
-///
-/// # egui::__run_test_ui(|ui| {
-/// let mut preference = ThemePreference::System;
-/// if ui.add(ThemeSwitch::new(&mut preference)).changed() {
-///     // ...
-/// }
-/// # });
-/// ```
-#[must_use = "You should put this widget in an ui with `ui.add(widget);`"]
-#[derive(Debug)]
-pub struct ThemeSwitch<'a> {
-    value: &'a mut ThemePreference,
-}
-
-impl<'a> ThemeSwitch<'a> {
-    pub fn new(value: &'a mut ThemePreference) -> Self {
-        Self { value }
-    }
-}
-
-impl Widget for ThemeSwitch<'_> {
-    fn ui(self, ui: &mut crate::Ui) -> crate::Response {
-        static OPTIONS: [SwitchOption<ThemePreference>; 3] = [
-            SwitchOption {
-                value: ThemePreference::System,
-                icon: cogwheel::cogwheel,
-                label: "Follow System",
-            },
-            SwitchOption {
-                value: ThemePreference::Dark,
-                icon: moon::moon,
-                label: "Dark",
-            },
-            SwitchOption {
-                value: ThemePreference::Light,
-                icon: sun::sun,
-                label: "Light",
-            },
-        ];
-        let (update, response) = switch(ui, *self.value, "Theme", &OPTIONS);
-
-        if let Some(value) = update {
-            *self.value = value;
-        }
-
-        response
-    }
-}
-
-#[derive(Debug, Clone)]
-struct SwitchOption<T> {
-    value: T,
-    icon: IconPainter,
-    label: &'static str,
-}
-
-type IconPainter = fn(&Painter, Pos2, f32, Color32);
-
-fn switch<T>(
-    ui: &mut Ui,
-    value: T,
-    label: &str,
-    options: &[SwitchOption<T>],
-) -> (Option<T>, Response)
-where
-    T: PartialEq + Clone,
-{
-    let mut space = space_allocation::allocate_space(ui, options);
-
-    let updated_value = interactivity::update_value_on_click(&mut space, &value);
-    let value = updated_value.clone().unwrap_or(value);
-
-    if ui.is_rect_visible(space.rect) {
-        painting::draw_switch_background(ui, &space);
-        painting::draw_active_indicator(ui, &space, &value);
-
-        for button in &space.buttons {
-            painting::draw_button(ui, button, value == button.option.value);
-        }
-    }
-
-    accessibility::attach_widget_info(ui, &space, label, &value);
-
-    (updated_value, unioned_response(space))
-}
-
-fn unioned_response<T>(space: AllocatedSpace<T>) -> Response {
-    space
-        .buttons
-        .into_iter()
-        .fold(space.response, |r, button| r.union(button.response))
-}
-
-struct AllocatedSpace<T> {
-    response: Response,
-    rect: Rect,
-    buttons: Vec<ButtonSpace<T>>,
-    radius: f32,
-}
-
-struct ButtonSpace<T> {
-    center: Pos2,
-    response: Response,
-    radius: f32,
-    option: SwitchOption<T>,
-}
-
-mod space_allocation {
-    use super::*;
-    use egui::emath::vec2;
-    use egui::{Id, Sense};
-
-    pub(super) fn allocate_space<T>(ui: &mut Ui, options: &[SwitchOption<T>]) -> AllocatedSpace<T>
-    where
-        T: Clone,
-    {
-        let (rect, response, measurements) = allocate_switch(ui, options);
-        let id = response.id;
-
-        // Focusable elements always get an accessible node, so let's ensure that
-        // the parent is set correctly when the responses are created the first time.
-        ui.ctx().with_accessibility_parent(id, || {
-            let buttons = options
-                .iter()
-                .enumerate()
-                .scan(rect, |remaining, (n, option)| {
-                    Some(allocate_button(ui, remaining, id, &measurements, n, option))
-                })
-                .collect();
-
-            AllocatedSpace {
-                response,
-                rect,
-                buttons,
-                radius: measurements.radius,
-            }
-        })
-    }
-
-    fn allocate_switch<T>(
-        ui: &mut Ui,
-        options: &[SwitchOption<T>],
-    ) -> (Rect, Response, SwitchMeasurements) {
-        let diameter = ui.spacing().interact_size.y;
-        let radius = diameter / 2.0;
-        let padding = ui.spacing().button_padding.min_elem();
-        let min_gap = 0.5 * ui.spacing().item_spacing.x;
-        let gap_count = options.len().saturating_sub(1) as f32;
-        let button_count = options.len() as f32;
-
-        let min_size = vec2(
-            button_count * diameter + (gap_count * min_gap) + (2.0 * padding),
-            diameter + (2.0 * padding),
-        );
-        let sense = Sense::focusable_noninteractive();
-        let (rect, response) = ui.allocate_at_least(min_size, sense);
-
-        // The space we're given might be larger so we calculate
-        // the margin based on the allocated rect.
-        let total_gap = rect.width() - (button_count * diameter) - (2.0 * padding);
-        let gap = total_gap / gap_count;
-
-        let measurements = SwitchMeasurements {
-            gap,
-            radius,
-            padding,
-            buttons: options.len(),
-        };
-
-        (rect, response, measurements)
-    }
-
-    struct SwitchMeasurements {
-        gap: f32,
-        radius: f32,
-        padding: f32,
-        buttons: usize,
-    }
-
-    fn allocate_button<T>(
-        ui: &Ui,
-        remaining: &mut Rect,
-        switch_id: Id,
-        measurements: &SwitchMeasurements,
-        n: usize,
-        option: &SwitchOption<T>,
-    ) -> ButtonSpace<T>
-    where
-        T: Clone,
-    {
-        let (rect, center) = partition(remaining, measurements, n);
-        let response = ui.interact(rect, switch_id.with(n), Sense::click());
-        ButtonSpace {
-            center,
-            response,
-            radius: measurements.radius,
-            option: option.clone(),
-        }
-    }
-
-    fn partition(
-        remaining: &mut Rect,
-        measurements: &SwitchMeasurements,
-        n: usize,
-    ) -> (Rect, Pos2) {
-        let (leading, trailing) = offset(n, measurements);
-        let center = remaining.left_center() + vec2(leading + measurements.radius, 0.0);
-        let right = remaining.min.x + leading + 2.0 * measurements.radius + trailing;
-        let (rect, new_remaining) = remaining.split_left_right_at_x(right);
-        *remaining = new_remaining;
-        (rect, center)
-    }
-
-    // Calculates the leading and trailing space for a button.
-    // The gap between buttons is divided up evenly so that the entire
-    // switch is clickable.
-    fn offset(n: usize, measurements: &SwitchMeasurements) -> (f32, f32) {
-        let leading = if n == 0 {
-            measurements.padding
-        } else {
-            measurements.gap / 2.0
-        };
-        let trailing = if n == measurements.buttons - 1 {
-            measurements.padding
-        } else {
-            measurements.gap / 2.0
-        };
-        (leading, trailing)
-    }
-}
-
-mod interactivity {
-    use super::*;
-
-    pub(super) fn update_value_on_click<T>(space: &mut AllocatedSpace<T>, value: &T) -> Option<T>
-    where
-        T: PartialEq + Clone,
-    {
-        let clicked = space
-            .buttons
-            .iter_mut()
-            .find(|b| b.response.clicked())
-            .filter(|b| &b.option.value != value)?;
-        clicked.response.mark_changed();
-        Some(clicked.option.value.clone())
-    }
-}
-
-mod painting {
-    use super::*;
-    use egui::emath::pos2;
-    use egui::epaint::Stroke;
-    use egui::style::WidgetVisuals;
-    use egui::{Id, StrokeKind};
-
-    pub(super) fn draw_switch_background<T>(ui: &Ui, space: &AllocatedSpace<T>) {
-        let rect = space.rect;
-        let rounding = 0.5 * rect.height();
-        let WidgetVisuals {
-            bg_fill, bg_stroke, ..
-        } = switch_visuals(ui, &space.response);
-        ui.painter()
-            .rect(rect, rounding, bg_fill, bg_stroke, StrokeKind::Inside);
-    }
-
-    fn switch_visuals(ui: &Ui, response: &Response) -> WidgetVisuals {
-        if response.has_focus() {
-            ui.style().visuals.widgets.hovered
-        } else {
-            ui.style().visuals.widgets.inactive
-        }
-    }
-
-    pub(super) fn draw_active_indicator<T: PartialEq>(
-        ui: &Ui,
-        space: &AllocatedSpace<T>,
-        value: &T,
-    ) {
-        let fill = ui.visuals().selection.bg_fill;
-        if let Some(pos) = space
-            .buttons
-            .iter()
-            .find(|button| &button.option.value == value)
-            .map(|button| button.center)
-        {
-            let pos = animate_active_indicator_position(ui, space.response.id, space.rect.min, pos);
-            ui.painter().circle(pos, space.radius, fill, Stroke::NONE);
-        }
-    }
-
-    fn animate_active_indicator_position(ui: &Ui, id: Id, anchor: Pos2, pos: Pos2) -> Pos2 {
-        let animation_time = ui.style().animation_time;
-        // Animate the relative position to prevent
-        // animating the active indicator when the switch itself is moved around.
-        let x = pos.x - anchor.x;
-        let x = anchor.x + ui.ctx().animate_value_with_time(id, x, animation_time);
-        pos2(x, pos.y)
-    }
-
-    pub(super) fn draw_button<T>(ui: &Ui, button: &ButtonSpace<T>, selected: bool) {
-        let visuals = ui.style().interact_selectable(&button.response, selected);
-        let animation_factor = animate_click(ui, &button.response);
-        let radius = animation_factor * button.radius;
-        let icon_radius = 0.5 * radius * animation_factor;
-        let bg_fill = button_fill(&button.response, &visuals);
-
-        let painter = ui.painter();
-        painter.circle(button.center, radius, bg_fill, visuals.bg_stroke);
-        (button.option.icon)(painter, button.center, icon_radius, visuals.fg_stroke.color);
-    }
-
-    // We want to avoid drawing a background when the button is either active itself or was previously active.
-    fn button_fill(response: &Response, visuals: &WidgetVisuals) -> Color32 {
-        if interacted(response) {
-            visuals.bg_fill
-        } else {
-            Color32::TRANSPARENT
-        }
-    }
-
-    fn interacted(response: &Response) -> bool {
-        response.clicked() || response.hovered() || response.has_focus()
-    }
-
-    fn animate_click(ui: &Ui, response: &Response) -> f32 {
-        let ctx = ui.ctx();
-        let animation_time = ui.style().animation_time;
-        let value = if response.is_pointer_button_down_on() {
-            0.9
-        } else {
-            1.0
-        };
-        ctx.animate_value_with_time(response.id, value, animation_time)
-    }
-}
-
-mod accessibility {
-    use super::*;
-    use egui::{WidgetInfo, WidgetType};
-
-    pub(super) fn attach_widget_info<T: PartialEq>(
-        ui: &Ui,
-        space: &AllocatedSpace<T>,
-        label: &str,
-        value: &T,
-    ) {
-        space
-            .response
-            .widget_info(|| radio_group_widget_info(ui, label));
-
-        for button in &space.buttons {
-            let selected = value == &button.option.value;
-            attach_widget_info_to_button(ui, button, selected);
-        }
-    }
-
-    fn attach_widget_info_to_button<T>(ui: &Ui, button: &ButtonSpace<T>, selected: bool) {
-        let response = &button.response;
-        let label = button.option.label;
-        response.widget_info(|| button_widget_info(ui, label, selected));
-        response.clone().on_hover_text(label);
-    }
-
-    fn radio_group_widget_info(ui: &Ui, label: &str) -> WidgetInfo {
-        WidgetInfo::labeled(WidgetType::RadioGroup, ui.is_enabled(), label)
-    }
-
-    fn button_widget_info(ui: &Ui, label: &str, selected: bool) -> WidgetInfo {
-        WidgetInfo::selected(WidgetType::RadioButton, ui.is_enabled(), selected, label)
-    }
-}
diff --git a/crates/egui-theme-switch/src/moon.rs b/crates/egui-theme-switch/src/moon.rs
deleted file mode 100644
index 6d987a2..0000000
--- a/crates/egui-theme-switch/src/moon.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-use super::arc;
-use egui::epaint::{CubicBezierShape, PathShape, PathStroke};
-use egui::{Color32, Painter, Pos2, Vec2};
-use std::f32::consts::{PI, TAU};
-
-/// Draws an outlined moon symbol in the waxing crescent phase.
-pub(crate) fn moon(painter: &Painter, center: Pos2, radius: f32, color: Color32) {
-    let stroke_width = radius / 5.0;
-
-    let start = 0.04 * TAU;
-    let start_vec = radius * Vec2::angled(start);
-    let size = 0.65 * TAU;
-    let end_vec = radius * Vec2::angled(start + size);
-
-    let direction_angle = start - (TAU - size) / 2.;
-    let direction = Vec2::angled(direction_angle);
-
-    // We want to draw a circle with the same radius somewhere on the line
-    // `direction` such that it intersects with our first circle at `start` and `end`.
-    // The connection between the start and end points is a chord of our occluding circle.
-    let chord = start_vec - end_vec;
-    let angle = 2.0 * (chord.length() / (2.0 * radius)).asin();
-    let sagitta = radius * (1.0 - (angle / 2.0).cos());
-    let apothem = radius - sagitta;
-    let occluding_center = center + midpoint(start_vec, end_vec) + apothem * direction;
-
-    let occlusion_start = direction_angle + PI - angle / 2.;
-    let occlusion_end = direction_angle + PI + angle / 2.;
-
-    let main_arc = arc::approximate_with_beziers(
-        center,
-        radius,
-        start..=(start + size),
-        Color32::TRANSPARENT,
-        (stroke_width, color),
-    );
-    let occluding_arc = arc::approximate_with_beziers(
-        occluding_center,
-        radius,
-        occlusion_end..=occlusion_start,
-        Color32::TRANSPARENT,
-        (stroke_width, color),
-    );
-
-    // We join the beziers together to a path which improves
-    // the drawing of the joints somewhat.
-    let path = to_path(main_arc.chain(occluding_arc), (stroke_width, color));
-
-    painter.add(path);
-}
-
-fn midpoint(a: Vec2, b: Vec2) -> Vec2 {
-    0.5 * (a + b)
-}
-
-fn to_path(
-    beziers: impl IntoIterator<Item = CubicBezierShape>,
-    stroke: impl Into<PathStroke>,
-) -> PathShape {
-    let points = beziers.into_iter().flat_map(|b| b.flatten(None)).collect();
-    PathShape {
-        points,
-        closed: false,
-        fill: Default::default(),
-        stroke: stroke.into(),
-    }
-}
diff --git a/crates/egui-theme-switch/src/rotated_rect.rs b/crates/egui-theme-switch/src/rotated_rect.rs
deleted file mode 100644
index 6962a0e..0000000
--- a/crates/egui-theme-switch/src/rotated_rect.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-use egui::emath::{vec2, Pos2, Rect, Rot2};
-use egui::epaint::{Color32, PathShape, Stroke};
-use egui::{CornerRadius, Painter};
-
-/// Draws a rectangle with rounded corners, rotated around an origin.
-pub(crate) fn draw_rotated_rect(
-    painter: &Painter,
-    rect: Rect,
-    rounding: impl Into<CornerRadius>,
-    fill: impl Into<Color32>,
-    rot: impl Into<Rot2>,
-    origin: Pos2,
-) {
-    let rounding = rounding.into();
-    let fill = fill.into();
-    let rot = rot.into();
-    let safe_inset_points = safe_inset_points(rect, rot, origin, rounding);
-
-    painter.add(PathShape::convex_polygon(
-        safe_inset_points.to_vec(),
-        fill,
-        Stroke::NONE,
-    ));
-
-    // Nobody will notice that we're not actually drawing
-    // the round bits... 🤫
-}
-
-fn safe_inset_points(rect: Rect, rot: Rot2, origin: Pos2, rounding: CornerRadius) -> [Pos2; 8] {
-    [
-        rotate(rect.left_top() + vec2(0.0, rounding.nw as f32), rot, origin),
-        rotate(rect.left_top() + vec2(rounding.nw as f32, 0.0), rot, origin),
-        rotate(
-            rect.right_top() - vec2(rounding.ne as f32, 0.0),
-            rot,
-            origin,
-        ),
-        rotate(
-            rect.right_top() + vec2(0.0, rounding.ne as f32),
-            rot,
-            origin,
-        ),
-        rotate(
-            rect.right_bottom() - vec2(0.0, rounding.se as f32),
-            rot,
-            origin,
-        ),
-        rotate(
-            rect.right_bottom() - vec2(rounding.se as f32, 0.0),
-            rot,
-            origin,
-        ),
-        rotate(
-            rect.left_bottom() + vec2(rounding.sw as f32, 0.0),
-            rot,
-            origin,
-        ),
-        rotate(
-            rect.left_bottom() - vec2(0.0, rounding.sw as f32),
-            rot,
-            origin,
-        ),
-    ]
-}
-
-fn rotate(point: Pos2, rot: Rot2, origin: Pos2) -> Pos2 {
-    origin + rot * (point - origin)
-}
diff --git a/crates/egui-theme-switch/src/sun.rs b/crates/egui-theme-switch/src/sun.rs
deleted file mode 100644
index 9730da0..0000000
--- a/crates/egui-theme-switch/src/sun.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-use super::rotated_rect::draw_rotated_rect;
-use egui::emath::{vec2, Pos2, Rect, Rot2, Vec2};
-use egui::epaint::{Color32, Stroke};
-use egui::Painter;
-use std::f32::consts::TAU;
-
-pub(crate) fn sun(painter: &Painter, center: Pos2, radius: f32, color: Color32) {
-    let clipped = painter.with_clip_rect(Rect::from_center_size(center, Vec2::splat(radius * 2.)));
-    let sun_radius = radius * 0.5;
-
-    clipped.circle(center, sun_radius, color, Stroke::NONE);
-
-    let rays = 8;
-    let ray_radius = radius / 4.;
-    let ray_spacing = radius / 7.5;
-    let ray_length = radius - sun_radius - ray_spacing;
-
-    for n in 0..rays {
-        let ray_center = center - vec2(0., sun_radius + ray_spacing + ray_length / 2.);
-        let ray_size = vec2(ray_radius, ray_length);
-        let rect = Rect::from_center_size(ray_center, ray_size);
-        let rotation = Rot2::from_angle(TAU / rays as f32 * n as f32);
-        draw_rotated_rect(painter, rect, ray_radius / 2.0, color, rotation, center);
-    }
-}
diff --git a/nxshell/Cargo.toml b/nxshell/Cargo.toml
index f56db08..6558785 100644
--- a/nxshell/Cargo.toml
+++ b/nxshell/Cargo.toml
@@ -11,7 +11,7 @@ categories.workspace = true
 keywords.workspace = true
 
 [dependencies]
-catppuccin-egui = { workspace = true, features = ["egui31"] }
+catppuccin-egui = { workspace = true, features = ["egui32"] }
 chrono.workspace = true
 copypasta.workspace = true
 egui.workspace = true
@@ -22,11 +22,11 @@ eframe = { workspace = true, features = [
     "persistence", # Enable restoring app state when restarting the app.
 ] }
 egui-term = { path = "../crates/egui-term" }
-egui_dock = { path = "../crates/egui-dock" }
+egui_dock.workspace = true
 egui_extras = { workspace = true, features = ["all_loaders"] }
 egui_form = { workspace = true, features = ["validator_garde"] }
 egui-phosphor.workspace = true
-egui-theme-switch = { path = "../crates/egui-theme-switch" }
+egui-theme-switch.workspace = true
 egui-toast = { path = "../crates/egui-toast" }
 garde = { workspace = true, features = ["full"] }
 homedir.workspace = true
@@ -37,7 +37,7 @@ rusqlite = { workspace = true, features = ["bundled"] }
 thiserror.workspace = true
 tracing.workspace = true
 tracing-subscriber = { workspace = true, features = ["env-filter"] }
-uuid = { workspace = true, features = ["v4"] }
+wgpu.workspace = true
 
 [target.'cfg(windows)'.dependencies]
 windows = { workspace = true, features = ["Win32_System_Threading"] }
diff --git a/nxshell/src/ui/menubar.rs b/nxshell/src/ui/menubar.rs
index c66376c..a30bb03 100644
--- a/nxshell/src/ui/menubar.rs
+++ b/nxshell/src/ui/menubar.rs
@@ -3,7 +3,7 @@ use crate::consts::{REPOSITORY_URL, SHOW_DOCK_PANEL_ONCE};
 use crate::db::Session;
 use crate::errors::NxError;
 use crate::ui::tab_view::Tab;
-use egui::{Button, Checkbox, Modifiers};
+use egui::{Button, Checkbox, MenuBar, Modifiers};
 use egui_dock::DockState;
 use egui_term::{Authentication, SshOptions, TermType};
 use orion::aead::{open as orion_open, SecretKey};
@@ -17,7 +17,7 @@ const BTN_WIDTH: f32 = 200.0;
 
 impl NxShell {
     pub fn menubar(&mut self, ui: &mut egui::Ui) {
-        egui::menu::bar(ui, |ui| {
+        MenuBar::new().ui(ui, |ui| {
             // Session
             self.session_menu(ui);
             // Window
@@ -43,7 +43,7 @@ impl NxShell {
             let new_session_btn = Button::new("New Session").min_size((BTN_WIDTH, 0.).into());
             if ui.add(new_session_btn).clicked() {
                 *self.opts.show_add_session_modal.borrow_mut() = true;
-                ui.close_menu();
+                ui.close();
             }
             let new_term_shortcut = ui.ctx().format_shortcut(&new_term_shortcut);
             let new_term_btn = Button::new("New Terminal")
@@ -56,7 +56,7 @@ impl NxShell {
                         working_directory: None,
                     },
                 );
-                ui.close_menu();
+                ui.close();
             }
             ui.separator();
             if ui.button("Quit").clicked() {
@@ -166,7 +166,7 @@ fn window_menu(ui: &mut egui::Ui) {
                 }
                 Err(err) => error!("failed to get current exe path: {err}"),
             }
-            ui.close_menu();
+            ui.close();
         }
     });
 }
diff --git a/nxshell/src/ui/tab_view/mod.rs b/nxshell/src/ui/tab_view/mod.rs
index 7682e52..502fadd 100644
--- a/nxshell/src/ui/tab_view/mod.rs
+++ b/nxshell/src/ui/tab_view/mod.rs
@@ -6,6 +6,7 @@ use crate::consts::GLOBAL_COUNTER;
 use crate::ui::tab_view::session::SessionList;
 use copypasta::ClipboardContext;
 use egui::{Label, Response, Sense, Ui};
+use egui_dock::tab_viewer::OnCloseResponse;
 use egui_dock::{DockArea, Style};
 use egui_phosphor::regular::{DRONE, NUMPAD};
 use egui_term::{
@@ -20,7 +21,7 @@ use tracing::error;
 
 #[derive(PartialEq)]
 enum TabInner {
-    Term(TerminalTab),
+    Term(Box<TerminalTab>),
     SessionList(SessionList),
 }
 
@@ -51,11 +52,11 @@ impl Tab {
 
         Ok(Self {
             id,
-            inner: TabInner::Term(TerminalTab {
+            inner: TabInner::Term(Box::new(TerminalTab {
                 terminal,
                 terminal_theme: TerminalTheme::default(),
                 term_type: typ,
-            }),
+            })),
         })
     }
 
@@ -158,15 +159,19 @@ impl egui_dock::TabViewer for TabViewer<'_> {
         matches!(&mut tab.inner, TabInner::Term(_))
     }
 
-    fn on_close(&mut self, tab: &mut Self::Tab) -> bool {
+    fn on_close(&mut self, tab: &mut Self::Tab) -> OnCloseResponse {
         match self.command_sender.send((tab.id, PtyEvent::Exit)) {
             Err(err) => {
                 error!("close tab {} failed: {err}", tab.id);
-                false
+                OnCloseResponse::Ignore
             }
-            Ok(_) => true,
+            Ok(_) => OnCloseResponse::Close,
         }
     }
+
+    fn scroll_bars(&self, _tab: &Self::Tab) -> [bool; 2] {
+        [false, false]
+    }
 }
 
 impl NxShell {