meltygui 0.1.0__py3-none-any.whl

meltygui/examples/tint_demo.py

@@ -0,0 +1,160 @@
+"""Tint debug window — a freeform external-edit rig for the manual merge
+system. It manages its OWN file IO on `sample.py` (raw read_text/write_text,
+no PendingSave, no code cache, no self-write hash), so its Save is
+indistinguishable from an outside program writing the file: the watcher
+tracks it as external drift, editors park on the merge banner, and the merge
+window shows the incoming diff. Load/Save are manual buttons only — nothing
+here is automatic."""
+
+from datetime import datetime
+from pathlib import Path
+
+import meltygui_imgui as imgui
+
+from meltygui.core.melty import Melty
+from meltygui.core.rendering.render_funcs import RenderFuncs
+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.view.text_view import draw_text
+
+# Anchored at src/sample.py regardless of cwd (this file lives at
+# src/lsd/gl_gui/view/playground/) - inside the watched project tree, where
+# MelWatch tracks external writes.
+SAMPLE_PATH = (Path(__file__).resolve().parents[1] / "examples" / "sample.py")
+
+_DEFAULT_SAMPLE = '''"""Freeform scratch file for external-edit testing."""
+
+
+class SampleTints:
+    tint = (0.5, 0.2, 0.8)
+    outline = (1.0, 0.5, 0.0)
+
+
+def sample_function():
+    return "hello"
+'''
+
+
+@window(disable_scroll=False, icon="", display_name="External Editor",
+        tint=(0.29, 0.08, 0.74))
+@render_func(tint=(0.35, 0.18, 0.42))
+def external_editor(draw_state=None):
+    misc = draw_state.misc
+    buffer = misc.get("_sample_buffer")
+
+    # First open: seed the buffer from disk (creating the file if needed) -
+    # the one implicit load; everything after is button-driven.
+    if buffer is None:
+        if not SAMPLE_PATH.exists():
+            SAMPLE_PATH.write_text(_DEFAULT_SAMPLE)
+        buffer = misc["_sample_buffer"] = SAMPLE_PATH.read_text()
+
+    row_h = 26
+    if RenderFuncs.button(" Load", width=90, height=row_h,
+                          name="tint_debug_load")[0]:
+        # Raw read, on purpose: NOT Melty.read_code - this window's view of
+        # the file must be its own, independent of the studio's cache.
+        try:
+            misc["_sample_buffer"] = buffer = SAMPLE_PATH.read_text()
+            misc["_sample_status"] = f"loaded {datetime.now():%H:%M:%S}"
+        except OSError as e:
+            misc["_sample_status"] = f"load failed: {e}"
+        draw_state.invalidate_up(max_depth=4)
+        request_render()
+    imgui.same_line(spacing=8)
+    if RenderFuncs.button(" Save", width=90, height=row_h,
+                          name="tint_debug_save")[0]:
+        # Raw write, on purpose: no codec, no PendingSave, no self-write
+        # hash - the watcher sees this as EXTERNAL edit.
+        try:
+            SAMPLE_PATH.write_text(buffer)
+            misc["_sample_status"] = f"saved {datetime.now():%H:%M:%S} (external write)"
+        except OSError as e:
+            misc["_sample_status"] = f"save failed: {e}"
+        draw_state.invalidate_up(max_depth=4)
+        request_render()
+    imgui.same_line(spacing=12)
+    imgui.align_text_to_frame_padding()
+    imgui.text_colored(str(SAMPLE_PATH), 0.6, 0.65, 0.7, 1.0)
+
+    # ── Canned edits: mutate the buffer without typing ────────────────────
+    # Each returns the new buffer text; None means "no change". The counter
+    # keeps generated names unique across clicks.
+    n = misc.get("_sample_counter", 0)
+
+    def _add_def(text):
+        return (text.rstrip("\n")
+                + f"\n\n\ndef generated_{n}():\n    return {n}\n")
+
+    def _add_comment_top(text):
+        # Insert below the module docstring if it leads the file, else at
+        # the very top - shifts every line down (good for rebase testing).
+        lines = text.split("\n")
+        at = 0
+        if lines and lines[0].lstrip().startswith(('"""', "'''")):
+            q = lines[0].lstrip()[:3]
+            at = 1 if lines[0].count(q) >= 2 else next(
+                (i + 1 for i in range(1, len(lines)) if q in lines[i]), 0)
+        lines.insert(at, f"# external comment {n} {datetime.now():%H:%M:%S}")
+        return "\n".join(lines)
+
+    def _bump_tint(text):
+        # Rewrite the first tuple line mentioning 'tint' with fresh values.
+        lines = text.split("\n")
+        for i, line in enumerate(lines):
+            if "tint" in line and "(" in line:
+                indent = line[:len(line) - len(line.lstrip())]
+                v = (n % 9 + 1) / 10.0
+                lines[i] = f"{indent}tint = ({v}, {v / 2:.2f}, {1.0 - v:.2f})"
+                return "\n".join(lines)
+        return None
+
+    def _edit_return(text):
+        # Change every `return "..."` / `return N` payload in place - an
+        # in-span body edit that does NOT shift line counts.
+        lines = text.split("\n")
+        hit = False
+        for i, line in enumerate(lines):
+            s = line.strip()
+            if s.startswith("return "):
+                indent = line[:len(line) - len(line.lstrip())]
+                lines[i] = f'{indent}return "edit {n}"'
+                hit = True
+        return "\n".join(lines) if hit else None
+
+    for label, fn in (("+ def", _add_def), ("+ top comment", _add_comment_top),
+                      ("~ tint", _bump_tint), ("~ returns", _edit_return)):
+        if RenderFuncs.button(f" {label}", height=row_h,
+                              name=f"tint_debug_{label}")[0]:
+            new = fn(buffer)
+            if new is not None:
+                misc["_sample_buffer"] = buffer = new
+                misc["_sample_counter"] = n + 1
+                misc["_sample_status"] = f"buffer edited ({label.strip()})"
+                draw_state.invalidate_up(max_depth=4)
+                request_render()
+        imgui.same_line(spacing=6)
+    imgui.new_line()
+
+    # Debug readout: does the studio currently see this file as drifted?
+    from meltygui.editor.external_changes import ExternalChanges
+    from meltygui.editor.pending_save import PendingSave
+    key = str(SAMPLE_PATH)
+    tracked = key in ExternalChanges.originals
+    unmerged = tracked and key in PendingSave.unmerged_drift_paths()
+    pending = any(a.path == SAMPLE_PATH for a in PendingSave.pending_saves)
+    status = misc.get("_sample_status", "")
+    imgui.text_colored(
+        f"tracked drift: {'yes' if tracked else 'no'}   "
+        f"unmerged: {'yes' if unmerged else 'no'}   "
+        f"pending edits: {'yes' if pending else 'no'}   {status}",
+        0.75, 0.7, 0.5, 1.0)
+
+    edited, new_text = draw_text(buffer, name="tint_debug_editor",
+                                 show_header=False, use_cache=True,
+                                 bg_offset=-4, shadow=True)
+    if edited and new_text != buffer:
+        misc["_sample_buffer"] = new_text
+
+    return False, None

