@perspective-dev/viewer 4.5.2 → 5.0.0

package/src/rust/components/viewer/render.rs

@@ -0,0 +1,243 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+// ┃ This file is part of the Perspective library, distributed under the terms ┃
+// ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+//! The root component's `view()`: composition of the settings pane, the
+//! column-settings drawer, and the multi-panel `MainPanel`.
+//!
+//! INVARIANT: the `SplitPanel` is ALWAYS rendered with `main_panel` as its
+//! last (flex-fill) pane — toggling the settings sidebar only adds/removes the
+//! leading pane, never reparents `main_panel` (a remount would tear down
+//! `<regular-layout>` + the plugin `<slot>`s).
+
+use yew::prelude::*;
+
+use super::PerspectiveViewer;
+use super::msg::PerspectiveViewerMsg::*;
+use crate::components::column_settings_sidebar::ColumnSettingsPanel;
+use crate::components::containers::split_panel::SplitPanel;
+use crate::components::font_loader::FontLoader;
+use crate::components::main_panel::MainPanel;
+use crate::components::panel_menu::PanelCommand;
+use crate::components::settings_panel::SettingsPanel;
+use crate::components::style::StyleProvider;
+use crate::queries::*;
+use crate::session::TableLoadState;
+
+impl PerspectiveViewer {
+    pub(super) fn render(&self, ctx: &Context<Self>) -> Html {
+        // The settings panel + status bar bind to the *active* panel's engines;
+        // `presentation` is element-level (shared).
+        let presentation = &ctx.props().presentation;
+        let renderer = &self.active_renderer;
+        let session = &self.active_session;
+
+        let is_settings_open = self.settings_open
+            && matches!(self.session_props.has_table, Some(TableLoadState::Loaded));
+
+        let mut class = classes!();
+        if !is_settings_open {
+            class.push("settings-closed");
+        }
+
+        if self.session_props.title.is_some() {
+            class.push("titled");
+        }
+
+        let on_open_expr_panel = ctx.link().callback(|c| OpenColumnSettings {
+            locator: c,
+            sender: None,
+            toggle: true,
+        });
+
+        let on_column_settings_panel_resize = ctx
+            .link()
+            .callback(|(x, _)| ColumnSettingsPanelSizeUpdate(Some(x)));
+
+        let on_close_settings = ctx.link().callback(|()| ToggleSettingsInit(None, None));
+        let on_debug = ctx.link().callback(|_| ToggleDebug);
+        let selected_column = get_current_column_locator(
+            &self.presentation_props.open_column_settings,
+            renderer,
+            &self.session_props.config,
+            &self.session_props.metadata,
+        );
+
+        let selected_tab = self.presentation_props.open_column_settings.tab;
+        let plugin_name = self.renderer_props.plugin_name.clone();
+        let available_plugins = self.renderer_props.available_plugins.clone();
+        let has_table = self.session_props.has_table.clone();
+        let named_column_count = self.renderer_props.config.config_column_names.len();
+
+        let view_config = self.session_props.config.clone();
+        let drag_column = self.dragdrop_props.column.clone();
+        let metadata = self.session_props.metadata.clone();
+        let on_select_tab = ctx.link().callback(SettingsPanelTabChanged);
+        let on_auto_width = ctx.link().callback(SettingsPanelAutoWidth);
+        let settings_panel = if is_settings_open {
+            html! {
+                <SettingsPanel
+                    on_close={on_close_settings}
+                    on_resize={&self.on_resize}
+                    on_select_column={on_open_expr_panel}
+                    is_debug={self.debug_open}
+                    {on_debug}
+                    {plugin_name}
+                    {available_plugins}
+                    {has_table}
+                    {named_column_count}
+                    {view_config}
+                    plugin_config={self.renderer_props.plugin_config.clone()}
+                    {drag_column}
+                    metadata={metadata.clone()}
+                    open_column_settings={self.presentation_props.open_column_settings.clone()}
+                    selected_theme={self.presentation_props.selected_theme.clone()}
+                    selected_tab={self.settings_geometry.selected_tab}
+                    auto_width={self.settings_geometry.auto_width}
+                    on_dimensions_reset={&self.on_settings_panel_dimensions_reset}
+                    {on_select_tab}
+                    {on_auto_width}
+                    {presentation}
+                    {renderer}
+                    {session}
+                />
+            }
+        } else {
+            html! { <></> }
+        };
+
+        let on_settings = ctx.link().callback(|()| ToggleSettingsInit(None, None));
+        let on_select_tab = ctx.link().callback(ColumnSettingsTabChanged);
+        let column_settings_panel = html! {
+            if let Some(selected_column) = selected_column {
+                <SplitPanel
+                    id="modal_panel"
+                    reverse=true
+                    initial_size={self.settings_geometry.column_settings_width_override}
+                    on_reset={ctx.link().callback(|_| ColumnSettingsPanelSizeUpdate(None))}
+                    on_resize={on_column_settings_panel_resize}
+                >
+                    <ColumnSettingsPanel
+                        {selected_column}
+                        {selected_tab}
+                        on_close={self.on_close_column_settings.clone()}
+                        width_override={self.settings_geometry.column_settings_width_override}
+                        {on_select_tab}
+                        plugin_name={self.renderer_props.plugin_name.clone()}
+                        {metadata}
+                        view_config={self.session_props.config.clone()}
+                        column_stats={self.session_props.column_stats.clone()}
+                        selected_theme={self.presentation_props.selected_theme.clone()}
+                        {presentation}
+                        {renderer}
+                        {session}
+                    />
+                    <></>
+                </SplitPanel>
+            }
+        };
+
+        let on_reset = ctx.link().callback(|all| ResetPanel(None, all, None));
+        let main_panel = html! {
+            <MainPanel
+                {on_settings}
+                {on_reset}
+                on_activate_panel={ctx.link().callback(|id| SetActivePanel(id, None))}
+                on_close_panel={ctx.link().callback(|id| ClosePanel(id, None))}
+                on_panel_command={ctx.link().batch_callback(|(id, cmd): (String, PanelCommand)| {
+                    match cmd {
+                        PanelCommand::New => vec![NewPanel(id)],
+                        PanelCommand::NewFrom { client, table } => {
+                            vec![NewPanelFrom { client, table }]
+                        },
+                        PanelCommand::Duplicate => vec![DuplicatePanel(id)],
+                        PanelCommand::Reset => vec![ResetPanel(Some(id), false, None)],
+                        PanelCommand::ToggleMaster => vec![ToggleMaster(id)],
+                        PanelCommand::Close => vec![ClosePanel(id, None)],
+                        PanelCommand::Maximize | PanelCommand::Restore => vec![],
+                    }
+                })}
+                session_props={self.session_props.clone()}
+                renderer_props={self.renderer_props.clone()}
+                presentation_props={self.presentation_props.clone()}
+                {is_settings_open}
+                update_count={self.update_count}
+                panel_ids={ctx.props().workspace.panel_ids()}
+                panel_titles={ctx.props()
+                    .workspace
+                    .panel_ids()
+                    .iter()
+                    .map(|id| {
+                        let title = ctx
+                            .props()
+                            .workspace
+                            .panel(id)
+                            .and_then(|p| p.session.get_title())
+                            .filter(|t| !t.is_empty());
+                        (id.as_str().to_owned(), title)
+                    })
+                    .collect::<Vec<_>>()}
+                panel_themes={ctx.props()
+                    .workspace
+                    .panel_ids()
+                    .iter()
+                    .map(|id| {
+                        (
+                            id.as_str().to_owned(),
+                            ctx.props().workspace.panel(id).and_then(|p| p.renderer.theme()),
+                        )
+                    })
+                    .collect::<Vec<_>>()}
+                panel_masters={ctx.props().workspace.masters()}
+                workspace={ctx.props().workspace.clone()}
+                global_filters={self.global_filters.clone()}
+                on_remove_global_filter={ctx.link().callback(RemoveGlobalFilter)}
+                on_clear_global_filters={ctx.link().callback(|_| ClearGlobalFilters)}
+                {presentation}
+                {renderer}
+                {session}
+            />
+        };
+
+        let is_single_panel = if ctx.props().workspace.placed_count() == 1 {
+            "only-child"
+        } else {
+            ""
+        };
+
+        html! {
+            <StyleProvider root={ctx.props().elem.clone()}>
+                <div id="component_container" class={is_single_panel}>
+                    <div id="layout_area">
+                        <SplitPanel
+                            id="app_panel"
+                            reverse=true
+                            skip_empty=true
+                            deferred=true
+                            size={self.settings_geometry.pane_width_override}
+                            initial_size={self.settings_geometry.pane_width_override}
+                            on_reset={ctx.link().callback(|_| SettingsPanelSizeUpdate(None))}
+                            on_resize={ctx.link().callback(|(x, _): (i32, i32)| SettingsDividerMove(x))}
+                            on_resize_finished={ctx.link().callback(|_| SettingsDividerFinish)}
+                        >
+                            { settings_panel }
+                            <div id="main_column_container">
+                                { main_panel }
+                                { column_settings_panel }
+                            </div>
+                        </SplitPanel>
+                    </div>
+                </div>
+                <FontLoader ..self.fonts.clone() />
+            </StyleProvider>
+        }
+    }
+}

