meltygui 0.1.0__py3-none-any.whl

meltygui/core/layout/cursor_core.py

@@ -0,0 +1,161 @@
+import inspect
+import sys
+
+import meltygui_imgui as imgui
+from meltygui.hdr_color import pack_color
+
+from meltygui.core.conversion.dict_conversion import DictConversion
+from meltygui.core.runtime.toggles import Toggles
+from meltygui.utils.render_utils import LSDView
+from meltygui.utils.render_utils import print_stack_trace
+from meltygui.utils.render_utils import push_style_color
+from meltygui.utils.render_utils import pop_style_color
+from meltygui.utils.render_utils import print_colored_traceback
+from meltygui.core.melty import Melty
+
+
+def set_cursor_pos_y(pos_y):
+    current_y = imgui.get_cursor_pos_y()
+    imgui.set_cursor_pos_y(pos_y)
+    height = imgui.get_cursor_pos_y() - current_y
+    if Toggles.show_line_breaks:
+        if draw_rect(width=5, height=None, color=(1.0, 0.0, 1.0, 0.8)):
+            print_stack_trace(skip=-2)
+
+
+def set_cursor_pos_x(pos_x):
+    current_x = imgui.get_cursor_pos_x()
+    imgui.set_cursor_pos_x(pos_x)
+    width = imgui.get_cursor_pos_x() - current_x
+    if Toggles.show_line_breaks:
+        if draw_rect(width=5, height=None, color=(1.0, 0.0, 1.0, 0.8)):
+            print_stack_trace(skip=-2)
+
+
+def set_cursor_screen_pos(pos):
+    imgui.set_cursor_screen_pos(pos)
+    if Toggles.show_line_breaks:
+        if draw_rect(width=5, height=None, color=(1.0, 0.0, 1.0, 0.8)):
+            print_stack_trace(skip=-2)
+
+
+def set_cursor_screen_position(pos):
+    imgui.set_cursor_screen_position(pos)
+    if Toggles.show_line_breaks:
+        if draw_rect(width=5, height=None, color=(1.0, 0.0, 1.0, 0.8)):
+            print_stack_trace(skip=-2)
+
+
+def set_cursor_pos(pos):
+    current_pos = imgui.get_cursor_pos()
+    imgui.set_cursor_pos(pos)
+    if Toggles.show_line_breaks:
+        if draw_rect(width=5, height=None, color=(1.0, 0.0, 1.0, 0.8)):
+            print_stack_trace(skip=-2)
+
+
+def spacing():
+    imgui.spacing()
+    if Toggles.show_line_breaks:
+        if draw_rect(width=3, height=None, color=(0, 0.1, 0.7, 0.8)):
+            print_stack_trace(skip=-2)
+
+
+def indent(indent_size=None, attr_name=None):
+    if Toggles.show_line_breaks:
+        if draw_rect(width=3, height=None, color=(0.1, 0.1, 1.0, 0.8)):
+            print_stack_trace(skip=-2)
+            if attr_name is not None:
+                print(f"=======Indenting for {attr_name}=========")
+
+        if not (is_hovered(width=5, height=None) and imgui.is_mouse_down(imgui.MOUSE_BUTTON_MIDDLE)):
+            imgui.indent(indent_size)
+    else:
+        imgui.indent(indent_size)
+
+
+def same_line(spacing=None):
+    if Toggles.show_line_breaks:
+        if draw_rect(width=3, height=None, color=(1.0, 0.5, 0.1, 0.5)):
+            print_stack_trace(skip=-2)
+        if not (is_hovered(width=3, height=None) and imgui.is_mouse_down(imgui.MOUSE_BUTTON_MIDDLE)):
+            if spacing is None:
+                imgui.same_line()
+            else:
+                imgui.same_line(spacing=spacing)
+    else:
+        if spacing is None:
+            imgui.same_line()
+        else:
+            imgui.same_line(spacing=spacing)
+
+
+def new_line():
+    if Toggles.show_line_breaks:
+        if draw_rect(width=3, height=None, color=(0.5, 0, 0, 0.5)):
+            print_stack_trace(skip=-2)
+        if not (is_hovered(width=3, height=None) and imgui.is_mouse_down(imgui.MOUSE_BUTTON_MIDDLE)):
+            imgui.new_line()
+    else:
+        imgui.new_line()
+
+
+
+def copy_attributes(source, target):
+    """
+    Copies attributes from source to target, excluding private attributes.
+    If an attribute exists in both, it will be overwritten in the target.
+    """
+    if not isinstance(source, DictConversion) and not isinstance(target, DictConversion):
+        return
+
+    for attr_name, attr_value in source.__dict__.items():
+        setattr(target, attr_name, attr_value)
+
+
+def is_hovered(x=None, y=None, width=5, height=None):
+    padding = imgui.get_style().window_padding
+    if x is None:
+        x = imgui.get_cursor_screen_pos()[0] - padding[0]
+    if y is None:
+        y = imgui.get_cursor_screen_pos()[1] - padding[1]
+    if height is None:
+        line_height = imgui.get_text_line_height()
+        height = line_height + padding[1] * 2
+    return imgui.is_mouse_hovering_rect(x, y, x + max(width, 10), y + height)
+
+
+def render_dict_as_table(input_value=None, config=None):
+    unique = config.unique
+
+    num_columns = 2  # For key / value pair
+    imgui.columns(num_columns, f"dict_columns##{unique}", True)
+    for key, value in input_value.items():
+        imgui.text(f"{key}")
+        imgui.next_column()
+        imgui.text(f"{value}")
+        imgui.next_column()
+
+    imgui.columns(1)  # Reset to single column layout
+
+
+def draw_rect(x=None, y=None, width=5, height=None, color=(1, 1, 1, 1)):
+    padding = imgui.get_style().window_padding
+    if x is None:
+        x = imgui.get_cursor_screen_pos()[0] - padding[0]
+    if y is None:
+        y = imgui.get_cursor_screen_pos()[1] - padding[1]
+    if height is None:
+        line_height = imgui.get_text_line_height()
+        height = line_height + padding[1] * 2
+    imgui.get_foreground_draw_list().add_rect_filled(
+        x, y, x + width, y + height, pack_color(*color))
+
+    clicked = False
+    if imgui.is_mouse_hovering_rect(x, y, x + max(width, 10), y + height):
+        white = (1.0, 1.0, 1.0, 1.0)
+        imgui.get_foreground_draw_list().add_rect(
+            x, y, x + width, y + height, pack_color(*white))
+        if imgui.is_mouse_clicked(imgui.MOUSE_BUTTON_LEFT):
+            clicked = True
+    return clicked

