meltygui 0.1.0__py3-none-any.whl

meltygui/model/collection_model.py

@@ -0,0 +1,41 @@
+"""Collection model functions and supporting definitions."""
+from enum import Enum
+from meltygui.core.runtime.toggles import Toggles
+from types import NoneType
+
+
+def annotation_item_type(annotation):
+    """Item type a collection annotation implies for new entries:
+    Dict[str, Lora] -> Lora, List[X] -> X, Optional[T] -> T. None when the
+    annotation carries no usable element type."""
+    args = [a for a in getattr(annotation, "__args__", ()) if a is not NoneType]
+    if not args:
+        return None
+    return args[-1]
+
+
+def _collection_match_keys(input_value, keys, excluded, show_excluded):
+    """The (index, lowercased key string) pairs draw_collection renders and
+    searches, in key order — the basis for both counting key matches and
+    resolving which key holds the current match, without rendering. `index` is
+    the position in `keys`, so it lines up with the render loop. Mirrors the
+    loop's key-string derivation and skip filters."""
+    out = []
+    parent_cls_name = input_value.__class__.__name__
+    excl_attrs = getattr(type(input_value), "__excluded_attrs__", None)
+    for idx, key in enumerate(keys):
+        if isinstance(key, (float, Enum, NoneType)):
+            key_str = parent_cls_name
+        elif isinstance(key, int):
+            key_str = f"{key}"
+        else:
+            key_str = str(key)
+        if str(key).split("##")[0] in excluded:
+            continue
+        if (not show_excluded and excl_attrs is not None
+                and not Toggles.show_excluded and str(key) in excl_attrs):
+            continue
+        if not show_excluded and (key_str.startswith("_") or key_str.endswith("_")):
+            continue
+        out.append((idx, key_str.lower()))
+    return out

meltygui/model/color_model.py

