meltygui 0.1.0__py3-none-any.whl

meltygui/examples/lora_policies.py

@@ -0,0 +1,67 @@
+"""Closable Melty LoRA windows sharing data and rendering, with different policies."""
+import meltygui_imgui as imgui
+import meltygui
+from meltygui import Style
+from meltygui import glfw_window
+from meltygui import pressed
+from meltygui import default_scalar_accumulation
+from meltygui import default_tint_accumulation
+from meltygui.examples.lora_data import lora_preview
+from meltygui.examples.lora_data import nested_style_kwargs
+from meltygui.examples.tint_functions import darken
+from meltygui.examples.tint_functions import wave
+from meltygui.examples.scalar_policies import subtract
+from meltygui.examples.scalar_policies import size_curve
+from meltygui.examples.scalar_policies import weight_curve
+from meltygui.examples.scalar_policies import shadow_curve
+from meltygui.core.melty import Melty
+from meltygui.core.core_render import render_func
+from meltygui.view.header_view import draw_header
+
+
+loras = lora_preview()
+children = nested_style_kwargs()
+node = children
+while node:
+    node['style'] = Style((.035, .025, .045), font_size=.5, font_weight=25, shadow_offset=.4)
+    node = node.get('child_kwargs')
+
+policies = (
+    ('Loras / Add', default_tint_accumulation, default_scalar_accumulation,
+     default_scalar_accumulation, default_scalar_accumulation),
+    ('Loras / Subtract', darken, subtract, subtract, subtract),
+    ('Loras / Nonlinear', wave, size_curve, weight_curve, shadow_curve),
+)
+
+
+def reopen():
+    for name, *_ in policies:
+        Melty.open_window(name)
+
+
+@render_func(use_cache=False)
+def lora_contents(input_value, draw_state):
+    changed, _ = meltygui.draw_any(input_value, name='Loras', icon='',
+                               style=Style((.035, .025, .045)),
+                               initial={'expanded': True}, child_kwargs=children)
+    return changed, input_value
+
+
+@glfw_window(name='LoRA accumulation comparison', width=1800, height=1040,
+             show_name=True, with_header=draw_header, app_id='meltygui-gui-playground', style=Style())
+@render_func(use_cache=False)
+def lora_comparison(input_value, draw_state):
+    from meltygui.examples.gui_playground import toggle_styles
+    if pressed('ctrl+d'):
+        toggle_styles()
+    meltygui.draw_menu_bar({'Windows': {'Reopen LoRA windows': reopen},
+                         'Styles': {'Enable / disable (Ctrl+D)': toggle_styles}}, name='lora-comparison-menu')
+    imgui.text('Same LoRA data and render function. Each Melty window can be moved, resized, scrolled, and closed.')
+    for i, (name, tint_fn, size_fn, weight_fn, shadow_fn) in enumerate(policies):
+        lora_contents(loras, name=name, as_window=True, shadow=True, with_header=draw_header,
+                      force_initial=True,
+                      style=Style((.50, .53, .57), absolute=True, tint_fn=tint_fn,
+                                  font_size_fn=size_fn, font_weight_fn=weight_fn, shadow_fn=shadow_fn),
+                      initial={'window_pos': (12 + i * 592, 15), 'width': 580,
+                               'height': 920, 'expanded': True})
+    return False, input_value

meltygui/examples/mode_demo.py

