meltygui 0.1.0__py3-none-any.whl

meltygui/state/file_state.py

@@ -0,0 +1,75 @@
+"""Injected state for file views."""
+from meltygui.core.rendering.core_decoration import no_save
+from meltygui.core.conversion.dict_conversion import DictConversion
+from pathlib import Path
+
+
+@no_save("_listing", "_last_dir", "_watched", "_search", "_search_for")
+class FileExplorerState(DictConversion):
+    """The listing's injected state (`explorer_state: FileExplorerState`).
+    Persists the selection, the scroll position per directory visited
+    (going back lands where you left) and the hidden-files switch."""
+    _owner_ds = None
+
+    def __init__(self):
+        super().__init__()
+        self.selected = None        # str path of the single-clicked row
+        self.scroll_by_dir = {}     # str dir -> scroll y
+        self.show_hidden = False    # dotfiles
+        self._listing = None        # (dir, mtime_ns, show_hidden, rows) memo
+        self._last_dir = None       # the dir of the last run: navigation detection
+        self._watched = None        # the dir the view's FileWatch emitter is on
+        self._search = ""           # the type-to-search query
+        self._search_for = None
+
+
+class ShortcutState(DictConversion):
+    """Persist sidebar order independently of directory listing order."""
+
+    def __init__(self):
+        super().__init__()
+        self.order = []
+
+
+class FileSelectorState(DictConversion):
+    def __init__(self):
+        super().__init__()
+        self.directory = None
+
+
+class FileTreeState(DictConversion):
+    """Injected per-draw_state state (`file_tree_state: FileTreeState = None`).
+    A DictConversion so it PERSISTS: every non-underscore attribute is saved
+    between sessions (style guide rules 6–7) — which folders were open and
+    what was selected come back on restart. Paths are stored as STRINGS
+    (a Path inside a set is not on the legacy to_dict primitive list)."""
+    _owner_ds = None
+
+    def __init__(self):
+        super().__init__()
+        self.expanded = set()   # str paths of open folders
+        self.selected = None    # str path of the last single-clicked file
+        self._graph = None      # file_graph.ImportGraph once built (not saved)
+        self._build = None      # file_graph.ImportBuildBuilder while building
+
+    def is_expanded(self, path):
+        return str(path) in self.expanded
+
+    def toggle(self, path):
+        self.expanded.symmetric_difference_update({str(path)})
+
+    def select(self, path):
+        self.selected = str(path) if path is not None else None
+
+    @property
+    def selected_path(self):
+        return Path(self.selected) if self.selected else None
+
+    def open_file(self, path):
+        from meltygui.core.files.file_tree_core import open_file
+
+        open_file(path)
+
+
+from meltygui.core.runtime.paths import application_root
+ROOT = application_root()

meltygui/state/graph_state.py

@@ -0,0 +1,26 @@
+"""Injected state for graph views."""
+from meltygui.core.conversion.dict_conversion import DictConversion
+from pathlib import Path
+
+
+class GraphViewState(DictConversion):
+    """Injected per-draw_state state (`graph_view_state: GraphViewState = None`):
+    the camera and the selection persist between sessions; the graph and
+    the in-flight build (underscored) do not."""
+    _owner_ds = None
+
+    def __init__(self):
+        super().__init__()
+        self.zoom = 1.0
+        self.pan_x = 0.0        # px, screen coordinates
+        self.pan_y = 0.0
+        self.selected = None    # str path of the selected node
+        self._graph = None
+        self._build = None
+
+    def select(self, path):
+        self.selected = str(path) if path is not None else None
+
+    @property
+    def selected_path(self):
+        return Path(self.selected) if self.selected else None

meltygui/state/inspection_state.py

@@ -0,0 +1,47 @@
+"""Injected state for inspection views."""
+
+
+
+class _InfoRow:
+    """One info-tab row: a param name plus the shared per-render tab context
+    (stamped onto `.ctx` by draw_info_tab each render). Exists so the tab's
+    rows go through draw_collection — the collection owns iteration, row
+    clipping, key search and scroll-to-match; this object type-routes each
+    row to draw_info_param."""
+    __slots__ = ("param", "group", "ctx")
+
+    def __init__(self, param):
+        self.param = param
+        self.group = None
+        self.ctx = None
+
+    def __repr__(self):
+        return f"_InfoRow({self.param!r})"
+
+
+class ContextMenuState:
+    def __init__(self):
+        self.decoration_key = None
+        self.decoration_str = None
+        self.decoration_dict = None
+        self.render_func_str = None
+        self.render_func_dict = None
+        self.class_str = None
+        self.class_dict = None
+        # One (str_host, dict_host) pair per call site shown - the direct
+        # caller, its caller, ... up to Toggles.caller_walk_steps. Innermost-first.
+        self.call_site_hosts = []
+        self.mode_str = None
+        self.mode_dict = None
+        # What the cached hosts above were built FOR. This menu's up/down nav
+        # retargets the same tab draw_state (and thus this same cm_state) at an
+        # ancestor view, so the hosts must rebuild when the target changes.
+        self.host_key = None
+        # Tuple of (filename, lineno) the caller hosts above were built for.
+        self.call_site_keys = None
+        self.mode_key = None
+        # (file, lineno) of class_to_show's definition - for the class-var /
+        # class-default jump buttons. Cached because inspect.getsourcelines()
+        # AST-parses the WHOLE module file (see the host_key block below), so it
+        # must not run per frame. Invariant for a given host_key.
+        self.class_loc = None

meltygui/state/menu_state.py

@@ -0,0 +1,10 @@
+"""Menu state functions and supporting definitions."""
+from meltygui.state.new_core_model import DropDownState
+
+
+def _menu_state(state, title):
+    """The DropDownState of `title`'s menu, created on first sight."""
+    menu_state = state.menus.get(title)
+    if not isinstance(menu_state, DropDownState):
+        menu_state = state.menus[title] = DropDownState()
+    return menu_state

meltygui/state/model_enums.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class RelaxedEnum(Enum):
+    def __eq__(self, other):
+        if isinstance(other, Enum):
+            return self.name == other.name
+        return super().__eq__(other)
+
+    def __hash__(self):
+        return hash(self.name)