meltygui 0.1.0__py3-none-any.whl

meltygui/view/tab_view.py

@@ -0,0 +1,258 @@
+"""Tab view functions and supporting definitions."""
+from meltygui.core.melty import Melty
+from meltygui.core.core_render import render_func
+from meltygui.core.rendering.core_decoration import Core
+from meltygui.state.new_core_model import TabState
+from meltygui.view.header_view import draw_header
+import meltygui_imgui as imgui
+
+
+@render_func(is_tree=False, show_bg=True, shadow=False, use_cache=False, header_same_line=True,
+             disable_scroll=True,
+             indent_size=0, show_add_delete=False,
+             show_name=False, selectable=False, parent_show_add_delete=False,
+             with_header=draw_header)
+def draw_tab_bar(input_value: list, tab_height=30, names=None, tint_value=0.235, tint_saturation=0.372, unique=None,
+                 collection=None, as_toggles=False, tints=None, icons=None, excluded=None, width=None,
+                 dnd_collection_ds=None, dnd_keys=None,
+                 draw_state=None):
+    """Tab bar with multi-select via shift-click. input_value is the list of selected items, collection is all available tabs.
+    Tabs wrap onto a new row when the cumulative width would exceed draw_state.content_width.
+
+    tints: optional list of (r, g, b) tint colors, one per tab in `collection`. Entries that are
+    None (or beyond the list) fall back to the neutral grey. (Defaults to None rather than [] to
+    avoid the mutable-default-arg pitfall; behaves identically to an empty list.)
+
+    dnd_collection_ds + dnd_keys: opt tabs into the framework DragDrop. Each
+    tab button registers as a whole-rect drag item of `dnd_collection_ds` (the
+    draw_state whose input_value is the collection being reordered — the
+    Reorder/Insert lands on ITS return via Melty.dnd_requests). dnd_keys is a
+    list parallel to `collection`: (key, collection_index) per tab, or None
+    for tabs that aren't draggable (e.g. a synthetic General tab). The owner
+    must stamp _dnd_drop_target/_dnd_horizontal on dnd_collection_ds so slot
+    lines render vertically between the tabs."""
+    from meltygui.view.control_view import button
+    from meltygui.view.header_view import flat_button
+    from meltygui.core.layout.cursor_core import same_line
+    import meltygui.core.input.drag_drop_core as _drag_drop
+
+    if collection is None:
+        return False, input_value
+
+    if excluded is None:
+        excluded = set()
+    # Content-left edge, captured before the dummy/same_line/-10 shift below.
+    # The wrap limit is measured from here so it lines up with content_width.
+    origin_x = imgui.get_cursor_screen_pos()[0]
+
+    imgui.dummy(0, 0)
+    imgui.same_line()
+
+    # [tint=(0.894, 0.568, 0.204, 1.0), show_tint=True]
+    io = imgui.get_io()
+    changed = False
+    selected = list(input_value)
+    if selected is None:
+        selected = []
+    if names is None and hasattr(input_value, 'keys') and hasattr(input_value, 'values'):
+        input_value = list(input_value.values())
+        names = list(input_value.keys())
+
+    imgui.set_cursor_screen_pos((imgui.get_cursor_screen_pos()[0] - 10, imgui.get_cursor_screen_pos()[1]))
+    # First-row start x after the -10 shift; wrapped rows realign to this
+    # (new_line() alone resets to the window content x, which is ~10px right).
+    row_start_x = imgui.get_cursor_screen_pos()[0]
+
+    # Mirror button()'s sizing: width = calc_text_size(label_text).x + text_pad (15).
+    # Scaled like button() scales its text_pad, so the wrap measurement below
+    # matches the width the buttons actually take.
+    # [tint=(0.124, 0.65, 0.087, 1.0), show_tint=True]
+    button_padding = Melty.px(15)
+    # tab_height arrives as an authored-at-1.0 constant (callers pass 30/40),
+    # so it scales here - once, up front, so the button, the click test and
+    # the drag placeholder below all agree on one height. The drag path
+    # deliberately overrides this with the MEASURED pickup height, which is
+    # already in real pixels.
+    tab_height = Melty.px(tab_height)
+    content_width = draw_state.content_width if draw_state is not None else 0
+    x_limit = origin_x + content_width if content_width > 0 else None
+
+    # An explicitly passed width is a real constraint content_width knows
+    # nothing about (the context menu passes width=content_width-282) — clamp
+    # to it. draw_state.width and abs_clip_rect are NOT constraints here: with
+    # wrap=True the wrapper writes the measured content extent back into
+    # draw_state.width (and the clip rect derives from it), so clamping to
+    # them ratchets the bar narrower on every reflow until each tab fits on
+    # its own row.
+    if width and draw_state is not None:
+        view_right = draw_state._abs_left() + width - 3
+        x_limit = view_right if x_limit is None else min(x_limit, view_right)
+
+    def _tab_text(t):
+        return t.name if hasattr(t, 'name') else str(t)
+
+    for i, tab in enumerate(collection):
+        raw = _tab_text(tab)
+        # label_text = raw.replace("_", " ")
+
+        if i in excluded:
+            continue
+        label = f"{raw}"
+        if names is not None and i < len(names):
+            label = f"{names[i]}"
+        # Icons parallels `collection` like tints; prefix before the## so the
+        # imgui id (and click identity) stays keyed on the bare tab name.
+        if icons is not None and i < len(icons) and icons[i]:
+            label = f"{icons[i]} {label}"
+        active = tab in selected
+
+        tab_color = (0.5, 0.5, 0.5)
+        tinted = tints is not None and i < len(tints) and tints[i] is not None
+        if tinted:
+            tab_color = tints[i]
+
+        new_value = 0.15 if not tinted else 0.1
+
+        # make_color_rgb mixes `color` toward the theme color by `factor`; factor=1.0 (button's
+        # default) discards `color` entirely. Drop factor for tinted tabs so the tint shows, and
+        # give inactive tinted tabs a faint fill (the default alpha=0.0 draws no rect at all).
+        tab_factor = 0.30 if tinted else 1.2
+
+        tab_width = imgui.calc_text_size(label.split("##")[0]).x + button_padding
+
+        # Wrap before drawing: the previous iteration's same_line() left the
+        # cursor at this tab's real start (with item spacing included), so
+        # comparing live cursor + width against the content right edge needs
+        # no estimated spacing or fudge factor.
+        if i > 0 and x_limit is not None and imgui.get_cursor_screen_pos()[0] + tab_width > x_limit:
+            imgui.new_line()
+            imgui.set_cursor_screen_pos((row_start_x, imgui.get_cursor_screen_pos()[1]))
+
+        # Framework drag-and-drop: this button acts as a whole-rect drag
+        # item of dnd_collection_ds (key= is what DragDrop._begin picks up).
+        # While IT is the dragged child it renders with the floating-window
+        # kwargs (detached, fixed to pickup size, glued to the cursor) and a
+        # plain dummy holds its slot open in the flow.
+        dnd = None
+        dragged = False
+        dnd_extra = {}
+        if dnd_collection_ds is not None and dnd_keys is not None and i < len(dnd_keys):
+            dnd = dnd_keys[i]
+        _tx, _ty = imgui.get_cursor_screen_pos()
+        btn_height = tab_height
+        if dnd is not None:
+            dnd_extra = {"key": dnd[0], "dnd_handle": True, "return_extras": True}
+            # Same (collection, key) can be carried by two views - this button
+            # and the tab's stacked content view (draw_collection_as_tabs
+            # multi-select). Only the view actually picked up detaches, so
+            # require the dragged item to BE this button's draw state.
+            dragged = (_drag_drop.DragDrop.is_dragged_child(dnd_collection_ds, dnd[0])
+                       and _drag_drop.DragDrop.item_ds is dnd_collection_ds._children.get(dnd[1]))
+            if dragged:
+                dnd_extra.update(_drag_drop.DragDrop.dragged_item_kwargs())
+                # dragged_item_kwargs pins width/height to the pickup size -
+                # height would collide with the explicit height= below, so
+                # route it through btn_height (the pinned button size).
+                btn_height = dnd_extra.pop("height", btn_height)
+
+        if dnd is not None:
+            # dnd: tabs - legacy @render_func buttons: DragDrop needs a
+            # per-tab draw_state to register as the drag child (pickup,
+            # floating window, slot placeholder). Only the context menu's
+            # reorderable tab bar takes this branch.
+            if active:
+                selected_value = 0.23
+                btn_res = button(label, z_offset=2, name=f"tab_{i}_{unique}",
+                                 height=btn_height, tint_value=new_value + selected_value - 0.03,
+                                 color=tab_color, factor=tab_factor, draw=True, **dnd_extra)
+            else:
+                saturation = 1.0 if tinted else 0.3
+                btn_res = button(label, indent_size=0, height=btn_height, draw=True, z_offset=0.0,
+                                 alpha=0.0 if tinted else 0.0, tint_value=new_value if not tinted else 0.1,
+                                 saturation=saturation,
+                                 name=f"tab_{i}_{unique}_deactivated", color=tab_color, factor=tab_factor,
+                                 text_value=1.0 if not tinted else 0.9,
+                                 shadow=False, **dnd_extra)
+            # A draggable tab must not change the selection on mouse-DOWN (a
+            # drag pickup would eat a multi-select). Override the button's
+            # down-click and select on CLICKED instead: the input handler only
+            # passes it for a release within MOVE_MAX_DISTANCE of the press,
+            # so a press that becomes a drag never selects.
+            clicked = False
+            if not dragged and draw_state is not None:
+                clicked = draw_state.on_action(
+                    "left_mouse_clicked", view_id=f"tab_click_{i}",
+                    rect=(_tx, _ty, _tx + tab_width, _ty + tab_height),
+                    priority_delta=2) is not None
+            btn_ds = btn_res[2] if len(btn_res) == 3 else None
+            if btn_ds is not None:
+                # Fulfill the drop-collection contract on the OWNER's ds (see
+                # DragDrop._is_drop_collection): children keyed by collection
+                # index, backlinked for register_item/_begin.
+                btn_ds._collection_draw_state = dnd_collection_ds
+                if dnd_collection_ds._children is None:
+                    dnd_collection_ds._children = {}
+                dnd_collection_ds._children[dnd[1]] = btn_ds
+            if dragged:
+                # The dragged button deferred to a floating window and drew
+                # nothing inline - hold its slot open at the current flow
+                # position so the bar doesn't reflow mid-drag.
+                imgui.dummy(tab_width, tab_height)
+                clicked = False
+        else:
+            # Plain tabs: draw-list rendering (flat_button - the fast-dock
+            # model). The per-tab @render_func buttons cost ~0.7ms each in
+            # wrapper machinery alone; on the editor's 8-tab strip that was
+            # the largest single slice of the hovered frame. Visual parity
+            # with the old button params: active tabs get the filled rect,
+            # inactive draw label-only (alpha=0), hover brightens the text
+            # like the button's hovered text_value boost. Framework
+            # shadows/z-offset on the active tab are gone (no draw_state) -
+            # the fast-dock tradeoff.
+            if active:
+                # flat_button applies its own shadow when it draws a bg (the
+                # inactive alpha=0 tabs stay flat).
+                clicked = flat_button(
+                    label, draw_state, view_id=f"tab_{i}",
+                    width=tab_width, height=btn_height,
+                    color=tab_color, factor=tab_factor,
+                    tint_value=new_value + 0.23 - 0.03)
+            else:
+                clicked = flat_button(
+                    label, draw_state, view_id=f"tab_{i}",
+                    width=tab_width, height=btn_height,
+                    color=tab_color, factor=tab_factor, alpha=0.0,
+                    tint_value=new_value if not tinted else 0.1,
+                    saturation=1.0 if tinted else 0.3,
+                    text_value=1.0 if not tinted else 0.9)
+
+        if clicked:
+            changed = True
+            if io.key_shift or as_toggles:
+                if active:
+                    selected.remove(tab)
+                else:
+                    selected.append(tab)
+            else:
+                selected = [tab]
+
+        same_line()
+
+    imgui.dummy(0, 0)
+
+    if changed:
+        Core.melty.refresh_nested_windows(draw_state)
+
+    return changed, selected
+
+
+@render_func(with_header=draw_header, is_tree=False, shadow=False)
+def draw_enum_tabs(input_value: type, tab_state: TabState):
+    enum_states = list(input_value)
+    selected = tab_state.selected_tabs
+
+    changed, new_selected = draw_tab_bar(selected, collection=enum_states)
+    if changed:
+        tab_state.selected_tabs = new_selected
+
+    return False, input_value