@@ -0,0 +1,49 @@
+"""Usage example for the inputs tab's mode-attached child_kwargs source.
+
+    @window draw_mode_test ──draw_any(mode=Modes.TEXT)──► draw_collection
+                                                            │ child_kwargs
+                                                            ▼
+                                                         draw_text  (one per key)
+
+Mode.TEXT (view/mode.py) carries `child_kwargs={line_height, wrap,
+syntax_highlight}` in its dict entry. Nothing here passes those — they reach
+each draw_text leaf purely through the mode.
+
+To see the new source: right-click a text leaf → inputs tab. Two child_kwargs
+rows appear, and they are independently editable:
+
+  child_kwargs (mode)   ← Mode.TEXT's dict, jumps to / saves into mode.py
+  child_kwargs          ← whichever NON-mode parent source sets one (the
+                          caller below, once you uncomment it)
+
+Editing `line_height` on the mode row rewrites mode.py and every leaf
+reflows; the plain row edits this file instead.
+"""
+import meltygui_imgui as imgui
+
+from meltygui.core.rendering.modes import Modes
+from meltygui.core.core_render import render_func
+from meltygui.core.rendering.window_decoration import window
+from meltygui.core.rendering.render_dispatch import draw_any
+
+# Module level so hotswap-re-exec reuses it - edits made in the window survive
+# while iterating on the mode.
+mode_test_text = {
+    "intro": "Mode.TEXT sends every string in this dict to draw_text.",
+    "styling": "line_height, wrap and syntax_highlight are NOT passed here — "
+               "they arrive from Mode.TEXT's child_kwargs and are editable "
+               "from the inputs tab's 'child_kwargs (mode)' row.",
+    "code_sample": "def unhighlighted(x):\n    return x * 2  # syntax_highlight=False",
+}
+
+
+@window
+@render_func(tint=(0.22, 0.38, 0.31), auto_resize=False, min_width=560, min_height=320)
+def draw_mode_test(input_value, draw_state):
+    imgui.text("Mode.TEXT — leaf style comes from the mode's child_kwargs")
+    draw_any(mode_test_text, name="mode_test_body", mode=Modes.TEXT)
+    # Uncomment to give the leaves a SECOND, non-mode child_kwargs setter (this
+    # call site) - the inputs tab then shows both rows side by side, the mode
+    # one still winning at runtime:
+    # draw_any(mode_test_text, name="mode_test_body_caller", mode=Modes.TEXT,
+    #          child_kwargs={"line_height": 2.0})

meltygui/examples/modifies_demo.py

