meltygui 0.1.0__py3-none-any.whl

meltygui/core/files/file_core.py

@@ -0,0 +1,208 @@
+"""
+Folder files — a directory tree rendered through a RenderHost.
+
+`folder_io` is the plain stateful wrapper — it knows nothing about RenderHost.
+It follows the same shape as `code_file_io` / `claude_terminals_io`:
+
+    discover()  →  view_func(dict)  →  apply()              (folder_io)
+
+except discover/apply are RECURSIVE: it reconciles a persistent nested dict
+against the directory tree on disk — subfolders become nested dicts, files
+become Path leaves. RenderHost wraps it so the program just sees "a dict
+shaped like the folder". File CONTENT never flows through here: each Path
+leaf renders via Mode.FILE_TREE → code_file_io, whose TextFileCodec owns that
+file's whole-file load/edit/save round-trip — the recursion is pure structure.
+
+The dict is mutable the way the terminals dict is: a key the user deletes
+deletes its file (claude_terminals kills the tmux session, we unlink); a key
+the user adds creates one (a held dict → mkdir, a held str → its contents).
+A background poller re-runs discovery when the tree changes on disk (the
+wrapper's body is blit-cached, so it wouldn't otherwise notice a file that
+appeared/vanished with no edit to invalidate it).
+"""
+
+import threading
+
+from meltygui.core.runtime.lifecycle import module_is_live
+import time
+from pathlib import Path
+
+import meltygui_imgui as imgui
+from meltygui.core.melty import Melty
+from meltygui.core.rendering.modes import Modes
+from meltygui.view.file_view import draw_file_tree
+from meltygui.view.file_view import draw_file_metadata
+from meltygui.core.windowing.glfw_utils import request_render
+from meltygui.core.conversion.render_host import RenderHost
+from meltygui.core.core_render import render_func
+from meltygui.core.rendering.window_decoration import window
+from meltygui.core.rendering.core_decoration import Core
+
+from meltygui.model.file_model import _scan
+from meltygui.model.file_model import _reconcile
+from meltygui.model.file_model import _file_meta
+from meltygui.model.file_model import _apply_meta
+from meltygui.model.file_model import _collect_meta
+
+# Keep the original default folder when the implementation moves packages.
+ROOT = Path(__file__).resolve().parents[2] / "files"
+from meltygui.core.runtime.paths import application_root
+TEST_FOLDER = application_root()
+
+
+# ── persisted per-file metadata (tint / expanded / order ...) ─────────────────────
+# The tree holds display params the framework ignores: each file dict holds
+# __overrides__['__<name>__'] = {param: value}, which core_render feeds into the
+# child row's view (same mechanism as '# [tint=...]' comment overrides). The
+# durable copy lives in AppModel.file_meta_collection.file_meta, keyed by
+# absolute path string, so it persists with the next save. folder_io syncs both
+# ways every run: APPLY meta → tree __overrides__ + key order before render,
+# COLLECT tree → meta after render (UI edits land in __overrides__ via
+# _LazyOverrideEntry / bubbling, drag reorders land as tree key order).
+
+
+# ── debug window: the persisted per-file metadata tree ──────────────────────────
+@window(disable_scroll=False, use_cache=True, tint=(0.18, 0.11, 0.11))
+def file_meta_debug(_, draw_state=None):
+    """Raw view of AppModel.file_meta_collection.file_meta — the path-keyed
+    params store the folder tree and the codec layer read/write (tint, order,
+    …). Rendered as a plain editable dict: edits land directly in the store
+    (bubble-free plain dicts, so a manual touch persists on the next root
+    save; deleting an entry clears that file's attributes)."""
+    meta = _file_meta()
+    if meta is None:
+        imgui.text("No app model loaded")
+        return
+    if not meta:
+        imgui.text("No file metadata yet")
+        return
+    return draw_file_metadata(meta)
+
+
+# ── the stateful wrapper: discover -> view_func(dict) -> apply ──────────────────
+# Shaped like claude_terminals_io. It does not know about RenderHost - the host
+# gives it `view_func` and holds whatever dict it passes through.
+@render_func(use_cache=True, selectable=False, show_bg=False)
+def folder_io(input_value, draw_state, view_func=None, root=None, external_change=False, **kwargs):
+    # ── IN: reconcile the HELD tree IN PLACE against the disk snapshot - same
+    # reason as claude_terminals_io: `input_value` IS the dict the host holds
+    # and the @window reads; a separate store would leave it a stale copy.
+    # The snapshot is PER ROOT: the single shared global handed the second
+    # window the first root's tree - the the store saw every ROOT entry as
+    # "new on disk", complete with Path leaves pointing into the wrong folder.
+    disk = _disk_trees.get(root)
+    if disk is None:
+        disk = _disk_trees[root] = _scan(root)
+    store = input_value if isinstance(input_value, dict) else {}
+    seen = getattr(draw_state, "_seen_paths", None)
+    if seen is None:
+        seen = draw_state._seen_paths = set()
+    _reconcile(store, disk, root, seen)
+
+    # ── META IN: persisted per-file params → the tree's __overrides__ + key
+    # order. On a change (first load, or the store edited elsewhere) the cached
+    # rows below still hold the old capture - invalidate this subtree so they
+    # repaint with the fresh kwargs.
+    meta = _file_meta()
+    if meta is not None and _apply_meta(store, root, meta):
+        tid = getattr(draw_state, "_tile_id", None)
+        if tid is not None and Melty.cache is not None:
+            Melty.cache.invalidate_up(tid, force=True, max_depth=8)
+        request_render()
+
+    # ── VIEW: hand the tree to the host's view func (which materializes + renders)
+    edited, value = view_func(input_value=store, external_change=False, **kwargs)
+
+    # ── META OUT: UI edits landed in __overrides__ (bubbling re-ran this body);
+    # drag reorders changed key order. Mirror both into the persisted store.
+    if meta is not None:
+        _collect_meta(store, root, meta)
+
+    imgui.text(str(root))
+    return edited, value
+
+
+# ── the proxy: to the program it's just a dict shaped like the folder ───────────
+if "files_proxy" not in globals():
+    files_proxy = RenderHost(io_function=folder_io, input_value=None,
+                             name="Folder Files", root=ROOT)
+if "test_folder_proxy" not in globals():
+    test_folder_proxy = RenderHost(io_function=folder_io, input_value=None,
+                                   name="TestFolderProxy", root=TEST_FOLDER)
+
+# ── per-root state: every root gets its own snapshot, window draw_state, and
+# poller entry. (These were single globals once: the second window reconciled
+# against the first root's snapshot and rendered ROOT's files.)
+_disk_trees = globals().get("_disk_trees", {})        # root -> the poller's nested snapshot ({name: Path | dict})
+_window_dss = globals().get("_window_dss", {})        # root -> that root's @window draw_state, stashed each render
+_proxies = globals().get("_proxies", {ROOT: files_proxy, TEST_FOLDER: test_folder_proxy})   # poller targets
+_poller_running = globals().get("_poller_running", False)
+
+
+@window(input_value=files_proxy, tint=(0.36, 0.46, 0.59), disable_scroll=False, mode=Modes.WINDOW)
+@render_func(show_bg=True, use_cache=True, shadow=True, selectable=False)
+def draw_folder_files(input_value, draw_state, **kwargs):
+    _draw_tree(input_value, draw_state, ROOT)
+    return False, None
+
+
+@window(input_value=test_folder_proxy, tint=(0.84, 0.933, 0.98), bg_offset=4, disable_scroll=False, mode=Modes.WINDOW)
+@render_func(show_bg=False, use_cache=True, selectable=False)
+def draw_test_folders(input_value, draw_state, **kwargs):
+    _draw_tree(input_value, draw_state, TEST_FOLDER)
+    return False, None
+
+
+def folder_proxy(root, name):
+    """A RenderHost over folder_io for `root`, registered with the poller —
+    the reusable entry point for other views (e.g. playground.file_tree)."""
+    proxy = _proxies.get(root)
+    if proxy is None:
+        proxy = _proxies[root] = RenderHost(io_function=folder_io, input_value=None,
+                                            name=name, root=root)
+    return proxy
+
+
+def watch_folder(root, draw_state):
+    """Per-frame from a folder window's body: start the (single, all-roots)
+    poller and stash this root's draw_state so a disk change re-renders it."""
+    global _poller_running
+    if not _poller_running:
+        threading.Thread(target=_poll_loop, daemon=True, name="folder-files-poller").start()
+        _poller_running = True
+    _window_dss[root] = draw_state
+
+
+def _draw_tree(input_value, draw_state, root):
+    """Shared @window body: watch the root and draw the held tree."""
+    watch_folder(root, draw_state)
+
+    # The tree is held one LEVEL UP under value name ("value") - same as
+    # claude_terminals: draw_collection on the proxy itself would render the
+    # single {"value": tree} key, not the files.
+    tree = input_value.get("value") if isinstance(input_value, dict) else {}
+    return draw_file_tree(tree if tree is not None else {}, root=root)
+
+
+# ── discovery poller: the wrappers' bodies are blit-cached, so they wouldn't
+# show a file that appeared/vanished with no way to render them. One
+# thread sweeps EVERY registered root; on a change to a tree, swap in the new
+# snapshot AND re-render that root's @window.
+def _poll_loop():
+    while module_is_live(globals()):   # exits once script restart purges this module
+        if Core.melty.frame_count < 4:
+            time.sleep(2)
+        for root, proxy in list(_proxies.items()):
+            try:
+                cur = _scan(root)
+                if cur != _disk_trees.get(root):
+                    _disk_trees[root] = cur
+                    for ds in (getattr(proxy, "_wrapper_draw_state", None),
+                               getattr(proxy, "_draw_state", None),
+                               _window_dss.get(root)):
+                        if ds is not None:
+                            ds.invalidate()
+                    request_render()
+            except Exception:
+                pass
+        time.sleep(1.0)