meltygui/view/tensor_view.py

@@ -0,0 +1,430 @@
+"""Tensor view functions and supporting definitions."""
+from meltygui.hdr_color import pack_color
+from meltygui.state.tensor_state import TensorErrorState
+from meltygui.model.tensor_model import TensorDim
+from meltygui.model.tensor_model import TensorDims
+from meltygui.core.core_render import render_func
+from meltygui.core.rendering.render_funcs import RenderFuncs
+from meltygui.view.header_view import draw_header
+import math
+import meltygui_imgui as imgui
+from meltygui.view.header_view import flat_button
+from meltygui.view.decoration_view import draw_bg
+
+
+@render_func(tint=(0.23, 0.49, 0.62), use_cache=True, show_bg=False,
+             with_header=None, show_header=False, shadow=False, auto_resize=True, wrap=False)
+def draw_tensor_slices(input_value: tuple, slider_dims=(), dim_names=(),
+                       source_shape=(), draw_state=None):
+    """Edit unmapped tensor dimensions through ordinary integer controls."""
+    from meltygui.view.control_view import draw_int_slider
+    values = list(input_value) + [0] * max(0, len(source_shape) - len(input_value))
+    changed = False
+    for dimension in slider_dims:
+        label = dim_names[dimension] if dimension < len(dim_names) else f"dim{dimension}"
+        upper_bound = max(0, source_shape[dimension] - 1)
+        current = max(0, min(int(values[dimension]), upper_bound))
+        edited, value = draw_int_slider(current, name=f"{label}##slice{dimension}",
+                                         min_value=0, max_value=upper_bound,
+                                         width=draw_state.content_width, height=22)
+        if edited and value != current:
+            values[dimension] = value
+            changed = True
+    return changed, tuple(values) if changed else input_value
+
+
+def _draw_slice_sliders(draw_state, slider_dims, dim_names, slices, source_shape, width):
+    changed, value = draw_tensor_slices(slices, slider_dims=slider_dims,
+                                        dim_names=dim_names, source_shape=source_shape,
+                                        name="Slice positions", width=width)
+    if changed:
+        draw_state.locate_slices = value
+    return changed, value
+
+
+@render_func(tint=(0.68, 0.22, 0.20), use_cache=True, show_bg=False,
+             with_header=None, show_header=False, shadow=False, auto_resize=False)
+def draw_tensor_error(input_value: str, draw_state=None,
+                       error_state: TensorErrorState = None, who="draw_voxels"):
+    """An error card with the same footprint as a tensor or graph view."""
+    import textwrap
+    left, top, right, bottom = draw_state.get_content_rect()
+    width, height = right - left, bottom - top
+    padding = 12.0
+    draw_list = imgui.get_window_draw_list()
+    draw_list.add_rect_filled(left, top, left + width, top + height,
+                              pack_color(0.09, 0.05, 0.05, 1.0), 6.0)
+    draw_list.add_rect(left, top, left + width, top + height,
+                       pack_color(0.75, 0.25, 0.25, 0.9), 6.0, thickness=1.5)
+    draw_list.add_text(left + padding, top + padding,
+                       pack_color(1.0, 0.55, 0.55, 1.0),
+                       f"{who} can't display this tensor")
+    line_height = imgui.get_font_size() + 2
+    line_top = top + padding + line_height + 4
+    columns = max(1, int((width - padding * 2) / max(1, imgui.calc_text_size("M")[0])))
+    draw_list.push_clip_rect(left + padding, top + padding, right - padding, bottom - padding)
+    for paragraph in input_value.splitlines():
+        for line in textwrap.wrap(paragraph, width=columns) or ['']:
+            draw_list.add_text(left + padding, line_top, pack_color(1.0, 0.85, 0.85, 1.0), line)
+            line_top += line_height
+    draw_list.pop_clip_rect()
+    imgui.dummy(width, height)
+    if error_state.last_error != input_value:
+        error_state.last_error = input_value
+        print(f"[{who}] {draw_state.name}: {input_value}")
+    return False, input_value
+
+
+def _draw_voxel_error(draw_state, message, who="draw_voxels"):
+    width, height = _view_size(draw_state)
+    return draw_tensor_error(message, name=f"{who} error", who=who,
+                              width=width, height=height)
+
+
+@render_func(is_default_for=("TensorDim", "TensorDims"), show_bg=False, is_tree=False,
+             header_same_line=True, with_header=draw_header)
+def draw_tensor_dim(input_value: TensorDim | TensorDims = None, draw_state=None,
+                    unique=0, ui_scale=1.0, style_manager=None, **kwargs):
+    """THE dim picker — one TAB per dim NAME instead of a bare number field,
+    shared by every dim-typed param. A TensorDim renders single-select with
+    a leading "off" tab that maps to -1 (unset: sort disabled, nf/axis dims
+    derived), so sort_dim and nf_chop/nf_along reuse it as-is. A TensorDims
+    renders the same tabs multi-select (mean_dims). The tabs are this view's
+    own flat_buttons (`_draw_dim_tabs`), not a nested draw_tab_bar. Picking
+    a dim a sibling AXIS row already holds swaps the two (`_swap_sibling_dim`,
+    SWAP_DIM_KEYS). The names
+    come from the sibling `dim_names` entry of the collection this row
+    renders in (the params panel's locate_params proxy); with no names in
+    reach it falls back to a plain int edit. Returns the SAME type it was
+    given so the value keeps routing here (a plain int/tuple would drop back
+    to the generic renderer next frame)."""
+    from meltygui.model.tensor_model import TensorDim
+    from meltygui.model.tensor_model import TensorDims
+    from meltygui.model.tensor_model import _collection_dim_labels
+
+    multi = isinstance(input_value, tuple)
+    col = _row_collection(draw_state, kwargs)
+    labels = _collection_dim_labels(col)
+    if not labels:
+        if multi:
+            imgui.text(f"dims: {tuple(int(v) for v in input_value)}")
+            return False, input_value
+        changed, v = RenderFuncs.draw_int(
+            0 if input_value is None else int(input_value),
+            name=f"dim##{unique}")
+        if changed and v is not None:
+            return True, TensorDim(int(v))
+        return False, input_value
+    n = len(labels)
+    if multi:
+        cur = [int(v) for v in input_value if isinstance(v, int)]
+        changed, selected = _draw_dim_tabs(
+            draw_state, list(range(n)), labels,
+            [d for d in cur if 0 <= d < n], multi=True,
+            ui_scale=ui_scale, style_manager=style_manager)
+        if changed:
+            return True, TensorDims(sorted(int(s) for s in selected))
+        return False, input_value
+    # Single-select: a leading "off" tab maps to -1 (unset - sort disabled,
+    # nf/axis dims derived), so unsetting doesn't rely on double-click.
+    cur = int(input_value) if input_value is not None else -1
+    if not (0 <= cur < n):
+        cur = -1
+    changed, selected = _draw_dim_tabs(
+        draw_state, [-1] + list(range(n)), ["off"] + labels, [cur], multi=False,
+        ui_scale=ui_scale, style_manager=style_manager)
+    if changed:
+        new = int(selected[0]) if selected else -1
+        _swap_sibling_dim(draw_state, kwargs, cur, new)
+        return True, TensorDim(new)
+    return False, input_value
+
+
+def _describe_tensor(t):
+    """'Tensor[32, 1, 570, 4096] float16 cuda:0' — for error cards."""
+    try:
+        dev = getattr(t, "device", None)
+        dev = f" {dev}" if dev is not None and str(dev) != "cpu" else ""
+        return f"{type(t).__name__}{list(t.shape)} {str(t.dtype).replace('torch.', '')}{dev}"
+    except Exception:
+        return repr(t)[:80]
+
+
+def _view_size(draw_state):
+    """(width, height) the 3-D image occupies — shared by the render path
+    and the error card so the card holds the view's footprint (no layout
+    jump between a good frame and a failed one). Sized from the OWNING
+    WINDOW, not this view's own content rect — a nested view's rect derives
+    from what it rendered last frame (self-referential), while the window's
+    height is the user-dragged size. The owning window IS the draw_state
+    when draw_voxels is itself a window (closable); parent_window for a
+    closable voxel grabbed an ANCESTOR that doesn't move with it."""
+    win = draw_state if draw_state.closable else (draw_state.parent_window or draw_state)
+    width = max(64, int(draw_state.content_width or win.content_width or 0))
+    # Vertical reserve: the actual header band (0 if hidden) plus a little
+    # slack for the footer/status margin (the old hardcoded 30 was the
+    # 23px header + this slack).
+    _reserve = int(draw_state.header_height or 0) + 7
+    if draw_state.closable:
+        height = max(100, draw_state.height - _reserve)
+    else:
+        # When in a parent's flow, draw_state.height is only trustworthy
+        # when something explicit wrote it - a user drag ("initial
+        # window size"), a passed height kwarg, fill_height. The auto_resize
+        # measurement path ("... item_rect[1]") is what this view drew last
+        # frame - sizing the image from it is a feedback loop that sustains
+        # any spike forever (image = height-30 → measures back ≈ height →
+        # committed again); fall back to the design height (min_height,
+        # overridable per call site) for that case, and a bad committed
+        # height self-heals on the next live render.
+        _h_src = str(draw_state._source.get("height", ""))
+        if draw_state.height and "item_rect" not in _h_src:
+            height = max(100, int(draw_state.height) - _reserve)
+        else:
+            height = max(100, int(draw_state.min_height or 293) - _reserve)
+    return width, height
+
+
+def _draw_image_notice(img_pos, width, text):
+    """Small wrapped caption on the image's top-left (clamp notices):
+    a translucent plate under wrapped imgui text, cursor restored after."""
+    x, y = img_pos
+    pad = 6.0
+    wrap_w = max(40.0, width - 2 * pad - 4)
+    tw, th = imgui.calc_text_size(text, wrap_width=wrap_w)
+    imgui.get_window_draw_list().add_rect_filled(
+        x + 2, y + 2, x + min(tw, wrap_w) + 2 * pad + 2, y + th + 2 * pad + 2,
+        pack_color(0.0, 0.0, 0.0, 0.6), 4.0)
+    cur = imgui.get_cursor_screen_pos()
+    imgui.set_cursor_screen_pos((x + pad + 2, y + pad + 2))
+    imgui.push_text_wrap_pos(x + pad + 2 + wrap_w)
+    imgui.push_style_color(imgui.COLOR_TEXT, 1.0, 0.8, 0.4, 1.0)
+    imgui.text_wrapped(text)
+    imgui.pop_style_color()
+    imgui.pop_text_wrap_pos()
+    imgui.set_cursor_screen_pos(cur)
+
+
+def format_bytes(n):
+    """Tensor byte count → 'KB' / 'MB' / 'GB' string (the old volume
+    renderer's 2-dp formatting) plus its size tint: green ≤10 MB, yellow
+    ≤100 MB, red above."""
+    n = int(n or 0)
+    if n > 1024 ** 3:
+        txt = f"{n / 1024 ** 3:.2f} GB"
+    elif n > 1024 ** 2:
+        txt = f"{n / 1024 ** 2:.2f} MB"
+    else:
+        txt = f"{n / 1024:.2f} KB"
+    if n > 100 * 1024 ** 2:
+        tint = (1.0, 0.45, 0.4, 1.0)
+    elif n > 10 * 1024 ** 2:
+        tint = (1.0, 0.85, 0.35, 1.0)
+    else:
+        tint = (0.5, 0.9, 0.5, 1.0)
+    return txt, tint
+
+
+def _draw_tensor_meta(img_pos, height, t):
+    """Bottom-left caption over the image: shape · dtype · device · bytes
+    (size tinted by magnitude), read straight off the source tensor."""
+    try:
+        shape = "×".join(str(int(d)) for d in t.shape)
+        dtype = str(t.dtype).replace("torch.", "")
+        nbytes = int(t.numel()) * int(t.element_size())
+    except Exception:
+        return
+    dev = str(getattr(t, "device", "cpu"))
+    head = "  ".join(p for p in (shape, dtype, dev if dev != "cpu" else "") if p)
+    size_txt, size_tint = format_bytes(nbytes)
+    pad, gap = 5.0, 8.0
+    hw, hh = imgui.calc_text_size(head)
+    sw, sh = imgui.calc_text_size(size_txt)
+    tw, th = hw + gap + sw, max(hh, sh)
+    x, y = img_pos
+    x0, y0 = x + 2, y + height - th - 2 * pad - 2
+    dl = imgui.get_window_draw_list()
+    dl.add_rect_filled(x0, y0, x0 + tw + 2 * pad, y0 + th + 2 * pad,
+                       pack_color(0.0, 0.0, 0.0, 0.55), 4.0)
+    dl.add_text(x0 + pad, y0 + pad, pack_color(0.85, 0.85, 0.85, 1.0), head)
+    dl.add_text(x0 + pad + hw + gap, y0 + pad, pack_color(*size_tint), size_txt)
+
+
+DIM_TAB_HEIGHT = 26
+
+
+DIM_TAB_TEXT_PAD = 11
+
+
+DIM_TAB_GAP = 3
+
+
+DIM_TAB_BAND_PAD = 3
+
+
+DIM_TAB_COLOR = (0.5, 0.5, 0.5)
+
+
+SWAP_DIM_KEYS = frozenset({"x_dim", "y_dim", "z_dim", "line_dim"})
+
+
+def _row_collection(draw_state, kwargs):
+    """The collection this row renders in (the params panel's locate_params
+    proxy) — sibling params like dim_names / x_dim live there."""
+    col = kwargs.get("collection")
+    if not isinstance(col, dict):
+        col = getattr(draw_state, "_collection", None)
+    return col if isinstance(col, dict) else None
+
+
+def _draw_dim_tabs(draw_state, options, labels, selected, multi, *,
+                   ui_scale=1.0, style_manager=None):
+    """The dim tab strip: one flat_button per option, laid out by hand
+    (wrapping at draw_state.content_width) over the same draw_bg band
+    draw_tab_bar's wrapper painted (bg_offset=-3, rounding 5), with the tab
+    bar's look — active = filled rect + shadow, inactive = label only, hover
+    brightens — but DIM_TAB_* geometry. No nested render_func: the buttons
+    paint straight into this view's draw list and claim their clicks through
+    this view's draw_state.on_action, so the row costs one wrapper instead
+    of two. Returns (changed, selected) with `selected` a list of option
+    values; multi toggles, single replaces."""
+    tab_h = DIM_TAB_HEIGHT * ui_scale
+    pad = DIM_TAB_TEXT_PAD * ui_scale
+    gap = DIM_TAB_GAP * ui_scale
+    band_pad = DIM_TAB_BAND_PAD * ui_scale
+    x0, y0 = imgui.get_cursor_screen_pos()
+    content_width = draw_state.content_width if draw_state is not None else 0
+    x_limit = x0 + content_width if content_width > 0 else None
+    # Layout first (pure math over the label widths) so the band can be
+    # painted UNDER the buttons without carrying last frame's extent on the
+    # draw_state the way the tab / show_bg path does.
+    rects = []
+    x, y = x0 + band_pad, y0 + band_pad
+    for label in labels:
+        w = imgui.calc_text_size(label).x + pad
+        if rects and x_limit is not None and x + w + band_pad > x_limit:
+            x, y = x0 + band_pad, y + tab_h + gap
+        rects.append((x, y, w))
+        x += w + gap
+    right = max(rx + rw for rx, _, rw in rects) + band_pad
+    bottom = rects[-1][1] + tab_h + band_pad
+    draw_bg(left=x0, top=y0, width=right - x0, height=bottom - y0,
+            rounding=5, bg_offset=-3, depth=draw_state.depth_and_layer[0], opacity=1.0,
+            selected=False, pressed=False, nested_bg=False,
+            style_manager=style_manager)
+    changed = False
+    selected = list(selected)
+    for i, (opt, label, (x, y, w)) in enumerate(zip(options, labels, rects)):
+        imgui.set_cursor_screen_pos((x, y))
+        active = opt in selected
+        # Same params draw_tab_bar hands flat_button for an untinted tab
+        # (new_value=0.15, factor=1.2): active keeps flat_button's full
+        # text/saturation, inactive is alpha=0 with the muted text.
+        if active:
+            clicked = flat_button(label, draw_state, view_id=f"dim_tab_{i}",
+                                  width=w, height=tab_h, color=DIM_TAB_COLOR,
+                                  factor=1.2, tint_value=0.15 + 0.23 - 0.03)
+        else:
+            clicked = flat_button(label, draw_state, view_id=f"dim_tab_{i}",
+                                  width=w, height=tab_h, color=DIM_TAB_COLOR,
+                                  factor=1.2, alpha=0.0, tint_value=0.15,
+                                  saturation=0.3, text_value=1.0)
+        if clicked:
+            changed = True
+            if multi:
+                if active:
+                    selected.remove(opt)
+                else:
+                    selected.append(opt)
+            else:
+                selected = [opt]
+    # Register the whole band (pads included) with the layout so the row's
+    # measured extent covers it, and leave the cursor below it.
+    imgui.set_cursor_screen_pos((x0, y0))
+    imgui.dummy(right - x0, bottom - y0)
+    return changed, selected
+
+
+def _sibling_dim_keys(draw_state):
+    """Keys of the OTHER draw_tensor_dim rows in the panel this row renders
+    in, found by walking the render tree (the parent's _view_children index,
+    where every rendered child self-registers) rather than the collection:
+    what is actually rendering as a dim picker right now, whatever the
+    collection stores. Read-only over the siblings — no value ever moves
+    through another row's draw_state."""
+    parent = draw_state._parent if draw_state is not None else None
+    if parent is None or parent is draw_state:      # a root ds parents itself
+        return []
+    keys = []
+    for sib in parent._view_children.values():
+        if sib is None or sib is draw_state or sib._parent is not parent:
+            continue
+        # Recognize the renderer by its stable name, including rows restored
+        # from older sessions or decorated through another call path.
+        if getattr(sib._view_func, "__name__", None) != "draw_tensor_dim":
+            continue
+        key = (sib._kwargs or {}).get("key")
+        if key is not None:
+            keys.append(key)
+    return keys
+
+
+def _swap_sibling_dim(draw_state, kwargs, old, new):
+    """This row just moved from `old` to `new`: if a sibling AXIS row holds
+    `new`, hand it `old` so the two axes swap. The hand-off is the same
+    write draw_collection performs when that row returns changed —
+    `collection[key] = value` on the panel's ParamProxy (→ set_anywhere) —
+    so the sibling's value takes the normal route whether or not that row
+    renders this frame, and nothing is posted on its draw_state."""
+    if new < 0:
+        return                              # "off" can be shared freely
+    key = (draw_state._kwargs or {}).get("key") if draw_state is not None else None
+    if key not in SWAP_DIM_KEYS:
+        return
+    col = _row_collection(draw_state, kwargs)
+    if col is None:
+        return
+    for sib_key in _sibling_dim_keys(draw_state):
+        if sib_key not in SWAP_DIM_KEYS or sib_key not in col:
+            continue
+        v = col.get(sib_key)
+        if isinstance(v, int) and not isinstance(v, bool) and int(v) == new:
+            col[sib_key] = TensorDim(old)
+            return
+
+
+def _tick_values(lo, hi, px_per_idx, num_px, spacing=1.6):
+    """Integer tick positions for the VISIBLE [lo, hi] index span of one
+    edge: EVERY integer when the labels fit, else the smallest 1-2-5·10ᵏ
+    step whose rotated labels keep clear of each other (footprint ≈ the
+    widest label's text width along the edge, in projected PIXELS — so
+    zooming in fits more ticks). `spacing` is the minimum gap between tick
+    centers in widest-label widths. The span's end values always show —
+    0/max on an unclipped edge, the boundary indices (a scrollbar-like
+    readout of where you are along the axis) on a clipped one; interior
+    step multiples stay GLOBAL multiples (they don't jitter as the clip
+    end moves) and yield when they would crowd an end."""
+    e0, e1 = int(math.ceil(lo - 1e-9)), int(math.floor(hi + 1e-9))
+    if e1 < e0:
+        return []
+    if e1 == e0:
+        return [e0]
+    widest = max(1, len(str(e1))) * 0.62 * num_px  # ~max glyph aspect
+    min_px = widest * spacing
+    step, k = None, 1
+    while step is None and k <= 10 ** 9:
+        for s in (1, 2, 5):
+            if s * k * px_per_idx >= min_px:
+                step = s * k
+                break
+        else:
+            k *= 10
+    if step is None or step > e1 - e0:
+        return [e0, e1]
+    ticks = [e0]
+    m = int(math.ceil((e0 + 0.6 * step) / step)) * step
+    while m <= e1 - 0.6 * step:
+        ticks.append(m)
+        m += step
+    ticks.append(e1)
+    return ticks