@@ -0,0 +1,119 @@
+import inspect
+import types
+from pathlib import Path
+
+import meltygui_imgui as imgui
+
+from meltygui.core.rendering.modes import Modes
+from meltygui.core.rendering.render_funcs import RenderFuncs
+from meltygui.core.runtime.toggles import Toggles
+from meltygui.code.new_converters import code_file_io
+from meltygui.code.new_converters import convert_in_and_out_value
+from meltygui.code.new_converters import string_to_cst_module
+from meltygui.code.new_converters import cst_module_to_string
+from meltygui.code.new_converters import cst_module_to_dict
+from meltygui.code.new_converters import dict_to_cst_module
+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.render_dispatch import draw_any
+from meltygui.view.text_view import draw_text
+from meltygui.core.cache.invalidation_tracker import Note
+from meltygui.core.rendering.mode import Mode
+
+class ModifiesPlayground:
+
+    def __init__(self, playground):
+        self.playground = playground
+
+    def modify(self, modification):
+        self.playground.modify(modification)
+
+class InCode:
+    value = 949
+    is_tree = False
+    name = "Unset"
+    show_bg = True
+    use_cache = False
+    some_val = 0
+    some_list = [-152,69,45,-22]
+    om_val2  =0
+
+
+ # [tint=(0.0923043042421341, 0.041103292256593704, 0.23255813121795654)]
+    class Nested:
+        inner_value = [110,172,28]
+
+# Two chained proxies. Each WRAPS a stateful func (stateful_work → view_func(value) →
+# stateful_work) and HOLDS the value that func hands its view_func - so each is "just a
+# dict with one value inside", at its own representation level:
+#
+#   string_proxy   wraps code_file_io              holds {value: <source string>}\
+#   dict_proxy     wraps convert_in_and_out_value  holds {value: <GeneralParse dict>}
+#
+# code_file_io hands its view_func the source string; convert_in_and_out_value hands its
+# view_func the chain_in OUTPUT (the new string) directly - so neither one needs a
+# routed side-channel or materialize_from. Chaining is data-flow: dict_proxy.input_value
+# IS string_proxy, so it reads string_proxy's held source ("just like a dict"); every
+# edit to the tree flows back → convert's new source string → written onto string_proxy
+# → code_file_io saves one frame later.
+#
+# Both are standalone, so draw_main calls draw() on each and renders it in its own
+# window (string_proxy first, so its source is fresh when dict_proxy reads it).
+
+# string_proxy = RenderHost(io_function=code_file_io, input_value=draw_text, name="String Proxy File",
+#
+#                           child_kwargs={"auto_load_edits": False, "auto_load":True})   # auto-reload on external file change
+#
+# dict_proxy = RenderHost(
+#     io_function=convert_in_and_out_value, input_value=string_proxy, name="Tree Proxy",
+#     child_kwargs={
+#         "chain_in": [string_to_cst_module, cst_module_to_dict],
+#         "chain_out": [dict_to_cst_module, cst_module_to_string],
+#         "route": {cst_module_to_dict: ("code_dict", "jump_to", "run_jedi", "drive")},
+#     })
+
+# draw_text_static_file_load = inspect.getsource(draw_text)
+
+# The shared framework pair, NOT a private copy. This module used to carry its
+# own copy of code_hosts_for and its own cache, so this window passed draw_text
+# through a second, independent pipeline while the editor route parsed the same
+# span through the framework pair: two full 102KB str→cst→dict conversions per
+# session (~430ms of duplicated background work, visible in the perf-trace
+# timeline). One cache, one pair, one parse.
+from meltygui.code.new_converters import code_hosts_for
+
+string_proxy, dict_proxy = code_hosts_for(draw_text)
+
+
+# @window(disable_scroll=False, use_cache=True)
+# @render_func(tint=(0.043, 0.11, 0.20), auto_resize=True)
+# def test_code_hosts(_, draw_state):
+    # Both proxies show themselves in their own windows (draw_main → draw()). This
+    # window just inspects them AS ordinary dicts - the framework has no idea they're
+    # proxies; it's rendering ordinary dicts whose single value was materialized by
+    # their wrappers. Editing here bubbles back exactly the same way.
+
+    #
+    # changed, value = draw_collection(string_proxy, name="String Proxy", disable_scroll=False, child_kwargs={"view_func": draw_text, "code_dict": dict_proxy})
+    # changed, value = draw_collection(dict_proxy, name="Dict Proxy", disable_scroll=False)
+
+    # draw_columns({"text":string_proxy, "dict":dict_proxy})
+
+    # global draw_text_static_file_load
+    # changed, value = draw_text(draw_text_static_file_load, show_name=True, use_cache=True, name="static baseline")
+    # if changed:
+    #     draw_text_static_file_load = value
+
+    # changed, value = draw_collection(string_proxy, name="String Proxy Dict", child_kwargs={"view_func":draw_text})
+
+    # if changed:
+    #     draw_state.invalidate_up_by_obj(obj=dict_proxy, time_delta=2, note=Note(name="String Proxy changed", tint=(1,1,1)), max_depth=10)
+
+        # request_render()
+    # New trick: `.deep.unwrap()` skips the redundant wrapper rungs (value / module /
+    # function name) and hands draw_collection the meaningful content dict with its keys
+    # intact - no manual ["value"][...] indexing or "if key in d" guards.
+    # tree = dict_proxy.deep.unwrap()
+    # if tree:
+    # changed, value = draw_collection(dict_proxy, name="Tree Proxy Dict", column=1, disable_scroll=False)

meltygui/examples/scalar_policies.py