@@ -0,0 +1,127 @@
+"""Color model functions and supporting definitions."""
+from meltygui.hdr_color import scale_saturation
+
+
+def _brightness_clamp(r, g, b, min_b, max_b):
+    """Clamp PERCEIVED brightness (0.299r + 0.587g + 0.114b) — the
+    legibility guard for tinted colors. Both directions SCALE the channels,
+    which preserves their ratios and therefore saturation — a dark
+    high-saturation tint lifts to a dark high-saturation color, it does NOT
+    wash toward gray (a uniform add did, which made lowering the value
+    factor also lose saturation). Only true near-black — no hue left to
+    preserve — falls back to the uniform add."""
+    # Inverted clamp (min above max - mid-drag or experimental toggle values)
+    # collapses to the floor: without this, dark colors LIFT to min while
+    # bright ones CRUSH to max < min, inverting brightness ordering and pinning
+    # every wash to near-identical luminance ("tints stopped responding").
+    if 0 < max_b < min_b:
+        max_b = min_b
+    lum = 0.299 * r + 0.587 * g + 0.114 * b
+    if lum < min_b:
+        if lum > 1e-4:
+            k = min_b / lum
+            return min(1.0, r * k), min(1.0, g * k), min(1.0, b * k)
+        d = min_b - lum
+        return min(1.0, r + d), min(1.0, g + d), min(1.0, b + d)
+    if lum > max_b > 0 and lum > 0:
+        k = max_b / lum
+        return r * k, g * k, b * k
+    return r, g, b
+
+
+def _clamp_bg_value(color, max_bg_value):
+    """Cap a background color's VALUE (max channel, as in HSV) at `max_bg_value`,
+    keeping hue exact and BOOSTING saturation by the same factor the value was
+    cut by (s / k, clamped to 1.0). A plain uniform channel scale holds HSV
+    saturation constant but still reads as washed out once it's dark, so the
+    boost buys the colorfulness back — the color only ever gets darker and
+    *more* saturated, never grayer.
+
+    This is the LAST thing applied to a bg color — it bounds the color actually
+    painted, not the depth ramp that fed it, so whatever the depth/tint/bleed
+    chain produced, `max_bg_value=0` is black and `0.2` is at most 20% value.
+    Deliberately not text_editor's _brightness_clamp: that one is a perceptual
+    (luma) guard and no-ops at max_b == 0, which would break the black case.
+
+    Done in raw channel arithmetic rather than a colorsys round trip: hue is
+    just the position of the mid channel in the [min, max] span, so rebuilding
+    against the new chroma preserves it without ever naming an angle."""
+    if max_bg_value is None or color is None or len(color) < 3:
+        return color
+    rest = tuple(color[3:])
+    red, green, blue = color[0], color[1], color[2]
+    value = max(red, green, blue)
+    if value <= max_bg_value:
+        return color
+    if max_bg_value <= 0 or value <= 0:
+        return (0.0, 0.0, 0.0) + rest
+
+    low = min(red, green, blue)
+    if low >= value:  # achromatic - no hue to preserve, just darken
+        return (max_bg_value, max_bg_value, max_bg_value) + rest
+
+    # k is the cut applied to the value; undo it with saturation.
+    k = max_bg_value / value
+    saturation = scale_saturation((value - low) / value, 1.0 / k)
+    chroma = max_bg_value * saturation
+    new_low = max_bg_value - chroma
+    span = value - low
+    return (new_low + (red - low) / span * chroma,
+            new_low + (green - low) / span * chroma,
+            new_low + (blue - low) / span * chroma) + rest
+
+
+def _wide_pick(fx, fy, top_fraction, max_stops):
+    """Square fractions (x right, y down) → (s, v, exposure)."""
+    fx = min(max(fx, 0.0), 1.0)
+    fy = min(max(fy, 0.0), 1.0)
+    if fy < top_fraction:
+        return fx, 1.0, 2.0 ** (max_stops * (1.0 - fy / top_fraction))
+    v = 1.0 - (fy - top_fraction) / max(1e-6, 1.0 - top_fraction)
+    return fx, min(max(v, 0.0), 1.0), 1.0
+
+
+def _wide_marker(s, v, exposure, top_fraction, max_stops):
+    """(s, v, exposure) → square fractions; the inverse of _wide_pick."""
+    import math
+    if exposure > 1.0:
+        fy = top_fraction * (1.0 - min(1.0, math.log2(exposure) / max_stops))
+    else:
+        fy = top_fraction + (1.0 - v) * (1.0 - top_fraction)
+    return min(max(s, 0.0), 1.0), min(max(fy, 0.0), 1.0)
+
+
+def _srgb_plus_pick(px, py, square, ext, band, max_stops):
+    """Cursor offset from the SQUARE's top-left, in px (negative y = over
+    the exposure band, x past `square` = over the P3 strip) →
+    (s, x, v, exposure)."""
+    if px <= square:
+        s, x = max(px / square, 0.0), 0.0
+    else:
+        s, x = 1.0, min(max((px - square) / max(1e-6, ext), 0.0), 1.0)
+    if py < 0.0:
+        fy = min(max(-py / max(1e-6, band), 0.0), 1.0)      # 0 at the seam, 1 at the top
+        return s, x, 1.0, 2.0 ** (max_stops * fy)
+    v = 1.0 - min(max(py / square, 0.0), 1.0)
+    return s, x, v, 1.0
+
+
+def _srgb_plus_marker(s, x, v, exposure, square, ext, band, max_stops):
+    """(s, x, v, exposure) → marker offset from the square's top-left, in
+    px; the inverse of _srgb_plus_pick."""
+    import math
+    px = s * square if x <= 0.0 else square + x * ext
+    if exposure > 1.0:
+        py = -band * min(1.0, math.log2(exposure) / max_stops)
+    else:
+        py = (1.0 - v) * square
+    return px, py
+
+
+def _extension_pick(fx, ext_fraction):
+    """Cursor x as a fraction of the SQUARE's width (past 1 = over the
+    extension, whose width is ext_fraction squares) → (s, x): the classic
+    saturation inside the square, s = 1 and the P3 depth x past the seam."""
+    if fx <= 1.0:
+        return max(fx, 0.0), 0.0
+    return 1.0, min(max((fx - 1.0) / max(1e-6, ext_fraction), 0.0), 1.0)

meltygui/model/cuda_tensor_model.py