package/src/rust/components/viewer/settings.rs

@@ -0,0 +1,402 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+// ┃ This file is part of the Perspective library, distributed under the terms ┃
+// ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+//! Settings-sidebar handlers: the open/close toggle (with its presize
+//! choreography), the deferred divider's latest-wins presize pump
+//! (`PRESIZE_EVERYWHERE_PLAN.md` P1/P2), and the column-settings drawer. The
+//! presize sweeps themselves live in [`crate::tasks`] (`presize_panels`).
+
+use futures::channel::oneshot::{Sender, channel};
+use perspective_js::utils::*;
+use wasm_bindgen::prelude::*;
+use yew::prelude::*;
+
+use super::PerspectiveViewer;
+use super::msg::PerspectiveViewerMsg::*;
+use crate::components::font_loader::FontLoaderStatus;
+use crate::components::settings_panel::SelectedTab;
+use crate::config::*;
+use crate::presentation::{ColumnLocator, ColumnSettingsTab};
+use crate::tasks::*;
+
+/// The settings sidebar's geometry state, folded into one field on
+/// [`PerspectiveViewer`]: the pane/drawer width overrides, the divider
+/// presize pump, and the open-state deltas cache.
+#[derive(Default)]
+pub(super) struct SettingsGeometry {
+    /// User-dragged settings-pane width (the deferred `SplitPanel`'s
+    /// controlled `size`); `None` until first dragged / after a reset.
+    pub pane_width_override: Option<i32>,
+
+    /// The selected settings-panel tab.
+    pub selected_tab: SelectedTab,
+
+    /// High-water-mark auto width reported by the settings panel.
+    pub auto_width: f64,
+
+    /// Latest-wins presize pump for the (deferred) settings divider: the
+    /// newest proposed pane width not yet presized, and whether a pump
+    /// iteration is in flight. See `SettingsDividerMove`.
+    pub divider_target: Option<i32>,
+    pub divider_pumping: bool,
+
+    /// Open-state geometry deltas `(layout_area.w − mpc.w, main_column.h −
+    /// mpc.h)`, cached at settings *close* time — used to presize panels to
+    /// their shrunk boxes BEFORE the pane mounts on the next *open* (P2).
+    /// `None` until the first close (the first-ever open is reactive).
+    pub open_deltas: Option<(f64, f64)>,
+
+    /// User-dragged column-settings drawer width override.
+    pub column_settings_width_override: Option<i32>,
+}
+
+impl PerspectiveViewer {
+    pub(super) fn on_toggle_settings_init(
+        &mut self,
+        ctx: &Context<Self>,
+        update: Option<SettingsUpdate>,
+        resolve: Option<Sender<ApiResult<JsValue>>>,
+    ) -> bool {
+        match (update, resolve) {
+            (Some(SettingsUpdate::Missing), None) => false,
+            (Some(SettingsUpdate::Missing), Some(resolve)) => {
+                resolve.send(Ok(JsValue::UNDEFINED)).unwrap();
+                false
+            },
+            (Some(SettingsUpdate::SetDefault), resolve) => {
+                self.init_toggle_settings_task(ctx, Some(false), resolve);
+                false
+            },
+            (Some(SettingsUpdate::Update(force)), resolve) => {
+                self.init_toggle_settings_task(ctx, Some(force), resolve);
+                false
+            },
+            (None, resolve) => {
+                self.init_toggle_settings_task(ctx, None, resolve);
+                false
+            },
+        }
+    }
+
+    pub(super) fn on_toggle_settings_complete(
+        &mut self,
+        ctx: &Context<Self>,
+        update: SettingsUpdate,
+        resolve: Sender<()>,
+    ) -> bool {
+        match update {
+            SettingsUpdate::SetDefault if self.settings_open => {
+                ctx.props().presentation.set_open_column_settings(None);
+                self.settings_open = false;
+                self.on_rendered.push(resolve);
+                true
+            },
+            SettingsUpdate::Update(force) if force != self.settings_open => {
+                ctx.props().presentation.set_open_column_settings(None);
+                self.settings_open = force;
+                self.on_rendered.push(resolve);
+                true
+            },
+            _ if matches!(self.fonts.get_status(), FontLoaderStatus::Finished) => {
+                if let Err(e) = resolve.send(()) {
+                    tracing::error!("toggle settings failed {:?}", e);
+                }
+
+                false
+            },
+            _ => {
+                ctx.props().presentation.set_open_column_settings(None);
+                self.on_rendered.push(resolve);
+                true
+            },
+        }
+    }
+
+    /// Toggle the settings, or force the settings panel either open (true) or
+    /// closed (false) explicitly.  In order to reduce apparent
+    /// screen-shear, `toggle_settings()` uses a somewhat complex render
+    /// order:  it first resize the plugin's `<div>` without moving it,
+    /// using `overflow: hidden` to hide the extra draw area;  then,
+    /// after the _async_ drawing of the plugin is complete, it will send a
+    /// message to complete the toggle action and re-render the element with
+    /// the settings removed.
+    ///
+    /// # Arguments
+    /// * `force` - Whether to explicitly set the settings panel state to
+    ///   Open/Close (`Some(true)`/`Some(false)`), or to just toggle the current
+    ///   state (`None`).
+    fn init_toggle_settings_task(
+        &mut self,
+        ctx: &Context<Self>,
+        force: Option<bool>,
+        sender: Option<Sender<ApiResult<JsValue>>>,
+    ) {
+        let is_open = ctx.props().presentation.is_settings_open();
+        ctx.props().presentation.set_settings_before_open(!is_open);
+        match force {
+            Some(force) if is_open == force => {
+                if let Some(sender) = sender {
+                    sender.send(Ok(JsValue::UNDEFINED)).unwrap();
+                }
+            },
+            Some(_) | None => {
+                let force = !is_open;
+                let callback = ctx.link().callback(move |resolve| {
+                    let update = SettingsUpdate::Update(force);
+                    ToggleSettingsComplete(update, resolve)
+                });
+
+                // P2: at CLOSE time the open-state geometry is measurable —
+                // cache the deltas the next OPEN needs to presize with.
+                if is_open {
+                    self.settings_geometry.open_deltas =
+                        measure_settings_open_deltas(&ctx.props().elem);
+                }
+
+                let open_deltas = self.settings_geometry.open_deltas;
+                let workspace = ctx.props().workspace.clone();
+                let presentation = ctx.props().presentation.clone();
+                let elem = ctx.props().elem.clone();
+
+                ApiFuture::spawn(async move {
+                    // Resize every visible plugin (not just the active one) to its
+                    // new cell as the settings pane toggles. The pane is the outer
+                    // SplitPanel, which emits no `before-resize`, so this is driven
+                    // explicitly here. CLOSING grows the cells, so pre-size each
+                    // plugin to its grown box BEFORE collapsing the pane; OPENING
+                    // shrinks them, so pre-size to the shrunk box (from the deltas
+                    // cached at the last close; the first-ever open has none and
+                    // stays reactive) BEFORE the pane mounts — either way, one
+                    // clean resize with the reactive pass after as the exactness
+                    // finalizer.
+                    let result: ApiResult<JsValue> = async {
+                        if is_open {
+                            let presents = presize_visible_panels_grown(&workspace, &elem).await;
+                            let (notify, rendered) = channel::<()>();
+                            callback.emit(notify);
+                            presentation.set_settings_open(false);
+                            rendered.await?;
+                            // `notify` fires in `rendered()` (same task as the
+                            // Yew DOM patch) and this future resumes as one of
+                            // its microtasks — so the staged reveal below and
+                            // the pane's geometry change reach the screen in a
+                            // single paint.
+                            presents.reveal();
+                            // I6: the exactness-finalizer resize is part of
+                            // what this toggle caused — await it here rather
+                            // than leaving it to the ResizeObserver (whose
+                            // continuous pass remains as the reactive
+                            // backstop).
+                            resize_visible_panels(&workspace).await;
+                        } else {
+                            let presents = if let Some((delta_w, delta_h)) = open_deltas {
+                                presize_visible_panels_open(&workspace, &elem, delta_w, delta_h)
+                                    .await
+                            } else {
+                                StagedPresents::default()
+                            };
+
+                            let (notify, rendered) = channel::<()>();
+                            callback.emit(notify);
+                            presentation.set_settings_open(true);
+                            rendered.await?;
+                            presents.reveal();
+                            resize_visible_panels(&workspace).await;
+                        }
+                        Ok(JsValue::UNDEFINED)
+                    }
+                    .await;
+
+                    if let Some(sender) = sender {
+                        let msg = result.ignore_view_delete();
+                        sender
+                            .send(msg.map(|x| x.unwrap_or(JsValue::UNDEFINED)))
+                            .into_apierror()?;
+                    };
+
+                    Ok(JsValue::undefined())
+                });
+            },
+        };
+    }
+
+    pub(super) fn on_settings_panel_size_update(&mut self, x: Option<i32>) -> bool {
+        match x {
+            Some(x) => {
+                self.settings_geometry.pane_width_override = Some(x);
+                false
+            },
+            None => {
+                self.settings_geometry.pane_width_override = None;
+                self.settings_geometry.auto_width = 0.0;
+                self.on_settings_panel_dimensions_reset.emit(());
+                true
+            },
+        }
+    }
+
+    pub(super) fn on_settings_divider_move(
+        &mut self,
+        ctx: &Context<Self>,
+        pane_width: i32,
+    ) -> bool {
+        // Latest-wins: overwrite the pending target; start the pump if
+        // idle. Intermediate targets that arrive while a presize is in
+        // flight are dropped (mirrors `PresizeQueue`'s single queued
+        // slot) — the pane tracks the pointer at content-render rate.
+        self.settings_geometry.divider_target = Some(pane_width);
+        if !self.settings_geometry.divider_pumping {
+            self.settings_geometry.divider_pumping = true;
+            ctx.link().send_message(SettingsDividerPump);
+        }
+
+        false
+    }
+
+    pub(super) fn on_settings_divider_pump(&mut self, ctx: &Context<Self>) -> bool {
+        if let Some(pane_width) = self.settings_geometry.divider_target.take() {
+            let workspace = ctx.props().workspace.clone();
+            let elem = ctx.props().elem.clone();
+            let link = ctx.link().clone();
+            ApiFuture::spawn(async move {
+                let presents =
+                    presize_visible_panels_pane_width(&workspace, &elem, pane_width as f64).await;
+                link.send_message(SettingsDividerCommit(pane_width));
+                // Same task as the commit's re-render (whether Yew drained it
+                // synchronously inside `send_message` or deferred it to a
+                // microtask): the staged reveal and the pane-width geometry
+                // land in one paint.
+                presents.reveal();
+                Ok(())
+            });
+        } else {
+            self.settings_geometry.divider_pumping = false;
+        }
+
+        false
+    }
+
+    pub(super) fn on_settings_divider_commit(
+        &mut self,
+        ctx: &Context<Self>,
+        pane_width: i32,
+    ) -> bool {
+        // Every visible panel has rendered at (approximately) its
+        // target box — NOW move the geometry: the re-render below
+        // applies this width to the deferred `SplitPanel`'s controlled
+        // `size`, in the same task as the presizes' inline clears.
+        self.settings_geometry.pane_width_override = Some(pane_width);
+        ctx.link().send_message(SettingsDividerPump);
+        true
+    }
+
+    pub(super) fn on_settings_divider_finish(&mut self, ctx: &Context<Self>) -> bool {
+        let workspace = ctx.props().workspace.clone();
+        ApiFuture::spawn(async move {
+            resize_visible_panels(&workspace).await;
+            Ok(())
+        });
+
+        false
+    }
+
+    pub(super) fn on_settings_panel_tab_changed(&mut self, tab: SelectedTab) -> bool {
+        let changed = tab != self.settings_geometry.selected_tab;
+        self.settings_geometry.selected_tab = tab;
+        changed
+    }
+
+    pub(super) fn on_settings_panel_auto_width(&mut self, w: f64) -> bool {
+        if w > self.settings_geometry.auto_width {
+            self.settings_geometry.auto_width = w;
+            true
+        } else {
+            false
+        }
+    }
+
+    pub(super) fn on_open_column_settings(
+        &mut self,
+        ctx: &Context<Self>,
+        locator: Option<ColumnLocator>,
+        sender: Option<Sender<()>>,
+        toggle: bool,
+    ) -> bool {
+        let mut open_column_settings = ctx.props().presentation.get_open_column_settings();
+        if locator == open_column_settings.locator {
+            if toggle {
+                ctx.props().presentation.set_open_column_settings(None);
+            }
+        } else {
+            open_column_settings.locator.clone_from(&locator);
+            open_column_settings.tab = if matches!(locator, Some(ColumnLocator::NewExpression)) {
+                Some(ColumnSettingsTab::Attributes)
+            } else {
+                locator.as_ref().and_then(|x| {
+                    x.name().map(|x| {
+                        if self.session_props.is_column_active(x) {
+                            ColumnSettingsTab::Style
+                        } else {
+                            ColumnSettingsTab::Attributes
+                        }
+                    })
+                })
+            };
+
+            ctx.props()
+                .presentation
+                .set_open_column_settings(Some(open_column_settings));
+
+            if locator.is_some() {
+                self.settings_geometry.selected_tab = SelectedTab::Query;
+            }
+        }
+
+        if let Some(sender) = sender {
+            // I6: resolve on the render commit that applies this change (the
+            // shared `on_rendered` queue, drained in `rendered()` once fonts
+            // settle), not at message-handling time.
+            self.on_rendered.push(sender);
+        }
+
+        true
+    }
+
+    pub(super) fn on_column_settings_panel_size_update(&mut self, x: Option<i32>) -> bool {
+        self.settings_geometry.column_settings_width_override = x;
+        false
+    }
+
+    pub(super) fn on_column_settings_tab_changed(
+        &mut self,
+        ctx: &Context<Self>,
+        tab: ColumnSettingsTab,
+    ) -> bool {
+        let mut open_column_settings = ctx.props().presentation.get_open_column_settings();
+        open_column_settings.tab.clone_from(&Some(tab));
+        ctx.props()
+            .presentation
+            .set_open_column_settings(Some(open_column_settings));
+        true
+    }
+
+    /// Toggling the debug tab re-renders the settings panel only — the
+    /// `DebugPanel` populates itself (`get_viewer_config` on mount +
+    /// change subscriptions), so no plugin dispatch is owed. The old
+    /// `just_render` here relied on the pre-amendment unconditional
+    /// `Unchanged → update` arm and repainted the plugin as a side effect
+    /// (`PLUGIN_DRAW_INVARIANT_PLAN.md` amendment, migration 2).
+    pub(super) fn on_toggle_debug(&mut self, _ctx: &Context<Self>) -> bool {
+        self.debug_open = !self.debug_open;
+        true
+    }
+}