meltygui/core/files/file_explorer_core.py

@@ -0,0 +1,104 @@
+"""Directory subscriptions and browser runtime diagnostics."""
+import os
+import sys
+from meltygui.core.melty import Melty, FileWatch
+
+# ── the directory watch ─────────────────────────────────────────────────────
+# directory (str) -> the listing draw_states showing it. One FileWatch emitter per
+# dir in this map; a listing moves its emitter on navigation (watch_directory)
+# and the observer-thread listener posts an invalidate to the render thread.
+def _existing_directory_watchers():
+    # One-time resource transfer when this module is first loaded by hotswap.
+    # Existing FileWatch callbacks and per-view state retain this same mapping.
+    previous_module = sys.modules.get("meltygui.files.fast_file_explorer")
+    if previous_module is not None:
+        return vars(previous_module).get("_WATCHERS", {})
+    return {}
+
+
+_WATCHERS = globals().get("_WATCHERS")
+if _WATCHERS is None:
+    _WATCHERS = _existing_directory_watchers()
+
+
+def _on_file_event(src_path):
+    """FileWatch global listener (observer thread): an entry of a watched
+    directory changed — created, modified, moved, deleted — repaint the
+    listings showing that directory. Bumps nothing else; the listing's
+    mtime memo notices what changed."""
+    directory = os.path.dirname(src_path)
+    watchers = _WATCHERS.get(directory) or _WATCHERS.get(src_path)
+    if not watchers:
+        return
+
+    def repaint(draw_states=tuple(watchers)):
+        for draw_state in draw_states:
+            draw_state.invalidate()
+    Melty.post_to_render(repaint)
+
+
+def watch_directory(draw_state, state, dir_key):
+    """Point this listing's emitter at `dir_key`: the previous directory's
+    emitter is retired when no other listing shows it (the inotify instance
+    cap is per user), the new one scheduled through FileWatch.watch_dir."""
+    if state._watched == dir_key:
+        return
+    if _on_file_event not in FileWatch.global_listeners:
+        # Hotswap-safe: an older copy of this function is replaced by itself.
+        FileWatch.global_listeners[:] = [f for f in FileWatch.global_listeners
+                                         if getattr(f, "__name__", "") != "_on_file_event"]
+        FileWatch.global_listeners.append(_on_file_event)
+    FileWatch.start()
+    previous = state._watched
+    if previous is not None:
+        holders = _WATCHERS.get(previous)
+        if holders is not None:
+            holders.discard(draw_state)
+            if not holders:
+                del _WATCHERS[previous]
+                FileWatch.unwatch_dir(previous)
+    _WATCHERS.setdefault(dir_key, set()).add(draw_state)
+    FileWatch.watch_dir(dir_key)
+    state._watched = dir_key
+
+
+
+from weakref import WeakKeyDictionary
+_browser_size_traces = globals().get("_browser_size_traces", WeakKeyDictionary())
+
+def _trace_browser_size(stage, draw_state, **details):
+    """File browser size diagnostics (the nested-OS-window resize glitch):
+    one line per CHANGE of the view's box / content rect / the surface's
+    GLFW window and framebuffer size, to the bounded resize trace
+    (.melty cache root, resize-<pid>.log) and stderr. Never raises."""
+    try:
+        import sys
+        import meltygui.core.diagnostics.resize_trace as resize_trace
+        from meltygui import window_api as glfw
+        window = getattr(Melty, "glfw_window", None)
+        window_size = fb_size = None
+        if window is not None:
+            window_size = tuple(glfw.get_window_size(window))
+            fb_size = tuple(glfw.get_framebuffer_size(window))
+        try:
+            import meltygui.core.windowing.geometry_feed as geometry_feed
+            frame = geometry_feed._current_frame()
+            details["feed"] = (geometry_feed.backend(), geometry_feed._hypr_selector(),
+                               geometry_feed.hypr_honors_geometry(),
+                               None if frame is None else (frame.get("at"), frame.get("size")))
+        except Exception as error:
+            details["feed"] = f"error {error!r}"
+        stamp = (draw_state.width, draw_state.height, draw_state.abs_left, draw_state.abs_top,
+                 window_size, fb_size, tuple(sorted(details.items())))
+        if _browser_size_traces.get(draw_state) == stamp:
+            return
+        _browser_size_traces[draw_state] = stamp
+        resize_trace.record(stage, draw_state, window_size=window_size, fb_size=fb_size,
+                            gesture=bool(Melty.resize_gesture_live()), **details)
+        print(f"[{stage}] f{Melty.frame_count} view {draw_state.width}x{draw_state.height} "
+              f"at ({draw_state.abs_left}, {draw_state.abs_top}) window {window_size} "
+              f"fb {fb_size} {details}", file=sys.stderr, flush=True)
+    except Exception:
+        pass
+
+