@@ -0,0 +1,36 @@
+"""CUDA decoding of tensor primitive dtypes without packing source storage."""
+
+DTYPE_CODES = {
+    "torch.float32": 0, "torch.float16": 1, "torch.bfloat16": 2,
+    "torch.float64": 3, "torch.int8": 4, "torch.uint8": 5, "torch.bool": 5,
+    "torch.int16": 6, "torch.int32": 7, "torch.int64": 8,
+}
+
+CUDA_LOAD_SOURCE = r"""
+#include <cuda_fp16.h>
+
+__device__ __forceinline__ float load_at(const unsigned char* __restrict__ d,
+                                         int dtype, long long e) {
+    switch (dtype) {
+        case 0: return ((const float*)d)[e];
+        case 1: return __half2float(((const __half*)d)[e]);
+        case 2: { unsigned short u = ((const unsigned short*)d)[e];
+                  return __uint_as_float(((unsigned)u) << 16); }
+        case 3: return (float)((const double*)d)[e];
+        case 4: return (float)((const signed char*)d)[e];
+        case 5: return (float)d[e];
+        case 6: return (float)((const short*)d)[e];
+        case 7: return (float)((const int*)d)[e];
+        case 8: return (float)((const long long*)d)[e];
+    }
+    return 0.0f;
+}
+
+"""
+
+
+def dtype_code(t):
+    code = DTYPE_CODES.get(str(t.dtype))
+    if code is None:
+        raise ValueError(f"unsupported CUDA tensor dtype {t.dtype}")
+    return code

meltygui/model/cuda_texture_model.py