@@ -0,0 +1,60 @@
+"""One nested view under three font/shadow accumulation policies."""
+import meltygui_imgui as imgui
+
+from meltygui import Style
+from meltygui import default_scalar_accumulation
+from meltygui import glfw_window
+from meltygui import pressed
+from meltygui.examples.style_layouts import panel
+from meltygui.core.styling.fonts import Font
+from meltygui.core.core_render import render_func
+from meltygui.view.header_view import draw_header
+
+
+def subtract(context, residual):
+    return context - residual
+
+
+def size_curve(context, residual):
+    return context * (1 + residual / 20)
+
+
+def weight_curve(context, residual):
+    return context * (1 + residual / 400)
+
+
+def shadow_curve(context, residual):
+    return context + residual / (1 + abs(context))
+
+
+def nested(depth=0):
+    content = {'text': [(.06, .08, f'Level {depth + 1} / Aa 012')]}
+    if depth < 3:
+        content['children'] = [('child', (.055, .24, .89, .70),
+                                Style((.055, .04, .065), font_size=2,
+                                      font_weight=100, shadow_offset=2), nested(depth + 1))]
+    return content
+
+
+@glfw_window(name='Font and shadow policies', width=1140, height=550,
+             show_name=True, with_header=draw_header, app_id='meltygui-gui-playground',
+             style=Style((.30, .32, .36), absolute=True))
+@render_func(use_cache=False)
+def scalar_policy_window(input_value, draw_state):
+    from meltygui.examples.gui_playground import toggle_styles
+    if pressed('ctrl+d'):
+        toggle_styles()
+    imgui.text('Same nested view: +2 size, +100 weight, +2 shadow at every child. Ctrl+D toggles styles.')
+    w = max(900, draw_state.content_width - 20)
+    policies = [('Add', default_scalar_accumulation, default_scalar_accumulation, default_scalar_accumulation),
+                ('Subtract', subtract, subtract, subtract),
+                ('Nonlinear', size_curve, weight_curve, shadow_curve)]
+    panel({'children': [(label, (i / 3 + .01, .02, .31, .96),
+                         Style((.055, .04, .065), font_size_fn=size_fn,
+                               font_weight_fn=weight_fn, shadow_fn=shadow_fn),
+                         {'text': [(.06, .03, label)], 'children': [
+                             ('tree', (.02, .14, .96, .84), Style(), nested())]})
+                        for i, (label, size_fn, weight_fn, shadow_fn) in enumerate(policies)]},
+          name='scalar-policies', style=Style(), font=Font.JETBRAINS_MONO_19,
+          width=w, height=450)
+    return False, input_value

meltygui/examples/style_layouts.py