meltygui/core/files/file_tree_core.py

@@ -0,0 +1,198 @@
+"""File tree — a general-purpose directory browser with collapsable folders.
+
+Unlike folder_files (which materializes file CONTENT through a RenderHost),
+this view is display-only: it walks the directory and draws just the names,
+straight to the window draw_list — no per-row widgets, no draw_states per
+file (the fast_dock.py interaction model: event params for clicks, blit
+cache while idle, wrapper re-renders every frame while hovered). Click a
+folder to expand/collapse it; double-click a file to open it
+(FileTreeState.open_file, a stub for now).
+
+Frame-to-frame state (which folders are expanded, selection) lives in
+FileTreeState, injected by annotation the same way GLState/CodeState are.
+"""
+
+import colorsys
+from pathlib import Path
+
+import meltygui_imgui as imgui
+from meltygui.hdr_color import pack_color
+from meltygui.hdr_color import with_alpha
+from meltygui.core.melty import Melty
+from meltygui.core.conversion.dict_conversion import DictConversion
+from meltygui.core.rendering.modes import Modes
+from meltygui.core.windowing.glfw_utils import request_render
+from meltygui.core.core_render import render_func
+from meltygui.core.layout.header_runtime import _brightness_clamp_fn
+import meltygui.model.import_graph_model as file_graph
+from meltygui.core.runtime.toggles import Toggles
+from meltygui.core.files.file_core import folder_proxy
+from meltygui.core.files.file_core import watch_folder
+from meltygui.model.file_model import _file_meta
+from meltygui.core.input.drag_drop_core import DragDrop
+from meltygui.core.cache.tile_cache import add_shadow
+from meltygui.core.rendering.window_decoration import window
+
+from meltygui.core.runtime.paths import application_root
+
+
+def open_file(path):
+    """Route `path` into the code editor (summons the editor window)."""
+    from meltygui.core.runtime.extensions import open_source as open_in_editor
+    open_in_editor(str(path))
+
+
+def _children(folder):
+    """Visible entries, folders first, case-insensitive by name."""
+    try:
+        entries = [p for p in folder.iterdir()
+                   if not p.name.startswith(".") and p.name != "__pycache__"]
+    except OSError:
+        return []
+    return sorted(entries, key=lambda p: (p.is_file(), p.name.lower()))
+
+
+def _flatten(folder, expanded, depth=0, rows=None):
+    """The tree as drawn: one (path, depth) per visible row."""
+    if rows is None:
+        rows = []
+    for p in _children(folder):
+        rows.append((p, depth))
+        if p.is_dir() and str(p) in expanded:
+            _flatten(p, expanded, depth + 1, rows)
+    return rows
+
+
+def _meta():
+    """AppModel's path → FileMeta store (None before the model exists)."""
+    return _file_meta()
+
+
+def _tint_of(meta, path):
+    """The row's background tint (rgb), or None for an unpainted file — no
+    stored tint, or FileMeta's black-transparent default."""
+    from meltygui.models.file_meta import FileMeta
+    entry = meta.get(str(path)) if meta is not None else None
+    tint = FileMeta.painted_tint(entry)
+    return tuple(tint[:3]) if tint else None
+
+
+def _ordered_children(folder, meta, position):
+    """`folder`'s visible entries in FILE-META ORDER: an entry's position in
+    the file_meta dict is its rank; entries the dict doesn't know yet trail
+    in the natural order (folders first, case-insensitive by name)."""
+    natural = _children(folder)
+    unknown = float("inf")
+    ranked = [(position.get(str(p), unknown), i, p) for i, p in enumerate(natural)]
+    ranked.sort(key=lambda t: (t[0], t[1]))
+    return [p for _r, _i, p in ranked]
+
+
+def _flatten_ordered(folder, expanded, meta, position, depth=0, rows=None):
+    """The tree as drawn — one (path, depth) per visible row — in meta order."""
+    if rows is None:
+        rows = []
+    for p in _ordered_children(folder, meta, position):
+        rows.append((p, depth))
+        if p.is_dir() and str(p) in expanded:
+            _flatten_ordered(p, expanded, meta, position, depth + 1, rows)
+    return rows
+
+
+def reorder_siblings(meta, siblings, dragged, insert_index):
+    """Move `dragged` to `insert_index` (pre-removal coordinates, the Reorder
+    convention) within `siblings` and write the new order into the file_meta
+    dict: every sibling gets an entry, and the siblings' existing SLOTS in the
+    dict (their key positions) are refilled in the new order, so nothing else
+    in the dict moves. Returns True when the order changed."""
+    from meltygui.models.file_meta import FileMeta
+    keys = [str(p) for p in siblings]
+    dragged_key = str(dragged)
+    if dragged_key not in keys:
+        return False
+    current = keys.index(dragged_key)
+    new_keys = list(keys)
+    new_keys.pop(current)
+    target = insert_index - 1 if current < insert_index else insert_index
+    target = max(0, min(target, len(new_keys)))
+    if target == current:
+        return False
+    new_keys.insert(target, dragged_key)
+    for k in keys:
+        if not isinstance(meta.get(k), dict):
+            meta[k] = FileMeta()
+    slots = [i for i, k in enumerate(meta) if k in set(keys)]
+    items = list(meta.items())
+    for slot, k in zip(slots, new_keys):
+        items[slot] = (k, meta[k])
+    meta.clear()
+    meta.update(items)
+    return True
+
+
+from meltygui.view.file_view import render_file_tree
+render_file_tree = window(initial={'width': 320, 'height': 540}, tint=(0.72, 0.79, 0.85))(render_file_tree)
+
+
+def _apply_row_drop(meta, dragged, visible, insert_index, position):
+    """Translate a flattened-row drop into a sibling reorder. Returns True
+    when the file_meta order changed."""
+    if meta is None:
+        return False
+    parent = dragged.parent
+    siblings = _ordered_children(parent, meta, position)
+    below = visible[insert_index][0] if 0 <= insert_index < len(visible) else None
+    above = visible[insert_index - 1][0] if 0 < insert_index <= len(visible) else None
+    if below is not None and below.parent == parent:
+        sibling_index = siblings.index(below)
+    elif above is not None and above.parent == parent:
+        sibling_index = siblings.index(above) + 1
+    elif above is not None and above.is_dir() and above == parent:
+        sibling_index = 0                      # dropped right above its own folder row
+    else:
+        return False
+    return reorder_siblings(meta, siblings, dragged, sibling_index)
+
+
+# # ── Framework file tree ──────────────────────────────────────────────────────
+# # The same directory rendered through the framework: folder_files' RenderHost
+# # (folder_io) holds the {name: Path | dict} tree - background loading, diff
+# # reconcile, and the change poller for free - and draw_collection renders it
+# # under Mode.FILE_TREE_NAMES (view/modes.py): folders are drawn with
+# # expandollapsing headers, add/delete, drag reorder - all framework - files route
+# # by name to draw_file_name below, which shows just the name. Contrast with
+# # the flat draw-list tree above: ~no code here, one draw_state per file item.
+#
+# # Disabled while diagnosing frame-time: registering the repo ROOT causes the
+# # folder poller to _poll_loop rescan 143k entries (venv included) every
+# # second, starving the render thread.
+# # files_host = folder_proxy(ROOT, "FileTreeRoot")
+#
+#
+# @render_func(is_render_for="PosixPath", show_bg=False, selectable=True,
+#              use_cache=True, is_tree=True, with_header=draw_header)
+# def draw_file_name(input_value=None, draw_state=None,
+#                    left_mouse_double_clicked=False, **kwargs):
+#     # The header draws the name (the dict key) and carries selection/drag -
+#     # the body is only the double-click → open handler.
+#     if left_mouse_double_clicked:
+#         open_file(input_value)
+#     return False, input_value
+#
+#
+# # @window(input_value=files_host, tint=(0.42, 0.36, 0.54), disable_scroll=False, mode=Modes.WINDOW)
+# @render_func(show_bg=True, use_cache=False, shadow=True, selectable=False)
+# def render_file_tree_melty(input_value=None, draw_state=None, **kwargs):
+#     from meltygui.core.rendering.render_funcs import RenderFuncs
+#     watch_folder(ROOT, draw_state)
+#     # Same shape as draw_folder_files: the host holds the tree one level down
+#     # under "value"; a simple top-level draw_collection, and the names-only
+#     # mode passed to the host.
+#     tree = input_value.get("value") if isinstance(input_value, dict) else {}
+#     RenderFuncs.draw_collection(tree if tree is not None else {}, name=ROOT.name,
+#                                 show_add_delete=True, new_item_type=str, temp=True,
+#                                 width=draw_state.content_width,
+#                                 show_scroll=True, show_bg=True,
+#                                 child_kwargs={"show_bg": True, "bg_offset": -4,
+#                                               "mode": Modes.FILE_TREE_NAMES})
+#     return True, None