meltygui/core/layout/dropdown_core.py

@@ -0,0 +1,278 @@
+"""Dropdown core functions and supporting definitions."""
+from meltygui.core.runtime.toggles import Toggles
+from meltygui.core.melty import Melty
+from meltygui.core.rendering.core_decoration import Core
+
+
+def _close_menu(draw_state, state):
+    """Close whatever menu is showing: release the popover slot, collapse
+    that menu's paths, hand text focus back to whoever had it."""
+    from meltygui.core.windowing.glfw_utils import request_render
+
+    if state.open_title is not None:
+        menu_state = state.menus.get(state.open_title)
+        _dd_close(menu_state)
+        # A picked action may remove this state before its next draw call.
+        # Close its surface now rather than waiting for closed=True next frame.
+        if menu_state is not None and menu_state._menu_ds is not None:
+            menu_state._menu_ds.closed = True
+    state.open_title = None
+    if Melty.popover_focused_ds is draw_state:
+        Melty.popover_focused_ds = None
+    if Melty.text_focused_ds is draw_state:
+        previous = state._prev_text_focus
+        Melty.text_focused_ds = previous if previous is not draw_state else None
+        if previous is not None:
+            Melty._text_focus_grant_frame = Melty.frame_count
+    state._prev_text_focus = None
+    draw_state.invalidate()
+    request_render()
+
+
+def _ds_in_subtree(node, ancestor, max_depth=64):
+    """Use the same window ancestry as focus dispatch, including popovers."""
+    return ancestor.id in Core.melty.ancestor_closure([node])
+
+
+def _dd_set_cursor(root_state, cursor_path, is_branch, menu_ds=None):
+    """Point the highlight at `cursor_path` and derive the open path from it: a
+    branch expands its own sub-menu, a leaf collapses back to its parent level.
+    This is the single writer for both hover and keyboard, so they stay in sync.
+
+    When the OPEN path changes, the containing menu's row tiles must re-run:
+    a branch row stamps `closed` on its submenu window only when its body
+    actually runs, and the blit cache has no kwargs key — a clean row tile
+    blit-skips even though its open_path input changed, leaving the submenu
+    stamped open forever (one leaked submenu per branch row swept). Keyboard
+    nav never leaked because begin_frame cascades invalidate_up from the menu
+    tile on every nav key; this is the hover-side equivalent. `menu_ds` is the
+    level's menu-window draw_state (row tiles are its direct tile children)."""
+    from meltygui.model.dropdown_model import _dd_as_tuple
+
+    if root_state is None:
+        return
+    new_cursor = tuple(cursor_path)
+    new_open = tuple(cursor_path) if is_branch else tuple(cursor_path[:-1])
+    old_open = _dd_as_tuple(root_state.open_path)
+    if (new_cursor == _dd_as_tuple(root_state.cursor_path)
+            and new_open == old_open):
+        return
+    root_state.cursor_path = new_cursor
+    root_state.open_path = new_open
+    if new_open != old_open:
+        _dd_invalidate_rows(root_state, menu_ds)
+
+
+def _dd_invalidate_rows(root_state, menu_ds=None):
+    """Cascade-invalidate a menu window's tile subtree so every row body
+    re-runs and re-stamps `closed` on its submenu from the current open_path.
+    Without a menu_ds at hand (close paths), resolve the root menu through the
+    search box tile — its parent_window is the root menu. bypass_clip so a
+    branch row scrolled out of the menu viewport is cleaned too (otherwise
+    scrolling it back in would revive its stale-open submenu). Submenu windows
+    are tile ROOTS (not tile children of their spawner rows), so this reaches
+    rows, not window interiors — which is all closing needs."""
+    from meltygui.core.windowing.glfw_utils import request_render
+
+    if menu_ds is None and root_state is not None:
+        box_tile = getattr(root_state, "_search_box_tile", None)
+        if box_tile is not None:
+            box_ds = Melty.cache.key_to_draw_state.get(box_tile)
+            menu_ds = getattr(box_ds, "parent_window", None) if box_ds is not None else None
+    if menu_ds is None or getattr(menu_ds, "_tile_id", None) is None:
+        return
+    from meltygui.core.cache.invalidation_tracker import Note
+    Melty.cache.invalidate_up(menu_ds._tile_id, force=True, bypass_clip=True,
+                              note=Note(name="dd open_path change", tint=(1, 0.6, 0.2)))
+    request_render()
+
+
+def _dd_scroll_cursor_into_view(menu_ds, row_index, row0_offset=0.0, pitch=None):
+    """Nudge a menu window's scroll_offset the minimal amount so keyboard-cursor
+    row `row_index` is fully visible. Rows are a fixed _DD_ROW_H pitch drawn
+    flush from the content origin in the manual-loop path; `row0_offset` covers
+    a level that draws chrome above its rows. Stateless — pure geometry from
+    the live draw_state, clamped to the wrapper-published _max_scroll_y so this
+    writer never fights core_render's own clamp."""
+    from meltygui.core.windowing.glfw_utils import request_render
+
+    if menu_ds is None or row_index is None or row_index < 0:
+        return
+    pitch = Toggles.Dropdown.row_height if pitch is None else pitch   # the usage picker's rows are taller
+    view_h = menu_ds.abs_clipped_height - menu_ds.header_height - menu_ds.footer_height
+    sx, sy = menu_ds.scroll_offset
+    row_top = row0_offset + row_index * pitch
+    row_bot = row_top + pitch
+    new_sy = sy
+    if view_h > 0 and row_bot > new_sy + view_h:  # below the viewport: minimal scroll down
+        new_sy = row_bot - view_h
+        max_y = menu_ds._max_scroll_y
+        if max_y is not None:
+            new_sy = min(new_sy, max_y)
+    if row_top < new_sy:  # above the viewport (top-centers a tiny view)
+        new_sy = row_top
+    new_sy = max(0.0, new_sy)
+    if new_sy != sy:
+        menu_ds.scroll_offset = (sx, new_sy)
+        # Own the repaint edge: scroll is BAKED into the blit capture at render
+        # time and only the wheel-event callback repaints on scroll change, so a
+        # clean tile would replay the old-offset capture (the caller's repaint gate
+        # doesn't always fire - e.g. a snap-to-top when the filtered list is
+        # value-identical). Change-edge-gated by `new_sy != sy` above, never
+        # per-frame. bypass_clip: the popup can protrude outside its parent.
+        if menu_ds._tile_id is not None:
+            from meltygui.core.cache.invalidation_tracker import Note
+            Melty.cache.invalidate_up(menu_ds._tile_id, force=True, bypass_clip=True,
+                                      note=Note(name="dd scroll-into-view", tint=(1, 0.6, 0.2)))
+        request_render()
+
+
+def _dd_pick(root_state, path):
+    """Keep a selection until the owning dropdown consumes it.
+
+    Submenus render as independent floating windows, often after their parent
+    has already drawn. A one-frame return value cannot reliably cross that
+    boundary; the shared dropdown state owns the pending selection.
+    """
+    from meltygui.core.windowing.glfw_utils import request_render
+
+    root_state._picked_path = tuple(path)
+    root_state._pending_pick = tuple(path)
+    owner = Melty.popover_focused_ds
+    if owner is not None:
+        owner.invalidate_up()
+    request_render()
+
+
+def _dd_close(root_state):
+    """Reset popover state on close: collapse the open/cursor paths, clear the
+    search query, and release the search box's text focus if it held it."""
+    from meltygui.model.dropdown_model import _dd_as_tuple
+
+    if root_state is None:
+        return
+    menu = getattr(root_state, "_menu_ds", None)
+    if menu is not None:
+        menu.closed = True
+    root_state._pending_pick = None
+    open_was = _dd_as_tuple(root_state.open_path)
+    root_state.open_path = ()
+    root_state.cursor_path = ()
+    root_state.search_query = ""
+    root_state.search = ""
+    root_state._focus_search = 0
+    root_state._had_focus = False
+    # A branch row left stamped open would blit-skip on reopen and revive its
+    # submenu window even though open_path was reset - dirty the rows now (the
+    # flags persist while the menu is hidden) so the first reopen render
+    # re-stamps every submenu closed.
+    if open_was:
+        _dd_invalidate_rows(root_state)
+    box_tile = getattr(root_state, "_search_box_tile", None)
+    tf = Melty.text_focused_ds
+    if tf is not None and box_tile is not None and getattr(tf, "_tile_id", None) == box_tile:
+        Melty.text_focused_ds = None
+
+
+def _dd_handle_keys(collection, root_state, search="", text_focused=False):
+    """Arrow-key navigation while the popover is open. Up/Down move within the
+    current level, Right (or Enter on a branch) descends, Left collapses to the
+    parent, Enter on a leaf picks it. Returns the picked leaf value, or
+    UNSET_VALUE when nothing was chosen this frame. Reads the GLFW-callback key
+    queue so it works without the menu being hovered."""
+    from meltygui.core.conversion.cache_tree import UNSET_VALUE
+    from meltygui.model.dropdown_model import _dd_as_tuple
+    from meltygui.model.dropdown_model import _dd_rows_at
+    from meltygui.core.windowing.glfw_utils import request_render
+    import meltygui.core.windowing.window_api as glfw
+
+    if root_state is None:
+        return UNSET_VALUE
+    keys = list(Core.melty.frame_key_events)
+
+    def pressed(*codes):
+        return any(k in codes for k, _ in keys)
+
+    down = pressed(glfw.KEY_DOWN)
+    up = pressed(glfw.KEY_UP)
+    right = pressed(glfw.KEY_RIGHT)
+    left = pressed(glfw.KEY_LEFT)
+    enter = pressed(glfw.KEY_ENTER, glfw.KEY_KP_ENTER)
+    # While typing a query, Left/Right are the search box's text cursor, not tree
+    # navigation, so the dropdown doesn't double-act on them.
+    if text_focused and search:
+        left = right = False
+    if not (down or up or right or left or enter):
+        return UNSET_VALUE
+
+    # A nav key fired: switch to keyboard-select mode so hover stops moving the
+    # cursor until the mouse actually moves again (cleared in draw_dropdown).
+    root_state._kbd_mode = True
+
+    # Navigation level = the cursor's parent; rows = its (search-filtered)
+    # siblings. Fall back to the root level if the cursor path went stale.
+    cursor = _dd_as_tuple(getattr(root_state, "cursor_path", ()))
+    level = cursor[:-1]
+    rows = _dd_rows_at(collection, level, search)
+    if not rows:
+        level = ()
+        rows = _dd_rows_at(collection, level, search)
+        cursor = ()
+    if not rows:
+        return UNSET_VALUE
+
+    level_keys = [r[0] for r in rows]
+    had_cursor = bool(cursor) and cursor[-1] in level_keys
+    idx = level_keys.index(cursor[-1]) if had_cursor else 0
+
+    # Left collapses the current sub-menu and highlights its parent row.
+    if left and level:
+        root_state.cursor_path = tuple(level)
+        root_state.open_path = tuple(level[:-1])
+        request_render()
+        return UNSET_VALUE
+
+    # From no selection, the first Up/Down just focuses on the first row; otherwise
+    # it steps (wrapping). Right/Enter act on whatever row is current.
+    if had_cursor:
+        if down:
+            idx = (idx + 1) % len(rows)
+        elif up:
+            idx = (idx - 1) % len(rows)
+    key, value, label, is_branch = rows[idx]
+    new_cursor = tuple(level) + (key,)
+
+    # Right / Enter on a branch descends into its first visible child.
+    if (right or enter) and is_branch:
+        kids = _dd_rows_at(collection, new_cursor, search)
+        if kids:
+            ck, cv, _cl, cbr = kids[0]
+            _dd_set_cursor(root_state, new_cursor + (ck,), cbr)
+            request_render()
+            return UNSET_VALUE
+
+    if enter and not is_branch:
+        _dd_set_cursor(root_state, new_cursor, False)
+        root_state._picked_path = tuple(new_cursor)
+        return value
+
+    _dd_set_cursor(root_state, new_cursor, is_branch)
+    request_render()
+    return UNSET_VALUE
+
+
+def _dd_update_menu_size(state, menu_ds, min_width=None, max_height=None):
+    from meltygui.core.windowing.glfw_utils import request_render
+    from meltygui.view.dropdown_view import _dd_menu_fit
+
+    current = (menu_ds.width, menu_ds.height)
+    last_fit = getattr(state, "_menu_fit", None)
+    if (getattr(menu_ds, "_initial_window_size", None) is not None
+            and last_fit is not None and current != last_fit and all(current)):
+        state.menu_size = current
+    elif getattr(state, "menu_size", None) is None:
+        fit = _dd_menu_fit(menu_ds, min_width=min_width, max_height=max_height)
+        if fit is not None and fit != current:
+            menu_ds.width, menu_ds.height = fit
+            request_render()
+    state._menu_fit = (menu_ds.width, menu_ds.height)