@@ -0,0 +1,149 @@
+"""Versioned CUDA tensors exposed as GLTexture values without a CPU upload.
+
+The injected GLState owns each texture/PBO/registration as one resource. CUDA
+unregistration must finish before the GL buffer is deleted. The resource holds
+no reference to the source tensor; cache hits do no tensor copies or syncs.
+"""
+import ctypes
+
+import OpenGL.GL as gl
+
+from meltygui.core.graphics.cuda_context_core import current_device_index
+from meltygui.core.graphics.cuda_interop_core import (
+    interop_context, copy_to_buffer, log_once,
+    register_buffer, unregister_buffer,
+)
+from meltygui.core.graphics.gl_state import (
+    GLTexture, _scalar, current_context, is_gl_thread, texture3d_fit, tight_unpack,
+)
+
+
+class CudaVolume:
+    """Owned allocation behind a texture value; its source tensor stays external."""
+    __slots__ = ("texture", "buffer", "registered", "nbytes", "last_version")
+
+    def __init__(self, texture, buffer, registered, nbytes):
+        self.texture = texture
+        self.buffer = buffer
+        self.registered = registered
+        self.nbytes = nbytes
+        self.last_version = object()  # even version=None must perform its first upload
+
+
+def _release_volume(volume, context):
+    # Each completed step is recorded so a failed deletion can be retried.
+    # Keep the implementation at module scope so queued deleters see hot edits.
+    if volume.registered is not None:
+        unregister_buffer(volume.registered, context)
+        volume.registered = None
+    if volume.buffer is not None:
+        gl.glDeleteBuffers(1, [volume.buffer])
+        volume.buffer = None
+    if volume.texture is not None:
+        gl.glDeleteTextures([volume.texture.texture_id])
+        volume.texture = None
+
+
+def tensor_to_texture(gl_state, key, tensor, version):
+    """Return a versioned 3-D float16/32 GLTexture, or None for CPU fallback.
+
+    Noncontiguous tensors are packed only on version misses. Tensors on another
+    GPU are staged by Torch onto the GL device, never copied across devices with
+    a raw CUDA pointer copy. Calls require the owner's GL context and a compatible
+    recorded CUDA context. Core activates it locally and restores the caller's
+    native context, or lazily establishes the display context when none exists.
+    An incompatible caller-owned PyCUDA context is left untouched.
+    """
+    if not is_gl_thread() or current_context() is None:
+        return None
+    if gl_state._context != current_context():
+        return None
+    import torch
+    if not (isinstance(tensor, torch.Tensor) and tensor.is_cuda
+            and tensor.dim() == 3 and tensor.dtype in (torch.float16, torch.float32)):
+        return None
+    with interop_context() as context:
+        if context is None:
+            return None
+        return _upload_tensor(gl_state, key, tensor, version, context)
+
+
+def _upload_tensor(gl_state, key, tensor, version, context):
+    import torch
+    device = current_device_index()
+    depth, height, width = (int(size) for size in tensor.shape)
+    half = tensor.dtype == torch.float16
+    internal = gl.GL_R16F if half else gl.GL_R32F
+    gl_type = gl.GL_HALF_FLOAT if half else gl.GL_FLOAT
+    nbytes = tensor.nelement() * tensor.element_size()
+
+    def delete(volume):
+        _release_volume(volume, context)
+
+    def create():
+        _, problems = texture3d_fit((depth, height, width), tensor.element_size())
+        if problems:
+            raise ValueError("tensor_to_texture: " + "; ".join(problems))
+        volume = CudaVolume(None, None, None, nbytes)
+        previous_buffer = _scalar(gl.glGetIntegerv(gl.GL_ARRAY_BUFFER_BINDING))
+        previous_unpack = _scalar(gl.glGetIntegerv(gl.GL_PIXEL_UNPACK_BUFFER_BINDING))
+        previous_texture = _scalar(gl.glGetIntegerv(gl.GL_TEXTURE_BINDING_3D))
+        try:
+            volume.buffer = _scalar(gl.glGenBuffers(1))
+            gl.glBindBuffer(gl.GL_ARRAY_BUFFER, volume.buffer)
+            gl.glBufferData(gl.GL_ARRAY_BUFFER, nbytes, None, gl.GL_DYNAMIC_DRAW)
+            volume.registered = register_buffer(volume.buffer)
+            texture_id = _scalar(gl.glGenTextures(1))
+            volume.texture = GLTexture(texture_id, gl.GL_TEXTURE_3D,
+                                       (depth, height, width), internal)
+            gl.glBindTexture(gl.GL_TEXTURE_3D, texture_id)
+            # NULL must mean no client data, not offset zero in a caller's PBO.
+            gl.glBindBuffer(gl.GL_PIXEL_UNPACK_BUFFER, 0)
+            gl.glTexImage3D(gl.GL_TEXTURE_3D, 0, internal, width, height, depth, 0,
+                            gl.GL_RED, gl_type, ctypes.c_void_p(0))
+            for parameter, value in (
+                    (gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST),
+                    (gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST),
+                    (gl.GL_TEXTURE_WRAP_S, gl.GL_CLAMP_TO_EDGE),
+                    (gl.GL_TEXTURE_WRAP_T, gl.GL_CLAMP_TO_EDGE),
+                    (gl.GL_TEXTURE_WRAP_R, gl.GL_CLAMP_TO_EDGE)):
+                gl.glTexParameteri(gl.GL_TEXTURE_3D, parameter, value)
+            return volume
+        except Exception:
+            gl_state.defer_delete(key, volume, delete)
+            raise
+        finally:
+            gl.glBindTexture(gl.GL_TEXTURE_3D, previous_texture)
+            gl.glBindBuffer(gl.GL_PIXEL_UNPACK_BUFFER, previous_unpack)
+            gl.glBindBuffer(gl.GL_ARRAY_BUFFER, previous_buffer)
+
+    try:
+        volume = gl_state.get(key, create, delete,
+            deps=((depth, height, width), "f16" if half else "f32", context))
+        if volume.last_version != version:
+            if tensor.device.index != device:
+                # Finish the source producer before Torch stages across devices.
+                torch.cuda.synchronize(tensor.device)
+                tensor = tensor.to(f"cuda:{device}")
+            tensor = tensor.contiguous()
+            # The producer can be on a nondefault stream. Waiting AFTER the
+            # driver copy is too late, and synchronize() without a device can
+            # wait on a completely different GPU.
+            torch.cuda.synchronize(device)
+            copy_to_buffer(volume.registered, context, tensor.data_ptr(), nbytes)
+            previous_unpack = _scalar(gl.glGetIntegerv(gl.GL_PIXEL_UNPACK_BUFFER_BINDING))
+            previous_texture = _scalar(gl.glGetIntegerv(gl.GL_TEXTURE_BINDING_3D))
+            try:
+                gl.glBindBuffer(gl.GL_PIXEL_UNPACK_BUFFER, volume.buffer)
+                gl.glBindTexture(gl.GL_TEXTURE_3D, volume.texture.texture_id)
+                with tight_unpack():
+                    gl.glTexSubImage3D(gl.GL_TEXTURE_3D, 0, 0, 0, 0, width, height, depth,
+                                       gl.GL_RED, gl_type, None)
+            finally:
+                gl.glBindTexture(gl.GL_TEXTURE_3D, previous_texture)
+                gl.glBindBuffer(gl.GL_PIXEL_UNPACK_BUFFER, previous_unpack)
+            volume.last_version = version
+        return volume.texture
+    except Exception as error:
+        log_once(f"interop upload failed ({error}); falling back to cpu path")
+        return None