meltygui/core/files/file_watch_core.py

@@ -0,0 +1,43 @@
+"""File Watch Debug window — what the watcher and symbol index can see, now.
+
+One row per known file, grouped by watched directory: whether its text is
+baselined in Melty.code_cache (an external edit to an UNCACHED file is
+invisible — nothing to diff), how many views watch it, whether it's
+project-tracked (watch_project_files), whether external drift is currently
+recorded for it, and the usage-symbol index status — the warmer's per-file
+refs cache (fresh/stale vs disk mtime) plus how many cached span-usage
+results are fresh under the current (mtime, pending-gen, index-gen)
+signature. The rescan button re-runs the project walk to pick up files/dirs
+created since startup.
+"""
+
+import os
+import sys
+from collections import defaultdict
+from pathlib import Path
+
+from meltygui.core.rendering.render_funcs import RenderFuncs
+from meltygui.core.core_render import render_func
+from meltygui.core.rendering.window_decoration import window
+
+
+def _symbol_index_view():
+    """Merged read-only view of the symbol index's per-file state across BOTH
+    module identities (src.lsd.… / lsd.… — the span/mtime stores are
+    sys-anchored and shared, but _index_refs_cache is module-level, so the
+    warmer may be filling either twin's dict)."""
+    refs, spans, snap, gen = {}, {}, {}, 0
+    for name in ("meltygui.code.libcst_conversion",
+                 "lsd.gl_gui.view.core_conversion.libcst_conversion"):
+        m = sys.modules.get(name)
+        if m is None:
+            continue
+        refs.update(getattr(m, "_index_refs_cache", {}))
+        spans.update(getattr(m, "_symbol_usage_cache", {}))
+        snap.update(getattr(m, "_mtime_snapshot", {}))
+        gen = max(gen, getattr(m, "_index_generation", 0))
+    return refs, spans, snap, gen
+
+
+from meltygui.view.file_view import file_watch_debug
+file_watch_debug = window(disable_scroll=False, tint=(0.16296297311782837, 0.2611111, 0.24118687212467194))(file_watch_debug)