meltygui/examples/tint_functions.py

@@ -0,0 +1,56 @@
+"""One reusable layout, three root-window tint accumulation policies."""
+import math
+
+import meltygui_imgui as imgui
+from meltygui import Style
+from meltygui import default_tint_accumulation
+from meltygui import glfw_window
+from meltygui import pressed
+from meltygui.examples.style_layouts import panel
+from meltygui.examples.style_layouts import terraces
+from meltygui.core.core_render import render_func
+from meltygui.view.header_view import draw_header
+
+
+def darken(context_tint, tint_res):
+    return tuple(c - r for c, r in zip(context_tint, tint_res))
+
+
+def wave(context_tint, tint_res):
+    # Nonlinear, deliberately bounded demo; zero residual remains an identity.
+    return tuple(math.sin(math.asin(max(-1, min(1, c))) + r * 3)
+                 for c, r in zip(context_tint, tint_res))
+
+
+@render_func(use_cache=False)
+def reusable_window(input_value, draw_state):
+    from meltygui.examples.gui_playground import toggle_styles
+    if pressed('ctrl+d'):
+        toggle_styles()
+    imgui.text('Same render function. Same positive residuals.')
+    w = max(320, draw_state.content_width - 18)
+    panel(terraces((.10, .08, .06)), name='levels',
+          style=Style((.10, .08, .06)), width=w, height=310)
+    imgui.text('Reusable cards inherit the window policy')
+    card = {'text': [(.08, .15, 'Shared component'), (.08, .43, 'Same text suggestion')],
+            'children': [('inset', (.08, .65, .84, .25), Style((.10, .08, .06)),
+                          {'text': [(.08, .18, 'Nested detail')]})]}
+    panel(card, name='card', style=Style((.10, .08, .06), shadow_offset=2),
+          width=w, height=150)
+    imgui.text('This subtree explicitly restores the default')
+    panel({'text': [(.05, .2, 'Default accumulation override')],
+           'children': [('nested', (.05, .50, .90, .4), Style((.10, .08, .06)),
+                         {'text': [(.04, .15, 'Descendants inherit the override')]})]},
+          name='override', style=Style((.10, .08, .06), tint_fn=default_tint_accumulation),
+          width=w, height=120)
+    return False, input_value
+
+
+# Register the SAME render function three times. Only root Style() changes.
+for title, accumulate in (('Lighten', default_tint_accumulation),
+                          ('Darken', darken), ('Wave', wave)):
+    glfw_window(name=f'Tint policy / {title}', width=560, height=720,
+                show_name=True, with_header=draw_header, app_id='meltygui-gui-playground',
+                disable_scroll=False,
+                style=Style((.52, .56, .60), absolute=True, tint_fn=accumulate))(
+                    reusable_window)