meltygui/model/dropdown_model.py

@@ -0,0 +1,137 @@
+"""Dropdown model functions and supporting definitions."""
+
+
+
+def _dd_entries(container):
+    """Normalized (key, value, label, is_branch) rows for one level. Dict rows
+    read by their key (small/medium); list/tuple rows by their value
+    (left/center/right) since the index isn't meaningful to the user."""
+    if isinstance(container, dict):
+        items = list(container.items())
+        labelled = [(k, v, str(k)) for k, v in items]
+    else:
+        labelled = [(i, v, str(v)) for i, v in enumerate(container)]
+    return [(k, v, lbl, isinstance(v, (dict, list))) for k, v, lbl in labelled]
+
+
+def _dd_subtree_matches(value, search):
+    """True if `search` (already lowercased) appears anywhere in this value's
+    subtree, so a branch stays visible while searching when a descendant matches."""
+    if not search:
+        return True
+    if isinstance(value, dict):
+        return any(search in str(k).lower() or _dd_subtree_matches(v, search)
+                   for k, v in value.items())
+    if isinstance(value, list):
+        return any(_dd_subtree_matches(v, search) for v in value)
+    return search in str(value).lower()
+
+
+def _dd_visible_entries(container, search=""):
+    """Rows shown for a level under `search`: a leaf whose label matches, or a
+    branch matching by label OR holding a matching descendant. Empty `search`
+    keeps everything."""
+    if not isinstance(container, (dict, list)):
+        return []
+    rows = _dd_entries(container)
+    if not search:
+        return rows
+    return [(k, v, lbl, br) for (k, v, lbl, br) in rows
+            if search in lbl.lower() or (br and _dd_subtree_matches(v, search))]
+
+
+def _dd_walk(collection, path):
+    """Descend `collection` along a key/index `path`, returning the node there or
+    None if the path no longer resolves (e.g. after a search prunes it)."""
+    node = collection
+    for k in path:
+        try:
+            node = node[k]
+        except (KeyError, IndexError, TypeError):
+            return None
+    return node
+
+
+def _dd_rows_at(collection, path, search):
+    """Visible rows at `path`, applying the once-a-branch-matches-by-label rule:
+    if any ancestor key on `path` matched the search by its own label, that whole
+    subtree counts as a match, so deeper levels are shown unfiltered."""
+    container = _dd_walk(collection, path)
+    ancestor_matched = bool(search) and any(search in str(k).lower() for k in path)
+    return _dd_visible_entries(container, "" if ancestor_matched else search)
+
+
+def _dd_first_match_leaf(container, search, prefix=()):
+    """DFS for the path to the first selectable leaf the search reveals, so the
+    cursor can jump straight to it (auto-expanding the branches above). A branch
+    that matches by its own label contributes its first leaf unfiltered."""
+    for key, value, label, is_branch in _dd_visible_entries(container, search):
+        path = tuple(prefix) + (key,)
+        if not is_branch:
+            return path
+        sub_search = "" if (search and search in label.lower()) else search
+        sub = _dd_first_match_leaf(value, sub_search, path)
+        if sub is not None:
+            return sub
+    return None
+
+
+def _dd_as_tuple(x):
+    """Coerce a stored path-state to a tuple. The states are meant to be key
+    tuples, but DropDownState is a DictConversion and its machinery can alias a
+    complex stored value (e.g. a Lora) across fields; this keeps the dropdown
+    robust to any input type by never iterating a non-sequence."""
+    if isinstance(x, tuple):
+        return x
+    if isinstance(x, list):
+        return tuple(x)
+    return ()
+
+
+def _dd_path_for_value(collection, value, _depth=0):
+    """The key/index path of the first LEAF in `collection` equal to
+    `value` (depth-first through nested dicts / lists), or None when no
+    leaf holds it — the inverse of _dd_walk for the trigger label sync."""
+    if _depth > 8 or value is None:
+        return None
+    items = (collection.items() if isinstance(collection, dict)
+             else enumerate(collection) if isinstance(collection, (list, tuple))
+             else ())
+    for key, node in items:
+        if isinstance(node, (dict, list, tuple)):
+            sub = _dd_path_for_value(node, value, _depth + 1)
+            if sub is not None:
+                return (key,) + sub
+            continue
+        try:
+            same = node == value
+        except Exception:
+            same = False
+        if same is True:
+            return (key,)
+    return None
+
+
+def _dd_label_for_path(collection, path):
+    """Display label for a selected leaf path: the KEY for a dict entry (e.g.
+    "red"), the VALUE for a list entry (e.g. "left"). Used for the trigger title
+    so it reads as a name, not a raw value (which may be a tuple/number)."""
+    if not path:
+        return ""
+    parent = _dd_walk(collection, tuple(path[:-1]))
+    if isinstance(parent, dict):
+        return str(path[-1])
+    return str(_dd_walk(collection, tuple(path)))
+
+
+def _dd_row_lookup(mapping, value):
+
+    """mapping.get(value), tolerant of UNHASHABLE row values — a BRANCH row's
+    value is the nested collection dict itself, which raised TypeError from
+    every value-keyed style lookup (row_tags/row_tints/...)."""
+    if not mapping:
+        return None
+    try:
+        return mapping.get(value)
+    except TypeError:
+        return None