@@ -0,0 +1,149 @@
+"""Three composed layouts for exploring residual styles in the GUI playground."""
+import meltygui_imgui as imgui
+
+import meltygui
+from meltygui import Style
+from meltygui import glfw_window
+from meltygui import pressed
+from meltygui.hdr_color import pack_color
+from meltygui.core.styling.fonts import Font
+from meltygui.core.melty import Melty
+from meltygui.core.runtime.toggles import Toggles
+from meltygui.core.core_render import render_func
+from meltygui.view.header_view import draw_header
+
+
+strength = 0.22
+type_size = 0
+type_weight = 0
+
+
+def stronger():
+    global strength
+    strength = min(0.8, strength + 0.1)
+
+
+def softer():
+    global strength
+    strength = max(0.02, strength - 0.1)
+
+
+def larger_type():
+    global type_size
+    type_size = min(10, type_size + 1)
+
+
+def smaller_type():
+    global type_size
+    type_size = max(-6, type_size - 1)
+
+
+def heavier_type():
+    global type_weight
+    type_weight = min(200, type_weight + 100)
+
+
+def lighter_type():
+    global type_weight
+    type_weight = max(-300, type_weight - 100)
+
+
+@render_func(show_bg=False, show_header=False, use_cache=False, auto_resize=False)
+def panel(input_value, draw_state, style=None):
+    """A real Melty context for each rectangle; children inherit its background."""
+    if Toggles.dynamic_styles:
+        Melty.add_background(style)
+    else:
+        imgui.get_window_draw_list().add_rect_filled(
+            draw_state.abs_left, draw_state.abs_top,
+            draw_state.abs_left + draw_state.width, draw_state.abs_top + draw_state.height,
+            pack_color(0.2, 0.22, 0.25, 1), 8)
+    x, y = draw_state.abs_left, draw_state.abs_top
+    w, h = draw_state.width, draw_state.height
+    # Paint children first, then text: crossing glyphs sample the actual surface.
+    for key, rect, child_style, content in input_value.get('children', ()):
+        left, top, width, height = rect
+        imgui.set_cursor_screen_pos((x + left * w, y + top * h))
+        panel(content, name=key, style=child_style, width=width * w, height=height * h)
+    dl = imgui.get_window_draw_list()
+    for left, top, label in input_value.get('text', ()):
+        dl.add_text(x + left * w, y + top * h, pack_color(0.58, 0.58, 0.58, 1), label)
+    imgui.set_cursor_screen_pos((x, y))
+    imgui.dummy(w, h)
+    return False, input_value
+
+
+def terraces(delta, depth=0):
+    content = {'text': [(0.04, 0.06, f'Level {depth + 1}') ]}
+    if depth < 3:
+        content['children'] = [('inset', (0.07, 0.23, 0.86, 0.71), Style(delta, shadow_offset=2),
+                                terraces(delta, depth + 1))]
+    return content
+
+
+def workspace():
+    tile = {'text': [(0.07, 0.15, 'Shared card'), (0.07, 0.39, 'Same residual'),
+                     (0.07, 0.65, 'Same text suggestion')]}
+    def column(label, base):
+        return (label, base, {'text': [(0.06, 0.06, label)], 'children': [
+            ('card', (0.06, 0.23, 0.88, 0.68), Style((strength, 0, strength)), tile)]})
+    columns = [column('Night', Style((0.07, 0.10, 0.16), absolute=True)),
+               column('Paper', Style((0.94, 0.91, 0.83), absolute=True)),
+               column('Ocean', Style((0.04, 0.43, 0.49), absolute=True))]
+    return {'children': [(label, (i / 3 + .012, .04, .309, .92), base, content)
+                         for i, (label, base, content) in enumerate(columns)]}
+
+
+def crossing():
+    veil = Style((.15, .45, .95, .35), absolute=True)
+    return {'children': [
+        ('night', (0, 0, .5, 1), Style((.035, .045, .07), absolute=True),
+         {'children': [('veil', (.16, .56, .84, .30), veil, {})]}),
+        ('paper', (.5, 0, .5, 1), Style((.95, .92, .84), absolute=True),
+         {'children': [('veil', (0, .56, .84, .30), veil, {})]})],
+        'text': [(.30, .18, 'One text run crosses both surfaces'),
+                 (.30, .36, 'The renderer chooses the contrast'),
+                 (.12, .66, 'Same translucent blue / different inherited surfaces')]}
+
+
+@glfw_window(name='Style compositions — GUI playground', width=1060, height=1000,
+             show_name=True, with_header=draw_header, app_id='meltygui-gui-playground',
+             style=Style(), disable_scroll=False)
+@render_func(use_cache=False)
+def style_compositions(input_value, draw_state):
+    from meltygui.examples.gui_playground import toggle_styles
+    from meltygui.examples.gui_playground import toggle_root
+    from meltygui.examples.gui_playground import reset
+    if pressed('ctrl+d'):
+        toggle_styles()
+    if pressed('ctrl+l'):
+        toggle_root()
+    meltygui.draw_menu_bar({
+        'Styles': {'Enable / disable (Ctrl+D)': toggle_styles,
+                   'Light / dark root (Ctrl+L)': toggle_root, 'Reset': reset},
+        'Residual': {'Stronger': stronger, 'Softer': softer},
+        'Typography': {'Larger (+1)': larger_type, 'Smaller (-1)': smaller_type,
+                       'Heavier (+100)': heavier_type, 'Lighter (-100)': lighter_type},
+    }, name='composition-menu')
+    imgui.text(f'Dynamic styles: {"ON" if Toggles.dynamic_styles else "OFF"}  |  Residual strength: {strength:.2f}')
+    w = max(520, draw_state.content_width - 20)
+    imgui.text('01  /  TERRACES     Nested colour + shadow depth residuals (+2 per level)')
+    panel({'children': [
+        ('warm', (.01, .02, .32, .96), Style((strength, 0, 0)), terraces((strength, 0, 0))),
+        ('cool', (.34, .02, .32, .96), Style((0, strength / 2, strength)), terraces((0, strength / 2, strength))),
+        ('shade', (.67, .02, .32, .96), Style((-strength,) * 3), terraces((-strength,) * 3))]},
+        name='terraces', style=Style(), width=w, height=300)
+    imgui.text('02  /  CONTEXT CARDS     The same component on three absolute surfaces')
+    panel(workspace(), name='workspace', style=Style(), width=w, height=240)
+    imgui.text('03  /  CROSSING     Text adapts per pixel; the inset composites translucent blue')
+    panel(crossing(), name='crossing', style=Style(), width=w, height=220)
+    imgui.text('04  /  TYPE     Native-size hinted fonts; children add +3 pixels and +100 weight')
+    panel({'text': [(.03, .05, f'Parent / size {18.5 + type_size:g}, weight {400 + type_weight}')], 'children': [
+        ('medium', (.03, .23, .94, .70), Style((.08, .04, .10), font_size=3, font_weight=100),
+         {'text': [(.03, .07, f'Child / +3 pixels, weight {500 + type_weight}')], 'children': [
+             ('semibold', (.04, .35, .92, .55),
+              Style((.08, .04, .10), font_size=3, font_weight=100),
+              {'text': [(.03, .22, f'Grandchild / +6 pixels, weight {600 + type_weight}  |  Il1 0O')]})]})]},
+        name='typography', font=Font.JETBRAINS_MONO_19,
+        style=Style(font_size=type_size, font_weight=type_weight), width=w, height=300)
+    return False, input_value