meltygui/core/layout/edge_constraints.py

@@ -0,0 +1,155 @@
+"""One-dimensional edge constraints, independent of views and native backends.
+
+Cells connect shared edge objects with a minimum and optional maximum span.
+Motion propagates only through those connections. The caller supplies walls and
+chooses which contacts belong to an interaction; overlapping coordinates alone
+do not create a collision.
+"""
+
+class EdgeGraph:
+    """Adjacency over cells: ``ahead[id(near)]`` → ``[(far, floor, cap)]``,
+    ``behind[id(far)]`` → ``[(near, floor, cap)]``, ``nodes`` id → edge."""
+
+    def __init__(self, cells):
+        self.ahead, self.behind, self.nodes = {}, {}, {}
+        for near, far, floor, cap in cells:
+            self.nodes[id(near)] = near
+            self.nodes[id(far)] = far
+            self.ahead.setdefault(id(near), []).append((far, floor, cap))
+            self.behind.setdefault(id(far), []).append((near, floor, cap))
+
+    def chain(self, start, goal, walls=frozenset(), forward=True,
+              capped_only=False):
+        """Weight of the binding chain of cells from ``start`` to ``goal``:
+        the LONGEST sum of floors (a push chain — ``capped_only=False``) or
+        the SHORTEST sum of caps over capped cells only (a pull chain —
+        ``capped_only=True``), walking cells ahead (``forward``) or behind.
+        None when no chain links them. Chains never pass through another
+        wall: a wall never moves, so nothing propagates past it."""
+        links = self.ahead if forward else self.behind
+        pick = min if capped_only else max
+        memo, on_stack = {}, set()
+
+        def best(edge):
+            edge_id = id(edge)
+            if edge_id == id(goal):
+                return 0.0
+            if edge_id in walls or edge_id in on_stack:
+                return None
+            if edge_id in memo:
+                return memo[edge_id]
+            on_stack.add(edge_id)
+            found = None
+            for other, floor, cap in links.get(edge_id, ()):
+                if capped_only:
+                    if cap is None:
+                        continue
+                    weight = cap
+                else:
+                    weight = floor
+                rest = best(other)
+                if rest is None:
+                    continue
+                total = weight + rest
+                found = total if found is None else pick(found, total)
+            on_stack.discard(edge_id)
+            memo[edge_id] = found
+            return found
+
+        return best(start)
+
+
+def solve_edge(graph, edge, target, walls=frozenset(), axis="x"):
+    """Move ``edge`` to ``target`` through the cell graph. Edges are
+    independent objects: no other edge moves unless the moving edge (or
+    one it already carried) makes CONTACT through a cell — two kinds, one
+    per side of the moving edge:
+
+      PUSH, ahead: the cell in front closes to its floor (_edge_min) and
+      its far edge is shoved on ahead.
+      PULL, behind: the cell it leaves behind opens to its cap (_edge_max)
+      and its far edge is dragged along behind.
+
+    Either chain runs cell by cell — a pushed edge closes the next cell, a
+    pulled edge opens the next — and stops at the first cell with slack;
+    consecutive capped cells therefore travel as one, exactly as
+    consecutive floor-packed cells do. A cell with no cap never pulls. An
+    edge several cells share (a nested layout's far edge) carries every
+    cell it bounds.
+
+    ``walls`` is a set of edge ids the cascade must NOT move. Contact stops
+    dead at a wall: the *dragged* edge itself is clamped so the pile packs
+    against the wall at its floors (push side) or stretches to its summed
+    caps (pull side) instead of the chain shoving the wall along. Used by
+    _solve_collisions to keep one FRAME edge from moving the other (breaks
+    the foreign-width feedback loop — see there; its mirror image is a
+    fully-capped row, which refuses a foreign widening the same way);
+    interior divider drags pass no walls, so a divider can still push or
+    pull a frame edge and slide/grow/shrink the window 1:1 with the
+    cursor. Returns True if anything moved."""
+    old = edge[axis]
+    if target == old or id(edge) not in graph.nodes:
+        return False
+    forward = target > old
+    # Wall clamps first: ahead through the floors, behind through the caps
+    # (a pull chain can only reach a wall over capped cells). The
+    # binding chain per wall is the longest floor chain / shortest cap
+    # chain - the one that would move the wall first.
+    for wall_id in walls:
+        wall = graph.nodes.get(wall_id)
+        if wall is None or wall is edge:
+            continue
+        push = graph.chain(edge, wall, walls, forward=forward)
+        if push is not None:
+            target = (min(target, wall[axis] - push) if forward
+                      else max(target, wall[axis] + push))
+        pull = graph.chain(edge, wall, walls, forward=not forward,
+                           capped_only=True)
+        if pull is not None:
+            target = (min(target, wall[axis] + pull) if forward
+                      else max(target, wall[axis] - pull))
+    if target == old:
+        return False
+    edge[axis] = float(target)
+    # Propagate contact. Every relaxation moves an edge the way the drag
+    # went and never back, so this is a monotone worklist that settles on
+    # its own; the guard only ever trips on a cyclic (corrupt) cell graph.
+    pending = [edge]
+    guard = 64 * (len(graph.nodes) + 1)
+    while pending and guard > 0:
+        guard -= 1
+        current = pending.pop()
+        current_id = id(current)
+        if forward:
+            for far, floor, _cap in graph.ahead.get(current_id, ()):    # push ahead
+                if id(far) in walls:
+                    continue
+                need = current[axis] + floor
+                if far[axis] < need:
+                    far[axis] = need
+                    pending.append(far)
+            for near, _floor, cap in graph.behind.get(current_id, ()):  # pull behind
+                if cap is None or id(near) in walls:
+                    continue
+                need = current[axis] - cap
+                if near[axis] < need:
+                    near[axis] = need
+                    pending.append(near)
+        else:
+            for near, floor, _cap in graph.behind.get(current_id, ()):  # push ahead
+                if id(near) in walls:
+                    continue
+                need = current[axis] - floor
+                if near[axis] > need:
+                    near[axis] = need
+                    pending.append(near)
+            for far, _floor, cap in graph.ahead.get(current_id, ()):    # pull behind
+                if cap is None or id(far) in walls:
+                    continue
+                need = current[axis] + cap
+                if far[axis] > need:
+                    far[axis] = need
+                    pending.append(far)
+    return True
+
+