meltygui/examples/trace_demo.py

@@ -0,0 +1,88 @@
+"""Stack trace playground — a window for exercising draw_stack_trace.
+
+Two capture buttons: "Raise & catch" runs a small three-deep helper chain
+that raises, catches the ValueError, and renders it — the trace reads main →
+render loop → this window → _alpha → _beta → _gamma with the raising line
+last. "Capture stack" snapshots the CURRENT live stack (no exception) as
+FrameSummary rows — the button-click path itself, straight down from main.
+"""
+
+import traceback
+
+from meltygui.core.rendering.render_funcs import RenderFuncs
+from meltygui.core.runtime.toggles import Tint
+from meltygui.core.core_render import render_func
+from meltygui.core.rendering.window_decoration import window
+from meltygui.view.trace_view import draw_stack_trace
+
+
+class StackTracePlayground:
+    # The captured exception / FrameSummary rows. A class attribute, not
+    # draw_state.misc: misc is serialized and an exception (with its live
+    # traceback frames) must never reach the pickle. Hotswap keeps the live
+    # value (unchanged source expression), so a capture survives edits here.
+    captured = None
+    status = ""
+
+
+# ── Sample call chain - three frames deep so the trace has some shape ────────
+
+def _alpha():
+    greeting = "hello from the playground"
+    return _beta(greeting)
+
+
+def _beta(greeting):
+    numbers = [1, 2, 3]
+    return _gamma(greeting, numbers)
+
+
+def _gamma(greeting, numbers):
+    raise ValueError(f"sample failure: {greeting!r} over {numbers!r}")
+
+
+def capture_sample_exception():
+    try:
+        _alpha()
+    except ValueError as exc:
+        return exc
+
+
+@window(disable_scroll=False, icon=None, display_name="Stack Trace Playground",
+        tint=(0.09, 0.035, 0.03))
+@render_func(tint=(0.9, 0.35, 0.28))
+def stack_trace_playground(draw_state=None):
+    # [tint=(0.9, 0.35, 0.28)]
+    button_height = 26
+
+    if RenderFuncs.button(" Raise & catch", width=130, height=button_height,
+                          name="stack playground raise")[0]:
+        StackTracePlayground.captured = capture_sample_exception()
+        StackTracePlayground.status = "caught ValueError from _gamma"
+    if RenderFuncs.button(" Capture stack", width=130, height=button_height,
+                          name="stack playground capture")[0]:
+        # FrameSummary rows, not live frames: a held frame object would pin
+        # this whole render pass's locals for the session.
+        StackTracePlayground.captured = traceback.extract_stack()
+        StackTracePlayground.status = "captured the live stack at the click"
+    if RenderFuncs.button(" Clear", width=90, height=button_height,
+                          name="stack playground clear")[0]:
+        StackTracePlayground.captured = None
+        StackTracePlayground.status = ""
+
+    if StackTracePlayground.captured is None:
+        RenderFuncs.draw_text("No capture yet — Raise & catch runs a sample "
+                              "three-deep failure; Capture stack snapshots "
+                              "the live stack under this click.",
+                              name="stack playground hint", show_bg=False,
+                              editable=False, tint=Tint.subtle_text())
+        return False, None
+
+    if StackTracePlayground.status:
+        RenderFuncs.draw_text(StackTracePlayground.status,
+                              name="stack playground status", show_bg=False,
+                              single_line=True, editable=False,
+                              syntax_highlight=False, tint=Tint.subtle_text())
+    draw_stack_trace(StackTracePlayground.captured,
+                     name="stack playground trace")
+    return False, None

meltygui/examples/two_windows.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+"""Two peer OS windows, one with a child window that follows it.
+
+    PYTHONPATH=<latent-descent> python meltygui/examples/two_windows.py
+"""
+import meltygui
+from meltygui import glfw_window
+from meltygui import pressed
+
+notes = "type here\n"
+log = "child window: drag me, then drag the parent\n"
+
+
+@glfw_window(name='Notes')
+def notes_window():
+    global notes, log
+    changed, new = meltygui.draw_text(notes, name='notes', syntax_highlight=False)
+    if changed:
+        notes = new
+    # A child OS window of this one: onable, follows it, closes
+    # when this call stops (Ctrl+L toggles it).
+    if not state['hide_log']:
+        changed, new = meltygui.draw_text(log, name='log', glfw_window=True, window_size=(520, 300),
+                                       syntax_highlight=False)
+        if changed:
+            log = new
+    if pressed('ctrl+l'):
+        state['hide_log'] = not state['hide_log']
+
+
+state = {'hide_log': False}
+
+
+@glfw_window(name='Scratch', width=600, height=400)
+def scratch_window():
+    meltygui.draw_text("a second peer window\n", name='scratch', syntax_highlight=False)