meltygui/examples/tile_manager_demo.py

@@ -0,0 +1,74 @@
+"""Demo for the tiled window manager (core/layout/tile_manager_core.py).
+
+A Blender-style area layout drawn flat on one draw_state: every divider —
+the window's frame edges, the column edges of the root split, the row
+edges inside each column — is a shared edge object in the window's
+collision solve, so dragging any of them pushes and pulls the rest and
+out through the window frame, exactly like the columns playground.
+"""
+from meltygui.core.conversion.dict_conversion import DictConversion
+from meltygui.core.core_render import render_func
+from meltygui.core.rendering.window_decoration import window
+from meltygui.model.tile_model import Split
+from meltygui.model.tile_model import Tile
+from meltygui.core.layout.tile_manager_core import TileManagerState
+from meltygui.core.layout.tile_manager_core import draw_tiles
+
+
+class CounterState(DictConversion):
+    def __init__(self):
+        super().__init__()
+        self.count = 0
+
+
+@render_func(multi_instance=True, tint=(0.20, 0.36, 0.52))
+def draw_tile_counter(input_value: object, draw_state,
+                      counter_state: CounterState = None, style_manager=None):
+    """Choose in two tiles to exercise independent, persisted view state."""
+    from meltygui.view.header_view import flat_button
+    clicked = flat_button(f"Count: {counter_state.count} — add one", draw_state,
+                          "increment", width=180, style_manager=style_manager)
+    if clicked:
+        counter_state.count += 1
+    return clicked, input_value
+
+
+@render_func(multi_instance=True, tint=(0.22, 0.44, 0.30))
+def draw_tile_notes(input_value: object):
+    from meltygui.view.text_view import draw_text
+    changed, value = draw_text("" if input_value is None else input_value)
+    return changed, value if changed else input_value
+
+
+class TileManagerDemoModel(DictConversion):
+    """The demo app owns the layout, including each tile's selected function."""
+
+    def __init__(self):
+        super().__init__()
+        self.tree = Split("x", [
+            Tile("outliner", tint=(0.20, 0.36, 0.52), render_func=draw_tile_counter),
+            Split("y", [
+                Tile("viewport", tint=(0.28, 0.28, 0.30), render_func=draw_tile_counter),
+                Tile("timeline", tint=(0.42, 0.30, 0.18)),
+            ]),
+            Split("y", [
+                Tile("properties", tint=(0.22, 0.44, 0.30)),
+                Tile("modifiers", tint=(0.36, 0.24, 0.44)),
+                Tile("materials", tint=(0.50, 0.22, 0.24)),
+            ]),
+        ])
+
+
+# auto_resize=False: a fixed-size window gives the tree a stable frame;
+# the tiles inside it and every edge moves independently of the rest.
+@window
+@render_func(tint=(0.24, 0.30, 0.20), auto_resize=False, min_width=720,
+             min_height=420, show_bg=True)
+def draw_tiled_window_manager_demo(input_value: object, draw_state,
+                                   tile_state: TileManagerState = None,
+                                   app_model: TileManagerDemoModel = None,
+                                   multi_instance_renderers=()):
+    tree = app_model.tree if input_value is None else input_value
+    changed = draw_tiles(tree, draw_state, tile_state=tile_state,
+                         multi_instance_renderers=multi_instance_renderers)
+    return changed, input_value