meltygui/model/file_metadata_model.py

@@ -0,0 +1,73 @@
+"""Operations over supplied per-file dictionaries; no shared-store discovery."""
+from meltygui.models.file_meta import FileMeta
+
+
+def set_row_tint(meta, path, value):
+    """Write `value` (an rgb(a) tuple) as the tint of `path` in the shared
+    file-meta store, creating the entry only now — the listing never
+    setdefault()s entries for the files it merely shows. None (the picker's
+    clear) removes the tint, and the entry too when it holds nothing else,
+    so an unpainted file leaves no trace in file_meta.pkl."""
+    key = str(path)
+    entry = meta.get(key)
+    if value is None:
+        if isinstance(entry, dict) and dict.__contains__(entry, "tint"):
+            del entry["tint"]
+            if dict.__len__(entry) == 0:
+                del meta[key]
+        return
+    if not isinstance(entry, dict):
+        entry = meta[key] = FileMeta()
+    entry["tint"] = tuple(value)
+
+
+def ordered_rows(rows, meta):
+    """`rows` ([(Path, is_dir)], natural order) sorted by the `order` stamps
+    in the meta store, the studio's rule (folder_files._apply_meta):
+    stamped rows first by their number, unstamped ones after in natural
+    order. No stamps at all: `rows` itself."""
+    if meta is None:
+        return rows
+    orders = {}
+    for i, (path, _is_dir) in enumerate(rows):
+        entry = meta.get(str(path))
+        if isinstance(entry, dict):
+            order = entry.get("order")
+            if isinstance(order, (int, float)):
+                orders[i] = order
+    if not orders:
+        return rows
+    indexed = sorted(range(len(rows)), key=lambda i: (orders.get(i, float("inf")), i))
+    return [rows[i] for i in indexed]
+
+
+def set_row_order(meta, paths):
+    """Stamp `order` = position into the meta entry of every path of a
+    directory (created for the rows that have none — a reorder is the
+    user's explicit edit of the folder, like painting it)."""
+    for i, path in enumerate(paths):
+        key = str(path)
+        entry = meta.get(key)
+        if not isinstance(entry, dict):
+            entry = meta[key] = FileMeta()
+        if entry.get("order") != i:
+            entry["order"] = i
+
+
+def apply_row_drop(rows, drag_keys, first_visible, drop):
+    """The directory's new order after `drop` (a DropEvent from on_drop, or
+    None): `drag_keys` are the rows that registered a drag handle this run
+    — the visible ones, a contiguous slice of `rows` starting at
+    `first_visible` — and the event's indices count in that slice. Returns
+    the complete [Path] order to stamp, or None when nothing moved (no
+    drop, a drop back in place, a cross-collection kind: rows only reorder
+    here)."""
+    if drop is None or drop.kind != "reorder" or not drag_keys:
+        return None
+    keys = list(drag_keys)
+    if not drop.apply(keys):
+        return None
+    paths = [path for path, _is_dir in rows]
+    return paths[:first_visible] + keys + paths[first_visible + len(drag_keys):]
+
+