meltygui/core/files/import_graph_core.py

@@ -0,0 +1,43 @@
+"""Import graph — every project file as a labelled box, every import a line.
+
+The whole `file_graph.ImportGraph` drawn straight to the window draw_list
+(the file_tree / fast_dock model: no per-node widgets, event params for
+gestures, blit cache while idle). The graph's layered layout
+(file_graph.layout_graph: column = dependency depth, left → right, rows
+ordered to keep lines short) gives the ORDER; this view sizes it in
+pixels — each node is a rounded box around its file name, a column is as
+wide as its widest box, rows share one pitch — so nothing overlaps, then
+projects it: screen = origin + (box − centre) · fit · zoom + pan, where
+zoom 1 fits the whole graph in the window.
+
+Gestures: middle-drag pans, wheel zooms about the cursor, click a box to
+select it (its importers light in the file's tint, its imports in the
+washed variant, everything else fades), Esc clears, `/` resets the camera.
+Box size follows USAGE (importer count, log scale) through the font scale,
+so the hubs read at a glance. Shares the graph with render_file_tree
+through file_graph.current(): either window's Build button serves both.
+"""
+
+from __future__ import annotations
+
+import colorsys
+import math
+from pathlib import Path
+
+import meltygui_imgui as imgui
+from meltygui.hdr_color import pack_color
+from meltygui.core.melty import Melty
+from meltygui.core.conversion.dict_conversion import DictConversion
+from meltygui.core.runtime.toggles import Toggles
+from meltygui.core.windowing.glfw_utils import request_render
+from meltygui.core.core_render import render_func
+from meltygui.core.rendering.window_decoration import window
+from meltygui.core.layout.header_runtime import _brightness_clamp_fn
+import meltygui.model.import_graph_model as file_graph
+from meltygui.core.files.file_tree_core import _meta
+from meltygui.core.files.file_tree_core import _tint_of
+from meltygui.core.files.file_tree_core import open_file
+
+
+from meltygui.view.graph_view import render_import_graph
+render_import_graph = window(initial={'width': 720, 'height': 620}, tint=(0.42, 0.36, 0.54), disable_scroll=True)(render_import_graph)

meltygui/core/files/metadata_core.py

@@ -0,0 +1,51 @@
+import inspect
+from functools import wraps
+from typing import Any
+
+
+def meta_preset(func, *o_args, **o_kwargs):
+    sig = inspect.signature(func)
+    params = sig.parameters
+    wanted_params = list(params.keys())
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        first_arg = args[0] if args else None
+
+        if 'for_type' in kwargs and not isinstance(first_arg, type):
+            def class_wrapper(cls):
+                inner_args = args[1:]
+                return wrapper(cls, *inner_args, **kwargs)
+            return class_wrapper
+
+        if isinstance(first_arg, type):
+            if 'default_value' in kwargs:
+                default_value = kwargs['default_value']
+            else:
+                default_value = None
+            for_type = kwargs.get('for_type', None)
+            kwargs.pop('for_type', None)
+            kwargs.pop('default_value', None)
+            args = args[1:] if len(args) > 1 else ()
+
+            retrieved_meta = func(default_value=default_value, *args, **kwargs)
+            if for_type is not None:
+                first_arg.default_meta_for = getattr(first_arg, 'default_meta_for', {})
+                first_arg.default_meta_for[for_type] = retrieved_meta
+            else:
+                first_arg.meta = retrieved_meta
+
+            return first_arg
+        else:
+            arg_idx = 0
+            # Clean up kwargs to only what the function wants
+            for wanted_param in wanted_params:
+                if wanted_param not in kwargs:
+                    kwargs[wanted_param] = args[arg_idx] if arg_idx < len(args) else None
+                arg_idx += 1
+
+            retrieved_meta = func(**kwargs)
+            return retrieved_meta
+
+    wrapper.__meta_preset__ = True
+    return wrapper

meltygui/core/graphics/__init__.py

@@ -0,0 +1 @@
+"""Shared framework graphics machinery."""